praxis 2.0.pre.18 → 2.0.pre.19

data/lib/praxis/extensions/pagination/pagination_handler.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Praxis
   module Extensions
     module Pagination
       class PaginationHandler
-        class PaginationException < Exception; end
+        class PaginationException < RuntimeError; end
 
         def self.paginate(query, pagination)
           return query unless pagination.paginator
@@ -10,57 +12,57 @@ module Praxis
           paginator = pagination.paginator
 
           q = if paginator.page
-            offset(query, (paginator.page - 1) * paginator.items)            
-          else
-            # If there is an order clause that complies with the "by" field sorting, we can use it directly
-            # i.e., We can be smart about allowing the main sort field matching the pagination one (in case you want to sub-order in a custom way)
-            oclause = if pagination.order.nil? || pagination.order.empty? # No ordering specified => use ascending based on the "by" field
-                        direction = :asc
-                        order(query, [{ asc: paginator.by }])
-                      else
-                        first_ordering = pagination.order.items.first
-                        direction = first_ordering.keys.first
-                        unless first_ordering[direction].to_sym == pagination.paginator.by.to_sym
-                          string_clause = pagination.order.items.map { |h|
-                            dir, name = h.first
-                            "#{name} #{dir}"
-                          }.join(',')
-                          raise PaginationException,
-                                "Ordering clause [#{string_clause}] is incompatible with pagination by field '#{pagination.paginator.by}'. " \
-                                "When paginating by a field value, one cannot specify the 'order' clause " \
-                                "unless the clause's primary field matches the pagination field."
-                        end
-                        order(query, pagination.order)
-                      end
-
-            if paginator.from
-              if direction == :desc
-                where_lt(oclause, paginator.by, paginator.from)
+                offset(query, (paginator.page - 1) * paginator.items)
               else
-                where_gt(oclause, paginator.by, paginator.from)
-              end
-            else
-              oclause
-            end
+                # If there is an order clause that complies with the "by" field sorting, we can use it directly
+                # i.e., We can be smart about allowing the main sort field matching the pagination one (in case you want to sub-order in a custom way)
+                oclause = if pagination.order.nil? || pagination.order.empty? # No ordering specified => use ascending based on the "by" field
+                            direction = :asc
+                            order(query, [{ asc: paginator.by }])
+                          else
+                            first_ordering = pagination.order.items.first
+                            direction = first_ordering.keys.first
+                            unless first_ordering[direction].to_sym == pagination.paginator.by.to_sym
+                              string_clause = pagination.order.items.map do |h|
+                                dir, name = h.first
+                                "#{name} #{dir}"
+                              end.join(',')
+                              raise PaginationException,
+                                    "Ordering clause [#{string_clause}] is incompatible with pagination by field '#{pagination.paginator.by}'. " \
+                                    "When paginating by a field value, one cannot specify the 'order' clause " \
+                                    "unless the clause's primary field matches the pagination field."
+                            end
+                            order(query, pagination.order)
+                          end
 
-          end
+                if paginator.from
+                  if direction == :desc
+                    where_lt(oclause, paginator.by, paginator.from)
+                  else
+                    where_gt(oclause, paginator.by, paginator.from)
+                  end
+                else
+                  oclause
+                end
+
+              end
           limit(q, paginator.items)
         end
 
-        def self.where_lt(query, attr, value)
-          raise "implement in derived class"
+        def self.where_lt(_query, _attr, _value)
+          raise 'implement in derived class'
         end
-        
-        def self.where_gt(query, attr, value)
-          raise "implement in derived class"
+
+        def self.where_gt(_query, _attr, _value)
+          raise 'implement in derived class'
         end
 
-        def self.offset(query, offset)
-          raise "implement in derived class"
+        def self.offset(_query, _offset)
+          raise 'implement in derived class'
         end
 
-        def self.limit(query, limit)
-          raise "implement in derived class"
+        def self.limit(_query, _limit)
+          raise 'implement in derived class'
         end
       end
     end

data/lib/praxis/extensions/pagination/pagination_params.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Praxis
   module Extensions
     module Pagination
@@ -76,40 +78,32 @@ module Praxis
             default_mode, default_value = target.defaults[:default_mode].first
             case pagination_type
             when :paging
-              if default_mode == :page
-                raise "Cannot disallow page-based pagination if you define a default pagination of:  page: #{default_value}"
-              end
+              raise "Cannot disallow page-based pagination if you define a default pagination of:  page: #{default_value}" if default_mode == :page
+
               target.defaults[:disallow_paging] = true
             when :cursor
