smart_properties 1.9.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9129f5a59082dea813606c2c71007a999765dec0
-  data.tar.gz: 580c42e4b0d7cc3c728a44374b2bbdbbd683b4cf
+  metadata.gz: c5343469849e0419f91004d5beab3e1516f1d609
+  data.tar.gz: 90469264e820a223d9d77a896f5899b10c67e3ba
 SHA512:
-  metadata.gz: 22e0491c55f9f6aa08621bc2501f66e093aa005412ae647768907d4dcae2b9c730fcf542a3ef5ac8ff30bdb8ef83f7ad62e406d7b4eb72cee449ee65ada9c3ad
-  data.tar.gz: 0706e812564f577b0da0dd2fd1fcea21aaea5e19321832be0151fb9b21c1bf9ea9c14774b549e1a59ce9e7d3de4defe46e3ffa58835201a694624a0fc6c44c65
+  metadata.gz: dacd46d89ef227413d25bb3770dcd3bfad5b340f212a46cbd385fd9063d66fa7979fbb84a030600810acc95b1cefdd4a2c562bf7c2cbab47c6afb90fc5dabc77
+  data.tar.gz: 73e2cac3ff5075e1cb1bc61d28c85e8a54d6e14174ad0dfcaf55cd3c1b419d916b3dad78c1a0e481a1aa57582e59ca3fb6e68030e72206820beff2bc681b38a3

data/README.md

@@ -1,4 +1,4 @@
-# Smartproperties
+# SmartProperties
 
 Ruby accessors on steroids.
 
@@ -61,34 +61,43 @@ require 'smart_properties'
 class Message
   include SmartProperties
 
-  property :subject,  :converts => :to_s,
-                      :required => true
+  property :subject,  converts: :to_s,
+                      required: true
 
-  property :body,     :converts => :to_s
+  property :body,     converts: :to_s
 
-  property :priority, :converts => :to_sym,
-                      :accepts  => [:low, :normal, :high],
-                      :default  => :normal,
-                      :required => true
+  property :priority, converts: :to_sym,
+                      accepts: [:low, :normal, :high],
+                      default: :normal,
+                      required: true
 end
 ```
 
 Creating an instance of this class without specifying any attributes will
-result in an `ArgumentError` telling you to specify the required property
-`subject`.
+result in an `SmartProperties::InitializationError` telling you to specify the
+required property `subject`.
 
 ```ruby
-Message.new # => raises ArgumentError, "Message requires the property subject to be set"
+Message.new # => raises SmartProperties::InitializationError, "Message requires the following properties to be set: subject"
 ```
 
-Providing the constructor with a title but with an invalid value for the
-property `priority` will also result in an `ArgumentError` telling you to
-provide a proper value for the property `priority`.
+Creating an instance of this class with all required properties but then
+setting the property `priority` to an invalid value will also result in an
+`SmartProperties::InvalidValueError`. Since the property is required, assigning
+`nil` is also prohibited and will result in a
+`SmartProperties::MissingValueError`. All errors `SmartProperties` raises are
+subclasses of `ArgumentError`.
 
 ```ruby
-m = Message.new :subject => 'Lorem ipsum'
+m = Message.new subject: 'Lorem ipsum'
 m.priority # => :normal
-m.priority = :urgent # => raises ArgumentError, Message does not accept :urgent as value for the property priority
+
+begin
+  m.priority = :urgent
+rescue ArgumentError => error
+  error.class # => raises SmartProperties::InvalidValueError
+  error.message # => "Message does not accept :urgent as value for the property priority"
+end
 ```
 
 Next, we discuss the various configuration options `SmartProperties` provide.
@@ -110,7 +119,7 @@ to implement a property that automatically converts all given input to a
 
 ```ruby
 class Article
-  property :title, :converts => :to_s
+  property :title, converts: :to_s
 end
 ```
 
@@ -122,7 +131,7 @@ converts all given input to a slug representation.
 
 ```ruby
 class Article
-  property :slug, :converts => lambda { |slug| slug.downcase.gsub(/\s+/, '-').gsub(/\W/, '') }
+  property :slug, converts: lambda { |slug| slug.downcase.gsub(/\s+/, '-').gsub(/\W/, '') }
 end
 ```
 
@@ -136,7 +145,7 @@ of type `String` as input.
 
 ```ruby
 class Article
