pragma-operation 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac19a311eb12471d8c69452399e599886d163d38
-  data.tar.gz: a9e946273b5d8367392099b62e07c7c2def07af6
+  metadata.gz: 0d6cc18cf80b23f1275cdea3bdbdb5f898ab18bc
+  data.tar.gz: 432bbd348981310bff295afb60c4e188d6767f4d
 SHA512:
-  metadata.gz: 0bffc30f709028c91ef22eefd54b652cc392a0d1474b502f708ce0594002aa110031e20151274df27ba50fe811c770a863384f7bb425eac31a89e62075f57bd3
-  data.tar.gz: 9e7fd12a051c7bebe37b11843f43b978533ed9489ee5f44d1ded52ec942efe473d880bae66b3ced4d7ad2d6d61037373b8a37068ae76a71da50a51d43a71b553
+  metadata.gz: 34357046619e0302eacf52f6143c72eab02324a8ce781eb1f400afcb315f06cba2ef9aa469c67a68174fb117c8d281410458c27cc078f909c57a4f4768918a1d
+  data.tar.gz: 530f950bb5901d6436edb3954ab4553483b6f4375c8f37fa36dfe5805e2595dca6885295c7d55aa3f130e911932f08ca999bebafd87e71b36ac9b5a726604312

data/.rubocop.yml

@@ -53,7 +53,7 @@ Style/BracesAroundHashParameters:
   EnforcedStyle: context_dependent
 
 Lint/EndAlignment:
-  AlignWith: variable
+  EnforcedStyleAlignWith: variable
   AutoCorrect: true
 
 Style/AndOr:
@@ -85,3 +85,10 @@ Metrics/CyclomaticComplexity:
 
 Metrics/ClassLength:
   Enabled: false
+
+Style/CaseIndentation:
+  EnforcedStyle: end
+  IndentOneStep: false
+
+Metrics/BlockLength:
+  Enabled: false

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in pragma-operation.gemspec
 gemspec
+
+gem 'pry'

data/doc/02-contracts.md

@@ -27,6 +27,29 @@ module API
 end
 ```
 
+You can also pass a block to compute the contract class dynamically. If the block returns `nil`,
+validation will be skipped:
+
+```ruby
+module API
+  module V1
+    module Post
+      module Operation
+        class Create < Pragma::Operation::Base
+          contract do |context|
+            # ...
+          end
+
+          def call
+            # ...
+          end
+        end
+      end
+    end
+  end
+end
+```
+
 If the contract passes validation, then all is good. If not, an error is raised:
 
 ```ruby

data/doc/03-policies.md

@@ -26,6 +26,29 @@ module API
 end
 ```
 
+You can also pass a block to compute the policy class dynamically. If the block returns `nil`,
+authorization will be skipped:
+
+```ruby
+module API
+  module V1
+    module Post
+      module Operation
+        class Create < Pragma::Operation::Base
+          policy do |context|
+            # ...
+          end
+
+          def call
+            # ...
+          end
+        end
+      end
+    end
+  end
+end
+```
+
 Of course, you will now have to pass the user performing the operation in addition to the usual
 parameters:
 

data/doc/04-decorators.md

@@ -1,7 +1,8 @@
 # Decorators
 
 Operations integrate with [Pragma::Decorator](https://github.com/pragmarb/pragma-decorator). All you
-have to do is specify the policy class with `#decorator`. This will give you access to `#decorate`:
+have to do is specify the decorator class with `#decorator`. This will give you access to
+`#decorate`:
 
 ```ruby
 module API
@@ -9,7 +10,7 @@ module API
     module Post
       module Operation
         class Show < Pragma::Operation::Base
-          policy API::V1::Post::Policy
+          decorator API::V1::Post::Decorator
 
           def call
             post = Post.find(params[:id])
@@ -22,5 +23,28 @@ module API
 end
 ```
 
