pragma 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27c896a2d1034183edbcae9079c7f435057e62da
-  data.tar.gz: bc5a709485d117f346b7d23880ab155e8d66392b
+  metadata.gz: 423424f1618e9c1e91217573586e6e10b70b5a06
+  data.tar.gz: 77cfe2fd44b3f5df6f22563345b9ae61d48413e4
 SHA512:
-  metadata.gz: b754320e5db9566992162c53ab8f1db93f5f073021745a5975ac7ea3ddd4c2334ebcaf39fb69447191c8dc2e2efd7574b685fa0703b222655303f2b00d4ebe79
-  data.tar.gz: 6067ff68d0fbaa81cc5de835109650bb4b7d4811a0795f0a76fc7b5dc6cbca8b042cbd54ebb9ea489dcec737e7b0df755d02b7609b2e3ab610e77312df537d66
+  metadata.gz: cea1554dba5bfdbb80680ea52d044843b7ab23ff28c04ccee072e750ae96b70cb2822963da3224b607fc06f9caa801e15ee8024037a2567dcb479fc7175c870b
+  data.tar.gz: f6af85934562c1538f576aba2e9a74dbfa2f2b60340a8e2a991a3cedfefd5edafd6eb44e23e7e80425861b4aa4cfe14d6212fb92bb7c84ac9f96f435259b2b21

data/.rubocop.yml

@@ -88,3 +88,15 @@ Metrics/ClassLength:
 
 Metrics/BlockLength:
   Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Naming/MethodName:
+  Enabled: false
+
+Naming/AccessorMethodName:
+  Enabled: false
+
+RSpec/MessageSpies:
+  EnforcedStyle: receive

data/CHANGELOG.md

@@ -1,8 +1,28 @@
 # Changelog
 
-## Unreleased
+All notable changes to this project will be documented in this file.
 
-- Removals
-- Bugfixes
-- Enhancements
-- Deprecation
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [2.1.0]
+
+### Added
+
+- Implemented `expand.limit` and `expand.enabled`
+- Implemented the `Ordering` macro
+- Implemented the `Filtering` macro
+
+### Fixed
+
+- Fixed automatic lookup of nested model classes
+
+## [2.0.0]
+
+First Pragma 2 release.
+
+[Unreleased]: https://github.com/pragmarb/pragma/compare/v2.1.0...HEAD
+[2.1.0]: https://github.com/pragmarb/pragma/compare/v2.0.0...v2.1.0
+[2.0.0]: https://github.com/pragmarb/pragma/compare/v1.2.6...v2.0.0

data/README.md

@@ -1,11 +1,12 @@
 # Pragma
 
