skinny_controllers 0.8.7 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d45d23ac0f04c5efbf788022aade5462a6a410a1
-  data.tar.gz: 037b8bbfb81b0e627ad9e799b4cf853c2954c862
+  metadata.gz: f20c80e6d30015ce35842974c6ce2bc4b559034f
+  data.tar.gz: d43809e60ad51ec26de9a1e329c6ec7c4d1a381b
 SHA512:
-  metadata.gz: cb9a6efa65736d0ee7006dcfd79955f3e1aae5d7642db7813b4d61414aaa1672090997546a4f8fe6d5b3540c584d611006d331d80dcf75d3d51d1e1cbbcebb2b
-  data.tar.gz: b0aeb2fc909bf923bb5cb00e19b625482b314a2bb2ed097b42f83c58a7a1f8397b06b633704e84fd456cb9ed7bac99abc4ac686a04b502ab4f3717ea50cc8e1c
+  metadata.gz: e059c8cf6a99882880258002dab529e429929fc98b165a69ff3b24990fd18b7b2a5b3380e7e6973daf83323ece699b4afda8de96d958d3af05432726c542300b
+  data.tar.gz: d6928db4a0884a190aabd50a1195f179b7f6aed7782742130ca5ed63d3bd37025a739f3288ecac98303201fd63f103c024c9605fb7bf69f4ec333dcc9cc596fd

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 L. Preston Sego III
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/lib/generators/operation/operation_generator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class OperationGenerator < Rails::Generators::NamedBase
   # gives us file_name
   source_root File.expand_path('../templates', __FILE__)

data/lib/generators/policy/policy_generator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class PolicyGenerator < Rails::Generators::NamedBase
   # gives us file_name
   source_root File.expand_path('../templates', __FILE__)

data/lib/generators/skinny_controller/skinny_controller_generator.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
 class SkinnyControllerGenerator < Rails::Generators::NamedBase
   # gives us file_name
   source_root File.expand_path('../templates', __FILE__)
 
   def generate_layout
-    template 'skinny_controller.rb.erb', File.join('app/controllers', class_path, "#{file_name}_controller.rb")
+    template 'skinny_controller.rb.erb',
+      File.join('app/controllers', class_path, "#{file_name}_controller.rb")
   end
 
   def operation_name

data/lib/skinny_controllers/default_verbs.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
   module DefaultVerbs
     # show

data/lib/skinny_controllers/diet.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
   module Diet
     extend ActiveSupport::Concern
@@ -16,7 +17,9 @@ module SkinnyControllers
       @operation ||= operation_class.new(
         current_user,
         params, params_for_action,
-        action_name, self.class.model_key)
+        action_name, self.class.model_key,
+        _lookup
+      )
     end
 
     # Assumes the operation name from the controller name
@@ -24,7 +27,15 @@ module SkinnyControllers
     # @example SomeObjectsController => Operation::SomeObject::Action
     # @return [Class] the operation class for the model and verb
     def operation_class
-      Lookup::Operation.from_controller(self.class.name, verb_for_action, self.class.model_class)
+      _lookup.operation_class
+    end
+
+    def _lookup
+      @_lookup ||= Lookup.from_controller(
+        controller_class: self.class,
+        verb:             verb_for_action,
+        model_class:      self.class.model_class
+      )
     end
 
     # abstraction for `operation.run`
@@ -61,7 +72,7 @@ module SkinnyControllers
         elsif klass
           klass.name.underscore
         else
-          Lookup::Controller.model_name(self.class.name).underscore
+          _lookup.model_name.underscore
         end
 
       action_params_method = "#{action_name}_#{model_key}_params"
@@ -81,8 +92,8 @@ module SkinnyControllers
 
     def verb_for_action
       SkinnyControllers.action_map[action_name] ||
-      (action_name && action_name.classify) ||
-      SkinnyControllers.action_map['default']
+        (action_name && action_name.classify) ||
+        SkinnyControllers.action_map['default']
     end
   end
 end

data/lib/skinny_controllers/exceptions.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module SkinnyControllers
+  class ModelNotFound < StandardError; end
+  class DeniedByPolicy < StandardError; end
+end