-              if default_mode == :by
-                raise "Cannot disallow cursor-based pagination if you define a default pagination of:   by: #{default_value}"
-              end
+              raise "Cannot disallow cursor-based pagination if you define a default pagination of:   by: #{default_value}" if default_mode == :by
+
               target.defaults[:disallow_cursor] = true
             end
           end
 
           def default(spec)
-            unless spec.is_a?(Hash) && spec.keys.size == 1 && [:by, :page].include?(spec.keys.first)
+            unless spec.is_a?(Hash) && spec.keys.size == 1 && %i[by page].include?(spec.keys.first)
               raise "'default' syntax for pagination takes exactly one key specification. Either by: <:fieldname> or page: <num>" \
                     "#{spec} is invalid"
             end
             mode, value = spec.first
             def_mode = case mode
                        when :by
-                         if target.fields_allowed && !target.fields_allowed&.include?(value)
-                           raise "Error setting default pagination. Field #{value} is not amongst the allowed fields."
-                         end
-                         if target.defaults[:disallow_cursor]
-                           raise "Cannot define a default pagination that is cursor based, if cursor-based pagination is disallowed."
-                         end
+                         raise "Error setting default pagination. Field #{value} is not amongst the allowed fields." if target.fields_allowed && !target.fields_allowed&.include?(value)
+                         raise 'Cannot define a default pagination that is cursor based, if cursor-based pagination is disallowed.' if target.defaults[:disallow_cursor]
+
                          { by: value }
                        when :page
-                         unless value.is_a?(Integer)
-                           raise "Error setting default pagination. Initial page should be a integer (but got #{value})"
-                         end
-                         if target.defaults[:disallow_paging]
-                           raise "Cannot define a default pagination that is page-based, if page-based pagination is disallowed."
-                         end
+                         raise "Error setting default pagination. Initial page should be a integer (but got #{value})" unless value.is_a?(Integer)
+                         raise 'Cannot define a default pagination that is page-based, if page-based pagination is disallowed.' if target.defaults[:disallow_paging]
+
                          { page: value }
                        end
             target.defaults[:default_mode] = def_mode
@@ -141,9 +135,8 @@ module Praxis
 
         def self.paging_default_mode(newval = nil)
           if newval
-            unless newval.respond_to?(:keys) && newval.keys.size == 1 && [:by, :page].include?(newval.keys.first)
-              raise "Error setting paging_default_mode, value must be a hash with :by or :page keys"
-            end
+            raise 'Error setting paging_default_mode, value must be a hash with :by or :page keys' unless newval.respond_to?(:keys) && newval.keys.size == 1 && %i[by page].include?(newval.keys.first)
+
             @paging_default_mode = newval
           end
           @paging_default_mode
@@ -152,14 +145,13 @@ module Praxis
         # Abstract class, which needs to be used by subclassing it through the .for method, to link it to a particular
         # MediaType, so that the field name checking and value coercion can be performed
         class << self
-          attr_reader :media_type
-          attr_reader :defaults
+          attr_reader :media_type, :defaults
           attr_accessor :fields_allowed
 
           def for(media_type, **_opts)
             unless media_type < Praxis::MediaType
               raise ArgumentError, "Invalid type: #{media_type.name} for Paginator. " \
-                "Must be a subclass of MediaType"
+                'Must be a subclass of MediaType'
             end
 
             ::Class.new(self) do
@@ -206,11 +198,7 @@ module Praxis
           self
         end
 