-  property :title, :accepts => String
+  property :title, accepts: String
 end
 ```
 
@@ -146,7 +155,7 @@ example below shows how to implement a property that only accepts `true` or
 
 ```ruby
 class Article
-  property :published, :accepts => [true, false]
+  property :published, accepts: [true, false]
 end
 ```
 
@@ -158,7 +167,7 @@ only accepts values which match the given regular expression.
 
 ```ruby
 class Article
-  property :title, :accepts => lambda { |title| /^Lorem \w+$/ =~ title }
+  property :title, accepts: lambda { |title| /^Lorem \w+$/ =~ title }
 end
 ```
 
@@ -171,12 +180,12 @@ default value.
 
 ```ruby
 class Article
-  property :id, :default => 42
+  property :id, default: 42
 end
 ```
 
 Default values can also be specified using blocks which are evaluated at
-runtime.
+runtime and only if no value was supplied.
 
 #### Presence checking
 
@@ -187,7 +196,7 @@ how to implement a property that may not be `nil`.
 
 ```ruby
 class Article
-  property :title, :required => true
+  property :title, required: true
 end
 ```
 
@@ -203,6 +212,35 @@ class Person
 end
 ```
 
+### Constructor argument forwarding
+
+The `SmartProperties` initializer forwards anything to the super constructor
+it does not process itself. This is true for all positional arguments
+and those keyword arguments that do not correspond to a property. The example
+below demonstrates how Ruby's `SimpleDelegator` in conjunction with
+`SmartProperties` can be used to quickly construct a very flexible presenter.
+
+```ruby
+class PersonPresenter < SimpleDelegator
+  include SmartProperties
+  property :name_formatter, accepts: Proc,
+                            required: true,
+                            default: lambda { |p| "#{p.firstname} #{p.lastname}" }
+
+  def full_name
+    name_formatter.call(self)
+  end
+end
+
+person = OpenStruct.new(firstname: "John", lastname: "Doe")
+presenter = PersonPresenter.new(person)
+presenter.full_name # => "John Doe"
+
+# Changing the format is easy
+presenter.name_formatter = lambda { |p| "#{p.lastename}, #{p.firstname}" }
+presenter.full_name # => "Doe, John"
+```
+
 ## Contributing
 
 1. Fork it

data/lib/smart_properties/errors.rb

@@ -0,0 +1,73 @@
+module SmartProperties
+  class Error < ::ArgumentError; end
+  class ConfigurationError < Error; end
+
+  class AssignmentError < Error
+    attr_accessor :sender
+    attr_accessor :property
+
+    def initialize(sender, property, message)
+      @sender = sender
+      @property = property
+      super(message)
+    end
+  end
+
+  class MissingValueError < AssignmentError
+    def initialize(sender, property)
+      super(
+        sender,
+        property,
+        "%s requires the property %s to be set" % [
+          sender.class.name,
+          property.name
+        ]
+      )
+    end
+
+    def to_hash
+      Hash[property.name, "must be set"]
+    end
+  end
+
+  class InvalidValueError < AssignmentError
+    attr_accessor :value
+
+    def initialize(sender, property, value)
+      @value = value
+      super(
+        sender,
+        property,
+        "%s does not accept %s as value for the property %s" % [
+          sender.class.name,
+          value.inspect,
+          property.name
+        ]
+      )
+    end
+
+    def to_hash
+      Hash[property.name, "does not accept %s as value" % value.inspect]
+    end
+  end
+
+  class InitializationError < Error
+    attr_accessor :sender
+    attr_accessor :properties
+
+    def initialize(sender, properties)
+      @sender = sender
+      @properties = properties
+      super(
+        "%s requires the following properties to be set: %s" % [
+          sender.class.name,
+          properties.map(&:name).sort.join(', ')
+        ]
+      )
+    end
+
+    def to_hash
+      properties.each_with_object({}) { |property, errors| errors[property.name] = "must be set" }
+    end
+  end
+end

data/lib/smart_properties/property.rb