data/lib/skinny_controllers/logging.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module SkinnyControllers
+  module Logging
+    extend ActiveSupport::Concern
+
+    included do
+      self.logger = Logger.new
+    end
+
+    class Logger
+      attr_accessor :_logger
+      attr_accessor :_tag
+      def initialize
+        @_logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+        @_tag = 'skinny_controllers'
+      end
+
+      def warn(*args)
+        _logger.tagged(_tag) { _logger.warn(*args) }
+      end
+
+      def info(*args)
+        _logger.tagged(_tag) { _logger.info(*args) }
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :logger
+    end
+  end
+end

data/lib/skinny_controllers/lookup/ensure_existence.rb

@@ -0,0 +1,117 @@
+module SkinnyControllers
+  class Lookup
+    module EnsureExistence
+      module_function
+
+      # @return [Module] namespace
+      def ensure_namespace!(namespace)
+        klass = namespace_lookup(namespace)
+        klass || Namespace.create_namespace(namespace)
+      end
+
+      def ensure_operation_class!(qualified_name)
+        klass = operation_lookup(qualified_name)
+        klass || use_defailt_operation(qualified_name)
+      end
+
+      def ensure_policy_class!(qualified_name)
+        klass = policy_lookup(qualified_name)
+        klass || Lookup::Policy.define_policy_class(qualified_name)
+      end
+
+      # This assumes the namespace already exists
+      # This is only to be used if there does not exist
+      # operation that goes by the name defined by
+      # qualified_name (hence the warn log at the top)
+      #
+      # @param [String] qualified_name the name of the class to create
+      # @example 'Api::V2::PostOperations::Create'
+      #
+      # @return [Class] a duplicate of the default operation
+      def use_defailt_operation(qualified_name)
+        SkinnyControllers.logger.warn("#{qualified_name} not found. Creating default...")
+
+        parts = qualified_name.split('::')
+        class_name = parts.pop
+        namespace = parts.join('::').safe_constantize
+
+        namespace.const_set(
+          class_name,
+          SkinnyControllers::Operation::Default.dup
+        )
+      end
+    end
+
+    def namespace_lookup(qualified_name)
+      return if qualified_name.blank?
+      klass = qualified_name.safe_constantize
+      return klass if klass
+      return unless qualified_name.include?('::')
+
+      parts = qualified_name.split('::')
+
+      # Api::V2::CategoriesNamespace
+      # => Api::CategoriesNamespace
+      demodulized = qualified_name.demodulize
+      namespace = parts[0..-3]
+      next_lookup = [namespace, demodulized].reject(&:blank?).join('::')
+      result = namespace_lookup(next_lookup)
+      return result if result
+
+      # Api::V2::CategoriesNamespace
+      # => V2::CategoriesNamespace
+      next_lookup = parts[1..-1].join('::')
+      namespace_lookup(next_lookup)
+    end
+
+    def policy_lookup(qualified_name)
+      return if qualified_name.blank?
+      klass = qualified_name.safe_constantize
+
+      # Return if the constant exists, or if we can't travel
+      # up any higher.
+      return klass if klass
+      return unless qualified_name.include?('::')
+
+      # "Api::V1::CategoryPolicy"
+      # => "CategorPolicy"
+      target = qualified_name.demodulize
+
+      # "Api::V1::CategoryPolicy"
+      # => "Api"
+      namespace = qualified_name.deconstantize.deconstantize
+      next_lookup = [namespace, target].reject(&:blank?).join('::')
+
+      # recurse
+      policy_lookup(next_lookup)
+    end
+
+    def operation_lookup(qualified_name)
+      return if qualified_name.blank?
+      klass = qualified_name.safe_constantize
+
+      # Return if the constant exists, or if we can't travel
+      # up any higher.
+      return klass if klass
+      return unless qualified_name.scan(/::/).count > 1
+
+      # "Api::V1::CategoryOperations::Create"
+      # => "CategorOperations::Create"
+      parts = qualified_name.split('::')
+      target = parts[-2..-1]
+
+      # TODO: Lookup Chopping of namespaces going ->
+      # "Api::V1::CategoryOperations::Create"
+      # => "V1::CategoryOperaitons::Create"
+
+      # Lookup Chopping of namespaces going <-
+      # "Api::V1::CategoryOperations::Create"
+      # => "Api::CategoryOperations::Create"
+      namespace = parts[0..-4]
+      next_lookup = [namespace, target].reject(&:blank?).join('::')
+
+      # recurse
+      operation_lookup(next_lookup)
+    end
+  end
+end

