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

data/lib/praxis/mapper/selector_generator.rb

@@ -1,151 +1,145 @@
-module Praxis::Mapper
+# frozen_string_literal: true
 
-  class SelectorGeneratorNode
-    attr_reader :select, :model, :resource, :tracks
+module Praxis
+  module Mapper
+    class SelectorGeneratorNode
+      attr_reader :select, :model, :resource, :tracks
 
-    def initialize(resource)
-      @resource = resource
+      def initialize(resource)
+        @resource = resource
 
-      @select = Set.new
-      @select_star = false
-      @tracks = Hash.new 
-    end
-
-    def add(fields)
-      fields.each do |name, field|
-        map_property(name, field)
+        @select = Set.new
+        @select_star = false
+        @tracks = {}
       end
-      self
-    end
 
-    def map_property(name, fields)
-      praxis_compat_model = resource.model && resource.model.respond_to?(:_praxis_associations)
-      if resource.properties.key?(name)
-        add_property(name, fields)
-      elsif praxis_compat_model && resource.model._praxis_associations.key?(name)
-        add_association(name, fields)
-      else
-        add_select(name)
+      def add(fields)
+        fields.each do |name, field|
+          map_property(name, field)
+        end
+        self
       end
-    end
 
-    def add_association(name, fields)
-      
-      association = resource.model._praxis_associations.fetch(name) do
-        raise "missing association for #{resource} with name #{name}"
-      end
-      associated_resource = resource.model_map[association[:model]]
-      unless associated_resource
-        raise "Whoops! could not find a resource associated with model #{association[:model]} (root resource #{resource})"
-      end
-      # Add the required columns in this model to make sure the association can be loaded
-      association[:local_key_columns].each {|col| add_select(col) }
-      
-      node = SelectorGeneratorNode.new(associated_resource)
-      unless association[:remote_key_columns].empty?
-        # Make sure we add the required columns for this association to the remote model query
-        fields = {} if fields == true
-        new_fields_as_hash = association[:remote_key_columns].each_with_object({}) do|name, hash|
-          hash[name] = true
+      def map_property(name, fields)
+        praxis_compat_model = resource.model&.respond_to?(:_praxis_associations)
+        if resource.properties.key?(name)
+          add_property(name, fields)
+        elsif praxis_compat_model && resource.model._praxis_associations.key?(name)
+          add_association(name, fields)
+        else
+          add_select(name)
         end
-        fields = fields.merge(new_fields_as_hash) 
       end
 
-      node.add(fields) unless fields == true
+      def add_association(name, fields)
+        association = resource.model._praxis_associations.fetch(name) do
+          raise "missing association for #{resource} with name #{name}"
+        end
+        associated_resource = resource.model_map[association[:model]]
+        raise "Whoops! could not find a resource associated with model #{association[:model]} (root resource #{resource})" unless associated_resource
+
+        # Add the required columns in this model to make sure the association can be loaded
+        association[:local_key_columns].each { |col| add_select(col) }
+
+        node = SelectorGeneratorNode.new(associated_resource)
+        unless association[:remote_key_columns].empty?
+          # Make sure we add the required columns for this association to the remote model query
+          fields = {} if fields == true
+          new_fields_as_hash = association[:remote_key_columns].each_with_object({}) do |key, hash|
+            hash[key] = true
+          end
+          fields = fields.merge(new_fields_as_hash)
+        end
+
+        node.add(fields) unless fields == true
 
-      self.merge_track(name, node)
-    end
+        merge_track(name, node)
+      end
 
-    def add_select(name)
-      return @select_star = true if name == :*
-      return if @select_star
-      @select.add name
-    end
+      def add_select(name)
+        return @select_star = true if name == :*
+        return if @select_star
 
-    def add_property(name, fields)
-      dependencies = resource.properties[name][:dependencies]
-      # Always add the underlying association if we're overriding the name...
-      praxis_compat_model = resource.model && resource.model.respond_to?(:_praxis_associations)
-      if praxis_compat_model && resource.model._praxis_associations.key?(name)
-        add_association(name, fields)
+        @select.add name
       end