@@ -0,0 +1,146 @@
+module SmartProperties
+  class Property
+    MODULE_REFERENCE = :"@_smart_properties_method_scope"
+
+    # Defines the two index methods #[] and #[]=. This module will be included
+    # in the SmartProperties method scope.
+    module IndexMethods
+      def [](name)
+        return if name.nil?
+        name &&= name.to_sym
+        public_send(name) if self.class.properties.key?(name)
+      end
+
+      def []=(name, value)
+        return if name.nil?
+        public_send(:"#{name.to_sym}=", value) if self.class.properties.key?(name)
+      end
+    end
+
+    attr_reader :name
+    attr_reader :converter
+    attr_reader :accepter
+    attr_reader :instance_variable_name
+
+    def self.define(scope, name, options = {})
+      new(name, options).tap { |p| p.define(scope) }
+    end
+
+    def initialize(name, attrs = {})
+      attrs = attrs.dup
+
+      @name      = name.to_sym
+      @default   = attrs.delete(:default)
+      @converter = attrs.delete(:converts)
+      @accepter  = attrs.delete(:accepts)
+      @required  = attrs.delete(:required)
+
+      @instance_variable_name = :"@#{name}"
+
+      unless attrs.empty?
+        raise ConfigurationError, "SmartProperties do not support the following configuration options: #{attrs.keys.map { |m| m.to_s }.sort.join(', ')}."
+      end
+    end
+
+    def required?(scope)
+      @required.kind_of?(Proc) ? scope.instance_exec(&@required) : !!@required
+    end
+
+    def optional?(scope)
+      !required?(scope)
+    end
+
+    def missing?(scope)
+      required?(scope) && !present?(scope)
+    end
+
+    def present?(scope)
+      !null_object?(get(scope))
+    end
+
+    def convert(scope, value)
+      return value unless converter
+      return value if null_object?(value)
+      scope.instance_exec(value, &converter)
+    end
+
+    def default(scope)
+      @default.kind_of?(Proc) ? scope.instance_exec(&@default) : @default
+    end
+
+    def accepts?(value, scope)
+      return true unless accepter
+      return true if null_object?(value)
+
+      if accepter.respond_to?(:to_proc)
+        !!scope.instance_exec(value, &accepter)
+      else
+        Array(accepter).any? { |accepter| accepter === value }
+      end
+    end
+
+    def prepare(scope, value)
+      required = required?(scope)
+      raise MissingValueError.new(scope, self) if required && null_object?(value)
+      value = convert(scope, value)
+      raise MissingValueError.new(scope, self) if required && null_object?(value)
+      raise InvalidValueError.new(scope, self, value) unless accepts?(value, scope)
+      value
+    end
+
+    def define(klass)
+      property = self
+
+      scope =
+        if klass.instance_variable_defined?(MODULE_REFERENCE)
+          klass.instance_variable_get(MODULE_REFERENCE)
+        else
+          m = Module.new { include IndexMethods }
+          klass.send(:include, m)
+          klass.instance_variable_set(MODULE_REFERENCE, m)
+          m
+        end
+
+      scope.send(:attr_reader, name)
+      scope.send(:define_method, :"#{name}=") do |value|
+        property.set(self, value)
+      end
+    end
+
+    def set(scope, value)
+      scope.instance_variable_set(instance_variable_name, prepare(scope, value))
+    end
+
+    def set_default(scope)
+      return false if present?(scope)
+
+      default_value = default(scope)
+      return false if null_object?(default_value)
+
+      set(scope, default_value)
+      true
+    end
+
+    def get(scope)
+      return nil unless scope.instance_variable_defined?(instance_variable_name)
+      scope.instance_variable_get(instance_variable_name)
+    end
+
+    private
+
+    def null_object?(object)
+      return true if object == nil
+      return true if object.nil?
+      false
+    rescue NoMethodError => error
+      # BasicObject does not respond to #nil? by default, so we need to double
+      # check if somebody implemented it and it fails internally or if the
+      # error occured because the method is actually not present. In the former
+      # case, we want to raise the exception because there is something wrong
+      # with the implementation of object#nil?. In the latter case we treat the
+      # object as truthy because we don't know better.
+      raise error if (class << object; self; end).public_instance_methods.include?(:nil?)
+      false
+    end
+  end
+end

data/lib/smart_properties/property_collection.rb