-[![Build Status](https://img.shields.io/travis/pragmarb/pragma.svg?maxAge=3600&style=flat-square)](https://travis-ci.org/pragmarb/pragma)
-[![Dependency Status](https://img.shields.io/gemnasium/pragmarb/pragma.svg?maxAge=3600&style=flat-square)](https://gemnasium.com/github.com/pragmarb/pragma)
-[![Code Climate](https://img.shields.io/codeclimate/github/pragmarb/pragma.svg?maxAge=3600&style=flat-square)](https://codeclimate.com/github/pragmarb/pragma)
-[![Coveralls](https://img.shields.io/coveralls/pragmarb/pragma.svg?maxAge=3600&style=flat-square)](https://coveralls.io/github/pragmarb/pragma)
+[![Build Status](https://travis-ci.org/pragmarb/pragma.svg?branch=master)](https://travis-ci.org/pragmarb/pragma)
+[![Dependency Status](https://gemnasium.com/badges/github.com/pragmarb/pragma.svg)](https://gemnasium.com/github.com/pragmarb/pragma)
+[![Coverage Status](https://coveralls.io/repos/github/pragmarb/pragma/badge.svg?branch=master)](https://coveralls.io/github/pragmarb/pragma?branch=master)
+[![Maintainability](https://api.codeclimate.com/v1/badges/e51e8d7489eb72ab97ba/maintainability)](https://codeclimate.com/github/pragmarb/pragma/maintainability)
 
-Welcome to Pragma, a pragmatic (duh!), opinionated architecture for building JSON APIs with Ruby!
+Welcome to Pragma, an expressive, opinionated ecosystem for building beautiful RESTful APIs with 
+Ruby.
 
 You can think of this as a meta-gem that pulls in the following pieces:
 
@@ -99,8 +100,10 @@ This gem works best if you follow the recommended structure for organizing resou
             │   ├── destroy.rb
             │   ├── index.rb
             │   └── update.rb
+            └── decorator
+            |   ├── collection.rb
+            |   └── instance.rb
             └── policy.rb
-            └── decorator.rb
 ```
 
 Your modules and classes would, of course, follow the same structure: `API::V1::Article::Policy` and 
@@ -128,10 +131,10 @@ module API
       module Operation
         class Create < Pragma::Operation::Create
           # This assumes that you have the following:
-          #   - a policy that responds to #create?
-          #   - a Create contract
-          #   - a decorator
-          #   - an Article model
+          #   1) an Article model
+          #   2) a Policy (responding to #create?)
+          #   3) a Create contract
+          #   4) an Instance decorator
         end
       end
     end
@@ -139,6 +142,357 @@ module API
 end
 ```
 
+## Macros
+
+The FF are implemented through their own set of macros, which take care of stuff like authorizing,
+paginating, filtering etc.
+
+If you want, you can use these macros in your own operations.
+
+### Classes
+
+**Used in:** Index, Show, Create, Update, Destroy
+
+The `Classes` macro is responsible of tying together all the Pragma components: put it into an
+operation and it will determine the class names of the related policy, model, decorators and 
+contract. You can override any of these classes when defining the operation or at runtime if you
+wish.
+
+Example usage:
+
+```ruby
+module API
+  module V1
+    module Article
+      module Operation
+        class Create < Pragma::Operation::Base
+          # Let the macro figure out class names.
+          step Pragma::Operation::Macro::Classes()
+          step :execute!
+          
+          # But override the contract.
+          self['contract.default.class'] = Contract::CustomCreate
+          
+          def execute!(options)
+            # `options` contains the following:
+            #    
+            #    `model.class`
+            #    `policy.default.class`
+            #    `policy.default.scope.class`
+            #    `decorator.instance.class`
+            #    `decorator.collection.class`
+            #    `contract.default.class` 
+            #    
+            # These will be `nil` if the expected classes do not exist.
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+### Model
+
+**Used in:** Index, Show, Create, Update, Destroy
+
+The `Model` macro provides support for performing different operations with models. It can either
+build a new instance of the model, if you are creating a new record, for instance, or it can find
+an existing record by ID.
+
+Example of building a new record:
+
+```ruby
+module API
+  module V1
+    module Article
+      module Operation
+        class Create < Pragma::Operation::Base
+          # This step can be done by Classes if you want.
+          self['model.class'] = ::Article
+           
+          step Pragma::Operation::Macro::Model(:build)
+          step :save!
+          
+          def save!(options)
+            # Here you'd usually validate and assign parameters before saving.
+  
+            # ...
+  
+            options['model'].save!
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+As we mentioned, `Model` can also be used to find a record by ID:
+
+```ruby
+module API
+  module V1
+    module Article
+      module Operation
+        class Show < Pragma::Operation::Base
+          # This step can be done by Classes if you want.
+          self['model.class'] = ::Article
+           
+          step Pragma::Operation::Macro::Model(:find_by), fail_fast: true
+          step :respond!
+          
+          def respond!(options)
+            options['result.response'] = Response::Ok.new(
+              entity: options['model']
+            )
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+In the example above, if the record is not found, the macro will respond with `404 Not Found` and a
+descriptive error message for you. If you want to override the error handling logic, you can remove 
+the `fail_fast` option and instead implement your own `failure` step.
+
+### Policy
+
+**Used in:** Index, Show, Create, Update, Destroy
+
+The `Policy` macro ensures that the current user can perform an operation on a given record.
+
+Here's a usage example:
+
+```ruby
+module API
+  module V1
+    module Article
+      module Operation
+        class Show < Pragma::Operation::Base
+          # This step can be done by Classes if you want.
+          self['policy.default.class'] = Policy
+          
+          step :model!
+          step Pragma::Operation::Macro::Policy(), fail_fast: true
+          step :respond!
+          
+          def model!(params:, **)
+            options['model'] = ::Article.find(params[:id])
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+If the user is not authorized to perform the operation (i.e. if the policy's `#show?` method returns
+`false`), the macro will respond with `403 Forbidden` and a descriptive error message. If you want 
+to override the error handling logic, you can remove the `fail_fast` option and instead implement 
+your own `failure` step.
+
+### Filtering
+
+**Used in:** Index
+
+The `Filtering` macro provides a simple interface to define basic filters for your API. You simply
+include the macro and configure which filters you want to expose to the users.
+
+```ruby
+module API
+  module V1
+    module Article
+      module Operation
+        class Index < Pragma::Operation::Base
+          step :model!
+          step Pragma::Operation::Macro::Filtering()
+          step :respond!
+
+          self['filtering.filters'] = [
+            Pragma::Operation::Filter::Equals.new(param: :by_category, column: :category_id),
+            Pragma::Operation::Filter::Ilike.new(param: :by_title, column: :title)
+          ]
+          
+          def model!(params:, **)
+            options['model'] = ::Article.all
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+With the example above, you are exposing the `by_category` filter and the `by_title` filters. The 
+following filters are available for ActiveRecord currently:
+
+- `Equals`: performs an equality (`=`) comparison.
+- `Like`: performs a `LIKE` comparison.
+- `Ilike`: performs an `ILIKE` comparison.
+
+Support for more clauses as well as more ORMs will come soon.
+
+### Ordering
+
+**Used in:** Index
+
+As the name suggests, the `Ordering` macro allows you to easily implement default and user-defined
+ordering.
+
+Here's an example:
+
+```ruby
+module API
+  module V1
+    module Article
+      module Operation
+        class Index < Pragma::Operation::Base
+          # This step can be done by Classes if you want.
+          self['model.class'] = ::Article
+
+          self['ordering.default_column'] = :published_at
+          self['ordering.default_direction'] = :desc
+          self['ordering.columns'] = %i[title published_at updated_at]
+
+          step :model!
+
+          # This will override `model` with the ordered relation.
+          step Pragma::Operation::Macro::Ordering(), fail_fast: true
+
+          step :respond!
+
+          def model!(options)
+            options['model'] = options['model.class'].all
+          end
+          
+          def respond!(options)
+            options['result.response'] = Response::Ok.new(
+              entity: options['model']
+            )
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+If the user provides an invalid order column or direction, the macro will respond with `422 Unprocessable Entity`
+and a descriptive error message. If you wish to implement your own error handling logic, you can
+remove the `fail_fast` option and implement your own `failure` step.
+
+The macro accepts the following options, which can be defined on the operation or at runtime:
+
+- `ordering.columns`: an array of columns the user can order by.
+- `ordering.default_column`: the default column to order by (default: `created_at`).
+- `ordering.default_direction`: the default direction to order by (default: `desc`).
+- `ordering.column_param`: the name of the parameter which will contain the order column.
+- `ordering.direction_param`: the name of the parameter which will contain the order direction.
+
+### Pagination
+
+**Used in:** Index
+
+The `Pagination` macro is responsible for paginating collections of records through 
+[will_paginate](https://github.com/mislav/will_paginate). It also allows your users to set the 
+number of records per page.
+
+```ruby
+module API
+  module V1
+    module Article
+      module Operation
+        class Index < Pragma::Operation::Base
+          # This step can be done by Classes if you want.
+          self['model.class'] = ::Article
+
+          step :model!
+
+          # This will override `model` with the paginated relation.
+          step Pragma::Operation::Macro::Pagination(), fail_fast: true
+
+          step :respond!
+
+          def model!(options)
+            options['model'] = options['model.class'].all
+          end
+          
+          def respond!(options)
+            options['result.response'] = Response::Ok.new(
+              entity: options['model']
+            )
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+In the example above, if the page or per-page number fail validation, the macro will respond with
+`422 Unprocessable Entity` and a descriptive error message. If you wish to implement your own error 
+handling logic, you can remove the `fail_fast` option and implement your own `failure` step.
+
+The macro accepts the following options, which can be defined on the operation or at runtime:
+
+- `pagination.page_param`: the parameter that will contain the page number.
+- `pagination.per_page_param`: the parameter that will contain the number of items to include in each page.
+- `pagination.default_per_page`: the default number of items per page.
+- `pagination.max_per_page`: the max number of items per page.
+
+This macro is best used in conjunction with the [Collection](https://github.com/pragmarb/pragma-decorator#collection) 
+and [Pagination](https://github.com/pragmarb/pragma-decorator#pagination) modules of 
+[Pragma::Decorator](https://github.com/pragmarb/pragma-decorator), which will expose all the 
+pagination metadata.
+
+### Decorator
+
+**Used in:** Index, Show, Create, Update
+
+The `Decorator` macro uses one of your decorators to decorate the model. If you are using 
+[expansion](https://github.com/pragmarb/pragma-decorator#associations), it will also make sure that
+the expansion parameter is valid.
+
+Example usage:
+
+```ruby
+module API
+  module V1
+    module Article
+      module Operation
+        class Show < Pragma::Operation::Base
+          # This step can be done by Classes if you want.
+          self['decorator.instance.class'] = Decorator::Instance
+          
+          step :model!
+          step Pragma::Operation::Macro::Decorator(), fail_fast: true
+          step :respond!
+          
+          def model!(params:, **)
+            options['model'] = ::Article.find(params[:id])
+          end
+          
+          def respond!(options)
+            # Pragma does this for you in the default operations.
+            options['result.response'] = Response::Ok.new(
+              entity: options['result.decorator.instance']
+            )
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+The macro accepts the following options, which can be defined on the operation or at runtime:
+
+- `expand.enabled`: whether associations can be expanded.
+- `expand.limit`: how many associations can be expanded at once.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/pragmarb/pragma.

data/lib/pragma.rb

@@ -12,8 +12,15 @@ require 'pragma/version'
 
 require 'pragma/decorator/error'
 
+require 'pragma/operation/filter/base'
+require 'pragma/operation/filter/equals'
+require 'pragma/operation/filter/like'
+require 'pragma/operation/filter/ilike'
+
 require 'pragma/operation/macro/classes'
 require 'pragma/operation/macro/decorator'
+require 'pragma/operation/macro/filtering'
+require 'pragma/operation/macro/ordering'
 require 'pragma/operation/macro/pagination'
 require 'pragma/operation/macro/policy'
 require 'pragma/operation/macro/model'

data/lib/pragma/operation/create.rb

@@ -8,10 +8,10 @@ module Pragma
     class Create < Pragma::Operation::Base
       step Macro::Classes()
       step Macro::Model()
-      step Macro::Policy(), fail_fast: true
+      step Macro::Policy()
       step Macro::Contract::Build()
-      step Macro::Contract::Validate(), fail_fast: true
-      step Macro::Contract::Persist(), fail_fast: true
+      step Macro::Contract::Validate()
+      step Macro::Contract::Persist()
       step Macro::Decorator()
       step :respond!
 

data/lib/pragma/operation/destroy.rb

@@ -7,20 +7,21 @@ module Pragma
     # @author Alessandro Desantis
     class Destroy < Pragma::Operation::Base
       step Macro::Classes()
-      step Macro::Model(:find_by), fail_fast: true
-      step Macro::Policy(), fail_fast: true
+      step Macro::Model(:find_by)
+      step Macro::Policy()
       step :destroy!
-      failure :handle_invalid_model!, fail_fast: true
       step :respond!
 
       def destroy!(_options, model:, **)
-        model.destroy
-      end
+        unless model.destroy
+          options['result.response'] = Response::UnprocessableEntity.new(
+            errors: model.errors
+          ).decorate_with(Decorator::Error)
+
+          return false
+        end
 
-      def handle_invalid_model!(options, model:, **)
-        options['result.response'] = Response::UnprocessableEntity.new(
-          errors: model.errors
-        ).decorate_with(Decorator::Error)
+        true
       end
 
       def respond!(options)

data/lib/pragma/operation/filter/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    module Filter
+      class Base
+        attr_reader :param, :column
+
+        def initialize(param:, column:)
+          @param = param.to_sym
+          @column = column.to_sym
+        end
+
+        def apply(*)
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/filter/equals.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    module Filter
+      class Equals < Base
+        def apply(relation:, value:)
+          relation.where(column => value)
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/filter/ilike.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    module Filter
+      class Ilike < Base
+        def apply(relation:, value:)
+          relation.where("#{column} ILIKE ?", "%#{value}%")
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/filter/like.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    module Filter
+      class Like < Base
+        def apply(relation:, value:)
+          relation.where("#{column} LIKE ?", "%#{value}%")
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/index.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'trailblazer/dsl'
-
 module Pragma
   module Operation
     # Finds all records of the requested resource, authorizes them, paginates them and decorates
@@ -12,8 +10,10 @@ module Pragma
       step Macro::Classes()
       step :retrieve!
       step :scope!
-      step Macro::Pagination(), fail_fast: true
-      step Macro::Decorator(name: :collection), fail_fast: true
+      step Macro::Filtering()
+      step Macro::Ordering()
+      step Macro::Pagination()
+      step Macro::Decorator(name: :collection)
       step :respond!
 
       def retrieve!(options)
@@ -24,7 +24,7 @@ module Pragma
         options['model'] = options['policy.default.scope.class'].new(current_user, model).resolve
       end
 
-      def respond!(options, model:, **)
+      def respond!(options, **)
         options['result.response'] = Response::Ok.new(
           entity: options['result.decorator.collection']
         )

data/lib/pragma/operation/macro/classes.rb

@@ -48,9 +48,14 @@ module Pragma
             input.class.name.split('::')[0..-3]
           end
 
+          def root_namespace(input, options)
+            resource_namespace = resource_namespace(input, options)
+            resource_namespace[0..((resource_namespace.index('API') || 1) - 1)]
+          end
+
           def expected_model_class(input, options)
             [
-              nil,
+              root_namespace(input, options).join('::'),
               resource_namespace(input, options).last
             ].join('::')
           end

data/lib/pragma/operation/macro/decorator.rb

@@ -11,10 +11,9 @@ module Pragma
       module Decorator
         class << self
           def for(_input, name, options)
-            unless validate_params(options)
-              handle_invalid_contract(options)
-              return false
-            end
+            set_defaults(options)
+
+            return false unless validate_params(options)
 
             options["result.decorator.#{name}"] = options["decorator.#{name}.class"].new(
               options['model']
@@ -25,20 +24,42 @@ module Pragma
 
           private
 
+          def set_defaults(options)
+            hash_options = options.to_hash
+
+            {
+              'expand.enabled' => true
+            }.each_pair do |key, value|
+              options[key] = value unless hash_options.key?(key.to_sym)
+            end
+          end
+
           def validate_params(options)
             options['contract.expand'] = Dry::Validation.Schema do
-              optional(:expand).each(:str?)
+              optional(:expand) do
+                if options['expand.enabled']
+                  array? do
+                    each(:str?) &
+                      # This is the ugliest, only way I found to define a dynamic validation tree.
+                      (options['expand.limit'] ? max_size?(options['expand.limit']) : array?)
+                  end
+                else
+                  none? | empty?
+                end
+              end
             end
 
             options['result.contract.expand'] = options['contract.expand'].call(options['params'])
 
-            options['result.contract.expand'].errors.empty?
-          end
+            if options['result.contract.expand'].errors.any?
+              options['result.response'] = Response::UnprocessableEntity.new(
+                errors: options['result.contract.expand'].errors
+              ).decorate_with(Pragma::Decorator::Error)
 
-          def handle_invalid_contract(options)
-            options['result.response'] = Response::UnprocessableEntity.new(
-              errors: options['result.contract.expand'].errors
-            ).decorate_with(Pragma::Decorator::Error)
+              return false
+            end
+
+            true
           end
 
           def validate_expansion(options, name)

data/lib/pragma/operation/macro/filtering.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    module Macro
+      def self.Filtering
+        step = ->(input, options) { Filtering.for(input, options) }
+        [step, name: 'filtering']
+      end
+
+      module Filtering
+        class << self
+          def for(_input, options)
+            set_defaults(options)
+
+            options['model'] = apply_filtering(options)
+
+            true
+          end
+
+          private
+
+          def set_defaults(options)
+            {
+              'filtering.filters' => []
+            }.each_pair do |key, value|
+              options[key] = value unless options[key]
+            end
+          end
+
+          def apply_filtering(options)
+            relation = options['model']
+
+            options['filtering.filters'].each do |filter|
+              value = options['params'][filter.param]
+              next unless value.present?
+
+              relation = filter.apply(relation: options['model'], value: value)
+            end
+
+            relation
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/macro/model.rb

@@ -20,7 +20,10 @@ module Pragma
           end
         end
 
-        [step, name: 'model.build']
+        [step, name: "model.#{action || 'build'}"]
+      end
+
+      module Model
       end
     end
   end

data/lib/pragma/operation/macro/ordering.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    module Macro
+      def self.Ordering
+        step = ->(input, options) { Ordering.for(input, options) }
+        [step, name: 'ordering']
+      end
+
+      module Ordering
+        class << self
+          def for(_input, options)
+            set_defaults(options)
+
+            unless validate_params(options)
+              handle_invalid_contract(options)
+              return false
+            end
+
+            order_column = order_column(options)
+
+            if order_column
+              options['model'] = options['model'].order(order_column => order_direction(options))
+            end
+
+            true
+          end
+
+          private
+
+          def set_defaults(options)
+            default_column = if options['model.class']&.method_defined?(:created_at)
+              :created_at
+            end
+
+            {
+              'ordering.columns' => [default_column].compact,
+              'ordering.default_column' => default_column,
+              'ordering.default_direction' => :desc,
+              'ordering.column_param' => :order_property,
+              'ordering.direction_param' => :order_direction
+            }.each_pair do |key, value|
+              options[key] = value unless options[key]
+            end
+          end
+
+          def validate_params(options)
+            options['contract.ordering'] = Dry::Validation.Schema do
+              optional(options['ordering.column_param']).filled do
+                str? & included_in?(options['ordering.columns'].map(&:to_s))
+              end
+              optional(options['ordering.direction_param']).filled do
+                str? & included_in?(%w[asc desc ASC DESC])
+              end
+            end
+
+            options['result.contract.ordering'] = options['contract.ordering'].call(
+              options['params']
+            )
+
+            options['result.contract.ordering'].errors.empty?
+          end
+
+          def handle_invalid_contract(options)
+            options['result.response'] = Response::UnprocessableEntity.new(
+              errors: options['result.contract.ordering'].errors
+            ).decorate_with(Pragma::Decorator::Error)
+          end
+
+          def order_column(options)
+            params = options['params']
+            params[options['ordering.column_param']] || options['ordering.default_column']
+          end
+
+          def order_direction(options)
+            params = options['params']
+            params[options['ordering.direction_param']] || options['ordering.default_direction']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/macro/pagination.rb

@@ -34,7 +34,7 @@ module Pragma
               'pagination.default_per_page' => 30,
               'pagination.max_per_page' => 100
             }.each_pair do |key, value|
-              options[key] ||= value
+              options[key] = value unless options[key]
             end
           end
 
@@ -53,10 +53,14 @@ module Pragma
           def validate_params(options)
             options['contract.pagination'] = Dry::Validation.Schema do
               optional(options['pagination.page_param']).filled { int? & gteq?(1) }
-              optional(options['pagination.per_page_param']).filled { int? & (gteq?(1) & lteq?(options['pagination.max_per_page'])) }
+              optional(options['pagination.per_page_param']).filled do
+                int? & (gteq?(1) & lteq?(options['pagination.max_per_page']))
+              end
             end
 
-            options['result.contract.pagination'] = options['contract.pagination'].call(options['params'])
+            options['result.contract.pagination'] = options['contract.pagination'].call(
+              options['params']
+            )
 
             options['result.contract.pagination'].errors.empty?
           end

data/lib/pragma/operation/macro/policy.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'trailblazer/operation/pundit'
-
 module Pragma
   module Operation
     module Macro
@@ -31,7 +29,9 @@ module Pragma
           private
 
           def handle_unauthorized!(options)
-            options['result.response'] = Pragma::Operation::Response::Forbidden.new.decorate_with(Pragma::Decorator::Error)
+            options['result.response'] = Pragma::Operation::Response::Forbidden.new.decorate_with(
+              Pragma::Decorator::Error
+            )
           end
         end
       end

data/lib/pragma/operation/show.rb

@@ -7,8 +7,8 @@ module Pragma
     # @author Alessandro Desantis
     class Show < Pragma::Operation::Base
       step Macro::Classes()
-      step Macro::Model(:find_by), fail_fast: true
-      step Macro::Policy(), fail_fast: true
+      step Macro::Model(:find_by)
+      step Macro::Policy()
       step Macro::Decorator()
       step :respond!
 

data/lib/pragma/operation/update.rb

@@ -7,11 +7,11 @@ module Pragma
     # @author Alessandro Desantis
     class Update < Pragma::Operation::Base
       step Macro::Classes()
-      step Macro::Model(:find_by), fail_fast: true
-      step Macro::Policy(), fail_fast: true
+      step Macro::Model(:find_by)
+      step Macro::Policy()
       step Macro::Contract::Build()
-      step Macro::Contract::Validate(), fail_fast: true
-      step Macro::Contract::Persist(), fail_fast: true
+      step Macro::Contract::Validate()
+      step Macro::Contract::Persist()
       step Macro::Decorator()
       step :respond!
 

data/lib/pragma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pragma
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

data/pragma.gemspec

@@ -21,17 +21,17 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'trailblazer', '~> 2.0'
-  spec.add_dependency 'pragma-operation', '~> 2.0'
-  spec.add_dependency 'pragma-policy', '~> 2.0'
   spec.add_dependency 'pragma-contract', '~> 2.0'
   spec.add_dependency 'pragma-decorator', '~> 2.0'
+  spec.add_dependency 'pragma-operation', '~> 2.0'
+  spec.add_dependency 'pragma-policy', '~> 2.0'
+  spec.add_dependency 'trailblazer', '~> 2.0'
   spec.add_dependency 'will_paginate', '~> 3.1'
 
   spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'coveralls'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'rubocop-rspec'
-  spec.add_development_dependency 'coveralls'
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: pragma
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Alessandro Desantis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-27 00:00:00.000000000 Z
+date: 2018-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: trailblazer
+  name: pragma-contract
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: pragma-operation
+  name: pragma-decorator
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: pragma-policy
+  name: pragma-operation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: pragma-contract
+  name: pragma-policy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: pragma-decorator
+  name: trailblazer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -123,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -137,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -151,7 +151,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-rspec
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -165,7 +165,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -200,13 +200,19 @@ files:
 - lib/pragma/decorator/error.rb
 - lib/pragma/operation/create.rb
 - lib/pragma/operation/destroy.rb
+- lib/pragma/operation/filter/base.rb
+- lib/pragma/operation/filter/equals.rb
+- lib/pragma/operation/filter/ilike.rb
+- lib/pragma/operation/filter/like.rb
 - lib/pragma/operation/index.rb
 - lib/pragma/operation/macro/classes.rb
 - lib/pragma/operation/macro/contract/build.rb
 - lib/pragma/operation/macro/contract/persist.rb
 - lib/pragma/operation/macro/contract/validate.rb
 - lib/pragma/operation/macro/decorator.rb
+- lib/pragma/operation/macro/filtering.rb
 - lib/pragma/operation/macro/model.rb
+- lib/pragma/operation/macro/ordering.rb
 - lib/pragma/operation/macro/pagination.rb
 - lib/pragma/operation/macro/policy.rb
 - lib/pragma/operation/show.rb