skinny_controllers 0.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad259a752520b2a0fbfd467b7f4dd50ee97ba1a2
-  data.tar.gz: b2a7c7b3d82895b1e66b1677f0137c6d91947503
+  metadata.gz: f549f005c93de6eb099efb11b80a429c99077cf0
+  data.tar.gz: 44dd3003008e227b826fff4c51b3c1e9d28cf9d7
 SHA512:
-  metadata.gz: 5d276829328864ccc91cda85e6b7c866a7e22b397fe598645eb0b5b2e0414c9bf23b54b13233951f56e156221a351d1ecd753be7339cd28ba1e016f6d8696fee
-  data.tar.gz: cc2d9d76498663038ea08a401cff03672da41115cfa1aa35b9f4ac4530129387225d699351e91f46d5b686c3411e321653f7c2b1e755fa79ffc5fdf717f59e9a
+  metadata.gz: 975ae25a383bee2c3b88d79b126c95be07c379cf69382ce24666ef0963cd89a6e312fa8cd530944f784c0ec63599b2afcdc294678cfe9f13f58bd4c649ee5c6d
+  data.tar.gz: c0a2877d7e19e90deaa5c5e43f54222ffc256fd2a7b1487ad79fd149011504288ffea052e8510bd9dd164bff20dd319f9e940727277a1d791a01ee683af92e15

data/README.md

@@ -42,7 +42,7 @@ The above does a multitude of assumptions to make sure that you can type the lea
 3. Your model responds to `find`, and `where`
 4. Your model responds to `is_accessible_to?`. This can be changed at `SkinnyControllers.accessible_to_method`
 
-### Your model name is different from your resource name
+### Your model name might be different from your resource name
 Lets say you have a JSON API resource that you'd like to render that has some additional/subset of data.
 Maybe the model is an `Event`, and the resource an `EventSummary` (which could do some aggregation of `Event` data).
 