@@ -0,0 +1,81 @@
+module SmartProperties
+  class PropertyCollection
+    include Enumerable
+
+    attr_reader :parent
+
+    def self.for(scope)
+      parent = scope.ancestors[1..-1].find do |ancestor|
+        ancestor.ancestors.include?(SmartProperties) && ancestor != SmartProperties
+      end
+
+      if parent.nil?
+        new
+      else
+        parent.properties.register(collection = new)
+        collection
+      end
+    end
+
+    def initialize
+      @collection = {}
+      @collection_with_parent_collection = {}
+      @children = []
+    end
+
+    def []=(name, value)
+      name = name.to_s
+      collection[name] = value
+      collection_with_parent_collection[name] = value
+      notify_children
+      value
+    end
+
+    def [](name)
+      collection_with_parent_collection[name.to_s]
+    end
+
+    def key?(name)
+      collection_with_parent_collection.key?(name.to_s)
+    end
+
+    def keys
+      collection_with_parent_collection.keys.map(&:to_sym)
+    end
+
+    def values
+      collection_with_parent_collection.values
+    end
+
+    def each(&block)
+      return to_enum(:each) if block.nil?
+      collection_with_parent_collection.each { |name, value| block.call([name.to_sym, value]) }
+    end
+
+    def to_hash
+      Hash[each.to_a]
+    end
+
+    def register(child)
+      children.push(child)
+      child.refresh(collection_with_parent_collection)
+      nil
+    end
+
+    protected
+
+    attr_accessor :children
+    attr_accessor :collection
+    attr_accessor :collection_with_parent_collection
+
+    def notify_children
+      @children.each { |child| child.refresh(collection_with_parent_collection) }
+    end
+
+    def refresh(parent_collection)
+      @collection_with_parent_collection = parent_collection.merge(collection)
+      notify_children
+      nil
+    end
+  end
+end

data/lib/smart_properties/version.rb

@@ -0,0 +1,3 @@
+module SmartProperties
+  VERSION = "1.10.0"
+end

data/lib/smart_properties.rb

@@ -21,211 +21,7 @@
 #                           :required => true
 #
 module SmartProperties
