pragma 2.1.1 → 2.2.0

data/lib/pragma/operation/macro.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    Macro = Pragma::Macro
+  end
+end

data/lib/pragma/operation/show.rb

@@ -10,7 +10,7 @@ module Pragma
       step Macro::Model(:find_by)
       step Macro::Policy()
       step Macro::Decorator()
-      step :respond!
+      step :respond!, name: 'respond'
 
       def respond!(options)
         options['result.response'] = Response::Ok.new(entity: options['result.decorator.instance'])

data/lib/pragma/operation/update.rb

@@ -13,7 +13,7 @@ module Pragma
       step Macro::Contract::Validate()
       step Macro::Contract::Persist()
       step Macro::Decorator()
-      step :respond!
+      step :respond!, name: 'respond'
 
       def respond!(options)
         options['result.response'] = Response::Ok.new(entity: options['result.decorator.instance'])

data/lib/pragma/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pragma
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Alessandro Desantis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-15 00:00:00.000000000 Z
+date: 2018-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pragma-contract
@@ -198,23 +198,27 @@ files:
 - bin/setup
 - lib/pragma.rb
 - lib/pragma/decorator/error.rb
+- lib/pragma/filter/base.rb
+- lib/pragma/filter/equals.rb
+- lib/pragma/filter/ilike.rb
+- lib/pragma/filter/like.rb
+- lib/pragma/filter/scope.rb
+- lib/pragma/filter/where.rb
+- lib/pragma/macro/classes.rb
+- lib/pragma/macro/contract/build.rb
+- lib/pragma/macro/contract/persist.rb
+- lib/pragma/macro/contract/validate.rb
+- lib/pragma/macro/decorator.rb
+- lib/pragma/macro/filtering.rb
+- lib/pragma/macro/model.rb
+- lib/pragma/macro/ordering.rb
+- lib/pragma/macro/pagination.rb
+- lib/pragma/macro/policy.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/filter.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/macro.rb
 - lib/pragma/operation/show.rb
 - lib/pragma/operation/update.rb
 - lib/pragma/version.rb
@@ -239,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.5
 signing_key: 
 specification_version: 4
 summary: A pragmatic architecture for building JSON APIs with Ruby.

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

@@ -1,20 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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/macro/classes.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Pragma
-  module Operation
-    module Macro
-      def self.Classes
-        step = ->(input, options) { Classes.for(input, options) }
-        [step, name: 'classes']
-      end
-
-      module Classes
-        class << self
-          def for(input, options)
-            {
-              'model.class' => expected_model_class(input, options),
-              'policy.default.class' => expected_policy_class(input, options),
-              'policy.default.scope.class' => expected_policy_scope_class(input, options),
-              'decorator.instance.class' => expected_instance_decorator_class(input, options),
-              'decorator.collection.class' => expected_collection_decorator_class(input, options),
-              'contract.default.class' => expected_contract_class(input, options)
-            }.each_pair do |key, value|
-              next if options[key]
-
-              # FIXME: This entire block is required to trigger Rails autoloading. Ugh.
-              begin
-                Object.const_get(value)
-              rescue NameError => e
-                # We check the error message to avoid silently ignoring other NameErrors
-                # thrown while initializing the constant.
-                if e.message.start_with?('uninitialized constant')
-                  # Required instead of a simple equality check because loading
-                  # API::V1::Post::Contract::Index might throw "uninitialized constant
-                  # API::V1::Post::Contract" if the resource has no contracts at all.
-                  error_constant = e.message.split.last
-                  raise e unless value.sub(/\A::/, '').start_with?(error_constant)
-                end
-              end
-
-              options[key] = if Object.const_defined?(value)
-                Object.const_get(value)
-              end
-            end
-          end
-
-          private
-
-          def resource_namespace(input, _options)
-            input.class.name.split('::')[0..-3]
-          end
-
-          def root_namespace(input, options)
-            resource_namespace = resource_namespace(input, options)
-            return [] if resource_namespace.first == 'API'
-            resource_namespace[0..((resource_namespace.index('API') || 1) - 1)]
-          end
-
-          def expected_model_class(input, options)
-            [
-              root_namespace(input, options).join('::'),
-              resource_namespace(input, options).last
-            ].join('::')
-          end
-
-          def expected_policy_class(input, options)
-            [
-              resource_namespace(input, options),
-              'Policy'
-            ].join('::')
-          end
-
-          def expected_policy_scope_class(input, options)
-            "#{expected_policy_class(input, options)}::Scope"
-          end
-
-          def expected_instance_decorator_class(input, options)
-            [
-              resource_namespace(input, options),
-              'Decorator',
-              'Instance'
-            ].join('::')
-          end
-
-          def expected_collection_decorator_class(input, options)
-            [
-              resource_namespace(input, options),
-              'Decorator',
-              'Collection'
-            ].join('::')
-          end
-
-          def expected_contract_class(input, options)
-            [
-              resource_namespace(input, options),
-              'Contract',
-              input.class.name.split('::').last
-            ].join('::')
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pragma/operation/macro/contract/build.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'trailblazer/operation/contract'
-
-module Pragma
-  module Operation
-    module Macro
-      module Contract
-        def self.Build(name: 'default', constant: nil, builder: nil)
-          step = lambda do |input, options|
-            Trailblazer::Operation::Contract::Build.for(
-              input,
-              options,
-              name: name,
-              constant: constant,
-              builder: builder
-            ).tap do |contract|
-              contract.current_user = options['current_user']
-            end
-          end
-
-          [step, name: 'contract.build']
-        end
-      end
-    end
-  end
-end