data/lib/skinny_controllers/lookup/model.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module SkinnyControllers
-  module Lookup
+  class Lookup
     module Model
       module_function
 

data/lib/skinny_controllers/lookup/namespace.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module SkinnyControllers
-  module Lookup
+  class Lookup
     module Namespace
       module_function
 
@@ -16,15 +17,19 @@ module SkinnyControllers
         namespaces.each do |namespace|
           current = (existing + [namespace]).join('::')
           begin
+            # binding.pry
             Object.const_get(current)
-          rescue NameError => e
+          rescue NameError
+            SkinnyControllers.logger.warn("Module #{namespace} not found, creating...")
             previous.const_set(namespace, Module.new)
           end
 
           existing << namespace
-          previous = current.constantize
+          previous = current.safe_constantize
         end
 
+        SkinnyControllers.logger.warn("Namespace is nil. Attempted: '#{desired_namespace}'") unless previous
+
         previous
       end
     end

data/lib/skinny_controllers/lookup/operation.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module SkinnyControllers
-  module Lookup
+  class Lookup
     module Operation
       module_function
 
@@ -14,15 +15,6 @@ module SkinnyControllers
         klass || default_operation_class_for(model_name, verb)
       end
 
-      # @param [String] controller name of the controller class
-      # @param [String] verb
-      # @param [String] model_name optional
-      # @return [Class] the class or default
-      def from_controller(controller, verb, model_name = nil)
-        model_name ||= Lookup::Controller.model_name(controller)
-        operation_of(model_name, verb)
-      end
-
       # dynamically creates a module for the model if it
       # isn't already defined
       # @return [Class] default operation class
@@ -31,7 +23,13 @@ module SkinnyControllers
         default_operation = SkinnyControllers::Operation::Default
         namespace = Lookup::Operation.default_operation_namespace_for(model_name)
 
-        default = "#{namespace.name}::#{verb}".safe_constantize
+        operation_class_name = "#{namespace.name}::#{verb}"
+        default = operation_class_name.safe_constantize
+
+        unless default
+          SkinnyControllers.logger.warn("#{operation_class_name} not found. Creating default...")
+        end
+
         default || namespace.const_set(verb, default_operation.dup)
       end
 
@@ -40,7 +38,14 @@ module SkinnyControllers
         # binding.pry
         desired_namespace = namespace_from_model(model_name)
         parent_namespace = SkinnyControllers.operations_namespace
-        namespace = "#{parent_namespace}::#{desired_namespace}".safe_constantize
+
+        namespace_name = "#{parent_namespace}::#{desired_namespace}"
+        namespace = namespace_name.safe_constantize
+
+        unless namespace
+          SkinnyControllers.logger.warn("#{namespace_name} not found. Creating...")
+        end
+
         namespace || Namespace.create_namespace(desired_namespace)
       end
 

data/lib/skinny_controllers/lookup/policy.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module SkinnyControllers
-  module Lookup
+  class Lookup
     module Policy
       module_function
 
@@ -8,6 +9,11 @@ module SkinnyControllers
       def class_from_model(name)
         policy_class_name = class_name_from_model(name)
         klass = policy_class_name.safe_constantize
+
+        unless klass
+          SkinnyControllers.logger.warn("#{policy_class_name} not found. Creating Default...")
+        end
+
         klass || define_policy_class(policy_class_name)
       end
 

