[WIP] Add Intrinsic Functions

lib/floe.rb

@@ -13,6 +13,8 @@
 require_relative "floe/workflow/choice_rule/and"
 require_relative "floe/workflow/choice_rule/data"
 require_relative "floe/workflow/context"
+require_relative "floe/workflow/intrinsic_function"
+require_relative "floe/workflow/intrinsic_functions/states/string_to_json"
 require_relative "floe/workflow/path"
 require_relative "floe/workflow/payload_template"
 require_relative "floe/workflow/reference_path"

lib/floe/workflow/intrinsic_function.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class IntrinsicFunction
+      INTRINSIC_FUNCTION_REGEX = /^(?<module>\w+)\.(?<function>\w+)\((?<args>.*)\)$/.freeze
+
+      class << self
+        def new(*args)
+          if self == Floe::Workflow::IntrinsicFunction
+            detect_class(*args).new(*args)
+          else
+            super
+          end
+        end
+
+        private def detect_class(payload)
+          function_module_name, function_name =
+            payload.match(INTRINSIC_FUNCTION_REGEX)
+                   .named_captures
+                   .values_at("module", "function")
+
+          begin
+            function_module = Floe::Workflow::IntrinsicFunctions.const_get(function_module_name)
+            function_module.const_get(function_name)
+          rescue NameError
+            raise NotImplementedError, "#{function_module_name}.#{function_name} is not implemented"
+          end
+        end
+
+        def value(payload, context, input = {})
+          new(payload).value(context, input)
+        end
+      end
+
+      attr_reader :args
+
+      def initialize(payload)
+        args  = payload.match(INTRINSIC_FUNCTION_REGEX).named_captures["args"]
+        @args = args.split(", ").map do |arg|
+          if arg.start_with?("$.")
+            Path.new(arg)
+          elsif arg.match?(INTRINSIC_FUNCTION_REGEX)
+            Floe::Workflow::IntrinsicFunction.new(arg)
+          else
+            arg
+          end
+        end
+      end
+
+      def value(_context, _inputs)
+        raise NotImplementedError, "must be implemented in a subclass"
+      end
+    end
+  end
+end

lib/floe/workflow/intrinsic_functions/states/string_to_json.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    module IntrinsicFunctions
+      module States
+        class StringToJson < Floe::Workflow::IntrinsicFunction
+          def value(context, inputs)
+            arg = args.first
+            arg = arg.value(context, inputs) if arg.respond_to?(:value)
+
+            JSON.parse(arg)
+          end
+        end
+      end
+    end
+  end
+end

lib/floe/workflow/payload_template.rb

@@ -44,14 +44,20 @@ def parse_payload_hash(value)
       end
 
       def parse_payload_string(value)
-        value.start_with?("$") ? Path.new(value) : value
+        if value.start_with?("$")
+          Path.new(value)
+        elsif value.match?(/^\w+\.\w+\(.+\)$/)
+          IntrinsicFunction.new(value)
+        else
+          value
+        end
       end
 
       def interpolate_value(value, context, inputs)
         case value
         when Array then interpolate_value_array(value, context, inputs)
         when Hash  then interpolate_value_hash(value, context, inputs)
-        when Path  then value.value(context, inputs)
+        when Path, IntrinsicFunction then value.value(context, inputs)
         else
           value
         end

spec/workflow/intrinsic_function_spec.rb

@@ -0,0 +1,51 @@
+RSpec.describe Floe::Workflow::IntrinsicFunction do
+  describe "#initialize" do
+    let(:payload) { "States.StringToJson()" }
+
+    it "returns an instance of the intrinsic function" do
+      expect(described_class.new(payload)).to be_kind_of(Floe::Workflow::IntrinsicFunctions::States::StringToJson)
+    end
+
+    context "with an invalid intrinsic function" do
+      let(:payload) { "States.MyFirstFunction()" }
+
+      it "raises an exception for an invalid intrinsic function" do
+        expect { described_class.new(payload) }.to raise_error(NotImplementedError)
+      end
+    end
+
+    context "with no arguments" do
+      it "parses args as empty" do
+        function = described_class.new(payload)
+        expect(function.args).to be_empty
+      end
+    end
+
+    context "with a string arguments" do
+      let(:payload) { "States.StringToJson(foobar)" }
+
+      it "parses the arguments" do
+        function = described_class.new(payload)
+        expect(function.args).to eq(["foobar"])
+      end
+    end
+
+    context "with a Path" do
+      let(:payload) { "States.StringToJson($.someString)" }
+
+      it "parses the arguments" do
+        function = described_class.new(payload)
+        expect(function.args.first).to be_kind_of(Floe::Workflow::Path)
+      end
+    end
+
+    context "with an IntrinsicFunction" do
+      let(:payload) { "States.StringToJson(States.StringToJson($.someString))" }
+
+      it "parses the arguments" do
+        function = described_class.new(payload)
+        expect(function.args.first).to be_kind_of(Floe::Workflow::IntrinsicFunction)
+      end
+    end
+  end
+end

spec/workflow/payload_template_spec.rb

@@ -38,5 +38,17 @@
         expect(subject.value(context, inputs)).to eq({"foo" => ["bar", "baz"], "bar" => {"hello" => "world"}})
       end
     end
+
+    context "with intrinsic functions" do
+      context "States.StringToJson" do
+        let(:context) { {} }
+        let(:payload) { {"foo.$" => "States.StringToJson($.someString)"} }
+        let(:inputs)  { {"someString" => "{\"number\": 20}"} }
+
+        it "sets foo to the parsed JSON from inputs" do
+          expect(subject.value(context, inputs)).to eq({"foo" => {"number" => 20}})
+        end
+      end
+    end
   end
 end