praxis 2.0.pre.31 → 2.0.pre.33

data/lib/praxis/extensions/attribute_filtering/active_record_filter_query_builder.rb

@@ -34,7 +34,7 @@ module Praxis
           @model = model
           @filters_map = filters_map
           @logger = debug ? Logger.new($stdout) : nil
-          @active_record_version_maj = ActiveRecord.gem_version.segments[0]
+          @active_record_version = ActiveRecord.gem_version
         end
 
         def debug_query(msg, query)
@@ -86,7 +86,8 @@ module Praxis
             )
           end
 
-          if @active_record_version_maj < 6
+          
+          if @active_record_version < Gem::Version.new('6')
             # ActiveRecord < 6 does not support '.and' so no nested things can be done
             # But we can still support the case of 1+ flat conditions of the same AND/OR type
             if root_parent_group.is_a?(FilteringParams::Condition)
@@ -347,8 +348,7 @@ module Praxis
         end
 
         # The value that we need to stick in the references method is different in the latest Rails
-        maj, min, = ActiveRecord.gem_version.segments
-        if maj == 5 || (maj == 6 && min.zero?)
+        if ActiveRecord.gem_version < Gem::Version.new('6')
           # In AR 6 (and 6.0) the references are simple strings
           def self.build_reference_value(column_prefix, **_args)
             column_prefix

data/lib/praxis/extensions/attribute_filtering/active_record_patches.rb

@@ -2,17 +2,11 @@
 
 require 'active_record'
 
-maj, min, = ActiveRecord.gem_version.segments
-
-case maj
-when 5
+if ActiveRecord.gem_version < Gem::Version.new('6')
   require_relative 'active_record_patches/5x'
-when 6
-  if min.zero?
-    require_relative 'active_record_patches/6_0'
-  else
-    require_relative 'active_record_patches/6_1_plus'
-  end
+elsif ActiveRecord.gem_version < Gem::Version.new('6.1')
+  require_relative 'active_record_patches/6_0'
 else
-  raise 'Filtering only supported for ActiveRecord >= 5 && <= 6'
-end
+  # As of 7.0.4 our 6.1-plus patches still work
+  require_relative 'active_record_patches/6_1_plus'
+end

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

@@ -45,6 +45,8 @@ module Praxis
             quoted_prefix = AttributeFiltering::ActiveRecordFilterQueryBuilder.quote_column_path(query: query, prefix: column_prefix, column_name: info[:attribute])
             order_clause = Arel.sql(ActiveRecord::Base.sanitize_sql_array("#{quoted_prefix} #{direction}"))
             query = query.order(order_clause)
+            # Add a select for any order clause (unless we're already selecting *), as latest MySQL versions require it for DISTINCT queries
+            query = query.select(quoted_prefix) unless query.select_values.empty?
           end
           query
         end

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

@@ -89,7 +89,7 @@ module Praxis
           end
 
           def default(spec)
-            unless spec.is_a?(Hash) && spec.keys.size == 1 && %i[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
@@ -101,7 +101,7 @@ module Praxis
 
                          { by: value }
                        when :page
-                         raise "Error setting default pagination. Initial page should be a integer (but got #{value})" unless value.is_a?(Integer)
+                         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 }

data/lib/praxis/field_expander.rb

@@ -68,7 +68,7 @@ module Praxis
       end
 
       # just include the full thing if it has no attributes
-      return true if object.attributes.empty?
+      return fields if object.attributes.empty?
 
       # True, expands to the default fieldset for blueprints
       fields = object.default_fieldset if object < Praxis::Blueprint && fields == true

data/lib/praxis/mapper/active_model_compat.rb

@@ -67,19 +67,17 @@ module Praxis
         end
 
         def _join_foreign_key_for(assoc_reflection)
-          maj, min, = ActiveRecord.gem_version.segments
-          if maj >= 6 && min >= 1
+          if ActiveRecord.gem_version >= Gem::Version.new('6.1')
             assoc_reflection.join_foreign_key.to_sym
-          else
+          else # below 6.1
             assoc_reflection.join_keys.foreign_key.to_sym
           end
         end
 
         def _join_primary_key_for(assoc_reflection)
