praxis 2.0.pre.17 → 2.0.pre.21

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)
@@ -36,18 +38,18 @@ module Praxis
       end
     end
     include Attributor::Type
+    include Attributor::Container
     include Attributor::Dumpable
 
     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 +67,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 +85,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 +97,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 +117,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 +140,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 +153,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 +185,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 +218,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 +264,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 +274,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 +292,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,26 +310,36 @@ 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 = []
-      self.class.attributes.each do |sub_attribute_name, sub_attribute|
-        sub_context = self.class.generate_subcontext(context, sub_attribute_name)
-        value = self.send(sub_attribute_name)
-        keys_with_values << sub_attribute_name unless value.nil?
+      keys_provided = []
+
+      self.class.attributes.each do |key, attribute|
+        sub_context = self.class.generate_subcontext(context, key)
+        value = _get_attr(key)
+        keys_provided << key if @object.key?(key)
+
+        next if value.respond_to?(:validating) && value.validating # really, it's a thing with sub-attributes
 
-        if value.respond_to?(:validating) # really, it's a thing with sub-attributes
-          next if value.validating
+        # Isn't this handled by the requirements validation? NO! we might want to combine
+        errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is required."] if attribute.options[:required] && !@object.key?(key)
+        if @object[key].nil?
+          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
+          errors.concat attribute.validate(value, sub_context)
         end
-        errors.concat(sub_attribute.validate(value, sub_context))
       end
-      self.class.attribute.type.requirements.each do |req|
-        validation_errors = req.validate(keys_with_values, context)
+      self.class.attribute.type.requirements.each do |requirement|
+        validation_errors = requirement.validate(keys_provided, context)
         errors.concat(validation_errors) unless validation_errors.empty?
       end
       errors
@@ -342,14 +349,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

data/lib/praxis/bootloader.rb

@@ -1,13 +1,12 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   class Bootloader
-
-    attr_reader :application
-    attr_reader :stages
+    attr_reader :application, :stages
 
     def initialize(application)
       @application = application
-      @stages = Array.new
+      @stages = []
 
       setup_stages!
     end
@@ -26,7 +25,7 @@ module Praxis
 
       # then setup plugins
       stages << BootloaderStages::PluginLoader.new(:plugins, application)
-      
+
       # then the initializers. as it is their job to ensure monkey patches and other
       # config is in place first.
       stages << BootloaderStages::FileLoader.new(:initializers, application)
@@ -50,24 +49,18 @@ module Praxis
         Praxis::Blueprint.finalize!
         Praxis::EndpointDefinition.finalize!
       end
-
     end
 
     def delete_stage(stage_name)
-      if (stage = stages.find { |stage| stage.name == stage_name })
-        stages.delete(stage)
-      else
-        raise Exceptions::StageNotFound.new(
-          "Cannot remove stage with name #{stage_name}, stage does not exist."
-        )
-      end
-    end
+      raise Exceptions::StageNotFound, "Cannot remove stage with name #{stage_name}, stage does not exist." unless (stage = stages.find { |s| s.name == stage_name })
 
+      stages.delete(stage)
+    end
 
     def before(*stage_path, &block)
       stage_name = stage_path.shift
       the_stage = stages.find { |stage| stage.name == stage_name }
-      raise Exceptions::StageNotFound.new("Error running a before block for stage #{stage_name}") unless the_stage
+      raise Exceptions::StageNotFound, "Error running a before block for stage #{stage_name}" unless the_stage
 
       the_stage.before(*stage_path, &block)
     end
@@ -75,36 +68,37 @@ module Praxis
     def after(*stage_path, &block)
       stage_name = stage_path.shift
       the_stage = stages.find { |stage| stage.name == stage_name }
-      raise Exceptions::StageNotFound.new("Error running an after block for stage #{stage_name}") unless the_stage
+      raise Exceptions::StageNotFound, "Error running an after block for stage #{stage_name}" unless the_stage
 
       the_stage.after(*stage_path, &block)
     end
 
-    def use(plugin,**options, &block)
+    def use(plugin, **options, &block)
       if plugin.ancestors.include?(PluginConcern)
         plugin.setup!
         plugin = plugin::Plugin
       end
 
       instance = if plugin.ancestors.include?(Singleton)
-        plugin.instance
-      elsif plugin.kind_of?(Class)
-        plugin.new
-      else
-        plugin
-      end
+                   plugin.instance
+                 elsif plugin.is_a?(Class)
+                   plugin.new
+                 else
+                   plugin
+                 end
 
       instance.application = application
       instance.options.merge!(options)
       instance.block = block if block_given?
 
       config_key = if instance.config_key.nil?
