nifty_services 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2388b61c2fa5d1fed162e0f46b7014fb780fda46
-  data.tar.gz: 2889984fdc020de82e987c288680f48814b22ed5
+  metadata.gz: 4b51ddb57c9b14189952188821a22c36ea9b7c35
+  data.tar.gz: 1bf6174e4899e88817ea3ec77db991d2cf249cdc
 SHA512:
-  metadata.gz: 49d2e94d0aae898be5056584865368b69131061d7a910edc1c6d52aa3530618899d8c9153ba264cd4c2cb245f65f46b09106a5d10a4b288eb85b544851f29fc8
-  data.tar.gz: 3c93bf62d33f637435c3b47c93160e3b873ae0169e1255c3a6a121ba632e68b32cbe103006d1bd74170fcbfc5042fa279a87aac5e86b111ec9d6581a8843170a
+  metadata.gz: b098ca14f8ad2789d6dc7e0fc4026452a79d30697f241d31d6b74dfb7397e50b89df681e7648648550e66b66e2f2ec52605dc96359a741ead9c4ebf456645024
+  data.tar.gz: ee3633820cc0690f469acd67a74c3ff63d6f86d19f08f92b4b09d26296cc448cfb003159295485ab5c4a47532defc8ca7072c302e523ee2cdbfcd7a69db251c8

data/README.md

@@ -4,18 +4,19 @@
 
 Nifty Services comes to solve your Ruby applications(*including but not limited to* Rails, Grape, Sinatra, and plain Ruby) code mess with **simplicity in mind**!
 
-NiftyServices provider a very nifty, simple & clear API to **organize and reuse** your application **domain logic in plain Ruby Services Objects** turning your codebase in a very extensible, standardized and reusable components.
+NiftyServices provides a very nifty, simple & clear API to **organize and reuse** your application **domain logic in plain Ruby Services Objects** turning your codebase in a very extensible, standardized and reusable components.
 
 **Most important:** You and your team win what I consider the best benefit when using Nifty Services: **Easily and scalable maintained code.**  
  Believe me, you'll fall in :heart_eyes: with this small piece of code, keep reading!
 