-          maj, min, = ActiveRecord.gem_version.segments
-          if maj >= 6 && min >= 1
+          if ActiveRecord.gem_version >= Gem::Version.new('6.1')
             assoc_reflection.join_primary_key.to_sym
-          else
+          else # below 6.1
             assoc_reflection.join_keys.key.to_sym
           end
         end

data/lib/praxis/mapper/selector_generator.rb

@@ -321,7 +321,7 @@ module Praxis
       end
 
       def inspect
-        "<#{self.class}# @root=#{@root.inspect}>"
+        "#<#{self.class} @resource=#{@resource.name.inspect} @select=#{@select.inspect} @select_star=#{@select_star.inspect} @tracking.keys=#{@tracks.keys} (recursion omitted)>"
       end
     end
 

data/lib/praxis/media_type_identifier.rb

@@ -45,7 +45,7 @@ module Praxis
     # @see Attributor::Model#load
     def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, recurse: false, **options)
       case value
-      when String
+      when ::String
         return nil if value.blank?
 
         base, *parameters = value.split(PARAMETER_SEPARATOR)
@@ -66,7 +66,7 @@ module Praxis
         else
           obj.type = 'application'
           obj.subtype = base.split(WORD_SEPARATOR, 2).first
-          obj.suffix = String.new
+          obj.suffix = ::String.new
           obj.parameters = {}
         end
         obj
@@ -126,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 = String.new("#{type}/#{subtype}")
+      s = ::String.new("#{type}/#{subtype}")
 
       # coated in a hard candy shell
       s << '+' << suffix unless suffix.empty?
@@ -204,7 +204,7 @@ module Praxis
       obj.type = type
       obj.subtype = subtype
       target_suffix = suffix || self.suffix
-      obj.suffix = redundant_suffix(target_suffix) ? String.new : target_suffix
+      obj.suffix = redundant_suffix(target_suffix) ? ::String.new : target_suffix
       obj.parameters = self.parameters.merge(parameters)
 
       obj

data/lib/praxis/request.rb

@@ -184,7 +184,7 @@ module Praxis
     # Override the inspect instance method of a request, as, by default, the kernel inspect will go nuts
     # traversing the action and app_instance and therefore all associated instance variables reachable through that
     def inspect
-      "'@env' => #{@env.inspect},\n'@headers' => #{@headers.inspect},\n'@params' => #{@params.inspect},\n'@query' => #{@query.inspect}"
+      "#<#{self.class}##{object_id} @action=#{@action.inspect} @params=#{@params.inspect}>"
     end
   end
 end

data/lib/praxis/tasks/console.rb

@@ -27,6 +27,9 @@ namespace :praxis do
       PROMPT_C: "%N(#{nickname}):%03n:%i* "
     }
 
+    # Disable inefficient, distracting autocomplete
+    IRB.conf[:USE_AUTOCOMPLETE] = false
+
     # Set the IRB main object.
     IRB.irb(nil, Praxis::Application.instance)
   end

data/lib/praxis/types/multipart_array.rb

@@ -219,13 +219,13 @@ module Praxis
         hash[:part_name] = { type: name_type.describe(true) }
 
         unless shallow
-          hash[:attributes] = {} if attributes.keys.any? { |name| name.is_a? String }
+          hash[:attributes] = {} if attributes.keys.any? { |name| name.is_a? ::String }
           hash[:pattern_attributes] = {} if attributes.keys.any? { |name| name.is_a? Regexp }
 
           if hash.key?(:attributes) || hash.key?(:pattern_attributes)
             describe_attributes(shallow, example: example).each do |name, sub_hash|
               case name
-              when String
+              when ::String
                 hash[:attributes][name] = sub_hash
               when Regexp
                 hash[:pattern_attributes][name.source] = sub_hash
@@ -305,7 +305,7 @@ module Praxis
           return self << part
         elsif self.class.options[:case_insensitive_load]
           name = self.class.attributes.keys.find do |k|
-            k.is_a?(String) && key.downcase == k.downcase
+            k.is_a?(::String) && key.downcase == k.downcase
           end
           if name
             part.name = name

data/lib/praxis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Praxis
-  VERSION = '2.0.pre.31'
+  VERSION = '2.0.pre.33'
 end

data/praxis.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.executables << 'praxis'
 
   spec.add_dependency 'activesupport', '>= 3'