data/lib/skinny_controllers/lookup.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+module SkinnyControllers
+  # This class provides a way to determine all names / classes of operations
+  # and policies based on he given information.
+  #
+  # The class methods show what is required for each scenario
+  class Lookup
+    include EnsureExistence
+    include Policy
+
+    class << self
+      def from_controller(controller_class:, verb:, model_class:)
+        Lookup.new(
+          controller_class_name: controller_class.name,
+          verb:                  verb,
+          model_class:           model_class
+        )
+      end
+
+      def from_operation(operation_class:)
+        qualified_name = operation_class.name
+        parts = qualified_name.split('::')
+        operation_name = parts[-2]
+        operation_parts = operation_name.split(SkinnyControllers.operations_suffix)
+
+        Lookup.new(
+          verb:            parts.last,
+          # namespace:       parts[0..-3],
+          operation_name:  operation_name,
+          operation_class: operation_class,
+          model_name:      operation_parts.first,
+          namespace:       qualified_name.deconstantize.deconstantize
+        )
+      end
+    end
+
+    # @param [Hash] args - all possible parameters
+    # - @option [String] controller_class_name
+    # - @option [Class] controller_class
+    # - @option [String] verb
+    # - @option [String] operation_name
+    # - @option [String] model_name
+    # - @option [Class] model_class
+    # - @option [Hash] options
+    def initialize(args = {})
+      @controller_class_name = args[:controller_class_name]
+      @controller_class = args[:controller_class]
+      @verb_for_action = args[:verb]
+      @operation_name = args[:operation_name]
+      @operation_class = args[:operation_class]
+      @model_name = args[:model_name]
+      @namespace = args[:namespace]
+      @model_class = args[:model_class]
+      @policy_method_name = args[:policy_method_name]
+      @options = args[:options] || {}
+    end
+
+    # PostsController
+    # => PostOperations::Verb
+    #
+    # Api::V2::PostsController
+    # => Api::V2::PostOperations::Verb
+    def operation_class
+      @operation_class ||= begin
+        found_namespace = ensure_namespace!(operation_namespace)
+
+        operation = namespaced_operation_name.split(found_namespace.name).last
+        qualified_name = found_namespace ? found_namespace.name + operation : namespaced_operation_name
+
+        ensure_operation_class!(qualified_name)
+      end
+    end
+
+    def policy_class
+      @policy_class ||= begin
+        ensure_namespace!(namespace) if namespace.present?
+        ensure_policy_class!(namespaced_policy_name)
+      end
+    end
+
+    def policy_method_name
+      @policy_method_name ||= @verb_for_action.underscore + POLICY_METHOD_SUFFIX
+    end
+
+    def model_class
+      @model_class ||= @options[:model_class] || model_name.safe_constantize
+    end
+
+    def model_name
+      @model_name ||= @model_class.try(:name) || resource_parts[-1].singularize
+    end
+
+    # @return [String] name of the supposed operation class
+    def namespaced_operation_name
+      @namespaced_operation_name ||= [
+        operation_namespace,
+        @verb_for_action
+      ].reject(&:blank?).join('::')
+    end
+
+    def namespaced_policy_name
+      @namespaced_policy_name ||= [
+        namespace,
+        "#{model_name}#{SkinnyControllers.policy_suffix}"
+      ].reject(&:blank?).join('::')
+    end
+
+    def operation_namespace
+      @operation_namespace ||= [
+        namespace,
+        operation_name
+      ].reject(&:blank?).join('::')
+    end
+
+    def operation_name
+      @operation_name ||= "#{model_name}#{SkinnyControllers.operations_suffix}"
+    end
+
+    # @return [String] the namespace
+    def namespace
+      @namespace ||= begin
+        resource_parts.length > 1 ? resource_parts[0..-2].join('::') : ''
+      end
+    end
+
+    # PostsController
+    # => Posts
+    #
+    # Api::V2::PostsController
+    # => Api, V2, Posts
+    def resource_parts
+      @resource_parts ||= controller_class_name.split(/::|Controller/)
+    end
+
+    def controller_class_name
+      @controller_class_name ||= @controller_class.name
+    end
+  end
+end

data/lib/skinny_controllers/operation/base.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
   module Operation
     #
@@ -15,24 +16,48 @@ module SkinnyControllers
     class Base
       include ModelHelpers
 
