light-service 0.6.0 → 0.6.1

data/lib/light-service.rb

@@ -1,6 +1,6 @@
 require 'logger'
 
-require "light-service/version"
+require 'light-service/version'
 
 require 'light-service/errors'
 require 'light-service/configuration'

data/lib/light-service/action.rb

@@ -1,12 +1,13 @@
 module LightService
   module Action
-
     def self.extended(base_class)
       base_class.extend Macros
     end
 
     def self.included(base_class)
-      ActiveSupport::Deprecation.warn "including LightService::Action is deprecated. Please use `extend LightService::Action` instead"
+      msg = "including LightService::Action is deprecated. " \
+            "Please use `extend LightService::Action` instead"
+      ActiveSupport::Deprecation.warn(msg)
       base_class.extend Macros
     end
 
@@ -46,22 +47,20 @@ module LightService
       end
 
       def rolled_back
-        raise "`rolled_back` macro can not be invoked again" if self.respond_to?(:rollback)
+        msg = "`rolled_back` macro can not be invoked again"
+        fail msg if respond_to?(:rollback)
 
         define_singleton_method :rollback do |context = {}|
           yield(context)
 
           context
         end
-
       end
 
       private
 
       def create_action_context(context)
-        if context.is_a? LightService::Context
-          return context
-        end
+        return context if context.is_a? LightService::Context
 
         LightService::Context.make(context)
       end
@@ -70,6 +69,5 @@ module LightService
         expected_keys + promised_keys
       end
     end
-
   end
 end

data/lib/light-service/configuration.rb

@@ -1,6 +1,5 @@
 module LightService
   class Configuration
-
     class << self
       attr_writer :logger, :localization_adapter
 
@@ -20,6 +19,5 @@ module LightService
         logger
       end
     end
-
   end
 end

data/lib/light-service/context.rb

@@ -7,28 +7,32 @@ module LightService
   class Context < Hash
     attr_accessor :message, :error_code, :current_action
 
-    def initialize(context={}, outcome=Outcomes::SUCCESS, message='', error_code=nil)
-      @outcome, @message, @error_code = outcome, message, error_code
+    def initialize(context = {},
+                   outcome = Outcomes::SUCCESS,
+                   message = '',
+                   error_code = nil)
+      @outcome = outcome
+      @message = message
+      @error_code = error_code
       @skip_all = false
-      context.to_hash.each {|k,v| self[k] = v}
+      context.to_hash.each { |k, v| self[k] = v }
       self
     end
 
-    def self.make(context={})
-      unless context.is_a? Hash or context.is_a? LightService::Context
-        raise ArgumentError, 'Argument must be Hash or LightService::Context'
+    def self.make(context = {})
+      unless context.is_a?(Hash) || context.is_a?(LightService::Context)
+        msg = 'Argument must be Hash or LightService::Context'
+        fail ArgumentError, msg
       end
 
-      unless context.is_a?(Context)
-        context = self.new(context)
-      end
+      context = new(context) unless context.is_a?(Context)
 
-      context.set_aliases(context.delete(:_aliases)) if context[:_aliases]
+      context.assign_aliases(context.delete(:_aliases)) if context[:_aliases]
       context
     end
 
     def add_to_context(values)
-      self.merge! values
+      merge! values
     end
 
     def success?
@@ -44,16 +48,20 @@ module LightService
     end
 
     def outcome
-      ActiveSupport::Deprecation.warn '`Context#outcome` attribute reader is DEPRECATED and will be removed'
+      msg = '`Context#outcome` attribute reader is ' \
+            'DEPRECATED and will be removed'
+      ActiveSupport::Deprecation.warn(msg)
       @outcome
     end
 
-    def succeed!(message=nil, options={})
-      @message = Configuration.localization_adapter.success(message, current_action, options)
+    def succeed!(message = nil, options = {})
+      @message = Configuration.localization_adapter.success(message,
+                                                            current_action,
+                                                            options)
       @outcome = Outcomes::SUCCESS
     end
 
-    def fail!(message=nil, options_or_error_code={})
+    def fail!(message = nil, options_or_error_code = {})
       options_or_error_code ||= {}
 
       if options_or_error_code.is_a?(Hash)
@@ -64,17 +72,19 @@ module LightService
         options = {}
       end
 
