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

data/lib/praxis/api_general_info.rb

@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 module Praxis
   class ApiGeneralInfo
-
     attr_reader :version
 
-    def initialize(global_info=nil, version: nil)
-      @data = Hash.new
+    def initialize(global_info = nil, version: nil)
+      @data = {}
       @global_info = global_info
       @version = version
 
-      if @global_info.nil? # this *is* the global info
-        version_with [:header, :params]
-        consumes 'json', 'x-www-form-urlencoded'
-        produces 'json'
-      end
+      return unless @global_info.nil?
+
+      # this *is* the global info
+      version_with %i[header params]
+      consumes 'json', 'x-www-form-urlencoded'
+      produces 'json'
     end
 
     # Allow any custom method to get/set any value
-    def method_missing(name, val=nil)
+    def method_missing(name, val = nil)
       if val.nil?
         get(name)
       else
@@ -28,17 +30,18 @@ module Praxis
       true
     end
 
-    def get(k)
-      return @data[k] if @data.key?(k)
-      return @global_info.get(k) if @global_info
+    def get(key)
+      return @data[key] if @data.key?(key)
+      return @global_info.get(key) if @global_info
+
       nil
     end
 
-    def set(k, v)
-      @data[k] = v
+    def set(key, val)
+      @data[key] = val
     end
 
-    def name(val=nil)
+    def name(val = nil)
       if val.nil?
         get(:name)
       else
@@ -46,7 +49,7 @@ module Praxis
       end
     end
 
-    def title(val=nil)
+    def title(val = nil)
       if val.nil?
         get(:title)
       else
@@ -54,7 +57,7 @@ module Praxis
       end
     end
 
-    def logo_url(val=nil)
+    def logo_url(val = nil)
       if val.nil?
         get(:logo_url)
       else
@@ -62,7 +65,7 @@ module Praxis
       end
     end
 
-    def description(val=nil)
+    def description(val = nil)
       if val.nil?
         get(:description)
       else
@@ -70,106 +73,92 @@ module Praxis
       end
     end
 
-    def version_with(val=nil)
+    def version_with(val = nil)
       if val.nil?
         get(:version_with)
+      elsif @global_info.nil?
+        Application.instance.versioning_scheme = val
+        set(:version_with, val) # this *is* the global info
       else
-        if @global_info.nil? # this *is* the global info
-          Application.instance.versioning_scheme = val
-          set(:version_with, val)
-        else
-          raise "Use of version_with is only allowed in the global part of " \
-            "the API definition (but you are attempting to use it in the API " \
-            "definition of version #{self.version}"
-        end
+        raise 'Use of version_with is only allowed in the global part of ' \
+          'the API definition (but you are attempting to use it in the API ' \
+          "definition of version #{version}"
       end
     end
 
-    def endpoint(val=nil)
+    def endpoint(val = nil)
       if val.nil?
         get(:endpoint)
+      elsif @global_info.nil?
+        set(:endpoint, val) # this *is* the global info
       else
-        if @global_info.nil? # this *is* the global info
-          set(:endpoint, val)
-        else
-          raise "Use of endpoint is only allowed in the global part of " \
-            "the API definition (but you are attempting to use it in the API " \
-            "definition of version #{self.version}"
-        end
+        raise 'Use of endpoint is only allowed in the global part of ' \
+          'the API definition (but you are attempting to use it in the API ' \
+          "definition of version #{version}"
       end
     end
 
-    def documentation_url(val=nil)
+    def documentation_url(val = nil)
       if val.nil?
         get(:documentation_url)
+      elsif @global_info.nil?
+        set(:documentation_url, val) # this *is* the global info
       else
-        if @global_info.nil? # this *is* the global info
-          set(:documentation_url, val)
-        else
-          raise "Use of documentation_url is only allowed in the global part of " \
-            "the API definition (but you are attempting to use it in the API " \
-            "definition of version #{self.version}"
-        end
+        raise 'Use of documentation_url is only allowed in the global part of ' \
+          'the API definition (but you are attempting to use it in the API ' \
+          "definition of version #{version}"
       end
     end
 
-    def base_path(val=nil)
-      if val
-        return set(:base_path, val)
-      end
+    def base_path(val = nil)
+      return set(:base_path, val) if val
 
       if @global_info # this is for a specific version
         global_path = @global_info.base_path
         if version_with == :path
           global_pattern = Mustermann.new(global_path)
-          global_path = global_pattern.expand(Request::API_VERSION_PARAM_NAME => self.version.to_s)
+          global_path = global_pattern.expand(Request::API_VERSION_PARAM_NAME => version.to_s)
         end
 
