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

data/lib/praxis/extensions/field_selection/active_record_query_selector.rb

@@ -1,30 +1,32 @@
 # frozen_string_literal: true
+
 module Praxis
   module Extensions
     module FieldSelection
       class ActiveRecordQuerySelector
         attr_reader :selector, :query
+
         # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
         def initialize(query:, selectors:, debug: false)
           @selector = selectors
           @query = query
-          @logger = debug ? Logger.new(STDOUT) : nil
+          @logger = debug ? Logger.new($stdout) : nil
         end
 
         def generate
-          # TODO: unfortunately, I think we can only control the select clauses for the top model 
+          # TODO: unfortunately, I think we can only control the select clauses for the top model
           # (as I'm not sure ActiveRecord supports expressing it in the join...)
           @query = add_select(query: query, selector_node: selector)
           eager_hash = _eager(selector)
 
-          @query = @query.includes(eager_hash)          
+          @query = @query.includes(eager_hash)
           explain_query(query, eager_hash) if @logger
 
           @query
         end
 
         def add_select(query:, selector_node:)
-          # We're gonna always require the PK of the model, as it is a special case for AR, and the app itself 
+          # We're gonna always require the PK of the model, as it is a special case for AR, and the app itself
           # might assume it is always there and not be surprised by the fact that if it isn't, it won't blow up
           # in the same way as any other attribute not being loaded...i.e., ActiveModel::MissingAttributeError: missing attribute: xyz
           select_fields = selector_node.select + [selector_node.resource.model.primary_key.to_sym]
@@ -32,8 +34,8 @@ module Praxis
         end
 
         def _eager(selector_node)
-          selector_node.tracks.each_with_object({}) do |(track_name, track_node), h|
-            h[track_name] = _eager(track_node)
+          selector_node.tracks.transform_values do |track_node|
+            _eager(track_node)
           end
         end
 
@@ -41,9 +43,9 @@ module Praxis
           @logger.debug("Query plan for ...#{selector.resource.model} with selectors: #{JSON.generate(selector.dump)}")
           @logger.debug(" ActiveRecord query: #{selector.resource.model}.includes(#{eager_hash})")
           query.explain
-          @logger.debug("Query plan end")
+          @logger.debug('Query plan end')
         end
       end
     end
   end
-end
+end

data/lib/praxis/extensions/field_selection/field_selector.rb

@@ -1,123 +1,122 @@
+# frozen_string_literal: true
 
 module Praxis
   module Extensions
     module FieldSelection
+      class FieldSelector
+        include Attributor::Type
+        include Attributor::Dumpable
 
-        class FieldSelector
-          include Attributor::Type
-          include Attributor::Dumpable
+        def self.json_schema_type
+          :string
+        end
 
-          def self.json_schema_type
-            :string
-          end
-      
-          def self.native_type
-            self
-          end
+        def self.native_type
+          self
+        end
 
-          def self.display_name
-            'FieldSelector'
+        def self.display_name
+          'FieldSelector'
+        end
+
+        def self.family
+          'string'
+        end
+
+        def self.for(media_type)
+          unless media_type < Praxis::MediaType
+            raise ArgumentError, "Invalid type: #{media_type.name} for FieldSelector. " \
+                                 'Must be a subclass of MediaType'
           end
 
-          def self.family
-            'string'
+          ::Class.new(self) do
+            @media_type = media_type
           end
+        end
 
