Add new setters to variable: setFloat, setInteger and setString (#378)

Author: patrick-tolosa

__TESTS__/unit/actions/Variable.test.ts

@@ -1,5 +1,5 @@
 import {createNewImage} from "../../TestUtils/createCloudinaryImage";
-import {Variable} from "../../../src/actions/variable";
+import {setFloat, setInteger, setString, Variable} from "../../../src/actions/variable";
 import {Expression} from "../../../src/qualifiers/expression";
 
 const {set} = Variable;
@@ -12,6 +12,29 @@ describe('Tests for Transformation Action -- Variable', () => {
     expect(set('a', '30').toString()).toBe('$a_!30!');
   });
 
+  it('tests setFloat with common variable values', () => {
+    expect(setFloat('a', -1).toString()).toBe(`$a_-1.0`);
+    expect(setFloat('a', 0).toString()).toBe(`$a_0.0`);
+    expect(setFloat('a', 1).toString()).toBe(`$a_1.0`);
+    expect(setFloat('a', 0.01).toString()).toBe(`$a_0.01`);
+  });
+
+  it('tests setInteger with common variable values', () => {
+    expect(setInteger('a', -1).toString()).toBe(`$a_-1`);
+    expect(setInteger('a', 0).toString()).toBe(`$a_0`);
+    expect(setInteger('a', 0.9).toString()).toBe(`$a_1`);
+    expect(setInteger('a', 1).toString()).toBe(`$a_1`);
+    expect(setInteger('a', 0.01).toString()).toBe(`$a_0`); // Round down
+  });
+
+  it('tests setString with common variable values', () => {
+    // Strings are trivially supported, so this test tests for numbers
+    expect(setString('a', -1).toString()).toBe(`$a_!-1!`);
+    expect(setString('a', 0).toString()).toBe(`$a_!0!`);
+    expect(setString('a', 1).toString()).toBe(`$a_!1!`);
+    expect(setString('a', 0.01).toString()).toBe(`$a_!0.01!`);
+  });
+
   it('Creates a cloudinaryURL with number variable', () => {
     const url = createNewImage('sample')
       .addVariable(set('a', 30))

src/actions/variable.ts

@@ -3,6 +3,7 @@ import SetAssetReferenceAction from "./variable/SetAssetReferenceAction";
 import SetFromContextAction from "./variable/SetFromContextAction";
 import SetFromMetadataAction from "./variable/SetFromMetadataAction";
 import {ExpressionQualifier} from "../qualifiers/expression/ExpressionQualifier";
+import {toFloatAsString} from "../internal/utils/toFloatAsString";
 
 /**
  * Defines a new user variable with the given value.
@@ -34,14 +35,67 @@ import {ExpressionQualifier} from "../qualifiers/expression/ExpressionQualifier"
  * @summary action
  * @description Sets a new user variable with the given value.
  * @memberOf Actions.Variable
- * @param name Variable name
+ * @param {string} name Variable name
  * @param {number | string | number[] | string[]} value Variable value
  * @return {Actions.Variable.SetAction}
  */
 function set(name: string, value: number | string | number[] | string[] | ExpressionQualifier): SetAction {
+  if (Object.prototype.hasOwnProperty.call(value, 'push')) {
+    return new SetAction(name, value);
+  }
+
   return new SetAction(name, value);
 }
 
+/**
+ * @summary action
+ * @description Same as 'set', but forces the end value to be a float  setFloat(1) will result in $foo_1.0
+ * @memberOf Actions.Variable
+ * @param {string} name Variable name
+ * @param {number} value Variable value
+ * @return {Actions.Variable.SetAction}
+ */
+function setFloat(name: string, value: number): SetAction {
+  return new SetAction(name, toFloatAsString(value), '');
+}
+
+/**
+ * @summary action
+ * @description Same as 'set', but forces the end value to be an integer setInteger(1.1) will result in $foo_1, input is rounded down
+ * @memberOf Actions.Variable
+ * @param {string} name Variable name
+ * @param {number} value Variable value
+ * @return {Actions.Variable.SetAction}
+ */
+function setInteger(name: string, value: number): SetAction {
+  let val = value;
+  if (typeof value === 'string') {
+    val = parseInt(value);
+  }
+
+  if (isNaN(val)) {
+    val = 0;
+  }
+
+  return new SetAction(name, Math.round(val));
+}
+
+
+/**
+ * @summary action
+ * @description Same as 'set', but forces the end value to be a string setString(1) will result in $foo_!1!
+ * @memberOf Actions.Variable
+ * @param {string, number} name Variable name
+ * @param {number} value Variable value
+ * @return {Actions.Variable.SetAction}
+ */
+function setString(name: string, value: string | number): SetAction {
+  return new SetAction(name, value.toString());
+}
+
+
+
+
 /**
  * @summary action
  * @description Allows adding a variable by sending a key and value which is a reference to an asset.
@@ -82,12 +136,18 @@ function setFromMetadata(name: string, value: string): SetFromMetadataAction {
 
 const Variable = {
   set,
+  setFloat,
+  setString,
+  setInteger,
   setAssetReference,
   setFromContext,
   setFromMetadata
 };
 export {
   set,
+  setFloat,
+  setString,
+  setInteger,
   setAssetReference,
   setFromContext,
   setFromMetadata,

src/actions/variable/SetAction.ts

@@ -9,16 +9,22 @@ import {ExpressionQualifier} from "../../qualifiers/expression/ExpressionQualifi
  * @see Visit {@link Actions.Variable|Variable} for an example
  */
 class SetAction extends VariableAction {
-  constructor(name: string, value: number | string | string[] | number[] | ExpressionQualifier) {
-    const parsedValue = Array.isArray(value) ? value.join(':') : value;
+  constructor(name: string, value: number | string | string[] | number[] | ExpressionQualifier, wrapper = '!') {
+    let finalValue: string | number | ExpressionQualifier;
 
+    const parsedValue = Array.isArray(value) ? value.join(':') : value;
 
-    let finalValue: string | number | ExpressionQualifier;
     if (isString(parsedValue)) {
-      finalValue = `!${parsedValue
+      /*
+       * Encoding needed to make the Variable value Cloudinary Safe
+       * If a string, we also determine what wrapper is used (wrapper variable)
+       * The wrapper variable is needed because floats are passed as strings ('1.0') - in those case
+       * we don't need to treat them as URL strings ($foo_!1.0!), but instead as foo_1.0
+       */
+      finalValue = `${wrapper}${parsedValue
         .replace(/,/g, '%2C')
         .replace(/\//g, '%2F')
-        .replace(/!/g, '%21')}!`;
+        .replace(/!/g, '%21')}${wrapper}`;
     } else {
       finalValue = parsedValue;
     }