-      attr_accessor :params, :current_user, :authorized_via_parent, :action, :params_for_action, :model_key
+      attr_accessor :params, :current_user, :authorized_via_parent,
+        :action, :params_for_action, :model_key, :_lookup
 
-      def self.run(current_user, params)
-        object = new(current_user, params)
-        object.run
+      class << self
+        def run(current_user, params)
+          object = new(current_user, params)
+          object.run
+        end
+
+        # To support the shorthand ruby/block syntax
+        # e.g.: MyOperation.()
+        alias_method :call, :run
       end
 
+      # To be overridden
+      def run; end
+
+      # To support teh shorthand ruby/block syntax
+      # e.g.: MyOperation.new().()
+      alias_method :call, :run
+
       # @param [Model] current_user the logged in user
       # @param [Hash] controller_params the params hash raw from the controller
       # @param [Hash] params_for_action optional params hash, generally the result of strong parameters
       # @param [string] action the current action on the controller
-      def initialize(current_user, controller_params, params_for_action = nil, action = nil, model_key = nil)
+      def initialize(current_user, controller_params, params_for_action = nil, action = nil,
+          model_key = nil, lookup = nil)
         self.authorized_via_parent = false
         self.current_user = current_user
         self.action = action || controller_params[:action]
         self.params = controller_params
         self.params_for_action = params_for_action || controller_params
         self.model_key = model_key
+        self._lookup = lookup
+      end
+
+      def lookup
+        @lookup ||= begin
+          _lookup || Lookup.from_operation(
+            operation_class: self.class
+          )
+        end
       end
 
       def id_from_params
@@ -46,13 +71,9 @@ module SkinnyControllers
         @id_from_params
       end
 
-      def model_class
-        @model_class ||= Lookup::Model.class_from_operation(self.class.name)
-      end
-
-      def model_name
-        @object_type_name ||= Lookup::Model.name_from_operation(self.class.name)
-      end
+      delegate :model_class, :model_name,
+        :policy_class, :policy_method_name,
+        to: :lookup
 
       # @example model_name == Namespace::Item
       #  -> model_name.tableize == namespace/items
@@ -63,26 +84,13 @@ module SkinnyControllers
         model_name.tableize.split('/').last
       end
 
-      # Takes the class name of self and converts it to a Policy class name
-      #
-      # @example In Operation::Event::Read, Policy::EventPolicy is returned
-      def policy_class
-        @policy_class ||= Lookup::Policy.class_from_model(model_name)
-      end
-
-      # Converts the class name to the method name to call on the policy
-      #
-      # @example Operation::Event::Read would become read?
-      def policy_method_name
-        @policy_method_name ||= Lookup::Policy.method_name_for_operation(self.class.name)
-      end
-
       # @return a new policy object and caches it
       def policy_for(object)
         @policy ||= policy_class.new(
           current_user,
           object,
-          authorized_via_parent: authorized_via_parent)
+          authorized_via_parent: authorized_via_parent
+        )
       end
 
       def allowed?

data/lib/skinny_controllers/operation/default.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
   module Operation
     class Default < Base
@@ -12,11 +13,14 @@ module SkinnyControllers
         #  - EventOperations::Destroy
         if creating?
           @model = model_class.new(model_params)
-          @model.save if allowed?
+
+          check_allowed!
+
+          @model.save
           return @model
         end
 
-        return unless allowed?
+        check_allowed!
 
         if updating?
           model.update(model_params)
@@ -40,6 +44,10 @@ module SkinnyControllers
       def destroying?
         action == 'destroy'
       end
+
+      def check_allowed!
+        raise DeniedByPolicy, action unless allowed?
+      end
     end
   end
 end

data/lib/skinny_controllers/operation/model_helpers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
   module Operation
     module ModelHelpers
@@ -42,7 +43,7 @@ module SkinnyControllers
         unless @model_params
           model_params = (params_for_action[model_param_name] || params_for_action)
 
-          @model_params = (model_params == params) ? {} : model_params.symbolize_keys
+          @model_params = model_params == params ? {} : model_params.symbolize_keys
         end
 
         @model_params
@@ -84,10 +85,9 @@ module SkinnyControllers
       def model_from_named_id(key, id)
         name = key.gsub(/_id$/, '')
         name = name.camelize