-      @message = Configuration.localization_adapter.failure(message, current_action, options)
+      @message = Configuration.localization_adapter.failure(message,
+                                                            current_action,
+                                                            options)
       @error_code = error_code
       @outcome = Outcomes::FAILURE
     end
 
-    def fail_with_rollback!(message=nil, error_code=nil)
+    def fail_with_rollback!(message = nil, error_code = nil)
       fail!(message, error_code)
-      raise FailWithRollbackError.new
+      fail(FailWithRollbackError)
     end
 
-    def skip_all!(message=nil)
+    def skip_all!(message = nil)
       @message = message
       @skip_all = true
     end
@@ -86,13 +96,13 @@ module LightService
     def define_accessor_methods_for_keys(keys)
       return if keys.nil?
       keys.each do |key|
-        next if self.respond_to?(key.to_sym)
-        define_singleton_method("#{key}") { self.fetch(key) }
+        next if respond_to?(key.to_sym)
+        define_singleton_method(key.to_s) { fetch(key) }
         define_singleton_method("#{key}=") { |value| self[key] = value }
       end
     end
 
-    def set_aliases(aliases)
+    def assign_aliases(aliases)
       @aliases = aliases
 
       aliases.each_pair do |key, key_alias|

data/lib/light-service/context/key_verifier.rb

@@ -1,114 +1,118 @@
-module LightService; class Context
-  class KeyVerifier
-    attr_reader :context, :action
+module LightService
+  class Context
+    class KeyVerifier
+      attr_reader :context, :action
+
+      def initialize(context, action)
+        @context = context
+        @action = action
+      end
 
-    def initialize(context, action)
-      @context = context
-      @action = action
-    end
+      def are_all_keys_in_context?(keys)
+        not_found_keys = keys_not_found(keys)
+        !not_found_keys.any?
+      end
 
-    def are_all_keys_in_context?(keys)
-      not_found_keys = keys_not_found(keys)
-      !not_found_keys.any?
-    end
+      def keys_not_found(keys)
+        keys ||= context.keys
+        keys - context.keys
+      end
 
-    def keys_not_found(keys)
-      keys ||= context.keys
-      keys - context.keys
-    end
+      def format_keys(keys)
+        keys.map { |k| ":#{k}" }.join(', ')
+      end
 
-    def format_keys(keys)
-      keys.map { |k| ":#{k}"}.join(', ')
-    end
+      def error_message
+        "#{type_name} #{format_keys(keys_not_found(keys))} " \
+        "to be in the context during #{action}"
+      end
 
-    def error_message
-      "#{type_name} #{format_keys(keys_not_found(keys))} to be in the context during #{action}"
-    end
+      def throw_error_predicate(_keys)
+        fail NotImplementedError, 'Sorry, you have to override length'
+      end
 
-    def throw_error_predicate(keys)
-      raise NotImplementedError, 'Sorry, you have to override length'
-    end
+      def verify
+        return context if context.failure?
 
-    def verify
-      return context if context.failure?
+        if throw_error_predicate(keys)
+          Configuration.logger.error error_message
+          fail error_to_throw, error_message
+        end
 
-      if throw_error_predicate(keys)
-        Configuration.logger.error error_message
-        fail error_to_throw, error_message
+        context
       end
 
-      context
-    end
-
-    def self.verify_keys(context, action, &block)
-      ReservedKeysVerifier.new(context, action).verify
-      ExpectedKeyVerifier.new(context, action).verify
+      def self.verify_keys(context, action, &block)
+        ReservedKeysVerifier.new(context, action).verify
+        ExpectedKeyVerifier.new(context, action).verify
 
-      block.call
+        block.call
 
-      PromisedKeyVerifier.new(context, action).verify
+        PromisedKeyVerifier.new(context, action).verify
+      end
     end
-  end
 
-  class ExpectedKeyVerifier < KeyVerifier
-    def type_name
-      "expected"
-    end
+    class ExpectedKeyVerifier < KeyVerifier
+      def type_name
+        "expected"
+      end
 
-    def keys
-      action.expected_keys
-    end
+      def keys
+        action.expected_keys
+      end
 
-    def error_to_throw
-      ExpectedKeysNotInContextError
-    end
+      def error_to_throw
+        ExpectedKeysNotInContextError
+      end
 