-This gem was designed and conventioned to be used specially with **Web API applications**, but this is just a convention, you can use it's even with [shoes (for desktop apps)](https://github.com/shoes/shoes) applications if you  want, for example.
+This gem was designed and conventioned to be used specially with **Web API applications**, but this is just a convention, you can use it even with [shoes (for desktop apps)](https://github.com/shoes/shoes) applications if you  want, for example.
 
 #### :book: I know, this README is very huge
 
 As you can see, this README needs some time to be full read, but is very difficulty to explain all things, concepts and philosophy of this gem without writing a lot, we can't escape this :(   
 
-But remember one thing: This is a **tecnical documentation**, not a blog post, I'm pretty sure you can take 1 or 2 hours + :coffee: to better understand all NiftyServices can do for you and your project. Good reading, and if you have some question, [please let me know](/issues/new).
+But remember one thing: This is a **tecnical documentation**, not a blog post, I'm pretty sure you can take about 30 minutes + some cups of :coffee: to better understand all NiftyServices can 
+do for you and your project. Good reading, and if you have some question, [please let me know](issues/new).
 
 ---
 
@@ -60,6 +61,11 @@ But remember one thing: This is a **tecnical documentation**, not a blog post, I
    * [Web Frameworks integration](#web-frameworks-integrations)
       * [Ruby on Rails](#frameworks-rails)
       * [Grape/Sinatra/Rack](#frameworks-rack) 
+   * [ Basic Services class Markups](#pray-basic-service-markups-raised_hands)
+      * [BaseCreateService Basic Markup](#basecreateservice-basic-markup)
+      * [BaseUpdateService Basic Markup](#baseupdateservice-basic-markup)
+      * [BaseDeleteService Basic Markup](#basedeleteservice-basic-markup)
+      * [BaseActionService Basic Markup](#baseactionservice-basic-markup)
    * [CLI Generators](#cli-generators)
    * [Roadmap](#roadmap)
    * [Development](#computer-development)
@@ -99,7 +105,7 @@ Now you know the basic concepts and philosophy of `NiftyServices`, lets start wo
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'nifty_services'
+gem 'nifty_services', '~> 0.0.5'
 ```
 
 And then execute:
@@ -139,7 +145,7 @@ class SemanticServiceName < NiftyServices::BaseService
 
     return not_found_error!('errors.message_key') if another_condition
 
-    return unprocessable_entity_error('errors.message_key') if other_condition
+    return unprocessable_entity_error!('errors.message_key') if other_condition
 
     # ok, this service can be executed
     return true
@@ -208,21 +214,31 @@ class DailyNewsMailSendService < NiftyServices::BaseService
 
     unless @user.abble_to_receive_daily_news_mail?
       # returns false
-      return forbidden_error!('users.yet_received_daily_news_mail')
+      return forbidden_error!('users.already_received_daily_news_mail')
     end
 
     return true
   end
+
   def send_mail_to_user
     # just to fake, a real implementation could be something like:
     # @user.send_daily_news_mail!
     return true
   end
-
+  
   def valid_user?
     # check if object is valid and is a User class type
     valid_object?(@user, User)
   end
+  
+  # you can use `default_options` method to add default { keys => values } to @options
+  # so you can use the option_enabled?(key) to verify if option is enabled
+  # or option_disabled?(key) to verify is option is disabled
+  # This default values can be override when creating new instance of Service, eg:
+  # DailyNewsMailSendService.new(User.last, validate_api_key: false)
+  def default_options
+    { validate_api_key: true }
+  end
 end
 
 class User < Struct.new(:name, :email)
@@ -268,7 +284,7 @@ W, [2016-07-15T17:12:10.955186 #756]  WARN -- : Something went wrong
 
 E, [2016-07-15T17:12:11.019645 #756] ERROR -- : Error sending email to user. See details below :(
 
-E, [2016-07-15T17:12:11.019838 #756] ERROR -- : ["User yet received daily news mail today"]
+E, [2016-07-15T17:12:11.019838 #756] ERROR -- : ["User has already received daily news mail today"]
 
 I, [2016-07-15T17:12:11.020073 #756]  INFO -- : Routine ended at: 2016-07-15 17:12:11 -0300
 
@@ -387,7 +403,7 @@ error!(409, :conflict_error, reason: 'unkown')
 
 #### Custom error response methods
 
-But you can always add new convenience errors methods via API, this way you gain more expressivity and sintax sugar:
+But you can always add new convenience errors methods via API, this way you will have more expressivity and sintax sugar:
 
 ```ruby
 ## API
@@ -397,7 +413,7 @@ NiftyServices.add_response_error_method(status, status_code)
 
 NiftyServices.add_response_error_method(:conflict, 409)
 
-## now you gain the methods:
+## now you have the methods:
 
 ## conflict_error(:conflict_error)
 ## conflit_error!(:conflict_error)
@@ -409,7 +425,7 @@ NiftyServices.add_response_error_method(:conflict, 409)
 
 So, until now we saw how to use `NiftyServices::BaseService` to create generic services to couple specific domain logic for actions,  this is very usefull, but things get a lot better when you're working with **CRUD** actions for your api.
 
-Above, an example of **Create, Update and Delete** CRUD services for `Post` resource:
+Follow an example of **Create, Update and Delete** CRUD services for `Post` resource:
 
 ## :white_check_mark: CRUD: Create
 
@@ -428,13 +444,14 @@ class PostCreateService < NiftyServices::BaseCreateService
  
  WHITELIST_ATTRIBUTES = [:title, :content]
  
- def record_params_whitelist
+ def record_attributes_whitelist
   WHITELIST_ATTRIBUTES
  end
  
- def build_record
-   # record_allowed_params auto magically use record_params_whitelist to remove unsafe attributes
-   @user.posts.build(record_allowed_params)
+ # use custom scope to create the record
+ # scope returned below must respond_to :build instance method
+ def build_record_scope
+   @user.posts
  end
  
  # this key is used for I18n translations
@@ -445,9 +462,9 @@ class PostCreateService < NiftyServices::BaseCreateService
  def user_can_create_record?
    # (here you can do any kind of validation, eg:)
    # check if user is trying to recreate a recent resource
-   # this will return false if user yet created a post with
+   # this will return false if user has already created a post with
    # this title in the last 30 seconds (usefull to ban bots)
-   @user.posts.exists(title: record_allowed_params[:title], created_at: "NOW() - interval(30 seconds)")
+   @user.posts.exists(title: record_allowed_attributes[:title], created_at: "NOW() - interval(30 seconds)")
  end
 end
 
@@ -534,7 +551,7 @@ class PostUpdateService < NiftyServices::BaseUpdateService
   
   WHITELIST_ATTRIBUTES = [:title, :content] 
   
-  def record_allowed_params
+  def record_allowed_attributes
    WHITELIST_ATTRIBUTES
   end
   
@@ -817,9 +834,9 @@ NiftyServices::BaseCreateService.class_eval do
   end
 end
 
-# This register an callback for ALL services who inherit from `NiftyServices::BaseCreateService`
+# This register a callback for ALL services who inherit from `NiftyServices::BaseCreateService`
 # In other words: Every and all records created in my application will be tracked
-# I can believe that's is easy like this, I need a beer right now!
+# I can believe that is easy like this, I need a beer right now!
 NiftyServices::BaseCreateService.register_callback(:after_success, :create_origin_for_record) do
   create_origin(@record, @options)
 end
@@ -859,7 +876,7 @@ end
 
 ### Rails <a name="frameworks-rails"></a>
 
-You need a very minimal setup to integrate with you existing or new Rails application. I prefer to put my services files inside the `lib/services` folder, cause this allow better namespacing configuration over `app/services`, but this is up to you to decide.
+You need a very minimal setup to integrate with your existing or new Rails application. I prefer to put my services files inside the `lib/services` folder, cause this allow better namespacing configuration over `app/services`, but this is up to you to decide.
 
 First thing to do is add `lib/` folder in `autoload` path, place the following in your `config/application.rb`
 
@@ -875,13 +892,13 @@ Second, create `lib/services` directory:
 `$ mkdir -p lib/services/v1/users`
 
 Next, configure:  
-**Note**:  See Configurations section below to see all available configs
 
 ```ruby
 NiftyServices.configure do |config|
  config.user_class = User
 end
 ```
+**Note**:  See [Configurations](#construction-configuration-construction) section to see all available configs
 
 Create your first service:
 
@@ -909,7 +926,7 @@ class UsersController < BaseController
 end
 ```
 
-This can be even better if you move response code to an helper:
+This can be even better if you move response code to a helper:
 
 ```ruby
 # helpers/users_helper.rb
@@ -920,7 +937,7 @@ module UsersHelper
     generic_response_for_service(service, success_response)
   end
 
-  # THIS IS GREAT, you can use this method to standartize ALL of your
+  # THIS IS GREAT, you can use this method to standardize ALL of your
   # endpoints responses, THIS IS SO FUCKING COOL!
   def generic_response_for_service(service, success_response)
     default_response = {
@@ -978,6 +995,230 @@ NiftyServices - Sinatra Sample
 
 ---
 
+## :pray: Basic Service Markups :raised_hands:
+
+Here, for your convenience and sanity all basic service structures for reference when you start a brand new Service.
+Most of time, the best way is to copy all content from each service described below and change according to your needs.
+
+### BaseCreateService Basic Markup
+
+```ruby
+class SomeCreateService < NiftyServices::BaseCreateService
+
+ # [Required]
+ # remember that inside the Service you always can use
+ # @record variable to access current record
+ # and from outside (service instance): 
+ # service.record or service.record_type
+ # eg: 
+ # record_type BlogPost
+ # service.record # BlogPost.new(...)
+ # service.blog_post # BlogPost.new(...)
+ # service.record == service.blog_post # true
+ # alias_name can be used to create a custom alias name
+ # eg: 
+ # record_type BlogPost, alias_name: :post
+ # service.record # BlogPost.new(...)
+ # service.post # BlogPost.new(...)
+ # service.record == service.post # true
+
+ record_type RecordType, alias_name: :my_custom_alias_name
+
+ private
+ # [Required]
+ # Always validate if @user can create the current record_type
+ # If this method is not implemented a NotImplementedError exception will be raised
+ def user_can_create_record?
+  return forbidden_error!('errors.some_error') if (some_validation)
+  
+  return bad_request_error!('errors.some_other_error') if (another_validation)
+  
+  # remember to return true after all validations
+  # if you don't return true Service will not be able to create the record
+  return true
+ end
+
+ # [Optional]
+ # method called when save_error method call raises an exception
+ # this ocurr for example with ActiveRecord objects
+ # default: unprocessable_entity_error!(error)
+ def on_save_record_error(error)
+   logger.error(error)
+   if error.is_a?(ActiveRecord::RecordNotUnique)
+     return unprocessable_entity_error!(%s(posts.duplicate_record))
+   end
+ end
+
+ # [Optional]
+ # determine wheter user will be validate as valid object before 
+ # record creation 
+ # (default: true)
+ def validate_user?
+  return true
+ end
+
+ # [Optional]
+ # custom scope for record, eg: @user.posts
+ # default is nil
+ def build_record_scope
+ end
+end
+```
+
+### BaseUpdateService Basic Markup
+
+```ruby
+class SomeUpdateService < NiftyServices::BaseUpdateService
+
+  # [Required]
+  record_type RecordType, alias_name: :custom_alias_name
+
+  WHITELIST_ATTRIBUTES = [
+    :safe_attribute_1,
+    :safe_attribute_2,
+  ]
+
+  private
+  # [Required]
+  # When a new instance of Service is created, the @options variables receive some
+  # values, eg: { user: { email: "...", name: "...."} }
+  # use record_attributes_hash to tell the Service from where to pull theses values
+  # eg: @options.fetch(:user, {})
+  # If this method is not implemented a NotImplementedError exception will be raised
+  def record_attributes_hash
+    @options.fetch(options_key, {})
+  end
+
+  # [Required]
+  # whitelisted attributes (must be an Array) which can be updated by this Service
+  # If this method is not implemented a NotImplementedError exception will be raised
+  def record_attributes_whitelist
+    WHITELIST_ATTRIBUTES
+  end
+
+  # [required]
+  # This is a VERY IMPORTANT point of attention
+  # always verify if @user has permissions to update the current @record object
+  # Hint: if @record respond_to `user_can_update?(user)` you can remove this
+  # method and do the validation inside `user_can_update(user)` method in @record
+  # If this method is not implemented a NotImplementedError exception will be raised
+  def user_can_update_record?
+    @record.user_id == @user.id
+  end
+
+
+  # [Optional]
+  # This is the default implementation of update record, you may overwrite it
+  # to to custom updates (MOST OF TIME YOU DONT NEED TO DO THIS)
+  # only change this if you know what you are really doing
+  def update_record
+    @record.class.send(:update, @record.id, record_allowed_attributes)
+  end
+
+
+  # [optional]
+  # Any callback is optional, this is just a example
+  def after_success
+    if changed?
+      logger.info 'Successfully update record ID %s' % @record.id
+      logger.info 'Changed attributes are %s' % changed_attributes
+    end
+  end
+end
+```
+
+---
+
+### BaseDeleteService Basic Markup
+
+```ruby
+class SomeDeleteService < NiftyServices::BaseDeleteService
+
+  # [Required]
+  record_type RecordType, alias_name: :custom_alias_name
+
+  private
+
+  # [Required]
+  # This is a VERY IMPORTANT point of attention
+  # always verify if @user has permissions to delete the current @record object
+  # Hint: if @record respond_to `user_can_delete?(user)` you can remove this
+  # method and do the validation inside `user_can_delete(user)` method in @record
+  # If this method is not implemented a NotImplementedError exception will be raised
+
+  def user_can_delete_record?
+    @record.user_id == @user.id
+  end
+
+  # [optional]
+   # Any callback is optional, this is just a example
+  def after_success
+    logger.info('Successfully Deleted resource ID %s' % @record.id)
+  end
+
+  # [Optional]
+  # This is the default implementation of delete record, you may overwrite it
+  # to do custom delete (MOST OF TIME YOU DONT NEED TO DO THIS)
+  # only change this if you know what you are really doing
+  def destroy_record
+    @record.try(:destroy) || @record.try(:delete)
+  end
+
+end
+
+```
+
+### BaseActionService Basic Markup
+
+```ruby
+class SomeCustomActionService < NiftyServices::BaseActionService
+  
+  # [required]
+  # this is the action identifier used internally
+  # and to generate error messages
+  # see: invalid_action_error_key method
+  action_name :custom_action_name
+
+  private
+  # [Required]
+  # Always validate if Service can execute the action
+  # This method MUST return a boolean value indicating if Service can or not
+  # run the method `execute_service_action`
+  # If this method is not implemented a NotImplementedError exception will be raised
+  def user_can_execute_action?
+    # do some specific validation here, you can return errors such:
+    # return not_found_error!(%(users.invalid_user)) # returns false and avoid execution
+    return true
+  end
+
+  # [Required]
+  # The core function of BaseActionServices
+  # This method is called when all validations passes, so here you can put
+  # all logic for Service (eg: send mails, clear logs, any kind of action you want)
+  # If this method is not implemented a NotImplementedError exception will be raised
+  def execute_service_action
+    # (do some complex stuff)
+  end
+    
+  # You dont need to overwrite this method, just `record_error_key`
+  # But it's important you know how final message key will be created
+  # using the pattern below
+  def invalid_action_error_key
+    "#{record_error_key}.cant_execute_#{action_name}"
+  end
+
+  # [Required]
+  # Key used to created the error messages for this Service
+  # If this method is not implemented a NotImplementedError exception will be raised
+  def record_error_key
+    :users
+  end
+end
+```
+
+
+--- 
+
 ## Full Public API methods list
 
 You can use any of the methods above with your `services instances`:
@@ -1016,7 +1257,7 @@ Currently NiftyServices don't have CLI(command line interface) generators, but i
 
 - :white_medium_small_square: Remove ActiveSupport dependency
 - :white_medium_small_square: Create CLI Generators
-- :white_medium_small_square: Document `BaseActionService`
+- :white_medium_small_square: Beter documentation for `BaseActionService`
 - :white_medium_small_square: Write Sample Applications
 - :white_medium_small_square: Write better tests for all `Crud Services`
 - :white_medium_small_square: Write better tests for `BaseActionServices`

data/lib/nifty_services/base_action_service.rb

@@ -8,12 +8,12 @@ module NiftyServices
     end
 
     def execute
-      with_before_and_after_callbacks(:action) do
-        if can_execute_action?
+      execute_action do
+        with_before_and_after_callbacks(:action) do
+          # here user can
+          execute_service_action
 
-          execute_action
-
-          if success_runned_action?
+          if valid?
             success_response
           else
             errors = action_errors
@@ -21,8 +21,6 @@ module NiftyServices
           end
         end
       end
-
-      success?
     end
 
     private
@@ -30,50 +28,31 @@ module NiftyServices
       []
     end
 
-    def can_execute_action?
-      unless valid_record?
-        return not_found_error!("#{record_error_key}.not_found")
-      end
-
-      unless valid_user?
-        return not_found_error!('users.not_found')
-      end
-
-      unless can_execute?
-        if @errors.blank?
-          return unprocessable_entity_error!("#{record_error_key}.user_cant_execute_#{action_name}")
-        else
-          return false
-        end
+    def can_execute?
+      unless user_can_execute_action?
+        return (valid? ? unprocessable_entity_error!(invalid_action_error_key) : false)
       end
 
       return true
     end
 
-    def can_execute?
-      return false unless valid_user?
-      return false unless valid_record?
-
-      user_can_execute_action?
-    end
-
-    def success_runned_action?
-      not_implemented_exception(__method__)
+    def invalid_action_error_key
+      "#{record_error_key}.cant_execute_#{action_name}"
     end
 
     def user_can_execute_action?
       not_implemented_exception(__method__)
     end
 
-    def execute_action
+    def execute_service_action
       not_implemented_exception(__method__)
     end
 
-    def valid_record?
+    def record_error_key
       not_implemented_exception(__method__)
     end
 
-    def record_error_key
+    def action_name
       not_implemented_exception(__method__)
     end
   end

data/lib/nifty_services/base_create_service.rb

@@ -25,7 +25,16 @@ module NiftyServices
 
     private
     def save_record
-      @record.save
+      begin
+        @record.save
+      rescue => e
+        on_save_record_error(e)
+        return false
+      end
+    end
+
+    def on_save_record_error(error)
+      return unprocessable_entity_error!(error)
     end
 
     def create_error_response(record)
@@ -40,21 +49,20 @@ module NiftyServices
       success_created_response
     end
 
-    def after_success
-    end
-
     def build_record
-      _record_params = record_allowed_params
-
-      if record_type.present? && _record_params.present?
-        return build_from_record_type(_record_params)
+      if record_type.present?
+        return build_from_record_type(record_allowed_attributes)
       end
 
       return not_implemented_exception(__method__)
     end
 
-    def build_from_record_type(record_params)
-      record_type.send(:new, record_params)
+    def build_from_record_type(params)
+      if !build_record_scope.nil? && build_record_scope.respond_to?(:build)
+        return build_record_scope.send(:build, params)
+      end
+
+      record_type.send(:new, params)
     end
 
     def can_execute?
@@ -62,25 +70,27 @@ module NiftyServices
         return forbidden_error!(%s(users.ip_temporarily_blocked))
       end
 
-      unless valid_user?
-        return not_found_error!(%s(users.not_found))
+      if validate_user? && !valid_user?
+        return not_found_error!(invalid_user_error_key)
       end
 
-      unless can_create?
-        if @errors.blank?
-          return forbidden_error!("#{record_error_key}.user_cant_create")
-        else
-          return false
-        end
+      return true
+    end
+
+    def can_create_record?
+      unless user_can_create_record?
+        return (valid? ? forbidden_error!(user_cant_create_error_key) : false)
       end
 
-      return valid?
+      return true
     end
 
-    def can_create?
-      return false unless valid_user?
+    def user_can_create_record?
+      not_implemented_exception(__method__)
+    end
 
-      return user_can_create_record?
+    def can_execute_action?
+      return can_create_record?
     end
 
     def can_create_with_ip?
@@ -92,8 +102,12 @@ module NiftyServices
       false
     end
 
-    def user_can_create_record?
-      not_implemented_exception(__method__)
+    def build_record_scope
+      nil
+    end
+
+    def user_cant_create_error_key
+      "#{record_error_key}.user_cant_create"
     end
   end
 end

data/lib/nifty_services/base_crud_service.rb

@@ -37,28 +37,31 @@ module NiftyServices
       super(options)
     end
 
-    def execute
-      not_implemented_exception(__method__)
+    def changed_attributes
+      []
+    end
+
+    def changed?
+      changed_attributes.any?
     end
 
     def record_type
       not_implemented_exception(__method__)
     end
 
-    def record_params
+    def record_attributes_hash
       not_implemented_exception(__method__)
     end
 
-    def record_params_whitelist
+    def record_attributes_whitelist
       not_implemented_exception(__method__)
     end
 
-    def record_allowed_params
-      filter_hash(record_params, record_params_whitelist)
+    def record_allowed_attributes
+      filter_hash(record_attributes_hash, record_attributes_whitelist)
     end
 
-    alias :record_whitelisted_params :record_allowed_params
-    alias :record_safe_params :record_allowed_params
+    alias :record_safe_attributes :record_allowed_attributes
 
     private
     def array_values_from_hash(options, key, root = nil)
@@ -77,16 +80,20 @@ module NiftyServices
       array_values_from_string(values)
     end
 
+    def invalid_user_error_key
+      %s(users.not_found)
+    end
+
+    def validate_user?
+      true
+    end
+
     alias :array_values_from_params :array_values_from_hash
 
     def array_values_from_string(string)
       string.to_s.split(/\,/).map(&:squish)
     end
 
-    def record_params
-      not_implemented_exception(__method__)
-    end
-
     def record_error_key
       record_type.to_s.pluralize.underscore
     end

data/lib/nifty_services/base_delete_service.rb

@@ -20,31 +20,38 @@ module NiftyServices
       @record.try(:destroy) || @record.try(:delete)
     end
 
-    def can_execute_action?
+    def can_execute?
       unless valid_record?
         return not_found_error!("#{record_error_key}.not_found")
       end
 
-      unless valid_user?
-        return not_found_error!('users.not_found')
+      if validate_user? && !valid_user?
+        return not_found_error!(invalid_user_error_key)
       end
 
-      unless can_delete?
-        return forbidden_error!("#{record_error_key}.user_cant_delete")
+      return true
+    end
+
+    def can_delete_record?
+      unless user_can_delete_record?
+        return (valid? ? forbidden_error!(user_can_delete_error_key) : false)
       end
 
       return true
     end
 
-    def can_delete?
-      return false unless valid_user?
-      return false unless valid_record?
-
-      return user_can_delete_record?
+    def can_execute_action?
+      return can_delete_record?
     end
 
     def user_can_delete_record?
+      return not_implemented_exception(__method__) unless @record.respond_to?(:user_can_delete?)
+
       @record.user_can_delete?(@user)
     end
+
+    def user_cant_delete_error_key
+      "#{record_error_key}.user_cant_delete"
+    end
   end
 end

data/lib/nifty_services/base_service.rb

@@ -26,7 +26,7 @@ module NiftyServices
     end
 
     def initialize(options = {}, initial_response_status = 400)
-      @options = options.to_options!
+      @options = default_options.to_options!.merge(options).to_options!
       @errors = []
       @logger = options[:logger] || default_logger
       @executed = false
@@ -36,6 +36,10 @@ module NiftyServices
       end
     end
 
+    def execute
+      not_implemented_exception(__method__)
+    end
+
     def valid?
       return @errors.blank?
     end
@@ -52,14 +56,6 @@ module NiftyServices
       @response_status ||= :bad_request
     end
 
-    def changed_attributes
-      []
-    end
-
-    def changed?
-      changed_attributes.any?
-    end
-
     def valid_user?
       user_class = NiftyServices.config.user_class
 
@@ -98,20 +94,28 @@ module NiftyServices
     alias :runned? :executed?
 
     private
+    def default_options
+      {}
+    end
+
     def can_execute?
       not_implemented_exception(__method__)
     end
 
     def execute_action(&block)
-      return nil if executed?
+      begin
+        return nil if executed?
 
-      with_before_and_after_callbacks(:execute) do
-        if can_execute?
-          yield(block) if block_given?
+        with_before_and_after_callbacks(:execute) do
+          if can_execute?
+            yield(block) if block_given?
+          end
         end
-      end
 
-      @executed = true
+        @executed = true
+      rescue Exception => e
+        add_error(e)
+      end
 
       self # allow chaining
     end
@@ -203,7 +207,7 @@ module NiftyServices
         changes << attribute if (old_attributes[attribute] != value)
       end
 
-      changes
+      changes.map(&:to_sym)
     end
 
     def i18n_namespace

data/lib/nifty_services/base_update_service.rb

@@ -5,8 +5,9 @@ module NiftyServices
       execute_action do
         with_before_and_after_callbacks(:update) do
           if can_execute_action?
-            @updated_record = update_record
-            @updated_record ||= @record
+            duplicate_records_before_update
+
+            @record = update_record
 
             if success_updated?
               success_response
@@ -21,58 +22,68 @@ module NiftyServices
 
     def changed_attributes
       return [] if fail?
-      @changed_attributes ||= changes(@old_record, @record, changed_attributes_array)
+      @changed_attributes ||= changes(@last_record, @record, changed_attributes_array)
     end
 
     private
 
     def changed_attributes_array
-      record_allowed_params.keys
+      record_allowed_attributes.keys
     end
 
     def success_updated?
-      @updated_record.valid?
+      @record.valid?
     end
 
     def update_errors
-      @updated_record.errors
+      @record.errors
     end
 
     def update_record
-      @record.class.send(:update, @record.id, record_allowed_params)
+      @record.class.send(:update, @record.id, record_allowed_attributes)
     end
 
-    def can_execute_action?
-
+    def can_execute?
       unless valid_record?
-        return not_found_error!("#{record_error_key}.not_found")
+        return not_found_error!(invalid_record_error_key)
       end
 
-      unless valid_user?
-        return not_found_error!('users.not_found')
+      if validate_user? && !valid_user?
+        return not_found_error!(invalid_user_error_key)
       end
 
-      unless can_update?
-        return forbidden_error!("#{record_error_key}.user_cant_update")
+      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
     end
 
-    def can_update?
-      return false unless valid_user?
-      return false unless valid_record?
-
-      return user_can_update_record?
+    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?)
+
       @record.user_can_update?(@user)
     end
 
-    def after_success
-      @old_record = @record.dup
-      @record = @updated_record
+    def duplicate_records_before_update
+      @last_record = @record.dup
+    end
+
+    def invalid_record_error_key
+      "#{record_error_key}.not_found"
     end
+
+    def user_cant_update_error_key
+      "#{record_error_key}.user_cant_update"
+    end
+
   end
 end

data/lib/nifty_services/configuration.rb

@@ -31,9 +31,9 @@ module NiftyServices
       end
     end
 
-    attr_reader :logger, :options, :i18n_namespace
+    attr_reader :options
 
-    attr_accessor :user_class, :service_concerns_namespace
+    attr_accessor :logger, :i18n_namespace, :user_class, :service_concerns_namespace
 
     def initialize(options = {})
       @options = options

data/lib/nifty_services/version.rb

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

data/nifty_services.gemspec

@@ -20,10 +20,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'activesupport', '~> 4.2.2'
-
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "pry"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", '~> 10.5.0'
+  spec.add_development_dependency "rspec", '~> 3.5.0'
+  spec.add_development_dependency "pry", '~> 0'
+  spec.add_runtime_dependency 'activesupport', '>= 4.2.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nifty_services
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Rafael Fidelis
@@ -11,75 +11,75 @@ cert_chain: []
 date: 2016-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.2
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.2
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: 10.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: 10.5.0
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 3.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 3.5.0
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 4.2.2
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.2.2
 description: The dead simple services object oriented layer for Ruby applications
   to give robustness and cohesion back to your code.
 email:
@@ -99,7 +99,6 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- daily_news.log
 - lib/nifty_services.rb
 - lib/nifty_services/base_action_service.rb
 - lib/nifty_services/base_create_service.rb
@@ -113,7 +112,6 @@ files:
 - lib/nifty_services/util.rb
 - lib/nifty_services/version.rb
 - nifty_services.gemspec
-- test.rb
 homepage: https://github.com/fidelisrafael/nifty_services
 licenses:
 - MIT

data/daily_news.log

@@ -1,7 +0,0 @@
-# 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/test.rb

@@ -1,82 +0,0 @@
-class DailyNewsMailSendService < NiftyServices::BaseService
-
-  before_execute do
-    log.info('Routine started at: %s' % Time.now)
-  end
-
-  after_execute do
-    log.info('Routine ended at: %s' % Time.now)
-  end
-
-  after_initialize do
-    user_data = [@user.name, @user.email]
-    log.info('Routine Details: Send daily news email to user %s(%s)' % user_data)
-  end
-
-  after_success do
-    log.info('Success sent daily news feed email to user')
-  end
-
-  before_error do
-    log.warn('Something went wrong')
-  end
-
-  after_error do
-    log.error('Error sending email to user. See details below :(')
-    log.error(errors)
-  end
-
-  attr_reader :user
-
-  def initialize(user, options = {})
-    @user = user
-    super(options)
-  end
-
-  def execute
-    execute_action do
-      if can_execute?
-        success_response if send_mail_to_user
-      end
-    end
-  end
-
-  private
-  def send_mail_to_user
-    # just to fake, a real implementation could be something like:
-    # @user.send_daily_news_mail!
-    return true
-  end
-
-  def can_execute?
-    unless valid_user?
-      # returns false
-      return not_found_error!('users.not_found')
-    end
-
-    unless @user.abble_to_receive_daily_news_mail?
-      # returns false
-      return forbidden_error!('users.yet_received_daily_news_mail')
-    end
-
-    return true
-  end
-
-  def valid_user?
-    # check if object is valid and is a User class type
-    valid_object?(@user, User)
-  end
-end
-
-class User < Struct.new(:name, :email)
-  # just to play around with results
-  def abble_to_receive_daily_news_mail?
-    rand(10) < 5
-  end
-end
-
-user = User.new('Rafael Fidelis', 'rafa_fidelis@yahoo.com.br')
-
-# Default logger is NiftyService.config.logger # Logger.new('/dev/null')
-service = DailyNewsMailSendService.new(user, logger: Logger.new('daily_news.log'))
-service.execute