-        model_from_scope(
-          id: id,
-          type: name
-        )
+        association = model_from_scope(id: id, type: name)
+
+        SkinnyControllers.search_proc.call(association)
       end
 
       def model_from_scope(scope = params[:scope])

data/lib/skinny_controllers/policy/allow_all.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
   module Policy
     class AllowAll < Base

data/lib/skinny_controllers/policy/base.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
   module Policy
     class Base
@@ -18,21 +19,24 @@ module SkinnyControllers
       # @param [Array] args
       # @param [Proc] block
       def method_missing(method_name, *args, &block)
-        # if the method ends in a question mark, re-route to default
-        if method_name.to_s =~ /(.+)\?/
-          action = Regexp.last_match(1)
-          # alias destroy to delete
-          # TODO: this means that a destroy method, if defined,
-          #       will never be called.... good or bad?
-          #       should there be a difference between delete and destroy?
-          return send('delete?'.freeze) if action == 'destroy'.freeze
+        # unless the method ends in a question mark, re-route to default method_missing
+        return super unless method_name.to_s =~ /(.+)\?/
 
-          # we know that these methods don't take any parameters,
-          # so args and block can be ignored
-          send(:default?)
-        else
-          super
-        end
+        action = Regexp.last_match(1)
+        # alias destroy to delete
+        # TODO: this means that a destroy method, if defined,
+        #       will never be called.... good or bad?
+        #       should there be a difference between delete and destroy?
+        return send('delete?'.freeze) if action == 'destroy'.freeze
+
+        # we know that these methods don't take any parameters,
+        # so args and block can be ignored
+        SkinnyControllers.logger.warn("method '#{action}' in policy '#{self.class.name}' was not found. Using :default?")
+        send(:default?)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name.to_s =~ /(.+)\?/ || super
       end
 
       # if a method is not defined for a particular verb or action,
@@ -47,7 +51,7 @@ module SkinnyControllers
 
       # this should be used when checking access to a single object
       def read?(o = object)
-        return  o.send(accessible_method, user) if o.respond_to?(accessible_method)
+        return o.send(accessible_method, user) if o.respond_to?(accessible_method)
         default?
       end
 

data/lib/skinny_controllers/policy/default.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
   module Policy
     class Default < Base

data/lib/skinny_controllers/policy/deny_all.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
   module Policy
     class DenyAll < Base

data/lib/skinny_controllers/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SkinnyControllers
-  VERSION = '0.8.7'.freeze
+  VERSION = '0.9.0'.freeze
 end

data/lib/skinny_controllers.rb

@@ -1,17 +1,22 @@
+# frozen_string_literal: true
 # required gems
 require 'active_support'
 require 'active_support/core_ext/class'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/module/delegation'
 
 # files for this gem
 require 'skinny_controllers/default_verbs'
+require 'skinny_controllers/exceptions'
+require 'skinny_controllers/logging'
 require 'skinny_controllers/lookup/namespace'
-require 'skinny_controllers/lookup/controller'
 require 'skinny_controllers/lookup/model'
 require 'skinny_controllers/lookup/operation'
 require 'skinny_controllers/lookup/policy'
+require 'skinny_controllers/lookup/ensure_existence'
+require 'skinny_controllers/lookup'
 require 'skinny_controllers/policy/base'
 require 'skinny_controllers/policy/default'
 require 'skinny_controllers/policy/deny_all'
@@ -23,7 +28,9 @@ require 'skinny_controllers/diet'
 require 'skinny_controllers/version'
 
 module SkinnyControllers
-  POLICY_METHOD_SUFFIX = '?'.freeze
+  include Logging
+
+  POLICY_METHOD_SUFFIX = '?'
 
   # Tells the Diet what namespace of the controller
   # isn't going to be part of the model name
@@ -34,20 +41,42 @@ module SkinnyControllers
   #  # 'API::' would be removed from 'API::Namespace::ObjectNamesController'
   cattr_accessor :controller_namespace
 
