hyper-operation 0.5.0

data/lib/hyper-operation/railway.rb

@@ -0,0 +1,5 @@
+module Hyperloop
+  class Operation
+
+  end
+end

data/lib/hyper-operation/railway/dispatcher.rb

@@ -0,0 +1,31 @@
+module Hyperloop
+  class Operation
+    class Railway
+
+      def receivers
+        self.class.receivers
+      end
+
+      class << self
+        def receivers
+          @receivers ||= []
+        end
+
+        def add_receiver(&block)
+          receivers << block
+        end
+      end
+
+      def dispatch
+        result.then do
+          receivers.each do |receiver|
+            receiver.call(
+              self.class.params_wrapper.dispatch_params(@operation.params),
+              @operation
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyper-operation/railway/operation_wrapper.rb

@@ -0,0 +1,106 @@
+# module Hyperloop
+#   class Operation
+#     class Railway
+#
+#       class Exit < StandardError
+#         attr_reader :state
+#         attr_reader :result
+#         def initialize(state, result)
+#           @state = state
+#           @result = result
+#         end
+#       end
+#
+#       class << self
+#         def add_param(*args, &block)
+#           Hyperloop::Operation::ParamsWrapper.add_param(hash_filter, *args, &block)
+#         end
+#
+#         def add_validation(*args, &block)
+#           validations << [args, block]
+#         end
+#
+#         def add_error(param, symbol, message, *args, &block)
+#           add_validation do
+#             add_error(param, symbol, message) if call_block_with_context(args, block)
+#           end
+#         end
+#
+#         def add_step(*args, &block)
+#           railway << [:step, args, block]
+#         end
+#
+#         def add_failed(*args, &block)
+#           railway << [:failed, args, block]
+#         end
+# 
+#         def add_async(*args, &block)
+#           railway << [:async, args, block]
+#         end
+#
+#         def apply(op, state, result, args, block)
+#           if block.arity == 0
+#             [state, op.instance_eval &block]
+#           elsif result.is_a? Array && block.arity == result.count
+#             [state, op.instance_exec(*result, &block)]
+#           else
+#             [state, op.instance_exec(result, block)]
+#           end
+#         rescue Exception => e
+#           [:failed, e]
+#         end
+#
+#         def run(op)
+#           state = :success # or :failed if @errors
+#           result = nil
+#           railway.each do |tie|
+#             case tie[0]
+#             when :step
+#               if result.is_a? Promise
+#                 result = result.then { |*result| apply(op, :success, result, *tie[1..2]) }
+#               elsif state == :success
+#                 state, result = apply(op, state, result, tie[1], tie[2])
+#               end
+#             when :failed
+#               if result.is_a? Promise
+#                 result = result.fail { |*result| apply(op, :failed, result, *tie[1..2]) }
+#               elsif state == :failed
+#                 state, result = apply(op, state, result, tie[1], tie[2])
+#               end
+#             when :async
+#               state, result = apply(op, state, result, tie[1], tie[2]) if state != :failed
+#             end
+#           end
+#         rescue Hyperloop::Operation::Wrapper::Exit => e
+#           result, state = [e.result, e.state]
+#         ensure
+#           if result.is_a? Promise
+#             result
+#           elsif state == :failed
+#             Promise.new.reject(result)
+#           else
+#             Promise.new.resolve(result)
+#           end
+#         end
+#
+#
+#
+#
+# # THIS SHOULD BE ADDED ONLY IN ServerOps
+#         def dispatch_to(*args, &block)
+#           dispatches << [args, block]
+#         end
+#
+#         def hash_filter
+#           @hash_filter ||= Mutations::HashFilter.new
+#         end
+#
+#         def validations
+#           @validations ||= []
+#         end
+#
+#
+#
+#         def dispatches
+#           @dispatches ||= []
+#         end

data/lib/hyper-operation/railway/params_wrapper.rb

@@ -0,0 +1,124 @@
+module Hyperloop
+  class Operation
+    class ParamsWrapper
+
+      def initialize(inputs)
+        @inputs = inputs
+      end
+
+      def lock
+        @locked = true
+        self
+      end
+
+      def to_h
+        @inputs.with_indifferent_access
+      end
+
+      def to_s
+        to_h.to_s
+      end
+
+      class << self
+
+        def combine_arg_array(args)
+          hash = args.inject({}.with_indifferent_access) do |h, arg|
+            raise ArgumentError.new("All arguments must be hashes") unless arg.respond_to? :to_h
+            h.merge!(arg.to_h)
+          end
+        end
+
+        def process_params(operation, args)
+          raw_inputs = combine_arg_array(args)
+          inputs, errors = hash_filter.filter(raw_inputs)
+          params_wrapper = new(inputs)
+          operation.instance_eval do
+            @raw_inputs, @params, @errors = [raw_inputs, params_wrapper, errors]
+          end
+        end
+
+        def add_param(*args, &block)
+          type_method, name, opts, block = translate_args(*args, &block)
+          if opts.key? :default
+            hash_filter.optional { send(type_method, name, opts, &block) }
+          else
+            hash_filter.required { send(type_method, name, opts, &block) }
+          end
+
+          # don't forget specially handling for procs
+          define_method(name) do
+            @inputs[name]
+          end
+          define_method(:"#{name}=") do |x|
+            method_missing(:"#{name}=", x) if @locked
+            @inputs[name] = x
+          end
+        end
+
+        def dispatch_params(params, hashes = {})
+          params = params.dup
+          hashes.each { |hash| hash.each { |k, v| params.send(:"#{k}=", v) } }
+          params.lock
+        end
+
+        def hash_filter
+          @hash_filter ||= Mutations::HashFilter.new
+        end
+
+        def translate_args(*args, &block)
+          name, opts = get_name_and_opts(*args)
+          if opts.key?(:type)
+            type_method = opts.delete(:type)
+            if type_method.is_a?(Array)
+              opts[:class] = type_method.first if type_method.count > 0
+              type_method = Array
+            elsif type_method.is_a?(Hash) || type_method == Hash
+              type_method = Hash
+              block ||= proc { duck :* }
+            end
+            type_method = type_method.to_s.underscore
+          else
+            type_method = :duck
+          end
+          [type_method, name, opts, block || proc {}]
+        end
+
+        def get_name_and_opts(*args)
+          if args[0].is_a? Hash
+            opts = args[0]
+            name = opts.first.first
+            opts[:default] = opts.first.last
+            opts.delete(name)
+          else
+            name = args[0]
+            opts = args[1] || {}
+          end
+          [name, opts]
+        end
+      end
+    end
+
+    class Railway
+      def process_params(args)
+        self.class.params_wrapper.process_params(@operation, args)
+      end
+
+      def self.add_param(*args, &block)
+        params_wrapper.add_param(*args, &block)
+      end
+
+      def self.params_wrapper
+        @params_wrapper ||= begin
+          if Railway == superclass
+            Class.new(ParamsWrapper)
+          else
+            Class.new(superclass.params_wrapper).tap do |wrapper|
+              hash_filter = superclass.params_wrapper.hash_filter
+              wrapper.instance_variable_set('@hash_filter', hash_filter && hash_filter.dup)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyper-operation/railway/run.rb

@@ -0,0 +1,140 @@
+module Hyperloop
+  class Operation
+
+    class Exit < StandardError
+      attr_reader :state
+      attr_reader :result
+      def initialize(state, result)
+        @state = state
+        @result = result
+      end
+    end
+
+    class Railway
+
+      def tracks
+        self.class.tracks
+      end
+
+      class << self
+        def tracks
+          @tracks ||= []
+        end
+
+        def to_opts(tie, args, block)
+          if args.count.zero?
+            { run: block }
+          elsif args[0].is_a?(Hash)
+            {
+              scope: args[0][:class] ? :class : args[0][:scope],
+              run: args[0][:class] || args[0][:run] || block
+            }
+          elsif args[0] == :class && block
+            { run: block, scope: :class }
+          elsif args[0].is_a?(Class) && args[0] < Operation
+            { run: proc { args[0].run(params) } }
+          else
+            scope = args[1][:scope] if args[1].is_a? Hash
+            { run: args[0], scope: scope }
+          end.merge(tie: instance_method(tie))
+        end
+
+        [:step, :failed, :async].each do |tie|
+          define_method :"add_#{tie}" do |*args, &block|
+            tracks << to_opts(tie, args, block)
+          end
+        end
+
+        def abort!(arg)
+          raise Exit.new(:failed, arg)
+        end
+
+        def succeed!(arg)
+          raise Exit.new(:success, arg)
+        end
+      end
+
+      def step(opts)
+        if @last_result.is_a? Promise
+          @last_result = @last_result.then do |*result|
+            @last_result = result
+            apply(opts, :in_promise)
+          end
+        elsif @state == :success
+          apply(opts)
+        end
+      end
+
+      def failed(opts)
+        if @last_result.is_a? Promise
+          @last_result = @last_result.fail do |e|
+            @last_result = e
+            apply(opts, :in_promise)
+            raise @last_result if @last_result.is_a? Exception
+            raise e
+          end
+        elsif @state == :failed
+          apply(opts)
+        end
+      end
+
+      def async(opts)
+        apply(opts) if @state != :failed
+      end
+
+      def apply(opts, in_promise = nil)
+        if opts[:scope] == :class
+          args = [@operation, *@last_result]
+          instance = @operation.class
+        else
+          args = @last_result
+          instance = @operation
+        end
+        block = opts[:run]
+        block = instance.method(block) if block.is_a? Symbol
+        @last_result =
+          if block.arity.zero?
+            instance.instance_exec(&block)
+          elsif args.is_a?(Array) && block.arity == args.count
+            instance.instance_exec(*args, &block)
+          else
+            instance.instance_exec(args, &block)
+          end
+        return @last_result unless @last_result.is_a? Promise
+        raise @last_result.error if @last_result.rejected?
+        @last_result = @last_result.value if @last_result.resolved?
+        @last_result
+      rescue Exit => e
+        @state = e.state
+        @last_result = (e.state != :failed || e.result.is_a?(Exception)) ? e.result : e
+        raise e
+      rescue Exception => e
+        @state = :failed
+        @last_result = e
+        raise e if in_promise
+      end
+
+      def run
+        if @operation.has_errors? || @state
+          @last_result ||= ValidationException.new(@operation.instance_variable_get('@errors'))
+          return if @state  # handles abort out of validation
+          @state = :failed
+        else
+          @state = :success
+        end
+        tracks.each { |opts| opts[:tie].bind(self).call(opts) }
+      rescue Exit
+      end
+
+      def result
+        return @last_result if @last_result.is_a? Promise
+        @last_result =
+          if @state == :success
+            Promise.new.resolve(@last_result)
+          else
+            Promise.new.reject(@last_result)
+          end
+      end
+    end
+  end
+end

data/lib/hyper-operation/railway/validations.rb

@@ -0,0 +1,63 @@
+module Hyperloop
+  class Operation
+    class Railway
+
+      def validations
+        self.class.validations
+      end
+
+      def add_validation_error(i, e)
+        @operation.add_error("param validation #{i+1}", :validation_error, e.to_s)
+      end
+
+      class << self
+        def validations
+          @validations ||= []
+        end
+
+        def add_validation(*args, &block)
+          block = args[0] if args[0]
+          validations << block
+        end
+
+        def add_error(param, symbol, message, *args, &block)
+          add_validation do
+            begin
+              add_error(param, symbol, message) if instance_eval(&block)
+            rescue Exit => e
+              raise e unless e.state == :failed
+              add_error(param, symbol, message)
+              raise Exit.new(:abort_from_add_error, e.result)
+            end
+          end
+        end
+      end
+
+      def process_validations
+        validations.each_with_index do |validator, i|
+          begin
+            validator = @operation.method(validator) if validator.is_a? Symbol
+            next if @operation.instance_exec(&validator)
+            add_validation_error(i, "param validation #{i+1} failed")
+          rescue Exit => e
+            case e.state
+            when :success
+              add_validation_error(i, "illegal use of succeed! in validation")
+            when :failed
+              add_validation_error(i, "param validation #{i+1} aborted")
+            end
+            @state = :failed
+            return # break does not work in Opal
+          rescue AccessViolation => e
+            add_validation_error(i, e)
+            @state = :failed
+            @last_result = e
+            return # break does not work in Opal
+          rescue Exception => e
+            add_validation_error(i, e)
+          end
+        end
+      end
+    end
+  end
+end