@@ -128,11 +128,14 @@ SkinnyControllers.controller_namespace = 'API'
 ```
 
 The following options are available:
- - `operations_namespace`
- - `operations_suffix`
- - `policy_suffix`
- - `controller_namespace` defaults to `''`
- - `allow_by_default` defaults to `true`
- - `accessible_to_method` defaults to `is_accessible_to?`
- - `accessible_to_scope` defaults to `accessible_to`
- - `action_map` see [skinny_controllers.rb](./lib/skinny_controllers.rb#L61)
+
+|Option|Default|Note|
+|------|-------|----|
+|`operations_namespace` | '' | Optional namespace to put all the operations in. |
+|`operations_suffix`|`'Operations'` | Default suffix for the operations namespaces. |
+|`policy_suffix`|`'Policy'`  | Default suffix for policies classes. |
+|`controller_namespace`|`''`| Global Namespace for all controllers (e.g.: `'API'`) |
+|`allow_by_default`| `true` | Default permission |
+|`accessible_to_method`|`is_accessible_to?`| method to call an the object that the user might be able to access |
+|`accessible_to_scope`| `accessible_to`| scope / class method on an object that the user might be able to access |
+|`action_map`| see [skinny_controllers.rb](./lib/skinny_controllers.rb#L61)| |

data/lib/skinny_controllers/diet.rb

@@ -2,6 +2,10 @@ module SkinnyControllers
   module Diet
     extend ActiveSupport::Concern
 
+    included do
+      cattr_accessor :model_class
+    end
+
     # TODO: what if we want multiple operations per action?
     #
     # @return an instance of the operation with default parameters
@@ -12,73 +16,27 @@ module SkinnyControllers
     # Assumes the operation name from the controller name
     #
     # @example SomeObjectsController => Operation::SomeObject::Action
-    #
+    # @return [Class] the operation class for the model and verb
     def operation_class
-      model_name = model_name_from_controller
-      klass_name = operation_class_from_model(model_name)
-      klass = klass_name.safe_constantize
-      klass || default_operation_class_for(model_name)
-    end
-
-    # dynamically creates a module for the model if it
-    # isn't already defined
-    def default_operation_class_for(model_name)
-      default_operation = Operation::Default
-      namespace = default_operation_namespace_for(model_name)
-
-      default = "#{namespace.name}::Default".safe_constantize
-      default || namespace.const_set('Default'.freeze, default_operation.dup)
-    end
-
-    def default_operation_namespace_for(model_name)
-      desired_namespace = operation_namespace_from_model(model_name)
-
-      parent_namespace = SkinnyControllers.operations_namespace
-      namespace = "#{parent_namespace}::#{desired_namespace}".safe_constantize
-      namespace || Object.const_set(desired_namespace, Module.new)
+      Lookup::Operation.from_controller(self.class.name, verb_for_action, model_class)
     end
 
     # abstraction for `operation.run`
     # useful when there is no logic needed for deciding what to
     # do with an operation or if there is no logic to decide which operation
     # to use
+    #
+    # @return [ActiveRecord::Base] the model
     def model
       @model ||= operation.run
     end
 
     private
 
-    def operation_namespace_from_model(model_name)
-      "#{model_name}#{SkinnyControllers::operations_suffix}"
-    end
-
     # action name is inherited from ActionController::Base
     # http://www.rubydoc.info/docs/rails/2.3.8/ActionController%2FBase%3Aaction_name
     def verb_for_action
       SkinnyControllers.action_map[action_name] || SkinnyControllers.action_map['default']
     end
-
-    def model_name_from_controller
-      object_name = resource_name_from_controller.singularize
-      # remove the namespace if one exists
-      object_name.slice! controller_name_prefix
-      object_name
-    end
-
-    def resource_name_from_controller
-      controller_name = self.class.name
-      controller_name.gsub('Controller', '')
-    end
-
-    def operation_class_from_model(model_name)
-      prefix = SkinnyControllers.operations_namespace
-      namespace = operation_namespace_from_model(model_name)
-      "#{prefix}::#{namespace}::#{verb_for_action}"
-    end
-
-    def controller_name_prefix
-      namespace = SkinnyControllers.controller_namespace || ''
-      "#{namespace}::" if namespace
-    end
   end
 end

data/lib/skinny_controllers/lookup/controller.rb

@@ -0,0 +1,38 @@
+module SkinnyControllers
+  module Lookup
+    module Controller
+      module_function
+
+      # @example ObjectsController => Objects
+      # @return [String] the resource name
+      def resource_name(controller_name)
+        controller_name.gsub('Controller', '')
+      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
+        object_name = resource_name.singularize
+        # remove the namespace if one exists
+        object_name.slice! namespace
+        object_name
+      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

data/lib/skinny_controllers/lookup/model.rb

@@ -0,0 +1,33 @@
+module SkinnyControllers
+  module Lookup
+    module Model
+      module_function
+
+      # @example 'ObjectOperations::Verb' => Object
+      #
+      # @return [Class] class based on the operation
+      def class_from_operation(operation_name)
+        # "Namespace::Model" => "Model"
+        model_name = Model.name_from_operation(operation_name)
+        # object_type_of_interest.demodulize
+
+        # "Model" => Model
+        model_name.constantize
+      end
+
+      # @example 'Namespace::ModelOperation::Verb' => 'Model'
+      # @return [String] the model name corresponding to the operation
+      def name_from_operation(operation_name)
+        # operation_name is something of the form:
+        # Namespace::ModelOperations::Verb
+
+        # Namespace::ModelOperations::Verb => Namespace::ModelOperations
+        namespace = operation_name.deconstantize
+        # Namespace::ModelOperations => ModelOperations
+        nested_namespace = namespace.demodulize
+        # ModelOperations => Model
+        nested_namespace.gsub(SkinnyControllers.operations_suffix, '')
+      end
+    end
+  end
+end

data/lib/skinny_controllers/lookup/operation.rb

@@ -0,0 +1,65 @@
+module SkinnyControllers
+  module Lookup
+    module Operation
+      module_function
+
+      # @example ObjectOperations::Verb
+      #
+      # @param [String] model_name name of the model
+      # @param [String] verb the verb/action for the operation
+      # @return [Class] the operation based on the model name and the verb
+      def operation_of(model_name, verb)
+        klass_name = Lookup::Operation.name_from_model(model_name, verb)
+        klass_name.safe_constantize
+      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)
+        klass = operation_of(model_name, verb)
+        klass || default_operation_class_for(model_name)
+      end
+
+      # dynamically creates a module for the model if it
+      # isn't already defined
+      # @return [Class] default operation class
+      def default_operation_class_for(model_name)
+        default_operation = SkinnyControllers::Operation::Default
+        namespace = Lookup::Operation.default_operation_namespace_for(model_name)
+
+        default = "#{namespace.name}::Default".safe_constantize
+        default || namespace.const_set('Default'.freeze, default_operation.dup)
+      end
+
+      # @return [Class] namespace for the default operation class
+      def default_operation_namespace_for(model_name)
+        desired_namespace = namespace_from_model(model_name)
+
+        parent_namespace = SkinnyControllers.operations_namespace
+        namespace = "#{parent_namespace}::#{desired_namespace}".safe_constantize
+        namespace || Object.const_set(desired_namespace, Module.new)
+      end
+
+      # @example 'Object' => 'ObjectOperations'
+      # @return [String] the operation namespace based on the model name
+      def namespace_from_model(model_name)
+        "#{model_name}#{SkinnyControllers.operations_suffix}"
+      end
+
+      # @example 'Model', 'Verb' => [optional namespace]::ModelOperations::Verb
+      #
+      # @param [String] model_name name of the model
+      # @param [String] the verb/action for the operation
+      # @return [String] the operation based on the model name
+      def name_from_model(model_name, verb)
+        # this namespace is '' by default
+        prefix = SkinnyControllers.operations_namespace
+        namespace = Lookup::Operation.namespace_from_model(model_name)
+        "#{prefix}::#{namespace}::#{verb}"
+      end
+    end
+  end
+end

data/lib/skinny_controllers/lookup/policy.rb

@@ -0,0 +1,25 @@
+module SkinnyControllers
+  module Lookup
+    module Policy
+      module_function
+
+      # @param [String] name the name of the model
+      # @return [Class] the policy class
+      def class_from_model(name)
+        (
+          "#{namespace}::#{name}" +
+          SkinnyControllers.policy_suffix
+        ).constantize
+      end
+
+      # @param [String] class_name name of the operation class
+      def method_name_for_operation(class_name)
+        class_name.demodulize.downcase + POLICY_METHOD_SUFFIX
+      end
+
+      def namespace
+        SkinnyControllers.policies_namespace
+      end
+    end
+  end
+end

data/lib/skinny_controllers/operation/base.rb

@@ -3,8 +3,8 @@ module SkinnyControllers
     #
     # An example Operation may looy like
     #
-    # module Operations
-    #   class Event::Read < Base
+    # module EventOperations
+    #   class Read < SkinnyControllers::Policy::Base
     #     def run
     #       model if allowed?
     #     end
@@ -13,13 +13,12 @@ module SkinnyControllers
     #
     # TODO: make the above the 'default' and not require to be defined
     class Base
-      include PolicyHelpers
       include ModelHelpers
 
       attr_accessor :params, :current_user, :authorized_via_parent
 
       def self.run(current_user, params)
-        object = self.new(current_user, params)
+        object = new(current_user, params)
         object.run
       end
 
@@ -41,34 +40,47 @@ module SkinnyControllers
       end
 
       def object_class
-        unless @object_class
-          # "Namespace::Model" => "Model"
-          model_name = object_type_of_interest.demodulize
-          # "Model" => Model
-          @object_class = model_name.constantize
-        end
-
-        @object_class
+        @object_class ||= Lookup::Model.class_from_operation(self.class.name)
       end
 
       def object_type_of_interest
-        unless @object_type_name
-          # Namespace::ModelOperations::Verb
-          klass_name = self.class.name
-          # Namespace::ModelOperations::Verb => Namespace::ModelOperations
-          namespace = klass_name.deconstantize
-          # Namespace::ModelOperations => ModelOperations
-          nested_namespace = namespace.demodulize
-          # ModelOperations => Model
-          @object_type_name = nested_namespace.gsub(SkinnyControllers.operations_suffix, '')
-        end
-
-        @object_type_name
+        @object_type_name ||= Lookup::Model.name_from_operation(self.class.name)
       end
 
       def association_name_from_object
         object_type_of_interest.tableize
       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(object_type_of_interest)
+      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)
+      end
+
+      def allowed?
+        allowed_for?(model)
+      end
+
+      # checks the policy
+      def allowed_for?(object)
+        policy_for(object).send(policy_method_name)
+      end
     end
   end
 end

data/lib/skinny_controllers/operation/model_helpers.rb

@@ -4,8 +4,6 @@ module SkinnyControllers
       def model
         # TODO: not sure if multiple ids is a good idea here
         # if we don't have a(ny) id(s), get all of them
-
-
         @model ||=
           if id_from_params
             model_from_id
@@ -27,8 +25,8 @@ module SkinnyControllers
       def scoped_model(scoped_params)
         unless @scoped_model
           klass_name = scoped_params[:type]
-          operation_name = operation_for(klass_name, 'Read'.freeze)
-          operation = operation_name.constantize.new(current_user, id: scoped_params[:id])
+          operation_class = Lookup::Operation.operation_of(klass_name, DefaultVerbs::Read)
+          operation = operation_class.new(current_user, id: scoped_params[:id])
           @scoped_model = operation.run
           self.authorized_via_parent = !!@scoped_model
         end
@@ -36,22 +34,13 @@ module SkinnyControllers
         @scoped_model
       end
 
-      def operation_for(klass_name, verb)
-        operations_class_namespace +
-        klass_name +
-        SkinnyControllers.operations_suffix +
-        "::#{verb}"
-      end
-
-      def operations_class_namespace
-        namespace = SkinnyControllers.policies_namespace
-        "#{namespace}::" if namespace
-      end
-
       def model_from_params
         ar_proxy = object_class.where(sanitized_params)
 
         if ar_proxy.respond_to? SkinnyControllers.accessible_to_scope
+          # It's better to filter in sql, than in the app, so if there is
+          # a way to do the filtering in active query, do that. This will help
+          # mitigate n+1 query scenarios
           return ar_proxy.accessible_to(current_user)
         end
 

data/lib/skinny_controllers/version.rb

@@ -1,3 +1,3 @@
 module SkinnyControllers
-  VERSION = 0.2
+  VERSION = 0.3
 end

data/lib/skinny_controllers.rb

@@ -7,21 +7,20 @@ require 'active_support/core_ext/string/inflections'
 
 # files for this gem
 require 'skinny_controllers/default_verbs'
+require 'skinny_controllers/lookup/controller'
+require 'skinny_controllers/lookup/model'
+require 'skinny_controllers/lookup/operation'
+require 'skinny_controllers/lookup/policy'
 require 'skinny_controllers/policy/base'
-require 'skinny_controllers/operation/policy_helpers'
 require 'skinny_controllers/operation/model_helpers'
 require 'skinny_controllers/operation/base'
 require 'skinny_controllers/operation/default'
 require 'skinny_controllers/diet'
 require 'skinny_controllers/version'
 
-# load the policies and operations to the top level name space.
-if defined? Rails
-  $LOAD_PATH.unshift Rails.root + '/app/operations'
-  $LOAD_PATH.unshift Rails.root + '/app/policies'
-end
-
 module SkinnyControllers
+  POLICY_METHOD_SUFFIX = '?'.freeze
+
   # Tells the Diet what namespace of the controller
   # isn't going to be part of the model name
   #
@@ -32,11 +31,11 @@ module SkinnyControllers
   cattr_accessor :controller_namespace
 
   cattr_accessor :operations_suffix do
-    'Operations'
+    'Operations'.freeze
   end
 
   cattr_accessor :policy_suffix do
-    'Policy'
+    'Policy'.freeze
   end
 
   cattr_accessor :operations_namespace do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skinny_controllers
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
 platform: ruby
 authors:
 - L. Preston Sego III
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-17 00:00:00.000000000 Z
+date: 2015-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -189,10 +189,13 @@ 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/lookup/model.rb
+- lib/skinny_controllers/lookup/operation.rb
+- lib/skinny_controllers/lookup/policy.rb
 - lib/skinny_controllers/operation/base.rb
 - lib/skinny_controllers/operation/default.rb
 - lib/skinny_controllers/operation/model_helpers.rb
-- lib/skinny_controllers/operation/policy_helpers.rb
 - lib/skinny_controllers/policy/base.rb
 - lib/skinny_controllers/version.rb
 homepage: https://github.com/NullVoxPopuli/skinny-controllers
@@ -218,5 +221,5 @@ rubyforge_project:
 rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: SkinnyControllers-0.2
+summary: SkinnyControllers-0.3
 test_files: []

data/lib/skinny_controllers/operation/policy_helpers.rb

@@ -1,49 +0,0 @@
-module SkinnyControllers
-  module Operation
-    module PolicyHelpers
-      POLICY_METHOD_SUFFIX = '?'.freeze
-
-      # 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 ||= (
-          policy_class_namespace +
-          object_type_of_interest +
-          SkinnyControllers.policy_suffix
-        ).constantize
-      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 ||= self.class.name.demodulize.downcase + POLICY_METHOD_SUFFIX
-      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)
-      end
-
-      def allowed?
-        allowed_for?(model)
-      end
-
-      # checks the policy
-      def allowed_for?(object)
-        policy_for(object).send(policy_method_name)
-      end
-
-      private
-
-      def policy_class_namespace
-        namespace = SkinnyControllers.policies_namespace
-        "#{namespace}::" if namespace
-      end
-    end
-  end
-end