nifty_services 0.0.5 → 0.0.6

data/lib/nifty_services/base_service.rb

@@ -1,8 +1,9 @@
+require File.expand_path('extensions/callbacks', File.dirname(__FILE__))
+require 'i18n'
+
 module NiftyServices
   class BaseService
 
-    include Extensions::CallbacksInterface
-
     attr_reader :response_status, :response_status_code
     attr_reader :options, :errors, :logger
 
@@ -23,12 +24,19 @@ module NiftyServices
           error!(status_code, message_key, options)
         end
       end
+
+      def concern(concern_module)
+        self.include(concern_module)
+      end
+
+      alias_method :include_concern, :concern
     end
 
     def initialize(options = {}, initial_response_status = 400)
-      @options = default_options.to_options!.merge(options).to_options!
+      @options = with_default_options(options)
       @errors = []
-      @logger = options[:logger] || default_logger
+      @logger = @options[:logger] || default_logger
+
       @executed = false
 
       with_before_and_after_callbacks(:initialize) do
@@ -41,7 +49,7 @@ module NiftyServices
     end
 
     def valid?
-      return @errors.blank?
+      return @errors.empty?
     end
 
     def success?
@@ -56,20 +64,12 @@ module NiftyServices
       @response_status ||= :bad_request
     end
 
-    def valid_user?
-      user_class = NiftyServices.config.user_class
-
-      raise 'Invalid User class. Use NitfyService.config.user_class = ClassName' if user_class.blank?
-
-      valid_object?(@user, user_class)
-    end
-
     def option_exists?(key)
       @options && @options.key?(key.to_sym)
     end
 
     def option_enabled?(key)
-      option_exists?(key) && @options[key.to_sym] == true
+      option_exists?(key) && [true, 'true'].member?(@options[key.to_sym])
     end
 
     def option_disabled?(key)
@@ -94,6 +94,10 @@ module NiftyServices
     alias :runned? :executed?
 
     private
+    def with_default_options(options)
+      default_options.merge(options).symbolize_keys
+    end
+
     def default_options
       {}
     end
@@ -103,21 +107,15 @@ module NiftyServices
     end
 
     def execute_action(&block)
-      begin
-        return nil if executed?
+      return nil if executed?
 
-        with_before_and_after_callbacks(:execute) do
-          if can_execute?
-            yield(block) if block_given?
-          end
+      with_before_and_after_callbacks(:execute) do
+        if can_execute?
+          yield(block) if block_given?
         end
-
-        @executed = true
-      rescue Exception => e
-        add_error(e)
       end
 
-      self # allow chaining
+      @executed = true
     end
 
     def success_response(status = :ok)
@@ -148,12 +146,8 @@ module NiftyServices
 
       response_list = error_list.merge(success_list)
 
-      selected_status = response_list.select do |status_key, status_code|
-        if select_method == :key
-          status_key == status
-        else
-          status_code == status
-        end
+      response_list.select do |status_key, status_code|
+        status == (select_method == :key ? status_key : status_code)
       end
     end
 
@@ -188,17 +182,17 @@ module NiftyServices
     end
 
     def valid_object?(record, expected_class)
-      record.present? && record.is_a?(expected_class)
+      record.class.to_s == expected_class.to_s
     end
 
-    def filter_hash(hash, whitelist_keys = [])
-      (hash || {}).symbolize_keys.slice(*whitelist_keys.map(&:to_sym))
+    def filter_hash(hash = {}, whitelist_keys = [])
+      hash.symbolize_keys.slice(*whitelist_keys.map(&:to_sym))
     end
 
     def changes(old, current, attributes = {})
       changes = []
 
-      return changes if old.blank? || current.blank?
+      return changes if old.nil? || current.nil?
 
       old_attributes = old.attributes.slice(*attributes.map(&:to_s))
       new_attributes = current.attributes.slice(*attributes.map(&:to_s))