+You can also pass a block to compute the decorator class dynamically. If the block returns `nil`,
+decoration will be skipped:
+
+```ruby
+module API
+  module V1
+    module Post
+      module Operation
+        class Show < Pragma::Operation::Base
+          decorator do |context|
+            # ...
+          end
+
+          def call
+            # ...
+          end
+        end
+      end
+    end
+  end
+end
+```
+
 Note that `#decorate` works with both singular resources and collections, as it uses the decorator's
 [`.represent`](http://trailblazer.to/gems/representable/3.0/api.html) method.

data/lib/pragma/operation/authorization.rb

@@ -14,8 +14,15 @@ module Pragma
         # Sets the policy to use for authorizing this operation.
         #
         # @param klass [Class] a subclass of +Pragma::Policy::Base+
-        def policy(klass)
-          @policy = klass
+        #
+        # @yield A block which will be called with the operation's context which should return
+        #   the policy class. The block can also return +nil+ if authorization should be skipped.
+        def policy(klass = nil, &block)
+          if !klass && !block_given?
+            fail ArgumentError, 'You must pass either a policy class or a block'
+          end
+
+          @policy = klass || block
         end
 
         # Returns the policy class.
@@ -24,19 +31,6 @@ module Pragma
         def policy_klass
           @policy
         end
-
-        # Builds the policy for the given user and resource, using the previous defined policy
-        # class.
-        #
-        # @param user [Object]
-        # @param resource [Object]
-        #
-        # @return [Pragma::Policy::Base]
-        #
-        # @see #policy
-        def build_policy(user:, resource:)
-          policy_klass.new(user: user, resource: resource)
-        end
       end
 
       module InstanceMethods # :nodoc:
@@ -50,7 +44,10 @@ module Pragma
         # @see .policy
         # @see .build_policy
         def build_policy(resource)
-          self.class.build_policy(user: current_user, resource: resource)
+          policy_klass = compute_policy_klass
+          return resource unless policy_klass
+
+          policy_klass.new(user: current_user, resource: resource)
         end
 
         # Authorizes this operation on the provided resource or policy.
@@ -61,13 +58,15 @@ module Pragma
         #
         # @return [Boolean] whether the operation is authorized
         def authorize(authorizable)
-          return true unless self.class.policy_klass
+          return true unless compute_policy_klass
 
-          policy = if self.class.policy_klass && authorizable.is_a?(self.class.policy_klass)
+          # rubocop:disable Metrics/LineLength
+          policy = if Object.const_defined?('Pragma::Policy::Base') && authorizable.is_a?(Pragma::Policy::Base)
             authorizable
           else
             build_policy(authorizable)
           end
+          # rubocop:enable Metrics/LineLength
 
           params.each_pair do |name, value|
             next unless policy.resource.respond_to?("#{name}=")
@@ -102,13 +101,22 @@ module Pragma
         #
         # @return [Pragma::Decorator::Base|Enumerable]
         def authorize_collection(collection)
-          return collection unless self.class.policy_klass
+          policy_klass = compute_policy_klass
+          return collection unless policy_klass
 
-          self.class.policy_klass.accessible_by(
+          policy_klass.accessible_by(
             user: current_user,
             scope: collection
           )
         end
+
+        def compute_policy_klass
+          if self.class.policy_klass.is_a?(Proc)
+            self.class.policy_klass.call(context)
+          else
+            self.class.policy_klass
+          end
+        end
       end
     end
   end

data/lib/pragma/operation/decoration.rb

@@ -11,11 +11,18 @@ module Pragma
       end
 
       module ClassMethods # :nodoc:
-        # Sets the decorator to use for validating this operation.
+        # Sets the decorator to use for decorating this operation.
         #
         # @param klass [Class] a subclass of +Pragma::Decorator::Base+
-        def decorator(klass)
-          @decorator = klass
+        #
+        # @yield A block which will be called with the operation's context which should return
+        #   the decorator class. The block can also return +nil+ if decoration should be skipped.
+        def decorator(klass = nil, &block)
+          if !klass && !block_given?
+            fail ArgumentError, 'You must pass either a decorator class or a block'
+          end
+
+          @decorator = klass || block
         end
 
         # Returns the decorator class.
@@ -24,20 +31,6 @@ module Pragma
         def decorator_klass
           @decorator
         end
-
-        # Builds the decorator for the given resource, using the previously defined decorator class.
-        #
-        # Works with both singular resources and collections.
-        #
-        # @param resource [Object]
-        #
-        # @return [Pragma::Decorator::Base]
-        #
-        # @see #decorator
-        def build_decorator(resource)
-          resource = resource.to_a if resource.is_a?(Enumerable)
-          decorator_klass.represent(resource)
-        end
       end
 
       module InstanceMethods # :nodoc:
@@ -52,7 +45,8 @@ module Pragma
         #
         # @see #decorate
         def build_decorator(resource)
-          self.class.build_decorator(resource)
+          resource = resource.to_a if resource.is_a?(Enumerable)
+          compute_decorator_klass.represent(resource)
         end
 
         # If a decorator is defined, acts as an alias for {#build_decorator}. If not, simply returns
@@ -63,9 +57,19 @@ module Pragma
         #
         # @see #build_decorator
         def decorate(decoratable)
-          return decoratable unless self.class.decorator_klass
+          return decoratable unless compute_decorator_klass
           build_decorator(decoratable)
         end
+
+        private
+
+        def compute_decorator_klass
+          if self.class.decorator_klass.is_a?(Proc)
+            self.class.decorator_klass.call(context)
+          else
+            self.class.decorator_klass
+          end
+        end
       end
     end
   end

data/lib/pragma/operation/validation.rb

@@ -14,30 +14,23 @@ module Pragma
         # Sets the contract to use for validating this operation.
         #
         # @param klass [Class] a subclass of +Pragma::Contract::Base+
-        def contract(klass)
-          @contract = klass
+        #
+        # @yield A block which will be called with the operation's context which should return
+        #   the contract class. The block can also return +nil+ if validation should be skipped.
+        def contract(klass = nil, &block)
+          if !klass && !block_given?
+            fail ArgumentError, 'You must pass either a contract class or a block'
+          end
+
+          @contract = klass || block
         end
 
         # Returns the contract class.
         #
-        # @return [Class]
+        # @return [Class|Proc]
         def contract_klass
           @contract
         end
-
-        # Builds the contract for the given resource, using the previous defined contract class.
-        #
-        # If no contract has been defined for this operation, simply returns the resource.
-        #
-        # @param resource [Object]
-        #
-        # @return [Pragma::Contract::Base]
-        #
-        # @see #contract
-        def build_contract(resource)
-          return resource unless contract_klass
-          contract_klass.new(resource)
-        end
       end
 
       module InstanceMethods # :nodoc:
@@ -51,9 +44,11 @@ module Pragma
         # @return [Pragma::Contract::Base]
         #
         # @see .contract
-        # @see .build_contract
         def build_contract(resource)
-          self.class.build_contract(resource)
+          contract_klass = compute_contract_klass(resource)
+          return resource unless contract_klass
+
+          contract_klass.new(resource)
         end
 
         # Validates this operation on the provided contract or resource.
@@ -65,7 +60,8 @@ module Pragma
         #
         # @return [Boolean] whether the operation is valid
         def validate(validatable)
-          contract = if self.class.contract_klass && validatable.is_a?(self.class.contract_klass)
+          # rubocop:disable Metrics/LineLength
+          contract = if Object.const_defined?('Pragma::Contract::Base') && validatable.is_a?(Pragma::Contract::Base)
             validatable
           else
             build_contract(validatable)
@@ -84,7 +80,8 @@ module Pragma
         #
         # @param validatable [Object|Pragma::Contract::Base] contract or resource
         def validate!(validatable)
-          contract = if self.class.contract_klass && validatable.is_a?(self.class.contract_klass)
+          # rubocop:disable Metrics/LineLength
+          contract = if Object.const_defined?('Pragma::Contract::Base') && validatable.is_a?(Pragma::Contract::Base)
             validatable
           else
             build_contract(validatable)
@@ -127,6 +124,14 @@ module Pragma
             }
           }
         end
+
+        def compute_contract_klass(_resource)
+          if self.class.contract_klass.is_a?(Proc)
+            self.class.contract_klass.call(context)
+          else
+            self.class.contract_klass
+          end
+        end
       end
     end
   end

data/lib/pragma/operation/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Pragma
   module Operation
-    VERSION = '1.4.0'
+    VERSION = '1.5.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pragma-operation
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Alessandro Desantis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-03 00:00:00.000000000 Z
+date: 2017-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: interactor
@@ -198,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Business logic encapsulation for your JSON API.