-    def throw_error_predicate(keys)
-      !are_all_keys_in_context?(keys)
+      def throw_error_predicate(keys)
+        !are_all_keys_in_context?(keys)
+      end
     end
-  end
 
-  class PromisedKeyVerifier < KeyVerifier
-    def type_name
-      "promised"
-    end
+    class PromisedKeyVerifier < KeyVerifier
+      def type_name
+        "promised"
+      end
 
-    def keys
-      action.promised_keys
-    end
+      def keys
+        action.promised_keys
+      end
 
-    def error_to_throw
-      PromisedKeysNotInContextError
-    end
+      def error_to_throw
+        PromisedKeysNotInContextError
+      end
 
-    def throw_error_predicate(keys)
-      !are_all_keys_in_context?(keys)
+      def throw_error_predicate(keys)
+        !are_all_keys_in_context?(keys)
+      end
     end
-  end
 
-  class ReservedKeysVerifier < KeyVerifier
-    def violated_keys
-      (action.promised_keys + action.expected_keys) & reserved_keys
-    end
+    class ReservedKeysVerifier < KeyVerifier
+      def violated_keys
+        (action.promised_keys + action.expected_keys) & reserved_keys
+      end
 
-    def error_message
-      "promised or expected keys cannot be a reserved key: [#{format_keys(violated_keys)}]"
-    end
+      def error_message
+        "promised or expected keys cannot be a " \
+        "reserved key: [#{format_keys(violated_keys)}]"
+      end
 
-    def keys
-      violated_keys
-    end
+      def keys
+        violated_keys
+      end
 
-    def error_to_throw
-      ReservedKeysInContextError
-    end
+      def error_to_throw
+        ReservedKeysInContextError
+      end
 
-    def throw_error_predicate(keys)
-      keys.any?
-    end
+      def throw_error_predicate(keys)
+        keys.any?
+      end
 
-    def reserved_keys
-      [:message, :error_code, :current_action].freeze
+      def reserved_keys
+        [:message, :error_code, :current_action].freeze
+      end
     end
   end
-end; end
+end

data/lib/light-service/localization_adapter.rb

@@ -1,22 +1,25 @@
 module LightService
   class LocalizationAdapter
-    def failure(message_or_key, action_class, i18n_options={})
+    def failure(message_or_key, action_class, i18n_options = {})
       find_translated_message(message_or_key,
                               action_class,
                               i18n_options,
-                              {:type => :failure})
+                              :type => :failure)
     end
 
-    def success(message_or_key, action_class, i18n_options={})
+    def success(message_or_key, action_class, i18n_options = {})
       find_translated_message(message_or_key,
                               action_class,
                               i18n_options,
-                              {:type => :success})
+                              :type => :success)
     end
 
     private
 
-    def find_translated_message(message_or_key, action_class, i18n_options, type)
+    def find_translated_message(message_or_key,
+                                action_class,
+                                i18n_options,
+                                type)
       if message_or_key.is_a?(Symbol)
         i18n_options.merge!(type)
         translate(message_or_key, action_class, i18n_options)
@@ -25,11 +28,11 @@ module LightService
       end
     end
 
-    def translate(key, action_class, options={})
+    def translate(key, action_class, options = {})
       type = options.delete(:type)
 
       scope = i18n_scope_from_class(action_class, type)
-      options.merge!(scope: scope)
+      options[:scope] = scope
 
       I18n.t(key, options)
     end

data/lib/light-service/organizer.rb

@@ -4,16 +4,19 @@ module LightService
       base_class.extend ClassMethods
       base_class.extend Macros
     end
+
     def self.included(base_class)
-      ActiveSupport::Deprecation.warn "including LightService::Organizer is deprecated. Please use `extend LightService::Organizer` instead"
+      warning_msg = "including LightService::Organizer is deprecated. " \
+                    "Please use `extend LightService::Organizer` instead"
+      ActiveSupport::Deprecation.warn(warning_msg)
       base_class.extend ClassMethods
       base_class.extend Macros
     end
 
     # In case this module is included
     module ClassMethods
-      def with(data={})
-        data.merge!(:_aliases => @aliases) if @aliases
+      def with(data = {})
+        data[:_aliases] = @aliases if @aliases
         WithReducerFactory.make(self).with(data)
       end