nifty_services 0.0.5 → 0.0.6

data/docs/webframeworks_integration.md

@@ -0,0 +1,145 @@
+# NiftyServices documentation
+
+---
+
+## Web Frameworks Integrations
+
+### Rails <a name="frameworks-rails"></a>
+
+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`
+
+```ruby
+# config/application.rb
+config.paths.add(File.join(Rails.root, 'lib'), glob: File.join('**', '*.rb'))
+
+config.autoload_paths << Rails.root.join('lib')
+```
+
+Second, create `lib/services` directory:
+
+`$ mkdir -p lib/services/v1/users`
+
+Next, configure:
+
+```ruby
+NiftyServices.configure do |config|
+  config.i18n_namespace = 'my_app'
+end
+```
+**Note**:  See [Configurations](./configuration.md) section to see all available configs
+
+Create your first service:
+
+```
+$ touch lib/services/v1/users/create_service.rb
+```
+
+Use in your controller:
+
+```ruby
+class UsersController < BaseController
+  def create
+    service = Services::V1::Users::CreateService.new(params).execute
+
+    default_response = { status: service.response_status, status_code: service.response_status_code }
+
+    if service.success?
+      response = { user: service.user, subscription: service.subscription }
+    else
+      response = { error: true, errors: service.errors }
+    end
+
+    render json: default_response.merge(response), status: service.response_status
+  end
+end
+```
+
+This can be even better if you move response code to a helper:
+
+```ruby
+# helpers/users_helper.rb
+module UsersHelper
+  include GenericHelpers
+
+  def response_for_user_create_service(service)
+    success_response = { user: service.user, subscription: service.subscription }
+    generic_response_for_service(service, success_response)
+  end
+
+end
+```
+
+```ruby
+# helpers/generic_helper.rb
+module GenericHelper
+
+  # 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 = {
+      status: service.response_status,
+      status_code: service.response_status_code,
+      success: service.success?
+    }
+
+    if service.success?
+      response = success_response
+    else
+      response = {
+        error: true,
+        errors: service.errors
+      }
+    end
+
+    default_response.merge(response)
+  end
+end
+
+Changing controller again: (looks so readable now <3)
+
+```ruby
+# controllers/users_controller.rb
+class UsersController < BaseController
+  def create
+    service = Services::V1::Users::CreateService.new(params).execute
+
+    render json: response_for_user_create_service(service), status: service.response_status
+  end
+end
+```
+
+Well done sir! Did you read the comments in `generic_response_for_service`? Read it and think a little about this and  prepare yourself for having orgasms when you realize how fuck awesome this will be for your API's. Need mode? Checkout [Sample Standartized API with NiftyServices Repository](http://github.com/fidelisrafael/nifty_services-api_sample)
+
+---
+
+### Grape/Sinatra/Padrino/Hanami/Rack <a name="frameworks-rack"></a>
+
+Well, the integration here don't variate too much from Rails, just follow the steps:
+
+**1 -** Decide where you'll put your services
+
+**2 -** Code that dam amazing services!
+
+**3 -** Instantiate the service in your framework entry point
+
+**4 -** Create helpers to handle service response
+
+**5 -** Be happy and go party!
+
+---
+
+## Integration Examples
+
+Need examples of integrations fully working? Check out one of the following repositories:
+
+[NiftyServices - Sinatra Sample](https://github.com/fidelisrafael/nifty_services-sinatra_example)
+NiftyServices - Grape Sample
+NiftyServices - Rails Sample
+
+---
+
+### Next
+
+See [Basic Services class Markups](./services_markup.md)

data/lib/nifty_services.rb

@@ -1,7 +1,8 @@
+require 'logger'
+
 require 'nifty_services/version'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/string/inflections'
+require 'nifty_services/support/hash'
+require 'nifty_services/support/string'
 
 module NiftyServices
 
@@ -16,12 +17,8 @@ module NiftyServices
   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)
+    def configuration
       @configuration ||= Configuration.new
 
       yield(@configuration) if block_given?