-  VERSION = "1.9.0"
-
-  class Error < ::ArgumentError; end
-  class ConfigurationError < Error; end
-
-  class AssignmentError < Error
-    attr_accessor :sender
-    attr_accessor :property
-
-    def initialize(sender, property, message)
-      @sender = sender
-      @property = property
-      super(message)
-    end
-  end
-
-  class MissingValueError < AssignmentError
-    def initialize(sender, property)
-      super(
-        sender,
-        property,
-        "%s requires the property %s to be set" % [
-          sender.class.name,
-          property.name
-        ]
-      )
-    end
-
-    def to_hash
-      Hash[property.name, "must be set"]
-    end
-  end
-
-  class InvalidValueError < AssignmentError
-    attr_accessor :value
-
-    def initialize(sender, property, value)
-      @value = value
-      super(
-        sender,
-        property,
-        "%s does not accept %s as value for the property %s" % [
-          sender.class.name,
-          value.inspect,
-          property.name
-        ]
-      )
-    end
-
-    def to_hash
-      Hash[property.name, "does not accept %s as value" % value.inspect]
-    end
-  end
-
-  class InitializationError < Error
-    attr_accessor :sender
-    attr_accessor :properties
-
-    def initialize(sender, properties)
-      @sender = sender
-      @properties = properties
-      super(
-        "%s requires the following properties to be set: %s" % [
-          sender.class.name,
-          properties.map(&:name).sort.join(', ')
-        ]
-      )
-    end
-
-    def to_hash
-      properties.each_with_object({}) { |property, errors| errors[property.name] = "must be set" }
-    end
-  end
-
-  class Property
-    # Defines the two index methods #[] and #[]=. This module will be included
-    # in the SmartProperties method scope.
-    module IndexMethods
-      def [](name)
-        return if name.nil?
-        name &&= name.to_sym
-        public_send(name) if self.class.properties.key?(name)
-      end
-
-      def []=(name, value)
-        return if name.nil?
-        public_send(:"#{name.to_sym}=", value) if self.class.properties.key?(name)
-      end
-    end
-
-    attr_reader :name
-    attr_reader :converter
-    attr_reader :accepter
-
-    def initialize(name, attrs = {})
-      attrs = attrs.dup
-
-      @name      = name.to_sym
-      @default   = attrs.delete(:default)
-      @converter = attrs.delete(:converts)
-      @accepter  = attrs.delete(:accepts)
-      @required  = attrs.delete(:required)
-
-      unless attrs.empty?
-        raise ConfigurationError, "SmartProperties do not support the following configuration options: #{attrs.keys.map { |m| m.to_s }.sort.join(', ')}."
-      end
-    end
-
-    def required?(scope)
-      @required.kind_of?(Proc) ? scope.instance_exec(&@required) : !!@required
-    end
-
-    def convert(value, scope)
-      return value unless converter
-      scope.instance_exec(value, &converter)
-    end
-
-    def default(scope)
-      @default.kind_of?(Proc) ? scope.instance_exec(&@default) : @default
-    end
-
-    def accepts?(value, scope)
-      return true unless value
-      return true unless accepter
-
-      if accepter.respond_to?(:to_proc)
-        !!scope.instance_exec(value, &accepter)
-      else
-        Array(accepter).any? { |accepter| accepter === value }
-      end
-    end
-
-    def prepare(value, scope)
-      raise MissingValueError.new(scope, self) if required?(scope) && value.nil?
-      value = convert(value, scope) unless value.nil?
-      raise MissingValueError.new(scope, self) if required?(scope) && value.nil?
-      raise InvalidValueError.new(scope, self, value) unless accepts?(value, scope)
-      value
-    end
-
-    def define(klass)
-      property = self
-
-      scope = klass.instance_variable_get(:"@_smart_properties_method_scope") || begin
-        m = Module.new { include IndexMethods }
-        klass.send(:include, m)
-        klass.instance_variable_set(:"@_smart_properties_method_scope", m)
-        m
-      end
-
-      scope.send(:attr_reader, name)
-      scope.send(:define_method, :"#{name}=") do |value|
-        instance_variable_set("@#{property.name}", property.prepare(value, self))
-      end
-    end
-
-  end
-
-  class PropertyCollection
-
-    include Enumerable
-
-    attr_reader :parent
-
-    def initialize(parent = nil)
-      @parent = parent
-      @collection = {}
-    end
-
-    def []=(name, value)
-      collection[name] = value
-    end
-
-    def [](name)
-      collection_with_parent_collection[name]
-    end
-
-    def key?(name)
-      collection_with_parent_collection.key?(name)
-    end
-
-    def keys
-      collection_with_parent_collection.keys
-    end
-
-    def values
-      collection_with_parent_collection.values
-    end
-
-    def each(&block)
-      collection_with_parent_collection.each(&block)
-    end
-
-    protected
-
-      attr_accessor :collection
-
-      def collection_with_parent_collection
-        parent.nil? ? collection : parent.collection.merge(collection)
-      end
-
-  end
-
   module ClassMethods
-
     ##
     # Returns a class's smart properties. This includes the properties that
     # have been defined in the parent classes.
@@ -233,13 +29,7 @@ module SmartProperties
     # @return [Hash<String, Property>] A map of property names to property instances.
     #
     def properties
-      @_smart_properties ||= begin
-        parent = if self != SmartProperties
-          (ancestors[1..-1].find { |klass| klass.ancestors.include?(SmartProperties) && klass != SmartProperties })
-        end
-
-        parent.nil? ? PropertyCollection.new : PropertyCollection.new(parent.properties)
-      end
+      @_smart_properties ||= PropertyCollection.for(self)
     end
 
     ##
@@ -290,29 +80,23 @@ module SmartProperties
     #                           :required => true
     #
     def property(name, options = {})
-      p = Property.new(name, options)
-      p.define(self)
-
-      properties[name] = p
+      properties[name] = Property.define(self, name, options)
     end
     protected :property
-
   end
 
   class << self
-
     private
 
-      ##
-      # Extends the class, which this module is included in, with a property
-      # method to define properties.
-      #
-      # @param [Class] base the class this module is included in
-      #
-      def included(base)
-        base.extend(ClassMethods)
-      end
-
+    ##
+    # Extends the class, which this module is included in, with a property
+    # method to define properties.
+    #
+    # @param [Class] base the class this module is included in
+    #
+    def included(base)
+      base.extend(ClassMethods)
+    end
   end
 
   ##