-        raise "Cannot use plugin: #{plugin}. It does not have a config_key defined, and its class does not have a name" unless instance.class.name
-        # Default the config key based on the full class name transformed to snake case (and joining modules with '_')
-        instance.class.name.to_s.split('::').collect{|n| n.underscore }.join('_').to_sym
-      else
-        instance.config_key
-      end
+                     raise "Cannot use plugin: #{plugin}. It does not have a config_key defined, and its class does not have a name" unless instance.class.name
+
+                     # Default the config key based on the full class name transformed to snake case (and joining modules with '_')
+                     instance.class.name.to_s.split('::').collect(&:underscore).join('_').to_sym
+                   else
+                     instance.config_key
+                   end
 
       if application.plugins.key?(instance.config_key)
         used_in = application.plugins[config_key].class
@@ -128,8 +122,5 @@ module Praxis
         stage.run
       end
     end
-
   end
-
-
 end

data/lib/praxis/bootloader_stages/environment.rb

@@ -1,21 +1,18 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   module BootloaderStages
-
     class Environment < Stage
-
       # require environment files. we will require 2 files:
       # 1) the environment.rb file    - generic stuff for all environments
       # 2) "Deployer.environment".rb  - environment specific stuff
       def execute
         setup_initial_config!
 
-        env_file = application.root + "config/environment.rb"
-        require env_file if File.exists? env_file
+        env_file = application.root / 'config/environment.rb'
+        require env_file if File.exist? env_file
 
-        unless application.file_layout
-          setup_default_layout!
-        end
+        setup_default_layout! unless application.file_layout
       end
 
       def setup_default_layout!
@@ -52,8 +49,6 @@ module Praxis
           end
         end
       end
-
     end
-
   end
 end

data/lib/praxis/bootloader_stages/file_loader.rb

@@ -1,10 +1,8 @@
-module Praxis
-
+# frozen_string_literal: true
 
+module Praxis
   module BootloaderStages
-
     class FileLoader < Stage
-
       attr_reader :path
 
       def initialize(name, application, path: nil)
@@ -16,6 +14,7 @@ module Praxis
         application.file_layout[*path].each do |file|
           next if application.loaded_files.include?(file)
           next unless file.extname == '.rb'
+
           require file
           application.loaded_files << file
         end
@@ -24,8 +23,6 @@ module Praxis
       def callback_args
         application.file_layout[*path]
       end
-
     end
   end
-
 end

data/lib/praxis/bootloader_stages/plugin_config_load.rb

@@ -1,21 +1,19 @@
+# frozen_string_literal: true
+
 module Praxis
   module BootloaderStages
     class PluginConfigLoad < Stage
-
       def execute
         application.plugins.each do |config_key, plugin|
           context = [plugin.class.name]
           value = plugin.load_config!
           object = plugin.config_attribute.load(value, context)
 
-          if object
-            application.config.send("#{config_key}=", object)
-          end
+          application.config.send("#{config_key}=", object) if object
 
-          plugin.config = application.config.send("#{config_key}")
+          plugin.config = application.config.send(config_key.to_s)
         end
       end
-
     end
   end
 end

data/lib/praxis/bootloader_stages/plugin_config_prepare.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Praxis
   module BootloaderStages
     class PluginConfigPrepare < Stage
-
       def execute
         application.plugins.each do |config_key, plugin|
           attribute = Attributor::Attribute.new(Attributor::Struct) {}
@@ -12,7 +13,6 @@ module Praxis
           application.config.class.attributes[config_key] = plugin.config_attribute
         end
       end
-
     end
   end
 end

data/lib/praxis/bootloader_stages/plugin_loader.rb

@@ -1,19 +1,15 @@
-module Praxis
-
+# frozen_string_literal: true
 
+module Praxis
   module BootloaderStages
-
     class PluginLoader < Stage
-
-      def initialize(name, context,**opts)
+      def initialize(name, context, **opts)
         super
 
         stages << PluginConfigPrepare.new(:prepare, context, parent: self)
         stages << PluginConfigLoad.new(:load, context, parent: self)
         stages << PluginSetup.new(:setup, context, parent: self)
       end
-
     end
-
   end
 end

data/lib/praxis/bootloader_stages/plugin_setup.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 module Praxis
   module BootloaderStages
     class PluginSetup < Stage
-
       def execute
-        application.plugins.each do |config_key, plugin|
+        application.plugins.each do |_config_key, plugin|
           plugin.setup!
         end
       end
-
     end
   end
 end