data/lib/nifty_services/base_action_service.rb

@@ -11,25 +11,22 @@ module NiftyServices
       execute_action do
         with_before_and_after_callbacks(:action) do
           # here user can
-          execute_service_action
-
-          if valid?
-            success_response
-          else
-            errors = action_errors
-            bad_request_error(errors) if errors.present?
+          with_before_and_after_callbacks(:execute_service_action) do
+            execute_service_action
           end
+
+          success_response if valid?
         end
       end
     end
 
     private
     def action_errors
-      []
+      @errors
     end
 
     def can_execute?
-      unless user_can_execute_action?
+      unless can_execute_action?
         return (valid? ? unprocessable_entity_error!(invalid_action_error_key) : false)
       end
 
@@ -40,7 +37,7 @@ module NiftyServices
       "#{record_error_key}.cant_execute_#{action_name}"
     end
 
-    def user_can_execute_action?
+    def can_execute_action?
       not_implemented_exception(__method__)
     end
 

data/lib/nifty_services/base_create_service.rb

@@ -1,18 +1,17 @@
 module NiftyServices
   class BaseCreateService < BaseCrudService
 
-    def initialize(user, options = {})
-      @user = user
-      super(nil, user, options)
+    def initialize(options = {})
+      super(nil, options)
     end
 
     def execute
       execute_action do
         with_before_and_after_callbacks(:create) do
           if can_execute_action?
-            @record = build_record
+            @record = with_before_and_after_callbacks(:build_record) { build_record }
 
-            if save_record
+            if try_to_save_record
               after_execute_success_response
             else
               errors = create_error_response(@record)
@@ -25,11 +24,20 @@ module NiftyServices
 
     private
     def save_record
+      save_method = NiftyServices.configuration.save_record_method
+
+      return save_method.call(@record) if save_method.respond_to?(:call)
+
+      @record.public_send(save_method)
+    end
+
+    def try_to_save_record
       begin
-        @record.save
+        save_record
       rescue => e
         on_save_record_error(e)
-        return false
+      ensure
+        return @record.valid?
       end
     end
 
@@ -42,7 +50,7 @@ module NiftyServices
     end
 
     def after_error_response(errors)
-      unprocessable_entity_error(errors) if errors.present?
+      unprocessable_entity_error(errors) if @errors.empty?
     end
 
     def after_execute_success_response
@@ -50,64 +58,46 @@ module NiftyServices
     end
 
     def build_record
-      if record_type.present?
-        return build_from_record_type(record_allowed_attributes)
+      unless record_type.nil?
+        # initialize @temp_record to be used in after_build_record callback
+        return @temp_record = build_from_record_type(record_allowed_attributes)
       end
 
-      return not_implemented_exception(__method__)
+      @temp_record = record_type.public_send(:new, record_allowed_attributes)
     end
 
-    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)
+    def build_record_scope
+      nil
     end
 
-    def can_execute?
-      if validate_ip_on_create? && !can_create_with_ip?
-        return forbidden_error!(%s(users.ip_temporarily_blocked))
-      end
+    def build_from_record_type(attributes)
+      scope = record_type
 
-      if validate_user? && !valid_user?
-        return not_found_error!(invalid_user_error_key)
+      if !build_record_scope.nil? && build_record_scope.respond_to?(:new)
+        scope = build_record_scope
       end
 
-      return true
+      scope.new(attributes)
     end
 
-    def can_create_record?
-      unless user_can_create_record?
-        return (valid? ? forbidden_error!(user_cant_create_error_key) : false)
-      end
-
+    def can_execute?
       return true
     end
 
-    def user_can_create_record?
+    def can_create_record?
       not_implemented_exception(__method__)
     end
 
     def can_execute_action?
-      return can_create_record?
-    end
-
-    def can_create_with_ip?
-      true
-    end
-
-    def validate_ip_on_create?
-      # TODO: Use NiftyService.config.validate_ip_on_create?
-      false
-    end
+      unless can_create_record?
+        return (valid? ? forbidden_error!(cant_create_error_key) : false)
+      end
 