@@ -322,38 +106,41 @@ module SmartProperties
   # @param [Hash] attrs the set of attributes that is used for initialization
   #
   def initialize(*args, &block)
-    attrs = args.last.is_a?(Hash) ? args.pop : {}
-    super(*args)
+    attrs = args.last.is_a?(Hash) ? args.pop.dup : {}
+    properties = self.class.properties
 
-    properties = self.class.properties.each.to_a
+    # Track missing properties
     missing_properties = []
 
-    # Assign attributes or default values
-    properties.each do |_, property|
-      if attrs.key?(property.name)
-        instance_variable_set("@#{property.name}", property.prepare(attrs[property.name], self))
+    # Set values
+    properties.each do |name, property|
+      if attrs.key?(name)
+        property.set(self, attrs.delete(name))
+      elsif attrs.key?(name.to_s)
+        property.set(self, attrs.delete(name.to_s))
       else
         missing_properties.push(property)
       end
     end
 
-    # Exectue configuration block
+    # Call the super constructor and forward unprocessed arguments
+    attrs.empty? ? super(*args) : super(*args.push(attrs))
+
+    # Execute configuration block
     block.call(self) if block
 
-    # Set defaults
-    missing_properties.each do |property|
-      variable = "@#{property.name}"
-      if instance_variable_get(variable).nil? && !(default_value = property.default(self)).nil?
-        instance_variable_set(variable, property.prepare(default_value, self))
-      end
-    end
+    # Set default values for missing properties
+    missing_properties.delete_if { |property| property.set_default(self) }
 
-    # Check presence of all required properties
-    faulty_properties =
-      properties.select { |_, property| property.required?(self) && instance_variable_get("@#{property.name}").nil? }.map(&:last)
-    unless faulty_properties.empty?
-      error = SmartProperties::InitializationError.new(self, faulty_properties)
-      raise error
-    end
+    # Recheck - cannot be done while assigning default values because
+    # one property might depend on the default value of another property
+    missing_properties.delete_if { |property| property.present?(self) || property.optional?(self) }
+
+    raise SmartProperties::InitializationError.new(self, missing_properties) unless missing_properties.empty?
   end
 end
+
+require_relative 'smart_properties/property_collection'
+require_relative 'smart_properties/property'
+require_relative 'smart_properties/errors'
+require_relative 'smart_properties/version'

data/smart_properties.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/smart_properties', __FILE__)
+require_relative 'lib/smart_properties/version'
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Konstantin Tennhard"]
@@ -21,4 +21,5 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency "rspec", "~> 3.0"
   gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "pry"
 end

data/spec/base_spec.rb

@@ -7,6 +7,20 @@ RSpec.describe SmartProperties do
     expect { klass.property }.to raise_error(NoMethodError)
   end
 
+  context "when used to build a class with a property that uses none of the features provided by SmartProperties" do
+    subject(:klass) { DummyClass.new { property :title } }
+
+    context "an instance of this class" do
+      it 'should accept an instance of BasicObject, which does not respond to nil?, as value for title' do
+        instance = klass.new
+        expect { instance.title = BasicObject.new }.to_not raise_error
+        expect { instance[:title] = BasicObject.new }.to_not raise_error
+
+        expect { instance = klass.new(title: BasicObject) }.to_not raise_error
+      end
+    end
+  end
+
   context "when used to build a class that has a property called title that utilizes the full feature set of SmartProperties" do
     subject(:klass) do
       default_title = double(to_title: 'chunky')
@@ -64,12 +78,58 @@ RSpec.describe SmartProperties do
       end
     end
 
+    context 'an instance of this class when initialized with a null object' do
+      let(:null_object) do
+        Class.new(BasicObject) do
+          def nil?
+            true
+          end
+        end
+      end
+
+      it 'should raise an error during initialization' do
+        exception = SmartProperties::MissingValueError
+        message = "Dummy requires the property title to be set"
+        further_expectations = lambda do |error|
+          expect(error.to_hash[:title]).to eq('must be set')
+        end
+
+        instance = klass.new
+        expect { instance.title = null_object.new }.to raise_error(exception, message, &further_expectations)
+        expect { instance[:title] = null_object.new }.to raise_error(exception, message, &further_expectations)
+
+        expect { klass.new(title: null_object.new) }.to raise_error(exception, message, &further_expectations)
+      end
+    end
+
+    context 'an instance of this class when initialized with a subclass of BasicObject that responds to #to_title but by design not to #nil?' do
+      let(:title) do
+        Class.new(BasicObject) do
+          def to_title
+            "Chunky bacon"
+          end
+        end
+      end
+
+      it 'should have the correct title' do
+        instance = klass.new(title: title.new)
+        expect(instance.title).to eq("Chunky bacon")
+      end
+    end
+
     context 'an instance of this class when initialized with a title argument' do
       it "should have the title specified by the corresponding keyword argument" do
         instance = klass.new(title: double(to_title: 'bacon'))
         expect(instance.title).to eq('bacon')
         expect(instance[:title]).to eq('bacon')
       end
