states-dsl 0.1.0

data/lib/states/dsl/condition_group.rb

@@ -0,0 +1,22 @@
+module States
+  module Dsl
+    class ConditionGroup < Choice
+      def initialize(type, naming)
+        super(naming)
+        @type = type
+        @parts = []
+      end
+
+      def variable(path, &block)
+        c = VariableConditionPart.new(path)
+        c.instance_eval(&block)
+        @parts << c
+        c
+      end
+
+      def serializable_hash
+        { @type => @parts.map(&:serializable_hash) }.merge(super)
+      end
+    end
+  end
+end

data/lib/states/dsl/context.rb

@@ -0,0 +1,47 @@
+module States
+  module Dsl
+    class Context
+      attr_accessor :naming, :traits, :resource_defaults
+
+      def initialize(options={})
+        @traits = {}
+        @naming = Naming.new(nil)
+        @naming.converter = options[:name_converter]
+        @resource_defaults = options[:resource] || {}
+      end
+
+      def create_sub_context(options={})
+        sub = Context.new
+        sub.traits = traits
+
+        sub.resource_defaults = resource_defaults
+        if defaults = options[:resource]
+          sub.resource_defaults = defaults
+        end
+
+        sub.naming = Naming.new(naming)
+        if converter = options[:name_converter]
+          sub.naming.converter = converter
+        end
+        sub
+      end
+
+      def register_trait(name, trait)
+        trait.context = self
+        @traits[name] = trait
+      end
+
+      def lookup_traits(names)
+        names.map { |nm| traits[nm] }
+      end
+
+      def function_resource(name)
+        ResourceLookup.new(resource_defaults).function(name)
+      end
+
+      def activity_resource(name)
+        ResourceLookup.new(resource_defaults).activity(name)
+      end
+    end
+  end
+end

data/lib/states/dsl/error_support.rb

@@ -0,0 +1,10 @@
+module States
+  module Dsl
+    module ErrorSupport
+      protected
+      def ensure_errors_array(arr)
+        [arr].flatten.map { |exc| exc == :all ? "States.ALL" : exc }
+      end
+    end
+  end
+end

data/lib/states/dsl/execution_context.rb

@@ -0,0 +1,39 @@
+module States
+  module Dsl
+    class ExecutionContext
+      attr_reader :context
+      attr_reader :resource_defaults
+
+      def initialize(context, options)
+        @context = if context.nil?
+          Context.new(options)
+        else
+          context.create_sub_context
+        end
+        if start_at = options[:start_at]
+          @start_at = @context.naming.ref(start_at)
+        end
+        @states = []
+      end
+
+      def state(name, options={}, &block)
+        state = State.new(name, @context, options)
+        state.instance_eval(&block) if block
+        @states << state
+        state
+      end
+
+      def start(name, options={}, &block)
+        @start_at = @context.naming.ref(name)
+        state(name, options, &block)
+      end
+
+      def serializable_hash
+        {
+          "StartAt" => @start_at,
+          "States" => @states.reduce({}) { |m,s| m[s.name.to_s] = s.serializable_hash; m }
+        }
+      end
+    end
+  end
+end

data/lib/states/dsl/fail.rb

@@ -0,0 +1,24 @@
+module States
+  module Dsl
+    class Fail
+      def initialize(error=nil,cause=nil)
+        @error, @cause = error, cause
+      end
+
+      def error(err)
+        @error = err
+      end
+
+      def cause(cause)
+        @cause = cause
+      end
+
+      def serializable_hash
+        h = {}
+        h["Error"] = @error if @error
+        h["Cause"] = @cause if @cause
+        h
+      end
+    end
+  end
+end

data/lib/states/dsl/namespace.rb