-        version_path = @data.fetch(:base_path,'')
+        version_path = @data.fetch(:base_path, '')
         "#{global_path}#{version_path}"
       else
-        @data.fetch(:base_path,'')
+        @data.fetch(:base_path, '')
       end
     end
 
     def consumes(*vals)
       if vals.empty?
-        return get(:consumes)
+        get(:consumes)
       else
-        return set(:consumes, vals)
+        set(:consumes, vals)
       end
     end
 
-
     def produces(*vals)
       if vals.empty?
-        return get(:produces)
+        get(:produces)
       else
-        return set(:produces, vals)
+        set(:produces, vals)
       end
     end
 
-
-    def base_params(type=Attributor::Struct, **opts, &block)
+    def base_params(type = Attributor::Struct, **opts, &block)
       if !block && type == Attributor::Struct
         get(:base_params)
       else
-        set(:base_params, Attributor::Attribute.new(type, opts, &block) )
+        set(:base_params, Attributor::Attribute.new(type, opts, &block))
       end
     end
 
     def describe
-      hash = { schema_version: "1.0".freeze }
-      [:name, :title, :description, :base_path, :version_with, :endpoint, :consumes, :produces].each do |attr|
-        val = self.__send__(attr)
+      hash = { schema_version: '1.0' }
+      %i[name title description base_path version_with endpoint consumes produces].each do |attr|
+        val = __send__(attr)
         hash[attr] = val unless val.nil?
       end
-      if base_params
-        hash[:base_params] = base_params.describe[:type][:attributes]
-      end
+      hash[:base_params] = base_params.describe[:type][:attributes] if base_params
       hash
     end
-
   end
-
 end

data/lib/praxis/application.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require 'mustermann'
 require 'logger'
@@ -6,28 +8,12 @@ module Praxis
   class Application
     include Singleton
 
-    attr_reader :router
-    attr_reader :controllers
-    attr_reader :endpoint_definitions
-    attr_reader :app
-    attr_reader :builder
-
-    attr_accessor :bootloader
-    attr_accessor :file_layout
-    attr_accessor :loaded_files
-    attr_accessor :logger
-    attr_accessor :plugins
-    attr_accessor :doc_browser_plugin_paths
-    attr_accessor :handlers
-    attr_accessor :root
-    attr_accessor :error_handler
-    attr_accessor :validation_handler
-
-    attr_accessor :versioning_scheme
+    attr_reader :router, :controllers, :endpoint_definitions, :app, :builder
 
+    attr_accessor :bootloader, :file_layout, :loaded_files, :logger, :plugins, :doc_browser_plugin_paths, :handlers, :root, :error_handler, :validation_handler, :versioning_scheme
 
     def self.configure
-      yield(self.instance)
+      yield(instance)
     end
 
     def initialize
@@ -44,16 +30,15 @@ module Praxis
 
       @bootloader = Bootloader.new(self)
       @file_layout = nil
-      @plugins = Hash.new
+      @plugins = {}
       @doc_browser_plugin_paths = []
-      @handlers = Hash.new
+      @handlers = {}
       @loaded_files = Set.new
       @config = Config.new
       @root = nil
-      @logger = Logger.new(STDOUT)
+      @logger = Logger.new($stdout)
     end
 
-
     def setup(root: '.')
       return self unless @app.nil?
 
@@ -92,9 +77,7 @@ module Praxis
       handler = handler.new
 
       # Make sure it quacks like a handler.
-      unless handler.respond_to?(:generate) && handler.respond_to?(:parse)
-        raise ArgumentError, "Media type handlers must respond to #generate and #parse"
-      end
+      raise ArgumentError, 'Media type handlers must respond to #generate and #parse' unless handler.respond_to?(:generate) && handler.respond_to?(:parse)
 
       # Register that thing!
       @handlers[name.to_s] = handler
@@ -102,17 +85,17 @@ module Praxis
 
     def call(env)
       response = []
-      Notifications.instrument 'rack.request.all'.freeze, response: response do
+      Notifications.instrument 'rack.request.all', response: response do
         response.push(*@app.call(env))
       end
     end
 
     def layout(&block)
-      self.file_layout = FileGroup.new(self.root, &block)
+      self.file_layout = FileGroup.new(root, &block)
     end
 
-    def config(key=nil, type=Attributor::Struct, **opts, &block)
-      if block_given? || (type==Attributor::Struct && !opts.empty? )
+    def config(key = nil, type = Attributor::Struct, **opts, &block)
+      if block_given? || (type == Attributor::Struct && !opts.empty?)
         @config.define(key, type, **opts, &block)
       else
         @config.get