-      if dependencies
-        dependencies.each do |dependency|
+
+      def add_property(name, fields)
+        dependencies = resource.properties[name][:dependencies]
+        # Always add the underlying association if we're overriding the name...
+        praxis_compat_model = resource.model&.respond_to?(:_praxis_associations)
+        add_association(name, fields) if praxis_compat_model && resource.model._praxis_associations.key?(name)
+        dependencies&.each do |dependency|
           # To detect recursion, let's allow mapping depending fields to the same name of the property
           # but properly detecting if it's a real association...in which case we've already added it above
           if dependency == name
-            unless praxis_compat_model && resource.model._praxis_associations.key?(name)
-              add_select(name)
-            end
+            add_select(name) unless praxis_compat_model && resource.model._praxis_associations.key?(name)
           else
             apply_dependency(dependency)
           end
         end
-      end
 
-      head, *tail = resource.properties[name][:through]
-      return if head.nil?
+        head, *tail = resource.properties[name][:through]
+        return if head.nil?
 
-      new_fields = tail.reverse.inject(fields) do |thing, step|
-        {step => thing}
-      end
+        new_fields = tail.reverse.inject(fields) do |thing, step|
+          { step => thing }
+        end
 
-      add_association(head, new_fields)
-    end
+        add_association(head, new_fields)
+      end
 
-    def apply_dependency(dependency)
-      case dependency
-      when Symbol
-        map_property(dependency, true)
-      when String
-        head, *tail = dependency.split('.').collect(&:to_sym)
-        raise "String dependencies can not be singular" if tail.nil?
+      def apply_dependency(dependency)
+        case dependency
+        when Symbol
+          map_property(dependency, true)
+        when String
+          head, *tail = dependency.split('.').collect(&:to_sym)
+          raise 'String dependencies can not be singular' if tail.nil?
 
-        add_association(head, tail.reverse.inject({}) { |hash, dep| { dep => hash } })
+          add_association(head, tail.reverse.inject({}) { |hash, dep| { dep => hash } })
+        end
       end
-    end
 
-    def merge_track( track_name, node )
-      raise "Cannot merge another node for association #{track_name}: incompatible model" unless node.model == self.model
+      def merge_track(track_name, node)
+        raise "Cannot merge another node for association #{track_name}: incompatible model" unless node.model == model
 
-      existing = self.tracks[track_name]
-      if existing
-        node.select.each do|col_name|
-          existing.add_select(col_name)
-        end
-        node.tracks.each do |name, n|
-          existing.merge_track(name, n)
+        existing = tracks[track_name]
+        if existing
+          node.select.each do |col_name|
+            existing.add_select(col_name)
+          end
+          node.tracks.each do |name, n|
+            existing.merge_track(name, n)
+          end
+        else
+          tracks[track_name] = node
         end
-      else
-        self.tracks[track_name] = node
       end
-    end
 
-    def dump
-      hash = {}
-      hash[:model] = resource.model
-      if !@select.empty? || @select_star
-        hash[:columns] = @select_star ? [ :* ] : @select.to_a 
-      end
-      unless @tracks.empty?
-        hash[:tracks] = @tracks.each_with_object({}) {|(name, node), hash|  hash[name] = node.dump }
+      def dump
+        hash = {}
+        hash[:model] = resource.model
+        if !@select.empty? || @select_star
+          hash[:columns] = @select_star ? [:*] : @select.to_a
+        end
+        hash[:tracks] = @tracks.transform_values(&:dump) unless @tracks.empty?
+        hash
       end
-      hash
     end
-  end
 
-  # Generates a set of selectors given a resource and
-  # list of resource attributes.
-  class SelectorGenerator
-    # Entry point
-    def add(resource, fields)
-      @root = SelectorGeneratorNode.new(resource)
-      @root.add(fields)
-      self
-    end
+    # Generates a set of selectors given a resource and
+    # list of resource attributes.
+    class SelectorGenerator
+      # Entry point
+      def add(resource, fields)
+        @root = SelectorGeneratorNode.new(resource)
+        @root.add(fields)
+        self
+      end
 
-    def selectors
-      @root
+      def selectors
+        @root
+      end
     end
   end
 end

data/lib/praxis/mapper/sequel_compat.rb

@@ -1,84 +1,87 @@
-require 'active_support/concern'
+# frozen_string_literal: true
 
+require 'active_support/concern'
 
-module Praxis::Mapper
-  module SequelCompat
-    extend ActiveSupport::Concern
+module Praxis
+  module Mapper
+    module SequelCompat
+      extend ActiveSupport::Concern
 