+
+      it "should have the title specified in the corresponding attributes hash that uses strings as keys" do
+        attributes = {"title" => double(to_title: 'bacon')}
+        instance = klass.new(attributes)
+        expect(instance.title).to eq('bacon')
+        expect(instance[:title]).to eq('bacon')
+      end
     end
 
     context "an instance of this class when initialized with a block" do

data/spec/default_values_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe SmartProperties, 'default values' do
     context "an instance of this class" do
       it "should evaluate the lambda in its own scope and thus differ from every other instance" do
         first_instance, second_instance = klass.new, klass.new
-        expect(klass.new.id).to_not eq(klass.new.id)
+        expect(first_instance.id).to_not eq(second_instance.id)
       end
     end
   end

data/spec/inheritance_spec.rb

@@ -17,14 +17,16 @@ RSpec.describe SmartProperties, 'intheritance' do
   context 'when modeling the following class hiearchy: Base > Section > SectionWithSubtitle' do
     let!(:base) do
       Class.new do
-        attr_reader :content
-        def initialize(content = nil)
+        attr_reader :content, :options
+        def initialize(content = nil, options = {})
           @content = content
+          @options = options
         end
       end
     end
     let!(:section) { DummyClass.new(base) { property :title } }
     let!(:subsection) { DummyClass.new(section) { property :subtitle } }
+    let!(:subsubsection) { DummyClass.new(subsection) { property :subsubtitle } }
 
     context 'the base class' do
       it('should not respond to #properties') { expect(base).to_not respond_to(:properties) }
@@ -47,6 +49,11 @@ RSpec.describe SmartProperties, 'intheritance' do
         subject { section.new }
         it { is_expected.to have_smart_property(:title) }
         it { is_expected.to_not have_smart_property(:subtitle) }
+
+        it 'should forward keyword arguments that do not correspond to a property to the super class constructor' do
+          instance = section.new('some content', answer: 42)
+          expect(instance.options).to eq({answer: 42})
+        end
       end
 
       context 'an instance of this class when initialized with content' do
@@ -89,6 +96,68 @@ RSpec.describe SmartProperties, 'intheritance' do
           expect(instance.title).to eq('some title')
           expect(instance.subtitle).to eq('some subtitle')
         end
