nifty_services 0.0.3 → 0.0.4

data/daily_news.log

@@ -0,0 +1,7 @@
+# Logfile created on 2016-07-15 17:46:01 -0300 by logger.rb/53141
+I, [2016-07-15T17:46:01.453040 #30030]  INFO -- : Routine Details: Send daily news email to user Rafael Fidelis(rafa_fidelis@yahoo.com.br)
+I, [2016-07-15T17:46:01.453179 #30030]  INFO -- : Routine started at: 2016-07-15 17:46:01 -0300
+W, [2016-07-15T17:46:01.453464 #30030]  WARN -- : Something went wrong
+E, [2016-07-15T17:46:01.484243 #30030] ERROR -- : Error sending email to user. See details below :(
+E, [2016-07-15T17:46:01.484330 #30030] ERROR -- : ["translation missing: en.nifty_services.errors.users.yet_received_daily_news_mail"]
+I, [2016-07-15T17:46:01.484470 #30030]  INFO -- : Routine ended at: 2016-07-15 17:46:01 -0300

data/lib/nifty_services/base_create_service.rb

@@ -7,20 +7,20 @@ module NiftyServices
     end
 
     def execute
-      with_before_and_after_callbacks(:create) do
-        if can_execute_action?
-          @record = build_record
-
-          if save_record
-            after_execute_success_response
-          else
-            errors = create_error_response(@record)
-            after_error_response(errors)
+      execute_action do
+        with_before_and_after_callbacks(:create) do
+          if can_execute_action?
+            @record = build_record
+
+            if save_record
+              after_execute_success_response
+            else
+              errors = create_error_response(@record)
+              after_error_response(errors)
+            end
           end
         end
       end
-
-      success?
     end
 
     private
@@ -57,7 +57,7 @@ module NiftyServices
       record_type.send(:new, record_params)
     end
 
-    def can_execute_action?
+    def can_execute?
       if validate_ip_on_create? && !can_create_with_ip?
         return forbidden_error!(%s(users.ip_temporarily_blocked))
       end

data/lib/nifty_services/base_delete_service.rb

@@ -2,22 +2,22 @@ module NiftyServices
   class BaseDeleteService < BaseCrudService
 
     def execute
-      with_before_and_after_callbacks(:delete) do
-        if can_execute_action?
-          if destroy_record
-            success_response
-          else
-            bad_request_error(@record.errors)
+      execute_action do
+        with_before_and_after_callbacks(:delete) do
+          if can_execute_action?
+            if destroy_record
+              success_response
+            else
+              bad_request_error(@record.errors)
+            end
           end
         end
       end
-
-      success?
     end
 
     private
     def destroy_record
-      @record.destroy
+      @record.try(:destroy) || @record.try(:delete)
     end
 
     def can_execute_action?

data/lib/nifty_services/base_service.rb

@@ -1,47 +1,19 @@
 module NiftyServices
   class BaseService
 
-    attr_reader :options, :response_status, :response_status_code, :errors
-
-    CALLBACKS = [
-      :after_initialize,
-      :before_error,
-      :after_error,
-      :before_success,
-      :after_success,
-      :before_create,
-      :after_create,
-      :before_update,
-      :after_update,
-      :before_delete,
-      :after_delete,
-      :before_action,
-      :after_action
-    ].freeze
-
-    @@registered_callbacks = Hash.new {|k,v| k[v] = Hash.new  }
+    include Extensions::CallbacksInterface
 
-    class << self
-      def register_callback(callback_name, method_name, &block)
-        method_name = "#{method_name.to_s.gsub(/\Z_callback/, '')}_callback"
-
-        @@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
+    attr_reader :response_status, :response_status_code
+    attr_reader :options, :errors, :logger
 
+    class << self
       def register_error_response_method(reason_string, status_code)
         NiftyServices::Configuration.add_response_error_method(reason_string, status_code)
         define_error_response_method(reason_string, status_code)
       end
 
       def define_error_response_method(reason_string, status_code)
-        method_name = "#{reason_string.to_s.gsub(/\Z_error/, '')}_error"
+        method_name = Util.normalized_callback_name(reason_string, '_error')
 
         define_method method_name do |message_key, options = {}|
           error(status_code, message_key, options)
@@ -53,19 +25,15 @@ module NiftyServices
       end
     end
 
-    CALLBACKS.each do |callback_name|
-      # empty method call (just returns nil)
-      define_method callback_name, -> {}
-    end
-
     def initialize(options = {}, initial_response_status = 400)
       @options = options.to_options!
       @errors = []
+      @logger = options[:logger] || default_logger
+      @executed = false
 
-      set_response_status(initial_response_status)
-      initial_callbacks_setup
-
-      call_callback(:after_initialize)
+      with_before_and_after_callbacks(:initialize) do
+        set_response_status(initial_response_status)
+      end
     end
 
     def valid?
@@ -84,6 +52,10 @@ module NiftyServices
       @response_status ||= :bad_request
     end
 
+    def changed_attributes
+      []
+    end
+
     def changed?
       changed_attributes.any?
     end
@@ -96,16 +68,6 @@ module NiftyServices
       valid_object?(@user, user_class)
     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 option_exists?(key)
       @options && @options.key?(key.to_sym)
     end
@@ -118,27 +80,40 @@ module NiftyServices
       !option_enabled?(key)
     end
 
-    def register_callback(callback_name, method_name, &block)
-      method_name = :"#{method_name.to_s.gsub(/\Z_callback/, '')}_callback"
-
-      @registered_callbacks[callback_name.to_sym] << method_name
+    def add_error(error)
+      add_method = error.is_a?(Array) ? :concat : :push
+      @errors.send(add_method, error)
     end
 
-    def register_callback_action(callback_name, &block)
-      cb_name = :"#{callback_name.to_s.gsub(/\Z_callback/, '')}_callback"
-      @callbacks_actions[cb_name] = block
+    def default_logger
+      NiftyServices.config.logger
     end
 
-    def add_error(error)
-      add_method = error.is_a?(Array) ? :concat : :push
-      @errors.send(add_method, error)
+    alias :log :logger
+
+    def executed?
+      @executed == true
     end
 
+    alias :runned? :executed?
+
     private
-    def initial_callbacks_setup
-      @fired_callbacks, @custom_fired_callbacks = {}, {}
-      @callbacks_actions = {}
-      @registered_callbacks = Hash.new {|k,v| k[v] = [] }
+    def can_execute?
+      not_implemented_exception(__method__)
+    end
+
+    def execute_action(&block)
+      return nil if executed?
+
+      with_before_and_after_callbacks(:execute) do
+        if can_execute?
+          yield(block) if block_given?
+        end
+      end
+
+      @executed = true
+
+      self # allow chaining
     end
 
     def success_response(status = :ok)
@@ -187,10 +162,12 @@ module NiftyServices
     end
 
     def error(status, message_key, options = {})
+      @success = false
+
       with_before_and_after_callbacks(:error) do
         set_response_status(status)
-        error_message = process_error_message_for_key(message_key, options)
 
+        error_message = process_error_message_for_key(message_key, options)
         add_error(error_message)
 
         error_message
@@ -206,20 +183,6 @@ module NiftyServices
       return false
     end
 
-    def call_callback(callback_name)
-      callback_name = callback_name.to_s.underscore.to_sym
-
-      if self.respond_to?(callback_name, true) # include private methods
-        @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 valid_object?(record, expected_class)
       record.present? && record.is_a?(expected_class)
     end
@@ -263,61 +226,6 @@ module NiftyServices
       message
     end
 
-    def with_before_and_after_callbacks(callback_basename, &block)
-      call_callback(:"before_#{callback_basename}")
-
-      response = yield(block) if block_given?
-
-      call_callback(:"after_#{callback_basename}")
-
-      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[callback_name.to_sym].present?
-    end
-
-    def invoke_callback(method)
-      method.call
-    end
-
     NiftyServices::Configuration.response_errors_list.each do |reason_string, status_code|
       define_error_response_method(reason_string, status_code)
     end

data/lib/nifty_services/base_update_service.rb

@@ -2,21 +2,21 @@ module NiftyServices
   class BaseUpdateService < BaseCrudService
 
     def execute
-      with_before_and_after_callbacks(:update) do
-        if can_execute_action?
-          @updated_record = update_record
-          @updated_record ||= @record
-
-          if success_updated?
-            success_response
-          else
-            errors = update_errors
-            bad_request_error(errors) if errors.present?
+      execute_action do
+        with_before_and_after_callbacks(:update) do
+          if can_execute_action?
+            @updated_record = update_record
+            @updated_record ||= @record
+
+            if success_updated?
+              success_response
+            else
+              errors = update_errors
+              bad_request_error(errors) if errors.present?
+            end
           end
         end
       end
-
-      success?
     end
 
     def changed_attributes
@@ -27,7 +27,7 @@ module NiftyServices
     private
 
     def changed_attributes_array
-      record_params.keys
+      record_allowed_params.keys
     end
 
     def success_updated?
@@ -39,7 +39,7 @@ module NiftyServices
     end
 
     def update_record
-      @record.class.send(:update, @record.id, record_params)
+      @record.class.send(:update, @record.id, record_allowed_params)
     end
 
     def can_execute_action?
@@ -72,7 +72,7 @@ module NiftyServices
 
     def after_success
       @old_record = @record.dup
-      @record     = @updated_record
+      @record = @updated_record
     end
   end
 end

data/lib/nifty_services/configuration.rb

@@ -31,7 +31,7 @@ module NiftyServices
       end
     end
 
-    attr_reader :logger, :options
+    attr_reader :logger, :options, :i18n_namespace
 
     attr_accessor :user_class, :service_concerns_namespace
 
@@ -39,11 +39,12 @@ module NiftyServices
       @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 i18n_namespace
-      @options[:i18n_namespace] || DEFAULT_I18N_NAMESPACE
+    def default_i18n_namespace
+       DEFAULT_I18N_NAMESPACE
     end
 
     private

data/lib/nifty_services/extensions/callbacks_interface.rb

@@ -0,0 +1,171 @@
+require 'active_support/concern'
+
+module NiftyServices
+  module Extensions::CallbacksInterface
+
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :before_initialize,
+      :after_initialize,
+      :before_execute,
+      :after_execute,
+      :before_error,
+      :after_error,
+      :before_success,
+      :after_success,
+      :before_create,
+      :after_create,
+      :before_update,
+      :after_update,
+      :before_delete,
+      :after_delete,
+      :before_action,
+      :after_action
+    ].freeze
+
+    class_methods do
+      @@registered_callbacks = Hash.new {|k,v| k[v] = Hash.new }
+
+      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
+
+    included do
+      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[callback_name.to_sym].present?
+      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
+end

data/lib/nifty_services/util.rb

@@ -0,0 +1,10 @@
+module NiftyServices
+  module Util
+    module_function
+    def normalized_callback_name(callback_name, prefix = '_callback')
+      cb_name = callback_name.to_s.gsub(%r(\Z#{prefix}), '')
+
+      [cb_name, prefix].join
+    end
+  end
+end

data/lib/nifty_services/version.rb

@@ -1,3 +1,3 @@
 module NiftyServices
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/nifty_services.rb

@@ -14,6 +14,11 @@ module NiftyServices
   autoload :Configuration,      'nifty_services/configuration'
   autoload :Error,              'nifty_services/errors'
   autoload :Errors,             'nifty_services/errors'
+  autoload :Util,               'nifty_services/util'
+
+  module Extensions
+    autoload :CallbacksInterface, 'nifty_services/extensions/callbacks_interface'
+  end
 
   class << self
     def configuration(&block)