@@ -123,9 +106,9 @@ module Praxis
       @config.set(config)
     end
 
-    # [DEPRECATED] - Warn of the change of method name for the transition 
+    # [DEPRECATED] - Warn of the change of method name for the transition
     def resource_definitions
-      raise "Praxis::Application.instance does not use `resource_definitions` any longer. Use `endpoint_definitions` instead."
+      raise 'Praxis::Application.instance does not use `resource_definitions` any longer. Use `endpoint_definitions` instead.'
     end
   end
 end

data/lib/praxis/blueprint.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 module Praxis
-  class Blueprint    
-    
+  class Blueprint
     # Simple helper class that can parse the `attribute :foobar` dsl into
     # an equivalent structure hash. Example:
     # do
@@ -13,22 +12,25 @@ module Praxis
     #  end
     # is parsed as: { one: true, complex: { sub1: true} }
     class FieldsetParser
-      def initialize( &block)
+      def initialize(&block)
         @hash = nil
         @block = block
       end
-    
+
       def attribute(name, **args, &block)
-        raise "Default fieldset definitions do not accept parameters (got: #{args})" \
-              "If you're upgrading from a previous version of Praxis and still using the view :default " \
-              "block syntax, make sure you don't use any view: X parameters when you define the attributes " \
-              "(expand them explicitly if you want deeper structure)" \
-              "The offending view with parameters is defined in:\n#{Kernel.caller.first}" unless args.empty?
+        unless args.empty?
+          raise "Default fieldset definitions do not accept parameters (got: #{args})" \
+                "If you're upgrading from a previous version of Praxis and still using the view :default " \
+                "block syntax, make sure you don't use any view: X parameters when you define the attributes " \
+                '(expand them explicitly if you want deeper structure)' \
+                "The offending view with parameters is defined in:\n#{Kernel.caller.first}"
+        end
         @hash[name] = block_given? ? FieldsetParser.new(&block).fieldset : true
       end
 
       def fieldset
         return @hash if @hash
+
         # Lazy eval
         @hash = {}
         instance_eval(&@block)
@@ -40,14 +42,13 @@ module Praxis
 
     extend Finalizable
 
-    @@caching_enabled = false
+    @@caching_enabled = false # rubocop:disable Style/ClassVars
 
     attr_reader :validating
     attr_accessor :object
 
     class << self
-      attr_reader :attribute
-      attr_reader :options
+      attr_reader :attribute, :options
       attr_accessor :reference
     end
 
@@ -65,14 +66,14 @@ module Praxis
     def self.new(object)
       # TODO: do we want to allow the identity map thing in the object?...maybe not.
       if @@caching_enabled
-        return self.cache[object] ||= begin
-          blueprint = self.allocate
+        return cache[object] ||= begin
+          blueprint = allocate
           blueprint.send(:initialize, object)
           blueprint
         end
       end
 
-      blueprint = self.allocate
+      blueprint = allocate
       blueprint.send(:initialize, object)
       blueprint
     end
@@ -83,15 +84,11 @@ module Praxis
 
     def self.attributes(opts = {}, &block)
       if block_given?
-        raise 'Redefining Blueprint attributes is not currently supported' if self.const_defined?(:Struct, false)
+        raise 'Redefining Blueprint attributes is not currently supported' if const_defined?(:Struct, false)
 
-        if opts.key?(:reference) && opts[:reference] != self.reference
-          raise "Reference mismatch in #{self.inspect}. Given :reference option #{opts[:reference].inspect}, while using #{self.reference.inspect}"
-        elsif self.reference
-          opts[:reference] = self.reference # pass the reference Class down
-        else
-          opts[:reference] = self
-        end
+        raise "Reference mismatch in #{inspect}. Given :reference option #{opts[:reference].inspect}, while using #{reference.inspect}" if opts.key?(:reference) && opts[:reference] != reference
+
+        opts[:reference] = (reference || self)
 
         @options.merge!(opts)
         @block = block
@@ -99,13 +96,14 @@ module Praxis
         return @attribute
       end
 
-      raise "@attribute not defined yet for #{self.name}" unless @attribute
+      raise "@attribute not defined yet for #{name}" unless @attribute
 
       @attribute.attributes
     end
 
     def self.domain_model(klass = nil)
       return @domain_model if klass.nil?
+
       @domain_model = klass
     end
 