-  spec.add_dependency 'attributor', '>= 6.5'
+  spec.add_dependency 'attributor', '>= 7.0'
   spec.add_dependency 'mime', '~> 0'
   spec.add_dependency 'mustermann', '>=1.1'
   spec.add_dependency 'rack', '>= 1'
@@ -32,6 +32,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '>= 12.3.3'
+  spec.add_development_dependency "appraisal"
 
   if RUBY_PLATFORM !~ /java/
     spec.add_development_dependency 'pry'
@@ -50,7 +51,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3'
   spec.add_development_dependency 'rspec-collection_matchers', '~> 1'
   spec.add_development_dependency 'rspec-its', '~> 1'
-  # Just for the query selector extensions etc...
-  spec.add_development_dependency 'activerecord', '> 4', '< 7'
-  spec.add_development_dependency 'sequel', '~> 5'
 end

data/spec/praxis/application_spec.rb

@@ -97,6 +97,17 @@ describe Praxis::Application do
     end
   end
 
+  describe '#inspect' do
+    let(:klass) { Class.new(Praxis::Application) }
+    subject { klass.instance }
+
+    it 'includes name, object ID and root' do
+      SomeApplication = klass # de-anonymize class name
+      klass.instance.instance_variable_set(:@root, '/tmp')
+      expect(subject.inspect).to match(%r{#<SomeApplication#[0-9]+ @root=/tmp>})
+    end
+  end
+
   describe '#setup' do
     subject { Class.new(Praxis::Application).instance }
 

data/spec/praxis/blueprint_spec.rb

@@ -7,6 +7,280 @@ describe Praxis::Blueprint do
 
   its(:family) { should eq('hash') }
 
+  # This context might seem a duplication of tests that should be covered by the underlying attributor gem
+  # but while it is in structure, it is different because we're doing it with Blueprints (not Attributor Models)
+  # to make sure our Blueprints are behaving as expected.
+  context 'type resolution, option inheritance for attributes with and without references' do
+    # Overall strategy
+    # 1) When no type is specified:
+    #   1.1) if it is a leaf (no block)
+    #     1.1.1) with an reference with an attr with the same name
+    #          - type copied from reference
+    #          - reference options are inherited as well (and can be overridden by local attribute ones)
+    #     1.1.2) without a ref (or the ref does not have same attribute name)
+    #          - Fail. Cannot determine type
+    #   1.2) if it has a block
+    #     1.2.1) with an reference with an attr with the same name
+    #          - We assume you're re/defining a new Struct (or Struct[]), and we will incorporate the reference type 
+    #           for the matching name in case you are indeed redefining a subset of the attributes, so you can enjoy inheritance
+    #     1.2.2) without a ref (or the ref does not have same attribute name)
+    #          - defaulted to Struct (if you meant Collection.of(Struct) things would fail later somehow)
+    #          - options are NOT inherited at all (This is something we should ponder more about)
+    # 2) When type is specified:
+    #   2.1) if it is a leaf (no block)
+    #     - ignore ref if there is one (with or without matching attribute name).
+    #     - simply use provided type, and provided options (no inheritance)
+    #   2.2) if it has a block
+    #     - Same as above: use type and options provided, ignore ref if there is one (with or without matching attribute name).
+
+    let(:mytype) do 
+      Praxis::Blueprint.finalize!
+      Class.new(Praxis::Blueprint, &myblock).tap{|c| c._finalize!}
+    end
+    context 'with no explicit type specified' do
+      context 'without a block (if it is a leaf)' do
+        context 'that has a reference with an attribute with the same name' do
+          let(:myblock) { 
+            Proc.new do
+              attributes reference: PersonBlueprint do
+                attribute :age, required: true, min: 42
+              end
+            end
+          }
+          it 'uses type from reference' do
+            expect(mytype.attributes).to have_key(:age)
+            expect(mytype.attributes[:age].type).to eq(PersonBlueprint.attributes[:age].type)
+          end
+          it 'copies over reference options and allows the attribute to override/add some' do
+            merged_options = PersonBlueprint.attributes[:age].options.merge(required: true, min: 42)
+            expect(mytype.attributes[:age].options).to include(merged_options)
+          end
+        end
+        context 'with a reference, but that does not have a matching attribute name' do
+          let(:myblock) { 
+            Proc.new do
+              attributes reference: AddressBlueprint do
+                attribute :age
+              end
+            end
+          }
+          it 'fails resolving' do
+            expect{mytype.attributes}.to raise_error(/Type for attribute with name: age could not be determined./)
+          end
+        end
+        context 'without a reference' do
+          let(:myblock) { 
+            Proc.new do
+              attributes do
+                attribute :age
+              end
+            end
+          }
+          it 'fails resolving' do
+            expect{mytype.attributes}.to raise_error(/Type for attribute with name: age could not be determined./)
+          end
+        end
+      end
+      context 'with block (if it is NOT a leaf)' do
+        context 'that has a reference with an attribute with the same name' do
+          context 'which is not a collection type' do
+            let(:myblock) { 
+              Proc.new do
+                attributes reference: PersonBlueprint do
+                  attribute :age , description: 'I am fully redefining' do
+                    attribute :foobar, Integer, min: 42
+                  end
+                end
+              end
+            }
+            it 'picks Struct, and makes sure to pass the reference of the attribute along' do
+              expect(mytype.attributes).to have_key(:age)
+              age_attribute = mytype.attributes[:age]
+              # Resolves to Struct
+              expect(age_attribute.type).to be < Attributor::Struct
+              # does NOT brings any ref options (except the right reference)
+              expect(age_attribute.options).to include(description: 'I am fully redefining')
+              # Yes, there is no way we can ever use an Integer when we're defining a Struct...but if the parent was a Struct, we would
+              expect(age_attribute.options).to include(reference: Attributor::Integer) 
+              # And the nested attribute is correctly resolved as well, and ensures options are there
+              expect(age_attribute.type.attributes[:foobar].type).to eq(Attributor::Integer)
+              expect(age_attribute.type.attributes[:foobar].options).to eq(min: 42)
+            end
+          end
+          context 'which is a collection type' do
+            let(:myblock) { 
+              Proc.new do
+                attributes reference: PersonBlueprint do
+                  attribute :prior_addresses , description: 'I am fully redefining' do
+                    attribute :street, required: true
+                    attribute :new_attribute, String, default: 'foo'
+                  end
+                end
+              end
+            }
+            it 'picks Struct, and makes sure to pass the reference of the attribute along' do
+              expect(mytype.attributes).to have_key(:prior_addresses)
+              prior_addresses_attribute = mytype.attributes[:prior_addresses]
+              # Resolves to Struct[]
+              expect(prior_addresses_attribute.type).to be < Attributor::Collection
+              expect(prior_addresses_attribute.type.member_type).to be < Attributor::Struct
+              # does NOT brings any ref options (except the right reference)
+              expect(prior_addresses_attribute.options).to include(description: 'I am fully redefining')
+              # Yes, there is no way we can ever use an Integer when we're defining a Struct...but if the parent was a Struct, we would
+              expect(prior_addresses_attribute.options).to include(reference: PersonBlueprint.attributes[:prior_addresses].type.member_type) 
+              # And the nested attributes are correctly resolved as well, and ensures options are there
+              street_options_from_ref = PersonBlueprint.attributes[:prior_addresses].type.member_type.attributes[:street].options
+              expect(prior_addresses_attribute.type.member_type.attributes[:street].type).to eq(Attributor::String)
+              expect(prior_addresses_attribute.type.member_type.attributes[:street].options).to eq(street_options_from_ref.merge(required: true))
+
+              expect(prior_addresses_attribute.type.member_type.attributes[:new_attribute].type).to eq(Attributor::String)
+              expect(prior_addresses_attribute.type.member_type.attributes[:new_attribute].options).to eq(default: 'foo')
+            end
+          end
+          context 'in the unlikely case that the reference type has an anonymous Struct (or collection of)' do
+            let(:myblock) { 
+              Proc.new do
+                attributes reference: PersonBlueprint do
+                  attribute :funny_attribute, description: 'Funny business' do
+                    attribute :foobar, Integer, min: 42
+                  end
+                end
+              end
+            }
+            it 'correctly inherits it (same result as defaulting to Struct) and brings in the reference' do
+              expect(mytype.attributes).to have_key(:funny_attribute)
+              # Resolves to Struct, and brings (and merges) the ref options with the attribute's
+              expect(mytype.attributes[:funny_attribute].type).to be < Attributor::Struct
+              merged_options = {reference: PersonBlueprint.attributes[:funny_attribute].type}.merge(description: 'Funny business')
+              expect(mytype.attributes[:funny_attribute].options).to include(merged_options)
+              # And the nested attribute is correctly resolved as well, and ensures options are there
+              expect(mytype.attributes[:funny_attribute].type.attributes[:foobar].type).to eq(Attributor::Integer)
+              expect(mytype.attributes[:funny_attribute].type.attributes[:foobar].options).to eq(min: 42)
+            end
+          end
+        end
+        context 'with a reference, but that does not have a matching attribute name' do
+          let(:myblock) { 
+            Proc.new do
+              attributes reference: AddressBlueprint do
+                attribute :age, description: 'I am redefining' do
+                  attribute :foobar, Integer, min: 42
+                end
+              end
+            end
+          }
+          it 'correctly defaults to Struct uses only the local options (same exact as if it had no reference)' do
+            expect(mytype.attributes).to have_key(:age)
+            age_attribute = mytype.attributes[:age]
+            # Resolves to Struct
+            expect(age_attribute.type).to be < Attributor::Struct
+            # does NOT brings any ref options 
+            expect(age_attribute.options).to  eq(description: 'I am redefining')
+            # And the nested attribute is correctly resolved as well, and ensures options are there
+            expect(age_attribute.type.attributes[:foobar].type).to eq(Attributor::Integer)
+            expect(age_attribute.type.attributes[:foobar].options).to eq(min: 42)
+          end
+        end
+        context 'without a reference' do
+          let(:myblock) { 
+            Proc.new do
+              attributes do
+                attribute :age, description: 'I am redefining' do
+                  attribute :foobar, Integer, min: 42
+                end
+              end
+            end
+          }
+          it 'correctly defaults to Struct uses only the local options' do
+            expect(mytype.attributes).to have_key(:age)
+            age_attribute = mytype.attributes[:age]
+            # Resolves to Struct
+            expect(age_attribute.type).to be < Attributor::Struct
+            # does NOT brings any ref options 
+            expect(age_attribute.options).to  eq(description: 'I am redefining')
+            # And the nested attribute is correctly resolved as well, and ensures options are there
+            expect(age_attribute.type.attributes[:foobar].type).to eq(Attributor::Integer)
+            expect(age_attribute.type.attributes[:foobar].options).to eq(min: 42)
+          end
+        end
+      end
+    end
+    context 'with an explicit type specified' do
+      context 'without a reference' do
+        let(:myblock) { 
+          Proc.new do
+            attributes do
+              attribute :age, String, description: 'I am a String now'
+            end
+          end
+        }
+        it 'always uses the provided type and local options specified' do
+          expect(mytype.attributes).to have_key(:age)
+          age_attribute = mytype.attributes[:age]
+          # Resolves to String
+          expect(age_attribute.type).to eq(Attributor::String)
+          # copies local options
+          expect(age_attribute.options).to  eq(description: 'I am a String now')
+        end
+      end
+      context 'with a reference' do
+        let(:myblock) { 
+          Proc.new do
+            attributes reference: PersonBlueprint do
+              attribute :age, String, description: 'I am a String now'
+            end
+          end
+        }
+        it 'always uses the provided type and local options specified (same as if it had no reference)' do
+          expect(mytype.attributes).to have_key(:age)
+          age_attribute = mytype.attributes[:age]
+          # Resolves to String
+          expect(age_attribute.type).to eq(Attributor::String)
+          # copies local options
+          expect(age_attribute.options).to  eq(description: 'I am a String now')
+        end
+      end
+
+      context 'with a reference, which can further percolate down' do
+        let(:myblock) { 
+          Proc.new do
+            attributes reference: PersonBlueprint do
+              attribute :age, String, description: 'I am a String now'
+              attribute :address, Struct, description: 'Address subset' do
+                attribute :street, required: true
+              end
+              attribute :tags
+            end
+          end
+        }
+        
+        it 'brings the child reference for address so we can redefine it' do
+          expect(mytype.attributes.keys).to eq([:age, :address, :tags])
+          age_attribute = mytype.attributes[:age]
+          expect(age_attribute.type).to eq(Attributor::String)
+          expect(age_attribute.options).to  eq(description: 'I am a String now')
+
+          address_attribute = mytype.attributes[:address]
+          expect(address_attribute.type).to be < Attributor::Struct
+          # It brings in our local options AND percolates down the reference type for address
+          expect(address_attribute.options).to include(description: 'Address subset', reference: AddressBlueprint)
+
+          # Address fields are properly resolved to match the corresponding AddressBlueprint
+          expect(address_attribute.type.attributes.keys).to eq([:street])
+          street_attribute = address_attribute.type.attributes[:street]
+          expect(street_attribute.type).to eq(AddressBlueprint.attributes[:street].type)
+          # Makes sure our local options on the street are kept
+          expect(street_attribute.options).to include(required: true)
+          # And brings in other options from the inherited street attribute
+          expect(street_attribute.options).to include(description: 'The street')
+        
+          # It also properly resolves the direct tags attribute from the reference, pointing to the same type
+          tags_attribute = mytype.attributes[:tags]
+          expect(tags_attribute.type).to eq PersonBlueprint.attributes[:tags].type
+        end
+      end
+    end
+  end
   context 'deterministic examples' do
     it 'works' do
       person1 = PersonBlueprint.example('person 1')
@@ -75,7 +349,7 @@ describe Praxis::Blueprint do
   end
 
   it 'has an inner Struct class for the attributes' do
-    expect(blueprint_class.attribute.type).to be blueprint_class::Struct
+    expect(blueprint_class.attribute.type).to be blueprint_class::InnerStruct
   end
 
   context 'an instance' do
@@ -166,6 +440,12 @@ describe Praxis::Blueprint do
       it { should be_empty }
     end
 
+    context 'with a valid nested blueprint' do
+      let(:hash) { { name: 'bob', myself: { name: 'PseudoBob'}} }
+
+      it { should be_empty }
+    end
+
     context 'with invalid sub-attribute' do
       let(:hash) { { name: 'bob', address: { state: 'ME' } } }
 
@@ -173,6 +453,15 @@ describe Praxis::Blueprint do
       its(:first) { should =~ /Attribute \$.address.state/ }
     end
 
+    context 'with an invalid nested blueprint' do
+      let(:hash) { { name: 'bob', myself: { name: 'PseudoBob', address: { state: 'ME' }}} }
+
+      it { should have(1).item }
+      its(:first) { should =~ /Attribute \$.myself.address.state/ }
+
+    end
+
+
     context 'for objects of the wrong type' do
       it 'raises an error' do
         expect do
@@ -206,22 +495,23 @@ describe Praxis::Blueprint do
     end
   end
 
-  context 'with a provided :reference option on attributes' do
-    context 'that does not match the value set on the class' do
-      subject(:mismatched_reference) do
-        Class.new(Praxis::Blueprint) do
-          self.reference = Class.new(Praxis::Blueprint)
-          attributes(reference: Class.new(Praxis::Blueprint)) {}
-        end
-      end
-
-      it 'should raise an error' do
-        expect do
-          mismatched_reference.attributes
-        end.to raise_error(/Reference mismatch/)
-      end
-    end
-  end
+  # TODO: Think about this 'feature' ...
+  # context 'with a provided :reference option on attributes' do
+  #   context 'that does not match the value set on the class' do
+  #     subject(:mismatched_reference) do
+  #       Class.new(Praxis::Blueprint) do
+  #         self.reference = Class.new(Praxis::Blueprint)
+  #         attributes(reference: Class.new(Praxis::Blueprint)) {}
+  #       end
+  #     end
+
+  #     it 'should raise an error' do
+  #       expect do
+  #         mismatched_reference.attributes
+  #       end.to raise_error(/Reference mismatch/)
+  #     end
+  #   end
+  # end
 
   context '.example' do
     context 'with some attribute values provided' do

data/spec/praxis/controller_spec.rb

@@ -31,4 +31,13 @@ describe Praxis::Controller do
       expect(subject).to eq(PeopleResource.controller)
     end
   end
+
+  describe '#inspect' do
+    it 'includes name, object ID and request' do
+      SomeController = subject # de-anonymize class name
+      expect(subject.new('eioio').inspect).to match(
+        /#<SomeController#[0-9]+ @request="eioio">/
+      )
+    end
+  end
 end