-    included do
-      attr_accessor :_resource
-      class <<self  
-        alias_method :find_by, :find # Easy way to be method compatible with AR
-      end       
-    end
+      included do
+        attr_accessor :_resource
 
-    module ClassMethods
-      def _filter_query_builder_class
-        # TODO: refactor the query builder, and add the explicit require in this file
-        Praxis::Extensions::SequelFilterQueryBuilder
+        class << self
+          alias_method :find_by, :find # Easy way to be method compatible with AR
+        end
       end
 
-      def _field_selector_query_builder_class
-        Praxis::Extensions::FieldSelection::SequelQuerySelector
-      end
+      module ClassMethods
+        def _filter_query_builder_class
+          # TODO: refactor the query builder, and add the explicit require in this file
+          Praxis::Extensions::SequelFilterQueryBuilder
+        end
 
-      def _pagination_query_builder_class
-        Praxis::Extensions::Pagination::SequelPaginationHandler
-      end
+        def _field_selector_query_builder_class
+          Praxis::Extensions::FieldSelection::SequelQuerySelector
+        end
 
-      def _praxis_associations
-        orig = self.association_reflections.clone
-        orig.each do |k,v|
-          v[:model] = v.associated_class
-          v[:local_key_columns] = local_columns_used_for_the_association(v[:type], v)
-          v[:remote_key_columns] = remote_columns_used_for_the_association(v[:type], v)
-          if v.respond_to?(:primary_key)
-            v[:primary_key] = v.primary_key
-          else
-            # FIXME: figure out exactly what to do here. 
-            # not super critical, as we can't track these associations
-            # directly, but it would be nice to traverse these
-            # properly.
-            v[:primary_key] = :unsupported
+        def _pagination_query_builder_class
+          Praxis::Extensions::Pagination::SequelPaginationHandler
+        end
+
+        def _praxis_associations
+          orig = association_reflections.clone
+          orig.each do |_k, v|
+            v[:model] = v.associated_class
+            v[:local_key_columns] = local_columns_used_for_the_association(v[:type], v)
+            v[:remote_key_columns] = remote_columns_used_for_the_association(v[:type], v)
+            v[:primary_key] = if v.respond_to?(:primary_key)
+                                v.primary_key
+                              else
+                                # FIXME: figure out exactly what to do here.
+                                # not super critical, as we can't track these associations
+                                # directly, but it would be nice to traverse these
+                                # properly.
+                                :unsupported
+                              end
           end
+          orig
         end
-        orig
-      end
 
-      private
-      def local_columns_used_for_the_association(type, assoc_reflection)
-        case type
-        when :one_to_many
-          # The associated table (or middle table if many to many) will point to us by PK
-          assoc_reflection[:primary_key_columns]
-        when :many_to_one
-          # We have the FKs to the associated model
-          assoc_reflection[:keys]
-        when :many_to_many
-          # The middle table if many to many) will point to us by key (usually the PK, but not always)
-          assoc_reflection[:left_primary_keys]
-        else 
-          raise "association type #{type} not supported"
+        private
+
+        def local_columns_used_for_the_association(type, assoc_reflection)
+          case type
+          when :one_to_many
+            # The associated table (or middle table if many to many) will point to us by PK
+            assoc_reflection[:primary_key_columns]
+          when :many_to_one
+            # We have the FKs to the associated model
+            assoc_reflection[:keys]
+          when :many_to_many
+            # The middle table if many to many) will point to us by key (usually the PK, but not always)
+            assoc_reflection[:left_primary_keys]
+          else
+            raise "association type #{type} not supported"
+          end
         end
-      end
 
-      def remote_columns_used_for_the_association(type, assoc_reflection)
-        case type
-        when :one_to_many
-          # The columns in the associated table that will point back to the original association
-          assoc_reflection[:keys]
-        when :many_to_one
-          # The columns in the associated table that the children will point to (usually the PK, but not always) ??
-          [assoc_reflection.associated_class.primary_key]
-        when :many_to_many
-          # The middle table if many to many will point to us by key (usually the PK, but not always) ??
-          [assoc_reflection.associated_class.primary_key]
-        else 
-          raise "association type #{type} not supported"
+        def remote_columns_used_for_the_association(type, assoc_reflection)
+          case type
+          when :one_to_many
+            # The columns in the associated table that will point back to the original association
+            assoc_reflection[:keys]
+          when :many_to_one
+            # The columns in the associated table that the children will point to (usually the PK, but not always) ??
+            [assoc_reflection.associated_class.primary_key]
+          when :many_to_many
+            # The middle table if many to many will point to us by key (usually the PK, but not always) ??
+            [assoc_reflection.associated_class.primary_key]
+          else
+            raise "association type #{type} not supported"
+          end
         end
       end