@@ -118,16 +116,16 @@ module Praxis
       when self
         value
       when nil, Hash, String
-        if (value = self.attribute.load(value, context, **options))
-          self.new(value)
+        if (value = attribute.load(value, context, **options))
+          new(value)
         end
       else
-        if value.is_a?(self.domain_model) || value.is_a?(self::Struct)
+        if value.is_a?(domain_model) || value.is_a?(self::Struct)
           # Wrap the value directly
-          self.new(value)
+          new(value)
         else
           # Wrap the object inside the domain_model
-          self.new(domain_model.new(value))
+          new(domain_model.new(value))
         end
       end
     end
@@ -141,7 +139,7 @@ module Praxis
     end
 
     def self.caching_enabled=(caching_enabled)
-      @@caching_enabled = caching_enabled
+      @@caching_enabled = caching_enabled # rubocop:disable Style/ClassVars
     end
 
     # Fetch current blueprint cache, scoped by this class
@@ -154,29 +152,28 @@ module Praxis
     end
 
     def self.valid_type?(value)
-      value.is_a?(self) || value.is_a?(self.attribute.type)
+      value.is_a?(self) || value.is_a?(attribute.type)
     end
 
     def self.example(context = nil, **values)
       context = case context
                 when nil
-                  ["#{self.name}-#{values.object_id}"]
+                  ["#{name}-#{values.object_id}"]
                 when ::String
                   [context]
                 else
                   context
                 end
 
-      self.new(self.attribute.example(context, values: values))
+      new(attribute.example(context, values: values))
     end
 
     def self.validate(value, context = Attributor::DEFAULT_ROOT_CONTEXT, _attribute = nil)
-      raise ArgumentError, "Invalid context received (nil) while validating value of type #{self.name}" if context.nil?
+      raise ArgumentError, "Invalid context received (nil) while validating value of type #{name}" if context.nil?
+
       context = [context] if context.is_a? ::String
 
-      unless value.is_a?(self)
-        raise ArgumentError, "Error validating #{Attributor.humanize_context(context)} as #{self.name} for an object of type #{value.class.name}."
-      end
+      raise ArgumentError, "Error validating #{Attributor.humanize_context(context)} as #{name} for an object of type #{value.class.name}." unless value.is_a?(self)
 
       value.validate(context)
     end
@@ -187,13 +184,14 @@ module Praxis
       @block_for_default_fieldset = block
     end
 
-    def self.view(name, **options, &block)
+    def self.view(name, **_options, &block)
       unless name == :default
         raise "[ERROR] Views are no longer supported. Please use fully expanded fields when rendering.\n" \
               "NOTE that defining the :default view is deprecated, but still temporarily allowed, as an alias to define the default_fieldset.\n" \
               "A view for name #{name} is attempted to be defined in:\n#{Kernel.caller.first}"
       end
-      raise "Cannot define the default fieldset through the default view unless a block is passed" unless block_given?
+      raise 'Cannot define the default fieldset through the default view unless a block is passed' unless block_given?
+
       puts "[DEPRECATED] default fieldsets should be defined through `default_fieldset` instead of using the view :default block.\n" \
            "A default view is attempted to be defined in:\n#{Kernel.caller.first}"
       default_fieldset(&block)
@@ -219,45 +217,45 @@ module Praxis
     # Internal finalize! logic
     def self._finalize!
       if @block
-        self.define_attribute!
-        self.define_readers!
+        define_attribute!
+        define_readers!
         # Don't blindly override a the default fieldset if the MediaType wants to define it on its own
         if @block_for_default_fieldset
-          parse_default_fieldset(@block_for_default_fieldset) 
+          parse_default_fieldset(@block_for_default_fieldset)
         else
-          self.generate_default_fieldset!
+          generate_default_fieldset!
         end
-        self.resolve_domain_model!
+        resolve_domain_model!
       end
       super
     end
 
     def self.resolve_domain_model!
-      return unless self.domain_model.is_a?(String)
+      return unless domain_model.is_a?(String)
 
-      @domain_model = self.domain_model.constantize
+      @domain_model = domain_model.constantize
     end
 
     def self.define_attribute!
       @attribute = Attributor::Attribute.new(Attributor::Struct, @options, &@block)
       @block = nil
       @attribute.type.anonymous_type true
-      self.const_set(:Struct, @attribute.type)
+      const_set(:Struct, @attribute.type)
     end
 
     def self.define_readers!
-      self.attributes.each do |name, _attribute|
+      attributes.each do |name, _attribute|
         name = name.to_sym
 
         # Don't redefine existing methods