-        attr_reader :by
-        attr_reader :from
-        attr_reader :items
-        attr_reader :page
-        attr_reader :total_count
+        attr_reader :by, :from, :items, :page, :total_count
 
         def self.example(_context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
           fields = if media_type
@@ -224,10 +212,10 @@ module Praxis
                      from = media_type.attributes[by].example(parent: mt_example).to_s
                      # Make sure to encode the value of the from, as it can contain commas and such
                      # Only add the from parameter if it's not empty (an empty from is not allowed and it's gonna blow up in load)
-                     optional_from_component = (from && !from.empty?) ? ",from=#{CGI.escape(from)}" : ''
+                     optional_from_component = from && !from.empty? ? ",from=#{CGI.escape(from)}" : ''
                      "by=#{by}#{optional_from_component},items=#{defaults[:page_size]}"
                    else
-                     "by=id,from=20,items=100"
+                     'by=id,from=20,items=100'
                    end
           load(fields)
         end
@@ -237,9 +225,10 @@ module Praxis
           instance.validate(context)
         end
 
-        CLAUSE_REGEX = /(?<type>[^=]+)=(?<value>.+)$/
+        CLAUSE_REGEX = /(?<type>[^=]+)=(?<value>.+)$/.freeze
         def self.load(paginator, _context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
           return paginator if paginator.is_a?(native_type) || paginator.nil?
+
           parsed = {}
           unless paginator.nil?
             parsed = paginator.split(',').each_with_object({}) do |paginator_string, hash|
@@ -305,7 +294,7 @@ module Praxis
           if media_type&.attributes
             attrs = media_type&.attributes || {}
             attribute = attrs[name.to_sym]
-            attribute.type.load(value) if attribute
+            attribute&.type&.load(value)
           else
             value
           end
@@ -320,28 +309,20 @@ module Praxis
           @total_count = parsed[:total_count]
         end
 
-        def validate(_context = Attributor::DEFAULT_ROOT_CONTEXT) # rubocop:disable Metrics/PerceivedComplexity
+        def validate(_context = Attributor::DEFAULT_ROOT_CONTEXT)
           errors = []
 
           if page
-            if self.class.defaults[:disallow_paging]
-              errors << "Page-based pagination is disallowed (i.e., using 'page=' parameter)"
-            end
+            errors << "Page-based pagination is disallowed (i.e., using 'page=' parameter)" if self.class.defaults[:disallow_paging]
           elsif self.class.defaults[:disallow_cursor]
             errors << "Cursor-based pagination is disallowed (i.e., using 'by=' or 'from=' parameter)"
           end
 
-          if page && page <= 0
-            errors << "Page parameter cannot be zero or negative! (got: #{parsed.page})"
-          end
+          errors << "Page parameter cannot be zero or negative! (got: #{parsed.page})" if page && page <= 0
 
-          if items && (items <= 0 || ( self.class.defaults[:max_items] && items > self.class.defaults[:max_items]) )
-            errors << "Value of 'items' is invalid (got: #{items}). It must be positive, and smaller than the maximum amount of items per request (set to #{self.class.defaults[:max_items]})"
-          end
+          errors << "Value of 'items' is invalid (got: #{items}). It must be positive, and smaller than the maximum amount of items per request (set to #{self.class.defaults[:max_items]})" if items && (items <= 0 || (self.class.defaults[:max_items] && items > self.class.defaults[:max_items]))
 
-          if page && (by || from)
-            errors << "Cannot specify the field to use and its start value to paginate from when using a fix pager (i.e., `by` and/or `from` params are not compabible with `page`)"
-          end
+          errors << 'Cannot specify the field to use and its start value to paginate from when using a fix pager (i.e., `by` and/or `from` params are not compabible with `page`)' if page && (by || from)
 
           if by && self.class.fields_allowed && !self.class.fields_allowed.include?(by.to_sym)
             errors << if self.class.media_type.attributes.key?(by.to_sym)
@@ -364,7 +345,7 @@ module Praxis
                   s
                 end
           str += ",items=#{items}" if @items
-          str += ",total_count=true" if @total_count
+          str += ',total_count=true' if @total_count
           str
         end
       end

data/lib/praxis/extensions/pagination/sequel_pagination_handler.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 require_relative 'pagination_handler'
 
 module Praxis
   module Extensions
     module Pagination
       class SequelPaginationHandler < PaginationHandler
-
         def self.where_lt(query, attr, value)
           query.where("#{attr} < ?", value)
         end
-        
+
         def self.where_gt(query, attr, value)
           query.where("#{attr} > ?", value)
         end
 
         def self.order(query, order)
           return query unless order
+
           order_clause = order.map do |spec_hash|
             direction, name = spec_hash.first
             case direction.to_sym
@@ -24,21 +26,20 @@ module Praxis
               Sequel.asc(name.to_sym)
             end
           end
-          query = query.order(*order_clause)
-          query
+          query.order(*order_clause)
         end
-        
+
         def self.count(query)
           query.count
         end
-        
+
         def self.offset(query, offset)
           query.offset(offset)
         end
 
         def self.limit(query, limit)
           query.limit(limit)
-        end        
+        end
       end
     end
   end

data/lib/praxis/extensions/pagination.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'link_header'
 rescue LoadError
@@ -43,17 +45,13 @@ module Praxis
 
       included do
         after :action do |controller, _callee|
-          if controller.response.status < 300
-            # If this action has the pagination parameter defined,
-            # calculate and set the pagination headers (Link header and possibly Total-Count)
-            if controller._pagination.paginator
-              headers = controller.build_pagination_headers(
-                pagination: controller._pagination,
-                current_url: controller.request.path,
-                current_query_params: controller.request.query
-              )
-              controller.response.headers.merge! headers
-            end
+          if controller.response.status < 300 && controller._pagination.paginator
+            headers = controller.build_pagination_headers(
+              pagination: controller._pagination,
+              current_url: controller.request.path,
+              current_query_params: controller.request.query
+            )
+            controller.response.headers.merge! headers
           end
         end
       end
@@ -75,9 +73,7 @@ module Praxis
         links = if pagination.paginator.by
                   # We're assuming that the last element has a "symbol/string" field with the same name of the "by" pagination.
                   last_element = response.body.last
-                  if last_element
-                    last_value = last_element[pagination.paginator.by.to_sym] || last_element[pagination.paginator.by]
-                  end
+                  last_value = last_element[pagination.paginator.by.to_sym] || last_element[pagination.paginator.by] if last_element
                   HeaderGenerator.build_cursor_headers(
                     paginator: pagination.paginator,
                     last_value: last_value,
@@ -97,7 +93,6 @@ module Praxis
           total_count: pagination.total_count
         )
       end
-
     end
   end
 end

data/lib/praxis/extensions/rails_compat/request_methods.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 # Make Praxis' request derive from ActionDispatch
 if defined? Praxis::Request
   puts "IT seems that we're trying to redefine Praxis' request parent too late."
-  puts "-> try to include the Rails compat pieces earlier in the bootstrap process (before Praxis::Request is requried)"
+  puts '-> try to include the Rails compat pieces earlier in the bootstrap process (before Praxis::Request is requried)'
   exit(-1)
 end
 
@@ -14,6 +16,3 @@ begin
   end
   require 'praxis/request'
 end
-
-
-

data/lib/praxis/extensions/rails_compat.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'praxis/extensions/rails_compat/request_methods'
 require 'praxis/plugins/rails_plugin'

data/lib/praxis/extensions/rendering.rb

@@ -1,32 +1,33 @@
+# frozen_string_literal: true
+
 module Praxis
   module Extensions
-
     module Rendering
       extend ActiveSupport::Concern
       include FieldExpansion
 
       def render(object, include_nil: false)
-        loaded = self.media_type.load(object)
+        loaded = media_type.load(object)
         renderer = Praxis::Renderer.new(include_nil: include_nil)
-        renderer.render(loaded, self.expanded_fields)
+        renderer.render(loaded, expanded_fields)
       rescue Attributor::DumpError
-        if self.media_type.domain_model == Object
-          warn "Detected the rendering of an object of type #{self.media_type} without having a domain object model set.\n" +
-               "Did you forget to define it?"
+        if media_type.domain_model == Object
+          warn "Detected the rendering of an object of type #{media_type} without having a domain object model set.\n" \
+               'Did you forget to define it?'
         end
         raise
       end
 
-      def display(object, include_nil: false, encoder: self.default_encoder )
-        identifier = Praxis::MediaTypeIdentifier.load(self.media_type.identifier)
+      def display(object, include_nil: false, encoder: default_encoder)
+        identifier = Praxis::MediaTypeIdentifier.load(media_type.identifier)
         identifier += encoder unless encoder.blank?
         response.headers['Content-Type'] = identifier.to_s
         response.body = render(object, include_nil: include_nil)
         response
       rescue Praxis::Renderer::CircularRenderingError => e
-          Praxis::Application.instance.validation_handler.handle!(
-          summary: "Circular Rendering Error when rendering response. " +
-                   "Please especify a view to narrow the dependent fields, or narrow your field set.",
+        Praxis::Application.instance.validation_handler.handle!(
+          summary: 'Circular Rendering Error when rendering response. ' \
+                   'Please especify a view to narrow the dependent fields, or narrow your field set.',
           exception: e,
           request: request,
           stage: :action,
@@ -37,7 +38,6 @@ module Praxis
       def default_encoder
         ''
       end
-
     end
   end
 end

data/lib/praxis/field_expander.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
+
 module Praxis
   class FieldExpander
     def self.expand(object, fields = true)
       new.expand(object, fields)
     end
 
-    attr_reader :stack
-    attr_reader :history
+    attr_reader :stack, :history
 
     def initialize
       @stack = Hash.new do |hash, key|
@@ -20,6 +20,7 @@ module Praxis
     def expand(object, fields = true)
       if stack[object].include? fields
         return history[object][fields] if history[object].include? fields
+
         # We should probably never get here, since we should have a record
         # of the history of an expansion if we're trying to redo it,
         # but we should also be conservative and raise here just in case.
@@ -61,11 +62,9 @@ module Praxis
 
     def expand_type(object, fields = true)
       unless object.respond_to?(:attributes)
-        if object.respond_to?(:member_attribute)
-          return expand_type(object.member_attribute.type, fields)
-        else
-          return true
-        end
+        return expand_type(object.member_attribute.type, fields) if object.respond_to?(:member_attribute)
+
+        return true
       end
 
       # just include the full thing if it has no attributes
@@ -80,11 +79,11 @@ module Praxis
       result = expand_fields(object.attributes, fields) do |dumpable, sub_fields|
         expand(dumpable.type, sub_fields)
       end
-      unless fields == true 
+      unless fields == true
         non_matching = fields.keys - object.attributes.keys
         raise "FieldExpansion error: attribute(s) #{non_matching} do not exist in #{object}" unless non_matching.empty?
       end
       history[object][fields].merge!(result)
     end
   end
-end
+end

data/lib/praxis/file_group.rb

@@ -1,26 +1,23 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   class FileGroup
-
     attr_reader :groups, :base
 
     def initialize(base, &block)
       if base.nil?
-        raise ArgumentError, "base must not be nil." \
-          "Are you missing a call Praxis::Application.instance.setup?"
+        raise ArgumentError, 'base must not be nil.' \
+          'Are you missing a call Praxis::Application.instance.setup?'
       end
 
-
-      @groups = Hash.new
+      @groups = {}
       @base = Pathname.new(base)
 
-      if block_given?
-        self.instance_eval(&block)
-      end
+      instance_eval(&block) if block_given?
     end
 
     def layout(&block)
-      self.instance_eval(&block)
+      instance_eval(&block)
     end
 
     def map(name, pattern, &block)
@@ -30,7 +27,7 @@ module Praxis
         @groups[name] = FileGroup.new(base + pattern, &block)
       else
         @groups[name] ||= []
-        files = Pathname.glob(base+pattern).select { |file| file.file? }
+        files = Pathname.glob(base + pattern).select(&:file?)
         files.sort_by! { |file| [file.to_s.split('/').size, file.to_s] }
         files.each { |file| @groups[name] << file }
       end
@@ -39,6 +36,5 @@ module Praxis
     def [](*names)
       names.inject(@groups) { |group, name| group[name] || [] }
     end
-
   end
 end

data/lib/praxis/finalizable.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Praxis
   module Finalizable
     def self.extended(klass)

data/lib/praxis/handlers/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Praxis
   module Handlers
     class JSON
@@ -9,7 +11,7 @@ module Praxis
       rescue LoadError
         # Should never happen since JSON is a default gem; might as well be cautious!
         raise Praxis::Exceptions::InvalidConfiguration,
-              "JSON handler depends on json ~> 1.0; please add it to your Gemfile"
+              'JSON handler depends on json ~> 1.0; please add it to your Gemfile'
       end
 
       # Parse a JSON document into structured data.
@@ -18,7 +20,8 @@ module Praxis
       # @return [Hash,Array] the structured-data representation of the document
       def parse(document)
         # Try to be nice and accept an empty string as an empty payload (seems nice to do for dumb http clients)
-        return nil if (document.nil? || document == '')
+        return nil if document.nil? || document == ''
+
         ::JSON.parse(document)
       end
 

data/lib/praxis/handlers/plain.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Praxis
   module Handlers
     class Plain
@@ -10,7 +12,6 @@ module Praxis
       def generate(structured_data)
         structured_data
       end
-
     end
   end
 end

data/lib/praxis/handlers/www_form.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 # This is an example of a handler that can load and generate www-url-encoded payloads.
-# Note that if you use your API to pass nil values for attributes as a way to unset their 
-# values, this handler will not work (as there isn't necessarily a defined "null" value in 
+# Note that if you use your API to pass nil values for attributes as a way to unset their
+# values, this handler will not work (as there isn't necessarily a defined "null" value in
 # this encoding (although you can probably define how to encode/decode it and use it as such)
 # Use at your own risk.
 module Praxis
@@ -19,8 +21,9 @@ module Praxis
       # is not very useful for a response body.
       def generate(structured_data)
         return nil if structured_data.nil?
+
         URI.encode_www_form(structured_data)
       end
     end
   end
-end
+end