simple_service 1.4.1 → 2.1.0

data/lib/simple_service/command.rb

@@ -1,28 +0,0 @@
-module SimpleService
-  class Command
-
-    include ServiceBase::InstanceMethods
-    extend ServiceBase::ClassMethods
-
-    attr_accessor :context
-
-    def initialize(context={})
-      @context = context
-      setup_call_chain
-      define_getters_and_setters
-
-      unless skip_validation
-        ValidatesExpectedKeys.new(provided_keys: context.keys).call
-      end
-    end
-
-    # call is where the command's behavior is defined
-    # call should be overriden by whatever class inherits from
-    # this class
-    def call
-      error_msg = "#{self.class} - does not define a call method"
-      raise SimpleService::CallNotDefinedError , error_msg
-    end
-
-  end
-end

data/lib/simple_service/commands/validates_commands_not_empty.rb

@@ -1,16 +0,0 @@
-module SimpleService
-  class ValidatesCommandsNotEmpty < Command
-
-    expects :provided_commands
-
-    skip_validation true # prevent infinite loop
-
-    def call
-      if provided_commands.nil? || provided_commands.empty?
-        error_msg = 'This Organizer class does not contain any command definitions'
-        raise SimpleService::OrganizerCommandsNotDefinedError, error_msg
-      end
-    end
-
-  end
-end

data/lib/simple_service/commands/validates_commands_properly_inherit.rb

@@ -1,24 +0,0 @@
-module SimpleService
-  class ValidatesCommandsProperlyInherit < Command
-
-    expects :provided_commands
-
-    skip_validation true # prevent infinite loop
-
-    def call
-      # valid commands inherit from Command and do not inherit from service
-      # reject all valid commands and anything left over is invalid
-      invalid_commands = provided_commands.to_a.reject do |command|
-        command.ancestors.include?(SimpleService::Command) ||
-        command.ancestors.include?(SimpleService::Organizer)
-      end
-
-      if invalid_commands.any?
-        error_msg = invalid_commands.join(', ') +
-          ' - must inherit from SimpleService::Command'
-        raise SimpleService::CommandParentClassInvalidError, error_msg
-      end
-    end
-
-  end
-end

data/lib/simple_service/commands/validates_expected_keys.rb

@@ -1,19 +0,0 @@
-module SimpleService
-  class ValidatesExpectedKeys < Command
-
-    expects :expected_keys, :provided_keys
-
-    skip_validation true # prevent infinite loop
-
-    def call
-      arguments_not_included = expected_keys.to_a - provided_keys.to_a
-
-      if arguments_not_included.any?
-        error_msg = 'keys required by the organizer but not found in the context: ' +
-          arguments_not_included.join(', ')
-        raise ExpectedKeyError, error_msg
-      end
-    end
-
-  end
-end

data/lib/simple_service/context.rb

@@ -1,32 +0,0 @@
-module SimpleService
-
-  # TODO: move context logic here?
-  module Context
-
-    def success?
-
-    end
-
-    def success!
-
-    end
-
-    def failure?
-
-    end
-
-    def failure!
-
-    end
-
-    def update_getters_and_setters
-
-    end
-
-    def prune!(*keys)
-
-    end
-
-  end
-
-end

data/lib/simple_service/ensure_organizer_is_valid.rb

@@ -1,22 +0,0 @@
-module SimpleService
-  class EnsureOrganizerIsValid < Organizer
-
-    expects :expected_keys, :provided_keys, :provided_commands
-
-    # makes sure validtion is only done once, prevents an infinite loop
-    skip_validation true
-
-    commands ValidatesExpectedKeys,
-             ValidatesCommandsNotEmpty,
-             ValidatesCommandsProperlyInherit
-
-    def call
-      super
-
-      # dont return the keys within this internal service
-      # so we dont pollute external service objects
-      context.select { |k,v| !expects.include?(k) }
-    end
-
-  end
-end

data/lib/simple_service/exceptions.rb

@@ -1,10 +0,0 @@
-module SimpleService
-
-  class OrganizerCommandsNotDefinedError < StandardError; end;
-  class CommandParentClassInvalidError < StandardError; end;
-  class ExpectedKeyError < StandardError; end;
-  class CallNotDefinedError < StandardError; end;
-  class ReturnKeyError < StandardError; end;
-  class InvalidArgumentError < StandardError; end;
-
-end

data/lib/simple_service/organizer.rb