data/lib/pragma/operation/macro/contract/persist.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'trailblazer/operation/persist'
-
-module Pragma
-  module Operation
-    module Macro
-      module Contract
-        def self.Persist(**args)
-          step = lambda do |input, options|
-            Trailblazer::Operation::Pipetree::Step.new(
-              Trailblazer::Operation::Contract::Persist(**args).first
-            ).call(input, options).tap do |result|
-              unless result
-                options['result.response'] = Pragma::Operation::Response::UnprocessableEntity.new(
-                  errors: options['model'].errors.messages
-                ).decorate_with(Pragma::Decorator::Error)
-              end
-            end
-          end
-
-          [step, name: 'persist.save']
-        end
-      end
-    end
-  end
-end

data/lib/pragma/operation/macro/contract/validate.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'trailblazer/operation/validate'
-
-module Pragma
-  module Operation
-    module Macro
-      module Contract
-        def self.Validate(name: 'default', **args)
-          step = lambda do |input, options|
-            Trailblazer::Operation::Pipetree::Step.new(
-              Trailblazer::Operation::Contract::Validate(**args).first
-            ).call(input, options).tap do |result|
-              unless result
-                options['result.response'] = Pragma::Operation::Response::UnprocessableEntity.new(
-                  errors: options['contract.default'].errors.messages
-                ).decorate_with(Pragma::Decorator::Error)
-              end
-            end
-          end
-
-          [step, name: "contract.#{name}.validate"]
-        end
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Pragma
-  module Operation
-    module Macro
-      def self.Decorator(name: :instance)
-        step = ->(input, options) { Decorator.for(input, name, options) }
-        [step, name: "decorator.#{name}"]
-      end
-
-      module Decorator
-        class << self
-          def for(_input, name, options)
-            set_defaults(options)
-
-            return false unless validate_params(options)
-
-            options["result.decorator.#{name}"] = options["decorator.#{name}.class"].new(
-              options['model']
-            )
-
-            validate_expansion(options, name)
-          end
-
-          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) 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'])
-
-            if options['result.contract.expand'].errors.any?
-              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)
-            return true unless options["result.decorator.#{name}"].respond_to?(:validate_expansion)
-            options["result.decorator.#{name}"].validate_expansion(options['params'][:expand])
-            true
-          rescue Pragma::Decorator::Association::ExpansionError => e
-            options['result.response'] = Response::BadRequest.new(
-              entity: Pragma::Operation::Error.new(
-                error_type: :expansion_error,
-                error_message: e.message
-              )
-            ).decorate_with(Pragma::Decorator::Error)
-            false
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# 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