@@ -218,13 +212,20 @@ module NiftyServices
       "#{i18n_namespace}.errors"
     end
 
-    def process_error_message_for_key(message_key, options)
-      if message_key.class.to_s == 'ActiveModel::Errors'
-        message = message_key.messages
-      elsif message_key.is_a?(Array) && message_key.first.is_a?(Hash)
-        message = message_key
+    def process_error_message_for_key(message_object, options)
+      if message_object.respond_to?(:messages)
+        message = message_object.messages
+      elsif message_object.respond_to?(:message)
+        message = message_object.message
+      elsif message_object.is_a?(Array) && message_object.first.is_a?(Hash)
+        message = message_object
+      elsif message_object.is_a?(String)
+        # if message_object is a string, use it as key to I18n or use pure string content
+        message = options[:translate].nil? || options[:translate] == true ?
+                    translate("#{i18n_errors_namespace}.#{message_object}", options) :
+                    message_object
       else
-        message = I18n.t("#{i18n_errors_namespace}.#{message_key}", options)
+        message = message_object
       end
 
       message
@@ -236,7 +237,16 @@ module NiftyServices
 
     protected
     def not_implemented_exception(method_name)
-      raise NotImplementedError, "#{method_name} must be implemented in subclass"
+      message = "##{method_name} method must be implemented in #{self.class} class"
+      raise NotImplementedError, message
+    end
+
+    def translate(key, options = {})
+      begin
+        I18n.t(key, options)
+      rescue => error
+        "Can't fecth key #{key} - #{error.message}"
+      end
     end
   end
 end

data/lib/nifty_services/base_update_service.rb

@@ -7,13 +7,13 @@ module NiftyServices
           if can_execute_action?
             duplicate_records_before_update
 
-            @record = update_record
+            @record = with_before_and_after_callbacks(:update_record) { update_record }
 
             if success_updated?
               success_response
             else
               errors = update_errors
-              bad_request_error(errors) if errors.present?
+              unprocessable_entity_error!(errors) unless errors.empty?
             end
           end
         end
@@ -40,7 +40,16 @@ module NiftyServices
     end
 
     def update_record
-      @record.class.send(:update, @record.id, record_allowed_attributes)
+      update_method = NiftyServices.configuration.update_record_method
+
+      if update_method.respond_to?(:call)
+        update_method.call(@record, record_allowed_attributes)
+      else
+        @record.public_send(update_method, record_allowed_attributes)
+      end
+
+      # initialize @temp_record to be used in after_update_record callback
+      @temp_record = @record
     end
 
     def can_execute?
@@ -48,29 +57,19 @@ module NiftyServices
         return not_found_error!(invalid_record_error_key)
       end
 
-      if validate_user? && !valid_user?
-        return not_found_error!(invalid_user_error_key)
-      end
-
       return true
     end
 
     def can_update_record?
-      unless user_can_update_record?
-        return (valid? ? forbidden_error!(user_cant_update_error_key) : false)
-      end
-
-      return true
+      not_implemented_exception(__method__)
     end
 
     def can_execute_action?
-      return can_update_record?
-    end
-
-    def user_can_update_record?
-      return not_implemented_exception(__method__) unless @record.respond_to?(:user_can_update?)
+      unless can_update_record?
+        return (valid? ? forbidden_error!(cant_update_error_key) : false)
+      end
 
-      @record.user_can_update?(@user)
+      return true
     end
 
     def duplicate_records_before_update
@@ -81,8 +80,8 @@ module NiftyServices
       "#{record_error_key}.not_found"
     end
 
-    def user_cant_update_error_key
-      "#{record_error_key}.user_cant_update"
+    def cant_update_error_key
+      "#{record_error_key}.cant_update"
     end
 
   end

data/lib/nifty_services/configuration.rb

@@ -1,10 +1,7 @@
-require 'logger'
-
 module NiftyServices
   class Configuration
 
     DEFAULT_I18N_NAMESPACE = "nifty_services"