@@ -1,113 +0,0 @@
-module SimpleService
-  class Organizer
-
-    include ServiceBase::InstanceMethods
-    extend ServiceBase::ClassMethods
-
-    attr_accessor :context
-
-    def initialize(_context = {})
-      @context = validate_context(_context)
-
-      symbolize_context_keys
-      setup_call_chain
-      define_getters_and_setters
-    end
-
-    def self.commands(*args)
-      @commands = args
-    end
-
-    def commands
-      self.class.instance_variable_get('@commands')
-    end
-
-    def call
-      # underscores used to disambiguate local vars from methods with the same name
-      with_validation do |_commands|
-        _commands.each do |command|
-
-          # halt further command calls if success has been set to false
-          # in a previously called command or halt is set
-          break if context[:success] == false || context[:halt] == true
-
-          # if command class defines "expects" then only feed the command
-          # those keys, otherwise just give it the entire context
-          _context = if command.get_expects.any?
-            {}.tap do |c|
-              command.get_expects.each {|key| c[key] = context[key] }
-            end
-          else
-            context
-          end
-
-          # also merge any optional keys
-          command.get_optional.each do |key|
-            _context[key] = context[key]
-          end
-
-          # instantiate and call the command
-          resulting_context = command.new(_context).call
-
-          # update the master context with the results of the command
-          @context.merge!(resulting_context)
-        end
-      end
-    end
-
-    # allow execution of the service from the class level for those
-    # that prefer that style
-    def self.call(context = {})
-      self.new(context).call
-    end
-
-    private
-
-    def validate_context(_context)
-      unless _context.class == Hash
-        raise InvalidArgumentError,
-          "Hash required as argument, but was given a #{_context.class}"
-      end
-
-      _context
-    end
-
-    def with_validation
-      # don't mess with the context if we are doing internal validation
-      add_validation_keys_to_context unless skip_validation
-
-      # ensure that the organizer and commands are setup correctly
-      # by injecting an internal service organizer into the stack of
-      # commands to be executed. Only include this if skip_validation is
-      # not set. Since both user defined and internal services use this code
-      # the skip_validation avoids an infinite loop
-      _commands = skip_validation ? commands : [EnsureOrganizerIsValid] + commands
-
-      yield(_commands)
-
-      # cleanup context keys that are used by the validation so the final
-      # return is clean even if the user does not define "returns" in their
-      # organizer
-      remove_validation_keys_from_context unless skip_validation
-    end
-
-    def add_validation_keys_to_context
-      context.merge!(validation_hash)
-    end
-
-    def remove_validation_keys_from_context
-      validation_hash.keys.each do |key|
-        context.delete(key)
-      end
-    end
-
-    def validation_hash
-      @validation_hash ||= {
-        provided_keys: context.keys,
-        expected_keys: expects,
-        provided_commands: commands
-      }
-    end
-  end
-
-end

data/lib/simple_service/service_base.rb

@@ -1,169 +0,0 @@
-module SimpleService
-  module ServiceBase
-
-    module ClassMethods
-      def expects(*args)
-        @expects = args
-      end
-
-      def get_expects
-        @expects || []
-      end
-
-      def optional(*args)
-        @optional = args
-      end
-
-      def get_optional
-        @optional || []
-      end
-
-      def returns(*args)
-        @returns = args
-      end
-
-      def get_returns
-        @returns || []
-      end
-
-      def skip_validation(skip=true)
-        @skip_validation = skip
-      end
-
-      # allow execution of the service or commands from the
-      # class level for those that prefer that style
-      def call(context = {})
-        new(context).call
-      end
-
-    end
-
-    module InstanceMethods
-
-      def failed?
-        !successful?
-      end
-
-      def halted?
-        context.has_key?(:halt) || context[:halt] == true
-      end
-
-      def successful?
-        !context.has_key?(:success) || context[:success] == true
-      end
-
-      # sets up an "after" filter for #call
-      #
-      # allows user to implement #call in their individual
-      # command and organizer # classes without having to
-      # rely on super or executing another other method
-      # to do post #call housekeeping such as returning
-      # only specific context keys
-      def setup_call_chain
-        self.class.class_eval do
-
-          # grab the method object and hold onto it here
-          call_method = instance_method(:call)
-
-          # redefine the call method, execute the existing call method object,
-          # and then run return key checking...
-          define_method :call do
-            call_method.bind(self).call
-            return_context_with_success_status
-          end
-        end
-      end
-
-      def symbolize_context_keys
-        context.keys.each do |key|
-          context[key.to_sym] = context.delete(key)
-        end
-      end
-
-      def return_context_with_success_status
-        _context = find_specified_return_keys
-
-        # only automatically set context[:success] on Organizers and only if its not already set
-        # by a command calling #failure!
-        if !_context.has_key?(:success) && organizer?
-          _context[:success] = true
-        end
-
-        _context
-      end
-
-      def find_specified_return_keys
-        if returns.nil? || returns.empty? || failed? || halted?
-          context
-        else
-          returns.inject({}) do |to_return, return_param|
-            if context.has_key?(return_param)
-              to_return[return_param] = context[return_param]
-            else
-              error_msg = "#{self.class} tried to return #{return_param}, but it did not exist in the context: #{context.inspect}"
-              raise ReturnKeyError, error_msg
-            end
-
-            to_return
-          end
-        end
-      end
-
-      def expects
-        self.class.get_expects
-      end
-
-      def optional
-        self.class.get_optional
-      end
-
-      def returns
-        self.class.get_returns
-      end
-
-      def skip_validation
-        self.class.instance_variable_get('@skip_validation')
-      end
-
-      def all_context_keys
-        (expects + optional + returns + ['message', 'success']).uniq
-      end
-
-      def organizer?
-        self.class.ancestors.include?(SimpleService::Organizer)
-      end
-
-      def failure!(message = nil)
-        context[:success] = false
-        context[:halt] = true
-        context[:message] = message || 'There was a problem'
-      end
-
-      def success!(message = nil)
-        context[:success] = true
-        context[:halt] = true
-        context[:message] = message || 'Success! Returned early'
-      end
-
-      def define_getters_and_setters
-        all_context_keys.each do |key|
-          self.class.class_eval do
-
-            # getter
-            define_method key do
-              self.context[key]
-            end
-
-            # setter
-            define_method "#{key}=" do |val|
-              self.context[key] = val
-            end
-
-          end
-        end
-      end
-
-    end
-
-  end
-end