@@ -0,0 +1,22 @@
+module States
+  module Dsl
+    class Namespace
+      def initialize
+        @source = {}
+        @plurals = {}
+      end
+
+      def resolve(name)
+        if usages = @source[name.local_name]
+          if usages.length == 1
+            usages[0].index = 0
+          end
+          name.index = usages.length
+          usages << name
+        else
+          @source[name.local_name] = [name]
+        end
+      end
+    end
+  end
+end

data/lib/states/dsl/naming.rb

@@ -0,0 +1,66 @@
+module States
+  module Dsl
+    class Naming
+      attr_accessor :converter
+
+      attr_reader :parent
+      attr_reader :namespace
+      attr_reader :children
+      attr_reader :names
+
+      def initialize(parent)
+        @parent = parent
+        @names = []
+        @references = []
+        @children = []
+        if parent
+          @namespace = parent.namespace
+          if parent.converter
+            self.converter = parent.converter
+          end
+          parent.children << self
+        else
+          @namespace = Namespace.new
+        end
+      end
+
+      def <<(name)
+        nm = StateName.new(name, self)
+        @names << nm
+        nm
+      end
+
+      def ref(name)
+        ref = StateReference.new(name, self)
+        @references << ref
+        ref
+      end
+
+      def convert(str)
+        if converter
+          converter.call(str)
+        else
+          str
+        end
+      end
+
+      def resolve
+        return if @resolved
+        if parent
+          parent.resolve
+        else
+          resolve_children
+        end
+      end
+
+      def resolve_children
+        @names.each { |name| @namespace.resolve(name) }
+        @references.each do |ref|
+          ref.resolved_to = @names.detect { |nm| nm.local_name == ref.name }
+        end
+        @children.each(&:resolve_children)
+        @resolved = true
+      end
+    end
+  end
+end

data/lib/states/dsl/parallel.rb

@@ -0,0 +1,21 @@
+module States
+  module Dsl
+    class Parallel
+      def initialize(context)
+        @context = context
+        @branches = []
+      end
+
+      def branch(options={}, &block)
+        branch = ExecutionContext.new(@context, options)
+        branch.instance_eval(&block)
+        @branches << branch
+        branch
+      end
+
+      def serializable_hash
+        { "Branches" => @branches.map(&:serializable_hash) }
+      end
+    end
+  end
+end

data/lib/states/dsl/resource_lookup.rb

@@ -0,0 +1,30 @@
+module States
+  module Dsl
+    class ResourceLookup
+      attr_reader :params
+
+      def initialize(defaults)
+        @defaults = defaults
+        @params = {}
+      end
+
+      def function(name)
+        resource(name, :function, :lambda)
+      end
+
+      def activity(name)
+        resource(name, :activity, :states)
+      end
+
+      def resource(name, type, service, options={})
+        @params = options.merge(name: name, type: type, service: service)
+        self
+      end
+
+      def to_s
+        values = {partition: "aws"}.merge(@defaults).merge(params)
+        ["arn", values[:partition], values[:service], values[:region], values[:account], values[:type], values[:name]].join(":")
+      end
+    end
+  end
+end

data/lib/states/dsl/retry.rb

@@ -0,0 +1,39 @@
+module States
+  module Dsl
+    class Retry
+      include States::Dsl::ErrorSupport
+
+      def initialize(*arguments)
+        options = arguments.last.is_a?(Hash) ? arguments.pop : {}
+        @error_equals = if arguments.length > 0
+          ensure_errors_array(arguments.first)
+        else
+          ensure_errors_array(options[:error_equals])
+        end
+        @max_attempts = options[:max_attempts]
+        @backoff_rate = options[:backoff_rate]
+        @interval_seconds = options[:interval_seconds]
+      end
+
+      def max_attempts(n)
+        @max_attempts = n
+      end
+
+      def backoff_rate(r)
+        @backoff_rate = r
+      end
+
+      def interval_seconds(s)
+        @interval_seconds = s
+      end
+
+      def serializable_hash
+        h = { "ErrorEquals" => @error_equals }
+        h["MaxAttempts"] = @max_attempts if @max_attempts
+        h["BackoffRate"] = @backoff_rate if @backoff_rate
+        h["IntervalSeconds"] = @interval_seconds if @interval_seconds
+        h
+      end
+    end
+  end
+end