-    DEFAULT_SERVICE_CONCERN_NAMESPACE = 'NitfyServices::Concerns'
 
     ERROR_RESPONSE_STATUS = {
       :bad_request           => 400,
@@ -12,6 +9,10 @@ module NiftyServices
       :forbidden             => 403,
       :not_found             => 404,
       :unprocessable_entity  => 422,
+      # internal_server_error_error!
+      :internal_server_error => 500,
+      # keeping compatibility
+      # internal_server_error!
       :internal_server       => 500,
       :not_implemented       => 501
     }
@@ -27,33 +28,31 @@ module NiftyServices
       end
 
       def add_response_error_method(reason, status_code)
-        response_errors_list[reason.to_sym] = status_code.to_i
+        ERROR_RESPONSE_STATUS[reason.to_sym] = status_code.to_i
       end
     end
 
     attr_reader :options
 
-    attr_accessor :logger, :i18n_namespace, :user_class, :service_concerns_namespace
+    attr_accessor :logger, :i18n_namespace,
+                  :delete_record_method, :update_record_method, :save_record_method
 
     def initialize(options = {})
       @options = options
-      @service_concerns_namespace = default_service_concerns_namespace
-      @user_class = options[:user_class] || default_user_class
-      @i18n_namespace = @options[:i18n_namespace] || default_i18n_namespace
-      @logger = options[:logger] || default_logger
-    end
-
-    def default_i18n_namespace
-       DEFAULT_I18N_NAMESPACE
+      @i18n_namespace = fetch(:i18n_namespace, default_i18n_namespace)
+      @delete_record_method = :delete
+      @update_record_method = :update
+      @save_record_method = :save
+      @logger = fetch(:logger, default_logger)
     end
 
     private
-    def default_service_concerns_namespace
-      DEFAULT_SERVICE_CONCERN_NAMESPACE
+    def fetch(option_key, default = nil)
+      @options[option_key] || default
     end
 
-    def default_user_class
-      nil
+    def default_i18n_namespace
+       DEFAULT_I18N_NAMESPACE
     end
 
     def default_logger

data/lib/nifty_services/errors.rb

@@ -3,9 +3,9 @@ module NiftyServices
   end
 
   module Errors
-    BaseService::ERROR_RESPONSE_METHODS.each do |error, status|
+    Configuration::ERROR_RESPONSE_STATUS.each do |error, status|
       class_eval <<-END
-        class #{error.to_s.camelize} < Error
+        class #{error.to_s.camel_case} < Error
         end
       END
     end

data/lib/nifty_services/extensions/callbacks.rb