-
     end
-
   end
-end
+end

data/lib/praxis/media_type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Praxis
   # An Internet Media Type as defined in RFC 1590, as used in HTTP (see RFC 2616). As used in the
   # Praxis framework, media types also define the structure and content of entities of that type:
@@ -43,8 +45,6 @@ module Praxis
   #     end
   #   end
   class MediaType < Praxis::Blueprint
-
     include Types::MediaTypeCommon
   end
-
 end

data/lib/praxis/media_type_identifier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require 'active_support/core_ext/object/blank'
 
@@ -10,7 +12,7 @@ module Praxis
     # the syntax for type identifiers is substantially narrower than what we accept there.
     #
     # Note that this ONLY matches type, subtype and suffix; we handle options differently.
-    VALID_TYPE = /^\s*(?<type>[^\/]+)\/(?<subtype>[^\+]+)(\+(?<suffix>[^; ]+))?\s*$/x.freeze
+    VALID_TYPE = %r{^\s*(?<type>[^/]+)/(?<subtype>[^+]+)(?<nothing>\+(?<suffix>[^; ]+))?\s*$}x.freeze
 
     # Pattern that separates parameters of a media type from each other, and from the base identifier.
     PARAMETER_SEPARATOR = /\s*;\s*/x.freeze
@@ -23,7 +25,7 @@ module Praxis
     QUOTED_STRING = /^".*"$/.freeze
 
     # Token that indicates a media-type component that matches anything.
-    WILDCARD = '*'.freeze
+    WILDCARD = '*'
 
     # Inner type representing semicolon-delimited parameters.
     Parameters = Attributor::Hash.of(key: String)
@@ -32,7 +34,7 @@ module Praxis
       attribute :type, Attributor::String, default: 'application', description: 'RFC2046 media type'
       attribute :subtype, Attributor::String, default: '*', description: 'RFC2046 media subtype', example: 'vnd.widget'
       attribute :suffix, Attributor::String, default: '', description: 'RFC6838 structured-syntax suffix', example: 'json'
-      attribute :parameters, Parameters, default: {}, description: "Type-specific parameters", example: "{'type' => 'collection'}"
+      attribute :parameters, Parameters, default: {}, description: 'Type-specific parameters', example: "{'type' => 'collection'}"
     end
 
     # Parse a media type identifier from a String, or load it from a Hash or Model. Assume malformed
@@ -41,10 +43,11 @@ module Praxis
     # @param [String,Hash,Attributor::Model] value
     # @return [MediaTypeIdentifier]
     # @see Attributor::Model#load
-    def self.load(value, context=Attributor::DEFAULT_ROOT_CONTEXT, recurse: false, **options)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, recurse: false, **options)
       case value
       when String
         return nil if value.blank?
+
         base, *parameters = value.split(PARAMETER_SEPARATOR)
         match = VALID_TYPE.match(base)
 
@@ -56,17 +59,19 @@ module Praxis
             h[k] = v
           end
 
-          obj.type, obj.subtype, obj.suffix, obj.parameters =
-              match[:type], match[:subtype], match[:suffix], parameters
+          obj.type = match[:type]
+          obj.subtype = match[:subtype]
+          obj.suffix = match[:suffix]
+          obj.parameters = parameters
         else
           obj.type = 'application'
           obj.subtype = base.split(WORD_SEPARATOR, 2).first
-          obj.suffix = ''
+          obj.suffix = String.new
           obj.parameters = {}
         end
         obj
       when nil
-        return nil
+        nil
       else
         super
       end
@@ -97,6 +102,7 @@ module Praxis
       return false unless type == other.type || type == WILDCARD
       return false unless subtype == other.subtype || subtype == WILDCARD
       return false unless suffix.empty? || suffix == other.suffix
+
       parameters.each_pair do |k, v|
         return false unless other.parameters[k] == v
       end