data/lib/states/dsl/state.rb

@@ -0,0 +1,22 @@
+module States
+  module Dsl
+    class State < StateLike
+      attr_reader :name
+
+      def initialize(name, context, options={})
+        super(options)
+        @name = context.naming << name
+        self.context = context
+      end
+
+      def serializable_hash
+        json = super
+        json["Type"] ||= "Pass"
+        if json["Next"].nil? && !%w(Choice Fail).include?(json["Type"])
+          json["End"] = true
+        end
+        json
+      end
+    end
+  end
+end

data/lib/states/dsl/state_like.rb

@@ -0,0 +1,127 @@
+module States
+  module Dsl
+    class StateLike
+      UNSET = Object.new
+
+      attr_accessor :context
+
+      def initialize(options={})
+        @traits = options[:traits] || []
+        @result_path = @output_path = @input_path = UNSET
+        @retries = []
+        @catches = []
+      end
+
+      def function(name)
+        resource(context.function_resource(name))
+      end
+
+      def activity(name)
+        resource(context.activity_resource(name))
+      end
+
+      def resource(arn)
+        @resource = arn
+      end
+
+      def result_path(path)
+        @result_path = path
+      end
+
+      def output_path(path)
+        @output_path = path
+      end
+
+      def input_path(path)
+        @input_path = path
+      end
+
+      def next_state(state)
+        @next_state = context.naming.ref(state)
+      end
+
+      def parallel(&block)
+        @parallel = Parallel.new(@context)
+        @parallel.instance_eval(&block)
+        @parallel
+      end
+
+      def choices(&block)
+        @choices = Choices.new(@context.naming)
+        @choices.instance_eval(&block)
+        @choices
+      end
+
+      def wait(&block)
+        @wait = Wait.new(@context.naming)
+        @wait.instance_eval(&block)
+        @wait
+      end
+
+      def fail(&block)
+        @fail = Fail.new
+        @fail.instance_eval(&block)
+        @fail
+      end
+
+      def retry_if(*arguments, &block)
+        _retry = Retry.new(*arguments)
+        if block_given?
+          _retry.instance_eval(&block)
+        end
+        @retries << _retry
+      end
+
+      def catch_if(options={}, &block)
+        katch = Catch.new(context, options)
+        if block_given?
+          katch.instance_eval(&block)
+        end
+        @catches << katch
+      end
+
+      def serializable_hash
+        j = context.lookup_traits(@traits).reduce({}) { |m, t| m.merge(t.serializable_hash) }
+        if @resource
+          j["Type"] = "Task"
+          j["Resource"] = @resource.to_s
+
+        elsif @parallel
+          j["Type"] = "Parallel"
+          j.merge!(@parallel.serializable_hash)
+
+        elsif @choices
+          j["Type"] = "Choice"
+          j.merge!(@choices.serializable_hash)
+
+        elsif @wait
+          j["Type"] = "Wait"
+          j.merge!(@wait.serializable_hash)
+
+        elsif @fail
+          j["Type"] = "Fail"
+          j.merge!(@fail.serializable_hash)
+        end
+
+        [
+          [@result_path, "ResultPath"],
+          [@input_path , "InputPath" ],
+          [@output_path, "OutputPath"],
+        ].each { |(k,v)| j[v] = k if k != UNSET }
+
+        unless @retries.empty?
+          j["Retry"] = @retries.map(&:serializable_hash)
+        end
+
+        unless @catches.empty?
+          j["Catch"] = @catches.map(&:serializable_hash)
+        end
+
+        if @next_state
+          j["Next"] = @next_state.to_s
+        end
+        j
+      end
+    end
+  end
+end