@@ -0,0 +1,173 @@
+module NiftyServices
+  class BaseService
+
+    @@registered_callbacks = Hash.new {|k,v| k[v] = Hash.new }
+
+    CALLBACKS = [
+      :before_execute_service_action,
+      :after_execute_service_action,
+      :before_delete_record,
+      :after_delete_record,
+      :before_update_record,
+      :after_update_record,
+      :before_build_record,
+      :after_build_record,
+      :before_initialize,
+      :after_initialize,
+      :before_execute,
+      :after_execute,
+      :before_success,
+      :after_success,
+      :before_error,
+      :after_error,
+      :before_create,
+      :after_create,
+      :before_update,
+      :after_update,
+      :before_delete,
+      :after_delete,
+      :before_action,
+      :after_action
+    ].freeze
+
+    class << self
+      def register_callback(callback_name, method_name, &block)
+        method_name = Util.normalized_callback_name(method_name)
+
+        @@registered_callbacks[self.name.to_sym][callback_name] ||= []
+        @@registered_callbacks[self.name.to_sym][callback_name] << method_name
+
+        register_callback_action(method_name, &block)
+      end
+
+      def register_callback_action(callback_name, &block)
+        define_method(callback_name, &block)
+      end
+
+      CALLBACKS.each do |callback_name|
+        define_method callback_name do |&block|
+          register_callback_action(callback_name, &block)
+        end
+      end
+    end
+
+    CALLBACKS.each do |callback_name|
+      # empty method call (just returns nil)
+      define_method callback_name, -> {}
+    end
+
+    def callback_fired?(callback_name)
+      return (
+              callback_fired_in?(@fired_callbacks, callback_name) ||
+              callback_fired_in?(@custom_fired_callbacks, callback_name) ||
+              callback_fired_in?(@custom_fired_callbacks, "#{callback_name}_callback")
+             )
+    end
+
+    alias :callback_called? :callback_fired?
+
+    def register_callback(callback_name, method_name, &block)
+      method_name = normalized_callback_name(method_name).to_sym
+
+      @registered_callbacks[callback_name.to_sym] << method_name
+      register_callback_action(callback_name, &block)
+    end
+
+    def register_callback_action(callback_name, &block)
+      cb_name = normalized_callback_name(callback_name).to_sym
+      @callbacks_actions[cb_name.to_sym] = block
+    end
+
+    private
+    def callbacks_setup
+      return nil if @callbacks_setup
+
+      @fired_callbacks, @custom_fired_callbacks = {}, {}
+      @callbacks_actions = {}
+      @registered_callbacks = Hash.new {|k,v| k[v] = [] }
+
+      @callbacks_setup = true
+    end
+
+    def call_callback(callback_name)
+      callback_name = callback_name.to_s.underscore.to_sym
+
+      if has_callback?(callback_name)
+        @fired_callbacks[callback_name.to_sym] = true
+
+        invoke_callback(method(callback_name))
+        call_registered_callbacks_for(callback_name)
+      end
+
+      # allow chained methods
+      self
+    end
+
+    def has_callback?(callback_name)
+      _callback_name = normalized_callback_name(callback_name).to_sym
+       # include private methods
+      respond_to?(callback_name, true) || respond_to?(_callback_name, true)
+    end
+
+    def with_before_and_after_callbacks(callback_basename, &block)
+      callbacks_setup
+
+      call_callback(:"before_#{callback_basename}")
+
+      block_response = yield(block) if block_given?
+
+      call_callback(:"after_#{callback_basename}")
+
+      block_response
+    end
+
+    def call_registered_callbacks_for(callback_name)
+      instance_call_all_custom_registered_callbacks_for(callback_name)
+      class_call_all_custom_registered_callbacks_for(callback_name)
+    end
+
+    def instance_call_all_custom_registered_callbacks_for(callback_name)
+      @fired_callbacks[callback_name] = true
+
+      callbacks = @registered_callbacks[callback_name.to_sym]
+
+      callbacks.each do |cb|
+        if callback = @callbacks_actions[cb.to_sym]
+          @custom_fired_callbacks[cb.to_sym] = true
+          invoke_callback(callback)
+        end
+      end
+    end
+
+    def class_call_all_custom_registered_callbacks_for(callback_name)
+      classes_chain = self.class.ancestors.map(&:to_s).grep /\ANiftyServices/
+      klasses = @@registered_callbacks.keys.map(&:to_s) & classes_chain
+
+      klasses.each do |klass|
+        class_call_all_custom_registered_callbacks_for_class(klass, callback_name)
+      end
+    end
+
+    def class_call_all_custom_registered_callbacks_for_class(class_name, callback_name)
+      class_callbacks = @@registered_callbacks[class_name.to_sym]
+      callbacks = class_callbacks[callback_name.to_sym] || []
+
+      callbacks.each do |cb|
+        @custom_fired_callbacks[cb.to_sym] = true
+        invoke_callback(method(cb))
+      end
+    end
+
+    def callback_fired_in?(callback_list, callback_name)
+      return callback_list.key?(callback_name.to_sym)
+    end
+
+    def normalized_callback_name(callback_name, prefix = '_callback')
+      Util.normalized_callback_name(callback_name, prefix)
+    end
+
+    def invoke_callback(method)
+      method.call
+    end
+  end
+end