@@ -120,7 +126,7 @@ module Praxis
     # @return [String] canonicalized representation of the media type including all suffixes and parameters
     def to_s
       # Our handcrafted media types consist of a rich chocolatey center
-      s = "#{type}/#{subtype}"
+      s = String.new("#{type}/#{subtype}")
 
       # coated in a hard candy shell
       s << '+' << suffix unless suffix.empty?
@@ -135,18 +141,17 @@ module Praxis
       s
     end
 
-    alias_method :to_str, :to_s
-
+    alias to_str to_s
 
     # If parameters are empty, return self; otherwise return a new object consisting of this type
     # minus parameters.
     #
     # @return [MediaTypeIdentifier]
     def without_parameters
-      if self.parameters.empty?
+      if parameters.empty?
         self
       else
-        val = {type: self.type, subtype: self.subtype, suffix: self.suffix}
+        val = { type: type, subtype: subtype, suffix: suffix }
         MediaTypeIdentifier.load(val)
       end
     end
@@ -176,12 +181,12 @@ module Praxis
     #
     # @example Indicate UTF8 encoding
     #     MediaTypeIdentifier.new('application/vnd.widget') + 'charset=UTF8' # => 'application/vnd.widget; charset="UTF8"'
-    def +(extension)
-      parameters = extension.split(PARAMETER_SEPARATOR)
+    def +(other)
+      parameters = other.split(PARAMETER_SEPARATOR)
       # remove useless initial '; '
       parameters.shift if parameters.first && parameters.first.empty?
 
-      raise ArgumentError, "Must pass a type identifier suffix and/or parameters" if parameters.empty?
+      raise ArgumentError, 'Must pass a type identifier suffix and/or parameters' if parameters.empty?
 
       suffix = parameters.shift unless parameters.first.include?('=')
       # remove redundant '+'
@@ -196,10 +201,10 @@ module Praxis
       parameters = Parameters.load(parameters)
 
       obj = self.class.new
-      obj.type = self.type
-      obj.subtype = self.subtype
+      obj.type = type
+      obj.subtype = subtype
       target_suffix = suffix || self.suffix
-      obj.suffix = redundant_suffix(target_suffix) ? '' : target_suffix
+      obj.suffix = redundant_suffix(target_suffix) ? String.new : target_suffix
       obj.parameters = self.parameters.merge(parameters)
 
       obj
@@ -208,9 +213,8 @@ module Praxis
     def redundant_suffix(suffix)
       # application/json does not need to be suffixed with +json (same for application/xml)
       # we're supporting text/json and text/xml for older formats as well
-      if (self.type == 'application' || self.type == 'text') && self.subtype == suffix
-        return true
-      end
+      return true if (type == 'application' || type == 'text') && subtype == suffix
+
       false
     end
   end

data/lib/praxis/middleware_app.rb

@@ -1,48 +1,51 @@
+# frozen_string_literal: true
+
 module Praxis
   class MiddlewareApp
-
     attr_reader :target
 
     # Initialize the application instance with the desired args, and return the wrapping class.
-    def self.for( **args )
+    def self.for(**args)
       Class.new(self) do
         @args = args
         @setup_done = false
         def self.name
           'MiddlewareApp'
         end
-        def self.args
-          @args
+
+        class << self
+          attr_reader :args
         end
-        def self.setup_done
-          @setup_done
+
+        class << self
+          attr_reader :setup_done
         end
+
         def self.setup
           @setup_done = true
           Praxis::Application.instance.setup(**@args)
         end
       end
-     end
+    end
 
-    def initialize( inner )
+    def initialize(inner)
       @target = inner
       @setup_done = false
     end
 
     def call(env)
       self.class.setup unless self.class.setup_done
-      
+
       result = Praxis::Application.instance.call(env)
 
-      unless ( [404,405].include?(result[0].to_i) && result[1]['X-Cascade'] == 'pass' )
-        # Respect X-Cascade header if it doesn't specify 'pass'
-        result
-      else
+      if [404, 405].include?(result[0].to_i) && result[1]['X-Cascade'] == 'pass'
         last_body = result[2]
         last_body.close if last_body.respond_to? :close
         target.call(env)
+      else
+        # Respect X-Cascade header if it doesn't specify 'pass'
+        result
       end
     end
-
   end
-end
+end