+
+        it 'should forward keyword arguments that do not correspond to a property to the super class constructor' do
+          instance = subsection.new('some content', answer: 42)
+          expect(instance.options).to eq({answer: 42})
+        end
+      end
+    end
+
+    context 'the subsubsectionclass' do
+      it "should expose the names of the properties through its property collection" do
+        expect(subsubsection.properties.keys).to eq([:title, :subtitle, :subsubtitle])
+      end
+
+      it "should expose the the properties through its property collection" do
+        properties = subsubsection.properties.values
+
+        expect(properties[0]).to be_kind_of(SmartProperties::Property)
+        expect(properties[0].name).to eq(:title)
+
+        expect(properties[1]).to be_kind_of(SmartProperties::Property)
+        expect(properties[1].name).to eq(:subtitle)
+
+        expect(properties[2]).to be_kind_of(SmartProperties::Property)
+        expect(properties[2].name).to eq(:subsubtitle)
+      end
+
+      context 'an instance of this class' do
+        subject(:instance) { subsubsection.new }
+        it { is_expected.to have_smart_property(:title) }
+        it { is_expected.to have_smart_property(:subtitle) }
+        it { is_expected.to have_smart_property(:subsubtitle) }
+
+        it 'should have content, a title, and a subtile when initialized with these parameters' do
+          instance = subsubsection.new('some content', title: 'some title', subtitle: 'some subtitle', subsubtitle: 'some subsubtitle')
+          expect(instance.content).to eq('some content')
+          expect(instance.title).to eq('some title')
+          expect(instance.subtitle).to eq('some subtitle')
+          expect(instance.subsubtitle).to eq('some subsubtitle')
+
+          instance = subsubsection.new('some content') do |s|
+            s.title, s.subtitle, s.subsubtitle = 'some title', 'some subtitle', 'some subsubtitle'
+          end
+          expect(instance.content).to eq('some content')
+          expect(instance.title).to eq('some title')
+          expect(instance.subtitle).to eq('some subtitle')
+          expect(instance.subsubtitle).to eq('some subsubtitle')
+        end
+
+        it 'should not accidentally forward attributes as options because the keys where strings' do
+          attributes = {'title' => 'some title', 'subtitle' => 'some subtitle', 'subsubtitle' => "some subsubtitle", "answer" => 42}
+          instance = subsubsection.new('some content', attributes)
+          expect(instance.content).to eq('some content')
+          expect(instance.title).to eq('some title')
+          expect(instance.subtitle).to eq('some subtitle')
+          expect(instance.subsubtitle).to eq('some subsubtitle')
+          expect(instance.options).to eq({"answer" => 42})
+        end
+
+        it 'should forward keyword arguments that do not correspond to a property to the super class constructor' do
+          instance = subsubsection.new('some content', answer: 42)
+          expect(instance.options).to eq({answer: 42})
+        end
       end
     end
 

data/spec/property_collection_caching_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe SmartProperties, "property collection caching:" do
+  specify "SmartProperty enabled objects should be extendable at runtime" do
+    base_class = DummyClass.new { property :title }
+    subclass = DummyClass.new(base_class) { property :body }
+    subsubclass = DummyClass.new(subclass) { property :attachment }
+
+    expect(base_class.new).to have_smart_property(:title)
+    expect(subclass.new).to have_smart_property(:title)
+    expect(subclass.new).to have_smart_property(:body)
+
+    base_class.class_eval { property :severity }
+    expect(base_class.new).to have_smart_property(:severity)
+    expect(subclass.new).to have_smart_property(:severity)
+    expect(subsubclass.new).to have_smart_property(:severity)
+
+    expected_names = [:title, :body, :attachment, :severity]
+
+    names = subsubclass.properties.map(&:first) # Using enumerable
+    expect(names - expected_names).to be_empty
+
+    names = subsubclass.properties.each.map(&:first) # Using enumerator
+    expect(names - expected_names).to be_empty
+
+    expect(subsubclass.properties.keys - expected_names).to be_empty
+    expect(subsubclass.properties.to_hash.keys - expected_names).to be_empty
+  end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,84 @@
 require 'bundler/setup'
 require 'rspec'
+require 'pry'
 
 require 'smart_properties'
 
 Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each { |f| require f }
 
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  #
+  # config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_properties
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.10.0
 platform: ruby
 authors:
 - Konstantin Tennhard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-25 00:00:00.000000000 Z
+date: 2015-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
     SmartProperties are a more flexible and feature-rich alternative to
     traditional Ruby accessors. They provide support for input conversion,
@@ -56,6 +70,10 @@ files:
 - README.md
 - Rakefile
 - lib/smart_properties.rb
+- lib/smart_properties/errors.rb
+- lib/smart_properties/property.rb
+- lib/smart_properties/property_collection.rb
+- lib/smart_properties/version.rb
 - smart_properties.gemspec
 - spec/acceptance_checking_spec.rb
 - spec/base_spec.rb
@@ -63,6 +81,7 @@ files:
 - spec/conversion_spec.rb
 - spec/default_values_spec.rb
 - spec/inheritance_spec.rb
+- spec/property_collection_caching_spec.rb
 - spec/required_values_spec.rb
 - spec/spec_helper.rb
 - spec/support/dummy_class.rb
@@ -97,6 +116,7 @@ test_files:
 - spec/conversion_spec.rb
 - spec/default_values_spec.rb
 - spec/inheritance_spec.rb
+- spec/property_collection_caching_spec.rb
 - spec/required_values_spec.rb
 - spec/spec_helper.rb
 - spec/support/dummy_class.rb