-    def build_record_scope
-      nil
+      return true
     end
 
-    def user_cant_create_error_key
-      "#{record_error_key}.user_cant_create"
+    def cant_create_error_key
+      "#{record_error_key}.cant_create"
     end
   end
 end

data/lib/nifty_services/base_crud_service.rb

@@ -1,7 +1,4 @@
 module NiftyServices
-  module Concerns
-  end
-
   class BaseCrudService < BaseService
 
     attr_reader :record
@@ -17,22 +14,29 @@ module NiftyServices
         alias_method record_alias.to_sym, :record
       end
 
-      def include_concern(namespace, concern_type)
-        _module = "#{services_concern_namespace}::#{namespace.to_s.camelize}::#{concern_type.to_s.camelize}"
+      def whitelist_attributes(*attrs)
+        raise "Invalid whitelist attributes(#{attrs}) array" unless attrs.is_a?(Array)
 
-        self.include(_module.constantize)
-      end
+        attributes = *attrs.flatten.map(&:to_sym)
+
+        define_method :record_attributes_whitelist do
+          attributes
+        end
+
+        define_singleton_method :get_whitelist_attributes do
+          attributes
+        end
 
-      def services_concern_namespace
-        NiftyServices.config.service_concerns_namespace
+        attributes
       end
 
-      alias_method :concern, :include_concern
+      def get_whitelist_attributes
+        []
+      end
     end
 
-    def initialize(record, user, options = {})
+    def initialize(record, options = {})
       @record = record
-      @user = user
 
       super(options)
     end
@@ -64,38 +68,9 @@ module NiftyServices
     alias :record_safe_attributes :record_allowed_attributes
 
     private
-    def array_values_from_hash(options, key, root = nil)
-      options = options.symbolize_keys
-
-      if root.present?
-        options = (options[root.to_sym] || {}).symbolize_keys
-      end
-
-      return [] unless options.key?(key.to_sym)
-
-      values = options[key.to_sym]
-
-      return values if values.is_a?(Array)
-
-      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_error_key
-      record_type.to_s.pluralize.underscore
+      # very simple and poor way to pluralize string
+      record_type.to_s.underscore + "s"
     end
 
     def valid_record?

data/lib/nifty_services/base_delete_service.rb

@@ -5,10 +5,12 @@ module NiftyServices
       execute_action do
         with_before_and_after_callbacks(:delete) do
           if can_execute_action?
-            if destroy_record
+            deleted_record = with_before_and_after_callbacks(:delete_record) { delete_record }
+
+            if deleted_record
               success_response
             else
-              bad_request_error(@record.errors)
+              unprocessable_entity_error!(@record.errors)
             end
           end
         end
@@ -16,8 +18,17 @@ module NiftyServices
     end
 
     private
-    def destroy_record
-      @record.try(:destroy) || @record.try(:delete)
+    def delete_record
+      delete_method = NiftyServices.configuration.delete_record_method
+
+      if delete_method.respond_to?(:call)
+        delete_method.call(@record)
+      else
+        @record.public_send(delete_method)
+      end
+
+      # initialize @temp_record to be used in after_delete_record callback
+      @temp_record = @record
     end
 
     def can_execute?
@@ -25,33 +36,23 @@ module NiftyServices
         return not_found_error!("#{record_error_key}.not_found")
       end
 
-      if validate_user? && !valid_user?
-        return not_found_error!(invalid_user_error_key)
-      end
-
       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
+      not_implemented_exception(__method__)
     end
 
     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?)
+      unless can_delete_record?
+        return (valid? ? forbidden_error!(cant_delete_error_key) : false)
+      end
 
-      @record.user_can_delete?(@user)
+      return true
     end
 
-    def user_cant_delete_error_key
-      "#{record_error_key}.user_cant_delete"
+    def cant_delete_error_key
+      "#{record_error_key}.cant_delete"
     end
   end
 end