+  # Allows integration of a search gem, like ransack.
+  # The scope of this proc is within an operation, so all operation
+  # instance variables will be available.
+  #
+  # - params
+  # - params_for_action
+  # - current_user
+  # - action
+  # - model_key
+  # - model_params
+  #
+  # @example
+  #   # config/initializers/skinny_controllers.rb
+  #   SkinnyControllers.search_proc = ->(association) {
+  #     association.ransack(params[:q]).result
+  #   }
+  cattr_accessor :search_proc do
+    lambda do |association|
+      association
+    end
+  end
+
   cattr_accessor :operations_suffix do
-    'Operations'.freeze
+    'Operations'
   end
 
   cattr_accessor :policy_suffix do
-    'Policy'.freeze
+    'Policy'
   end
 
   cattr_accessor :operations_namespace do
-    ''.freeze
+    ''
   end
 
   cattr_accessor :policies_namespace do
-    ''.freeze
+    ''
   end
 
   cattr_accessor :allow_by_default do
@@ -80,14 +109,14 @@ module SkinnyControllers
   cattr_accessor :action_map do
     {
       # @note the only way default will get called, is if action_name is nil
-      'default'.freeze => DefaultVerbs::Read,
-      'show'.freeze    => DefaultVerbs::Read,
-      'index'.freeze   => DefaultVerbs::ReadAll,
-      'destroy'.freeze => DefaultVerbs::Delete,
+      'default' => DefaultVerbs::Read,
+      'show'    => DefaultVerbs::Read,
+      'index'   => DefaultVerbs::ReadAll,
+      'destroy' => DefaultVerbs::Delete,
       # these two are redundant, as the action will be
       # converted to a verb via inflection
-      'create'.freeze  => DefaultVerbs::Create,
-      'update'.freeze  => DefaultVerbs::Update
+      'create'  => DefaultVerbs::Create,
+      'update'  => DefaultVerbs::Update
     }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skinny_controllers
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 0.9.0
 platform: ruby
 authors:
 - L. Preston Sego III
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-15 00:00:00.000000000 Z
+date: 2016-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -185,6 +185,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - lib/generators/operation/USAGE
 - lib/generators/operation/operation_generator.rb
@@ -198,7 +199,10 @@ files:
 - lib/skinny_controllers.rb
 - lib/skinny_controllers/default_verbs.rb
 - lib/skinny_controllers/diet.rb
-- lib/skinny_controllers/lookup/controller.rb
+- lib/skinny_controllers/exceptions.rb
+- lib/skinny_controllers/logging.rb
+- lib/skinny_controllers/lookup.rb
+- lib/skinny_controllers/lookup/ensure_existence.rb
 - lib/skinny_controllers/lookup/model.rb
 - lib/skinny_controllers/lookup/namespace.rb
 - lib/skinny_controllers/lookup/operation.rb
@@ -231,9 +235,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
-summary: SkinnyControllers-0.8.7
+summary: SkinnyControllers-0.9.0
 test_files: []
-has_rdoc: 

data/lib/skinny_controllers/lookup/controller.rb

@@ -1,38 +0,0 @@
-module SkinnyControllers
-  module Lookup
-    module Controller
-      module_function
-
-      # @example ObjectsController => Objects
-      # @return [String] the resource name
-      def resource_name(controller_name)
-        name = controller_name.gsub('Controller', '')
-        # remove the namespace if one exists
-        name.slice! namespace
-        name
-      end
-
-      # @example <ObjectsContreller> => Object
-      # @return [String] name of the class of the model
-      def model_name(controller)
-        resource_name = Controller.resource_name(controller)
-        # Convert Resources to Resource
-        resource_name.singularize
-      end
-
-      # TODO: add option to configure this per controller
-      #
-      # @example
-      #   If the controller_namespace is specified as 'API', and
-      #   the controller name is API::ObjectsController,
-      #   API:: will be ignored from the name. However if the
-      #   controller_namespace is left blank, API will be assumed to
-      #   be a part of the model's namespace.
-      # @return [String] the optional namespace of all controllers
-      def namespace
-        namespace = SkinnyControllers.controller_namespace || ''
-        "#{namespace}::" if namespace
-      end
-    end
-  end
-end