-        next if self.instance_methods.include? name
+        next if instance_methods.include? name
 
         define_reader! name
       end
     end
 
     def self.define_reader!(name)
-      attribute = self.attributes[name]
+      attribute = attributes[name]
       # TODO: profile and optimize
       # because we use the attribute in the reader,
       # it's likely faster to use define_method here
@@ -265,6 +263,7 @@ module Praxis
       define_method(name) do
         value = @object.__send__(name)
         return value if value.nil? || value.is_a?(attribute.type)
+
         attribute.load(value)
       end
     end
@@ -274,15 +273,16 @@ module Praxis
 
       @default_fieldset = {}
       attributes.each do |name, attr|
-        the_type = (attr.type < Attributor::Collection) ? attr.type.member_type : attr.type
+        the_type = attr.type < Attributor::Collection ? attr.type.member_type : attr.type
         next if the_type < Blueprint
-        # Note: we won't try to expand fields here, as we want to be lazy (and we're expanding)
+
+        # NOTE: we won't try to expand fields here, as we want to be lazy (and we're expanding)
         # every time a request comes in anyway. This could be an optimization we do at some point
         # or we can 'memoize it' to avoid trying to expand it over an over...
         @default_fieldset[name] = true
       end
     end
-    
+
     def initialize(object)
       @object = object
       @validating = false
@@ -291,18 +291,14 @@ module Praxis
     # By default we'll use the object identity, to avoid rendering the same object twice
     # Override, if there is a better way cache things up
     def _cache_key
-      self.object
+      object
     end
 
     # Render the wrapped data with the given fields (or using the default fieldset otherwise)
-    def render(fields: self.class.default_fieldset, context: Attributor::DEFAULT_ROOT_CONTEXT, renderer: Renderer.new, **opts)
-
+    def render(fields: self.class.default_fieldset, context: Attributor::DEFAULT_ROOT_CONTEXT, renderer: Renderer.new, **_opts)
       # Accept a simple array of fields, and transform it to a 1-level hash with true values
-      if fields.is_a? Array
-        fields = fields.each_with_object({}) { |field, hash| hash[field] = true }
-      end
+      fields = fields.each_with_object({}) { |field, hash| hash[field] = true } if fields.is_a? Array
 
-      expanded  = Praxis::FieldExpander.new.expand(self, fields)
       renderer.render(self, fields, context: context)
     end
 
@@ -313,11 +309,12 @@ module Praxis
     end
 
     def validate(context = Attributor::DEFAULT_ROOT_CONTEXT)
-      raise ArgumentError, "Invalid context received (nil) while validating value of type #{self.name}" if context.nil?
+      raise ArgumentError, "Invalid context received (nil) while validating value of type #{name}" if context.nil?
+
       context = [context] if context.is_a? ::String
-      keys_with_values = []
 
       raise 'validation conflict' if @validating
+
       @validating = true
 
       errors = []
@@ -328,18 +325,12 @@ module Praxis
         value = _get_attr(key)
         keys_provided << key if @object.key?(key)
 
-        if value.respond_to?(:validating) # really, it's a thing with sub-attributes
-          next if value.validating
-        end
+        next if value.respond_to?(:validating) && value.validating # really, it's a thing with sub-attributes
 
         # Isn't this handled by the requirements validation? NO! we might want to combine
-        if attribute.options[:required] && !@object.key?(key)
-          errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is required."]
-        end
+        errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is required."] if attribute.options[:required] && !@object.key?(key)
         if @object[key].nil?
-          if !Attributor::Attribute.nullable_attribute?(attribute.options) && @object.key?(key) # It is only nullable if there's an explicite null: true (undefined defaults to false)
-            errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is not nullable."]
-          end
+          errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is not nullable."] if !Attributor::Attribute.nullable_attribute?(attribute.options) && @object.key?(key) # It is only nullable if there's an explicite null: true (undefined defaults to false)
           # No need to validate the attribute further if the key wasn't passed...(or we would get nullable errors etc..cause the attribute has no
           # context if its containing key was even passed (and there might not be a containing key for a top level attribute anyways))
         else
@@ -357,14 +348,14 @@ module Praxis
 
     # generic semi-private getter used by Renderer
     def _get_attr(name)
-      self.send(name)
+      send(name)
     end
 
     # Delegates the json-schema methods to the underlying attribute/member_type
     def self.as_json_schema(**args)
       @attribute.type.as_json_schema(args)
     end
-    
+
     def self.json_schema_type
       @attribute.type.json_schema_type
     end