-          def self.for(media_type)
-            unless media_type < Praxis::MediaType
-              raise ArgumentError, "Invalid type: #{media_type.name} for FieldSelector. " +
-                "Must be a subclass of MediaType"
-            end
+        def self.load(value, _context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
+          return value if value.is_a?(native_type)
 
-            ::Class.new(self) do
-              @media_type = media_type
-            end
+          if value.nil? || value.blank?
+            new(true)
+          else
+            parsed = Attributor::FieldSelector.load(value)
+            new(parsed)
           end
+        end
 
-          def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
-            return value if value.kind_of?(self.native_type)
+        def self.example(context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
+          fields = if media_type
+                     media_type.attributes.keys.sample(3).join(',')
+                   else
+                     Attributor::FieldSelector.example(context, **options)
+                   end
+          self.load(fields)
+        end
 
-            if value.nil? || value.blank?
-              self.new(true)
-            else
-              parsed = Attributor::FieldSelector.load(value)
-              self.new(parsed)
-            end
-          end
+        def self.validate(value, context = Attributor::DEFAULT_ROOT_CONTEXT, _attribute = nil)
+          return [] unless media_type
 
-          def self.example(context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
-            fields = if media_type
-              media_type.attributes.keys.sample(3).join(',')
-            else
-              Attributor::FieldSelector.example(context,**options)
-            end
-            self.load(fields)
-          end
+          instance = self.load(value, context)
+          instance.validate(context)
+        end
 
-          def self.validate(value, context=Attributor::DEFAULT_ROOT_CONTEXT, _attribute=nil)
-            return [] unless media_type
-            instance = self.load(value, context)
-            instance.validate(context)
-          end
+        def self.dump(value, **_opts)
+          self.load(value).dump
+        end
 
-          def self.dump(value,**opts)
-            self.load(value).dump
-          end
+        class << self
+          attr_reader :media_type
+        end
 
-          class << self
-            attr_reader :media_type
-          end
+        attr_reader :fields
 
-          attr_reader :fields
+        def initialize(fields)
+          @fields = fields
+        end
 
-          def initialize(fields)
-            @fields = fields
-          end
+        def dump(*_args)
+          return '' if fields == true
 
-          def dump(*args)
-            return '' if self.fields == true
-            _dump(self.fields)
-          end
+          _dump(fields)
+        end
 
-          def _dump(fields)
-            fields.each_with_object([]) do |(field, spec), array|
-              if spec == true
-                array << field
-              else
-                array << "#{field}{#{_dump(spec)}}"
-              end
-            end.join(',')
-          end
+        def _dump(fields)
+          fields.each_with_object([]) do |(field, spec), array|
+            array << if spec == true
+                       field
+                     else
+                       "#{field}{#{_dump(spec)}}"
+                     end
+          end.join(',')
+        end
 
-          def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
-            errors = []
-            return errors if self.fields == true
-            _validate(self.class.media_type, fields)
-          end
+        def validate(_context = Attributor::DEFAULT_ROOT_CONTEXT)
+          errors = []
+          return errors if fields == true
+
+          _validate(self.class.media_type, fields)
+        end
 
-          def _validate(type, fields, context=Attributor::DEFAULT_ROOT_CONTEXT)
-            errors = []
-            fields.each do |name, field_spec|
-              unless type.attributes.key?(name)
-                errors << "Attribute with name #{name} not found in #{Attributor.type_name(type)}"
-                next
-              end
-
-              if field_spec.kind_of?(Hash)
-                sub_context = context + [name]
-                sub_attribute = type.attributes[name]
-                sub_type = sub_attribute.type
-                if sub_attribute.type.respond_to?(:member_attribute)
-                  sub_type = sub_type.member_type
-                end
-                errors.push(*_validate(sub_type,field_spec, sub_context))
-              end
+        def _validate(type, fields, context = Attributor::DEFAULT_ROOT_CONTEXT)
+          errors = []
+          fields.each do |name, field_spec|
+            unless type.attributes.key?(name)
+              errors << "Attribute with name #{name} not found in #{Attributor.type_name(type)}"
+              next
             end
-            errors
-          end
 
-        end
+            next unless field_spec.is_a?(Hash)
 
+            sub_context = context + [name]
+            sub_attribute = type.attributes[name]
+            sub_type = sub_attribute.type
+            sub_type = sub_type.member_type if sub_attribute.type.respond_to?(:member_attribute)
+            errors.push(*_validate(sub_type, field_spec, sub_context))
+          end
+          errors
+        end
+      end
     end
   end
 end

data/lib/praxis/extensions/field_selection/sequel_query_selector.rb

@@ -7,18 +7,19 @@ module Praxis
     module FieldSelection
       class SequelQuerySelector
         attr_reader :selector, :query
+
         # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
         def initialize(query:, selectors:, debug: false)
           @selector = selectors
           @query = query
-          @logger = debug ? Logger.new(STDOUT) : nil
+          @logger = debug ? Logger.new($stdout) : nil
         end
 
         def generate
           @query = add_select(query: query, selector_node: @selector)
-          
+
           @query = @selector.tracks.inject(@query) do |ds, (track_name, track_node)|
-            ds.eager(track_name => _eager(track_node) )
+            ds.eager(track_name => _eager(track_node))
           end
 
           explain_query(query) if @logger
@@ -29,30 +30,29 @@ module Praxis
           lambda do |dset|
             dset = add_select(query: dset, selector_node: selector_node)
 
-            dset = selector_node.tracks.inject(dset) do |ds, (track_name, track_node)|
-              ds.eager(track_name => _eager(track_node) )
+            selector_node.tracks.inject(dset) do |ds, (track_name, track_node)|
+              ds.eager(track_name => _eager(track_node))
             end
-
           end
         end
 
         def add_select(query:, selector_node:)
-          # We're gonna always require the PK of the model, as it is a special case for Sequel, and the app itself 
+          # We're gonna always require the PK of the model, as it is a special case for Sequel, and the app itself
           # might assume it is always there and not be surprised by the fact that if it isn't, it won't blow up
           # in the same way as any other attribute not being loaded...i.e., NoMethodError: undefined method `foobar' for #<...>
           select_fields = selector_node.select + [selector_node.resource.model.primary_key.to_sym]
-    
+
           table_name = selector_node.resource.model.table_name
           qualified = select_fields.map { |f| Sequel.qualify(table_name, f) }
           query.select(*qualified)
         end
 
-        def explain_query(ds)
+        def explain_query(dataset)
           @logger.debug("Query plan for ...#{selector.resource.model} with selectors: #{JSON.generate(selector.dump)}")
-          ds.all
-          @logger.debug("Query plan end")
+          dataset.all
+          @logger.debug('Query plan end')
         end
       end
     end
   end
-end
+end

data/lib/praxis/extensions/field_selection.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'attributor/extras/field_selector'
-require 'praxis/extensions/field_selection/field_selector'
+require 'praxis/extensions/field_selection/field_selector'

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

@@ -1,30 +1,32 @@
+# frozen_string_literal: true
+
 require_relative 'pagination_handler'
 
 module Praxis
   module Extensions
     module Pagination
       class ActiveRecordPaginationHandler < PaginationHandler
-
         def self.where_lt(query, attr, value)
           # TODO: common for AR/Sequel? Seems we could use Arel and more-specific Sequel things
           query.where(query.table[attr].lt(value))
         end
-        
+
         def self.where_gt(query, attr, value)
           query.where(query.table[attr].gt(value))
         end
 
         def self.order(query, order)
           return query unless order
+
           query = query.reorder('')
-          
+
           order.each do |spec_hash|
             direction, name = spec_hash.first
             query = query.order(name => direction)
           end
           query
         end
-        
+
         def self.count(query)
           query.count(:all)
         end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Praxis
   module Extensions
     module Pagination
-      class HeaderGenerator        
+      class HeaderGenerator
         def self.build_cursor_headers(paginator:, last_value:, total_count: nil)
-          [:next, :prev, :first, :last].each_with_object({}) do |rel_name, info|
+          %i[next prev first last].each_with_object({}) do |rel_name, info|
             case rel_name
             when :next
               # If we don't know the total, we'll try to go to the next page
@@ -26,26 +28,29 @@ module Praxis
         # This is only for plain paging
         def self.build_paging_headers(paginator:, total_count: nil)
           last_page = total_count.nil? ? nil : (total_count / (paginator.items * 1.0)).ceil
-          [:next, :prev, :first, :last].each_with_object({}) do |rel_name, info|
+          %i[next prev first last].each_with_object({}) do |rel_name, info|
             num = case rel_name
                   when :first
                     1
                   when :prev
                     next if paginator.page < 2
+
                     paginator.page - 1
                   when :next
                     # don't include this link if we know the total and we see there are no more pages
                     next if last_page.present? && (paginator.page >= last_page)
+
                     # if we don't know the total, we'll specify to the next page even if it ends up being blank
                     paginator.page + 1
                   when :last
                     next if last_page.blank?
+
                     last_page
                   end
             info[rel_name] = {
-              page:         num,
-              items:        paginator.items,
-              total_count:  total_count.present?
+              page: num,
+              items: paginator.items,
+              total_count: total_count.present?
             }
           end
         end
@@ -53,15 +58,15 @@ module Praxis
         def self.generate_headers(links:, current_url:, current_query_params:, total_count:)
           mapped = links.map do |(rel, info)|
             # Make sure to encode it our way (with comma-separated args, as it is our own syntax, and not a query string one)
-            pagination_param = info.map { |(k, v)| "#{k}=#{v}" }.join(",")
-            new_url = current_url + "?" + current_query_params.dup.merge(pagination:  pagination_param).to_query
+            pagination_param = info.map { |(k, v)| "#{k}=#{v}" }.join(',')
+            new_url = "#{current_url}?#{current_query_params.dup.merge(pagination: pagination_param).to_query}"
 
-            LinkHeader::Link.new(new_url, [["rel", rel.to_s]])
+            LinkHeader::Link.new(new_url, [['rel', rel.to_s]])
           end
           link_header = LinkHeader.new(mapped)
 
-          headers = { "Link" => link_header.to_s }
-          headers["Total-Count"] = total_count if total_count
+          headers = { 'Link' => link_header.to_s }
+          headers['Total-Count'] = total_count if total_count
           headers
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 module Praxis
@@ -65,13 +67,12 @@ module Praxis
         # MediaType, so that the field name checking and value coercion can be performed
         class << self
           attr_reader :media_type
-          attr_accessor :fields_allowed
-          attr_accessor :enforce_all # True when we need to enforce the allowed fields at all ordering positions
+          attr_accessor :fields_allowed, :enforce_all # True when we need to enforce the allowed fields at all ordering positions
 
           def for(media_type, **_opts)
             unless media_type < Praxis::MediaType
               raise ArgumentError, "Invalid type: #{media_type.name} for Ordering. " \
-                "Must be a subclass of MediaType"
+                'Must be a subclass of MediaType'
             end
 
             ::Class.new(self) do
@@ -121,22 +122,22 @@ module Praxis
 
         def self.example(_context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
           fields = if media_type
-                    chosen_set = if enforce_all
+                     chosen_set = if enforce_all
                                     fields_allowed.sample(2)
                                   else
                                     starting_set = fields_allowed.sample(1)
                                     simple_attrs = media_type.attributes.select do |_k, attr|
                                       attr.type == Attributor::String || attr.type < Attributor::Numeric || attr.type < Attributor::Temporal
                                     end.keys
-                                    starting_set + simple_attrs.select { |attr| attr != starting_set.first }.sample(1)
+                                    starting_set + simple_attrs.reject { |attr| attr == starting_set.first }.sample(1)
                                   end
-                    chosen_set.each_with_object([]) do |chosen, arr|
-                      sign = rand(10) < 5 ? "-" : ""
-                      arr << "#{sign}#{chosen}"
-                    end.join(',')
-                  else
-                    "name,last_name,-birth_date"
-                  end
+                     chosen_set.each_with_object([]) do |chosen, arr|
+                       sign = rand(10) < 5 ? '-' : ''
+                       arr << "#{sign}#{chosen}"
+                     end.join(',')
+                   else
+                     'name,last_name,-birth_date'
+                   end
           load(fields)
         end
 
@@ -151,13 +152,14 @@ module Praxis
           parsed_order = {}
           unless order.nil?
             parsed_order = order.split(',').each_with_object([]) do |order_string, arr|
-              item = if order_string[0] == '-'
-                      { desc: order_string[1..-1].to_s }
-                    elsif order_string[0] == '+'
-                      { asc: order_string[1..-1].to_s }
-                    else
-                      { asc: order_string.to_s }
-                    end
+              item = case order_string[0]
+                     when '-'
+                       { desc: order_string[1..-1].to_s }
+                     when '+'
+                       { asc: order_string[1..-1].to_s }
+                     else
+                       { asc: order_string.to_s }
+                     end
               arr.push item
             end
           end
@@ -195,7 +197,8 @@ module Praxis
             enforceable_items.each do |spec|
               _dir, field = spec.first
               field = field.to_sym
-              next unless !self.class.fields_allowed.include?(field)
+              next if self.class.fields_allowed.include?(field)
+
               errors << if self.class.media_type.attributes.key?(field)
                           "Ordering by field \'#{field}\' is disallowed. Ordering is only allowed using the following fields: " +
                           self.class.fields_allowed.map { |f| "\'#{f}\'" }.join(', ').to_s
@@ -213,17 +216,15 @@ module Praxis
           items.each_with_object([]) do |spec, arr|
             dir, field = spec.first
             arr << if dir == :desc
-                    "-#{field}"
-                  else
-                    field
-                  end
+                     "-#{field}"
+                   else
+                     field
+                   end
           end.join(',')
         end
 
-        def each
-          items.each do |item|
-            yield item
-          end
+        def each(&block)
+          items.each(&block)
         end
       end
     end