smart_properties 1.8.0 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 863983d7a1707f254f044997c1e35b193bfb2c36
-  data.tar.gz: 4853b0a0f314cc9c8f1062d293a5f550fce92f1c
+  metadata.gz: 01dcc093f88456b5adc03fda8756ce4c82fadf2d
+  data.tar.gz: 02e619aa94f6b2a1106e787f5f4ccfe4745f5b4d
 SHA512:
-  metadata.gz: 6cb253427617818e2969273311ffaa622289c8420920b7cb98cf981857693a7c0a2a06c8b789b33c1a258e978b4b3372e60d86c58a0e783a2369069637eb8432
-  data.tar.gz: d55fbab7960a235c68fcb28765366926de5fccad1daee313b437e135100ef5bb09fd755bbd9b6cffebaebd6bfd7ae5e9178b300ae400ad585ec88d3d67cefcd1
+  metadata.gz: ba7245f78b5720fe02adbf55f89a87f4a92c6525813fde45160c647f6506a76de3127606c0835c58584562a74ed05e2e106a69590372049983f89168a75014bd
+  data.tar.gz: 7b2ec9c3656e8d361e370118c9ef7f964770541a5ad84b725136796516179d25ddb225ea1fccb643fbe8fbe1408b0a429fdc97fb9227bb1bf15071e77c605c95

data/lib/smart_properties.rb

@@ -21,7 +21,7 @@
 #                           :required => true
 #
 module SmartProperties
-  VERSION = "1.8.0"
+  VERSION = "1.8.1"
 
   class Error < ::ArgumentError; end
   class ConfigurationError < Error; end
@@ -156,6 +156,7 @@ module SmartProperties
     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

data/spec/acceptance_checking_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+RSpec.describe SmartProperties, 'acceptance checking' do
+  context "when used to build a class that has a property called :visible which uses an array of valid values for acceptance checking" do
+    subject(:klass) { DummyClass.new { property :visible, accepts: [true, false] } }
+
+    context "an instance of this class" do
+      subject(:instance) { klass.new }
+
+      it "should allow to set true as value for visible" do
+        expect { instance.visible = true }.to_not raise_error
+        expect { instance[:visible] = true }.to_not raise_error
+      end
+
+      it "should allow to set false as value for visible" do
+        expect { instance.visible = false }.to_not raise_error
+        expect { instance[:visible] = false }.to_not raise_error
+      end
+
+      it "should not allow to set :maybe as value for visible" do
+        exception = SmartProperties::InvalidValueError
+        message =  "Dummy does not accept :maybe as value for the property visible"
+        further_expectations = lambda { |error| expect(error.to_hash[:visible]).to eq('does not accept :maybe as value') }
+
+        expect { klass.new visible: :maybe }.to raise_error(exception, message, &further_expectations)
+        expect { klass.new { |i| i.visible = :maybe } }.to raise_error(exception, message, &further_expectations)
+
+        expect { instance.visible = :maybe }.to raise_error(exception, message, &further_expectations)
+        expect { instance[:visible] = :maybe }.to raise_error(exception, message, &further_expectations)
+      end
+    end
+  end
+
+  context "when used to build a class that has a property called :title that accepts either a String or a Symbol" do
+    subject(:klass) { DummyClass.new { property :title, accepts: [String, Symbol] } }
+
+    context "an instance of this class" do
+      subject(:instance) { klass.new }
+
+      it "should accept a String as title" do
+        expect { subject.title = "Test" }.to_not raise_error
+        expect { subject[:title] = "Test" }.to_not raise_error
+      end
+
+      it "should accept a Symbol as title" do
+        expect { subject.title = :test }.to_not raise_error
+        expect { subject[:title] = :test }.to_not raise_error
+      end
+
+      it 'should not an instance of any other type' do
+        exception = SmartProperties::InvalidValueError
+        message = 'Dummy does not accept 13 as value for the property title'
+        further_expectations = lambda { |error| expect(error.to_hash[:title]).to eq('does not accept 13 as value') }
+
+        expect { klass.new title: 13 }.to raise_error(exception, message, &further_expectations)
+        expect { klass.new { |i| i.title = 13 } }.to raise_error(exception, message, &further_expectations)
+
+        expect { instance.title = 13 }.to raise_error(exception, message, &further_expectations)
+        expect { instance[:title] = 13 }.to raise_error(exception, message, &further_expectations)
+      end
+    end
+  end
+
+  context 'when used to build a class that has a property called :license_plate which uses a lambda statement for accpetance checking' do
+    subject(:klass) do
+      DummyClass.new do
+        property :license_plate, accepts: lambda { |v| license_plate_pattern.match(v) }
+
+        def license_plate_pattern
+          /\w{1,2} \w{1,2} \d{1,4}/
+        end
+      end
+    end
+
+    context 'an instance of this class' do
+      subject(:instance) { klass.new }
+
+      it 'should not a accept "invalid" as value for license_plate' do
+        exception = SmartProperties::InvalidValueError
+        message = 'Dummy does not accept "invalid" as value for the property license_plate'
+        further_expectations = lambda { |error| expect(error.to_hash[:license_plate]).to eq('does not accept "invalid" as value') }
+
+        expect { klass.new license_plate: "invalid" }.to raise_error(exception, message, &further_expectations)
+        expect { klass.new { |i| i.license_plate = "invalid" } }.to raise_error(exception, message, &further_expectations)
+
+        expect { instance.license_plate = "invalid" }.to raise_error(exception, message, &further_expectations)
+        expect { instance[:license_plate] = "invalid" }.to raise_error(exception, message, &further_expectations)
+      end
+
+      it 'should accept "NE RD 1337" as license plate' do
+        expect { klass.new.license_plate = "NE RD 1337" }.to_not raise_error
+        expect { klass.new { |i| i.license_plate = "NE RD 1337" } }.to_not raise_error
+
+        expect { instance.license_plate = "NE RD 1337" }.to_not raise_error
+        expect { instance[:license_plate] = "NE RD 1337" }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+RSpec.describe SmartProperties do
+  it 'should add a protected class method called .property when included' do
+    klass = Class.new { include SmartProperties }
+    expect(klass.respond_to?(:property, true)).to eq(true)
+    expect { klass.property }.to raise_error(NoMethodError)
+  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')
+
+      DummyClass.new do
+        property :title, converts: :to_title, accepts: String, required: true, default: default_title
+      end
+    end
+
+    it { is_expected.to have_smart_property(:title) }
+
+    context "an instance of this class when initialized with no arguments" do
+      subject(:instance) { klass.new }
+
+      it "should have the default title" do
+        expect(instance.title).to eq('chunky')
+        expect(instance[:title]).to eq('chunky')
+      end
+
+      it "should convert all values that are assigned to title into strings when using the #title= method" do
+        instance.title = double(to_title: 'bacon')
+        expect(instance.title).to eq('bacon')
+
+        instance[:title] = double(to_title: 'yummy')
+        expect(instance.title).to eq('yummy')
+      end
+
+      it "should not allow to assign an object as title that do not respond to #to_title" do
+        exception = NoMethodError
+        message = /undefined method `to_title'/
+
+        expect { instance.title = Object.new }.to raise_error(exception, message)
+        expect { instance[:title] = Object.new }.to raise_error(exception, message)
+      end
+
+      it "should not allow to assign nil as the title" 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
+
+        expect { instance.title = nil }.to raise_error(exception, message, &further_expectations)
+        expect { instance[:title] = nil }.to raise_error(exception, message, &further_expectations)
+
+        expect { instance.title = double(to_title: nil) }.to raise_error(exception, message, &further_expectations)
+        expect { instance[:title] = double(to_title: nil) }.to raise_error(exception, message, &further_expectations)
+      end
+
+      it "should not influence other instances that have been initialized with different attributes" do
+        other_instance = klass.new title: double(to_title: 'Lorem ipsum')
+
+        expect(instance.title).to eq('chunky')
+        expect(other_instance.title).to eq('Lorem ipsum')
+      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
+    end
+
+    context "an instance of this class when initialized with a block" do
+      it "should have the title specified in the block" do
+        instance = klass.new do |c|
+          c.title = double(to_title: 'bacon')
+        end
+        expect(instance.title).to eq('bacon')
+        expect(instance[:title]).to eq('bacon')
+      end
+    end
+  end
+end

data/spec/configuration_error_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe SmartProperties, 'configuration error' do
+  subject(:klass) { DummyClass.new }
+
+  context "when defining a property with invalid configuration options" do
+    it "should report all invalid options" do
+      invalid_property_definition = lambda do
+        klass.class_eval do
+          property :title, invalid_option_1: 'boom', invalid_option_2: 'boom', invalid_option_3: 'boom'
+        end
+      end
+
+      expect(&invalid_property_definition).to raise_error(SmartProperties::ConfigurationError, "SmartProperties do not support the following configuration options: invalid_option_1, invalid_option_2, invalid_option_3.")
+    end
+  end
+end

data/spec/conversion_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+RSpec.describe SmartProperties, 'conversion' do
+  context "when defining a class with a property whose converter is an object that responds to #to_proc" do
+    subject(:klass) do
+      converter = double(to_proc: lambda { |t| content_tag(:p, t.to_s) })
+      DummyClass.new do
+        property :title, converts: converter
+
+        def content_tag(name, content)
+          "<%s>%s</%s>" % [name, content, name]
+        end
+      end
+    end
+
+    context "an instance of this class" do
+      subject(:instance) { klass.new }
+
+      it "should convert the property using the proc" do
+        instance = klass.new title: 'Chunky Bacon'
+        expect(instance.title).to eq("<p>Chunky Bacon</p>")
+        expect(instance[:title]).to eq("<p>Chunky Bacon</p>")
+
+        instance.title = "Lorem Ipsum"
+        expect(instance.title).to eq("<p>Lorem Ipsum</p>")
+        expect(instance[:title]).to eq("<p>Lorem Ipsum</p>")
+      end
+    end
+  end
+end

data/spec/default_values_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+RSpec.describe SmartProperties, 'default values' do
+  context 'when used to build a class that has a property called :id whose default value is a lambda statement for retrieving the object_id' do
+    subject(:klass) { DummyClass.new { property :id, default: lambda { object_id } } }
+
+    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)
+      end
+    end
+  end
+
+  context 'when used to build a class that has a property called :boom whose default value is a lambda statement that raises an exception' do
+    subject(:klass) { DummyClass.new { property :boom, default: lambda { raise 'Boom!' } } }
+
+    context "an instance of this class" do
+      it "should raise during initialization if no other value for :boom has been provided" do
+        expect { klass.new }.to raise_error(RuntimeError, 'Boom!')
+      end
+
+      it "should not evaluate the lambda expression and thus not raise during initialization if a different value for :boom has been provided as a a parameter or in the initalization block" do
+        expect { klass.new(boom: 'Everything is just fine!') }.not_to raise_error
+        expect { klass.new { |inst| inst.boom = 'Everything is just fine!' } }.not_to raise_error
+      end
+    end
+  end
+
+  context "when building a class that has a property with a default value" do
+    subject(:klass) { DummyClass.new { property :title, default: 'Lorem Ipsum' } }
+
+    context 'an instance of that class' do
+      it 'should return nil for the title when the title was explicitly set to this value during initialization' do
+        instance = klass.new(title: nil)
+        expect(instance.title).to be_nil
+        expect(instance[:title]).to be_nil
+      end
+
+      it 'should return the default value if no other value has been provided during initialization' do
+        instance = klass.new
+        expect(instance.title).to eq('Lorem Ipsum')
+        expect(instance[:title]).to eq('Lorem Ipsum')
+
+        instance = klass.new {}
+        expect(instance.title).to eq('Lorem Ipsum')
+        expect(instance[:title]).to eq('Lorem Ipsum')
+      end
+    end
+  end
+end

data/spec/inheritance_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+RSpec.describe SmartProperties, 'intheritance' do
+  context 'when used to build a class that has a required property with no default called :text whose getter is overriden' do
+    subject(:klass) do
+      DummyClass.new do
+        property :text, required: true
+        def text; "<em>#{super}</em>"; end
+      end
+    end
+
+    specify "an instance of this class should raise an error during initilization if no value for :text has been specified" do
+      expect { klass.new }.to raise_error(SmartProperties::InitializationError)
+    end
+  end
+
+  context 'when modeling the following class hiearchy: Base > Section > SectionWithSubtitle' do
+    let!(:base) do
+      Class.new do
+        attr_reader :content
+        def initialize(content = nil)
+          @content = content
+        end
+      end
+    end
+    let!(:section) { DummyClass.new(base) { property :title } }
+    let!(:subsection) { DummyClass.new(section) { property :subtitle } }
+
+    context 'the base class' do
+      it('should not respond to #properties') { expect(base).to_not respond_to(:properties) }
+    end
+
+    context 'the section class' do
+      it('should respond to #properties') { expect(section).to respond_to(:properties) }
+
+      context 'an instance of this class' do
+        subject { section.new }
+        it { is_expected.to have_smart_property(:title) }
+        it { is_expected.to_not have_smart_property(:subtitle) }
+      end
+
+      context 'an instance of this class when initialized with content' do
+        subject(:instance) { section.new('some content') }
+        it('should have content') { expect(instance.content).to eq('some content') }
+      end
+    end
+
+    context 'the subsectionclass' do
+      it('should respond to #properties') { expect(subsection).to respond_to(:properties) }
+
+      context 'an instance of this class' do
+        subject(:instance) { subsection.new }
+        it { is_expected.to have_smart_property(:title) }
+        it { is_expected.to have_smart_property(:subtitle) }
+
+        it 'should have content, a title, and a subtile when initialized with these parameters' do
+          instance = subsection.new('some content', title: 'some title', subtitle: 'some subtitle')
+          expect(instance.content).to eq('some content')
+          expect(instance.title).to eq('some title')
+          expect(instance.subtitle).to eq('some subtitle')
+
+          instance = subsection.new('some content') do |s|
+            s.title, s.subtitle = 'some title', 'some subtitle'
+          end
+          expect(instance.content).to eq('some content')
+          expect(instance.title).to eq('some title')
+          expect(instance.subtitle).to eq('some subtitle')
+        end
+      end
+    end
+
+    context 'when the section class is extended with a property at runtime' do
+      before { section.send(:property, :type) }
+
+      context 'the section class' do
+        subject { section }
+        it { is_expected.to have_smart_property(:type) }
+
+        it 'should have content, a title, and a type when initialized with these parameters' do
+          instance = subsection.new('some content', title: 'some title', type: 'important')
+          expect(instance.content).to eq('some content')
+          expect(instance.title).to eq('some title')
+          expect(instance.type).to eq('important')
+
+          instance = subsection.new('some content') do |s|
+            s.title, s.type = 'some title', 'important'
+          end
+          expect(instance.content).to eq('some content')
+          expect(instance.title).to eq('some title')
+          expect(instance.type).to eq('important')
+        end
+      end
+
+      context 'the subsection class' do
+        subject { subsection }
+        it { is_expected.to have_smart_property(:type) }
+
+        it 'should have content, a title, a subtitle, and a type when initialized with these parameters' do
+          instance = subsection.new('some content', title: 'some title', subtitle: 'some subtitle', type: 'important')
+          expect(instance.content).to eq('some content')
+          expect(instance.title).to eq('some title')
+          expect(instance.subtitle).to eq('some subtitle')
+          expect(instance.type).to eq('important')
+
+          instance = subsection.new('some content') do |s|
+            s.title, s.subtitle, s.type = 'some title', 'some subtitle', 'important'
+          end
+          expect(instance.content).to eq('some content')
+          expect(instance.title).to eq('some title')
+          expect(instance.subtitle).to eq('some subtitle')
+          expect(instance.type).to eq('important')
+        end
+      end
+    end
+
+    context 'when the section class overrides the getter of the title property and uses super to retrieve the property\'s original value' do
+      before do
+        section.class_eval do
+          def title; super.to_s.upcase; end
+        end
+      end
+
+      specify 'an instance of the section class should transform the value as defined in the overridden getter' do
+        instance = section.new(title: 'some title')
+        expect(instance.title).to eq('SOME TITLE')
+        expect(instance[:title]).to eq('SOME TITLE')
+      end
+
+      specify 'an instance of the subsection class should transform the value as defined in the overridden getter in the superclass' do
+        instance = subsection.new(title: 'some title')
+        expect(instance.title).to eq('SOME TITLE')
+        expect(instance[:title]).to eq('SOME TITLE')
+      end
+    end
+  end
+end

data/spec/required_values_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+RSpec.describe SmartProperties do
+  context "when building a class that has a property which is required and has no default" do
+    subject(:klass) { DummyClass.new { property :title, required: true } }
+
+    context 'an instance of this class' do
+      it 'should have the correct title when provided with a title during initialization' do
+        instance = klass.new title: 'Lorem Ipsum'
+        expect(instance.title).to eq('Lorem Ipsum')
+        expect(instance[:title]).to eq('Lorem Ipsum')
+
+        instance = klass.new { |i| i.title = 'Lorem Ipsum' }
+        expect(instance.title).to eq('Lorem Ipsum')
+        expect(instance[:title]).to eq('Lorem Ipsum')
+      end
+
+      it "should raise an error stating that required properties are missing when initialized without a title" do
+        exception = SmartProperties::InitializationError
+        message = "Dummy requires the following properties to be set: title"
+        further_expectations = lambda { |error| expect(error.to_hash[:title]).to eq('must be set') }
+
+        expect { klass.new }.to raise_error(exception, message, &further_expectations)
+        expect { klass.new {} }.to raise_error(exception, message, &further_expectations)
+      end
+
+      it "should not allow to set nil as the property's value" do
+        instance = klass.new title: 'Lorem Ipsum'
+
+        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
+
+        expect { instance.title = nil }.to raise_error(exception, message, &further_expectations)
+        expect { instance[:title] = nil }.to raise_error(exception, message, &further_expectations)
+      end
+    end
+  end
+
+  context "when building a class that has a property name which is only required if the property anonymous is set to false" do
+    subject(:klass) do
+      DummyClass.new do
+        property :name, required: lambda { not anonymous }
+        property :anonymous, accepts: [true, false], default: true
+      end
+    end
+
+    it "should not raise an error when created with no arguments" do
+      expect { klass.new }.to_not raise_error
+    end
+
+    it "should raise an error indicating that a required property was not specified when created with no name and anonymous being set to false" do
+      exception = SmartProperties::InitializationError
+      message = "Dummy requires the following properties to be set: name"
+      further_expectations = lambda { |error| expect(error.to_hash[:name]).to eq("must be set") }
+
+      expect { klass.new anonymous: false }.to raise_error(exception, message, &further_expectations)
+      expect { klass.new { |i| i.anonymous = false } }.to raise_error(exception, message, &further_expectations)
+    end
+
+    it "should not raise an error when created with a name and anonymous being set to false" do
+      expect { klass.new name: "John Doe", anonymous: false }.to_not raise_error
+    end
+  end
+
+  context "when building a class that has a property which is required and has false as default" do
+    subject(:klass) { DummyClass.new { property :flag, required: true, default: false } }
+
+    context 'an instance of this class' do
+      it 'should return true as value for this property if provided with this value for the property during initialization' do
+        instance = klass.new flag: true
+        expect(instance.flag).to eq(true)
+        expect(instance[:flag]).to eq(true)
+
+        instance = klass.new { |i| i.flag = true }
+        expect(instance.flag).to eq(true)
+        expect(instance[:flag]).to eq(true)
+      end
+
+      it 'should return false as value for this property when initialized with no arguments' do
+        instance = klass.new
+        expect(instance.flag).to eq(false)
+        expect(instance[:flag]).to eq(false)
+      end
+    end
+  end
+
+  context "when building a class that has a required property with a default value and a malicious converter that always returns nil" do
+    subject(:klass) { DummyClass.new { property :title, required: true, converts: ->(_) { nil }, default: "Lorem Ipsum" } }
+
+    context 'an instance of this class' do
+      it "should raise an error when initialized" do
+        exception = SmartProperties::MissingValueError
+        message = "Dummy requires the property title to be set"
+        further_expectations = lambda { |error| expect(error.to_hash[:title]).to eq("must be set") }
+
+        expect { klass.new }.to raise_error(exception, message)
+        expect { klass.new(title: 'Lorem Ipsum') }.to raise_error(exception, message, &further_expectations)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -6,5 +6,4 @@ require 'smart_properties'
 Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each { |f| require f }
 
 RSpec.configure do |config|
-  
 end

data/spec/support/dummy_class.rb

@@ -0,0 +1,9 @@
+class << (DummyClass = BasicObject.new)
+  def new(superclass = ::Object, class_name = 'Dummy', &block)
+    c = ::Class.new(superclass) { include ::SmartProperties }
+    c.define_singleton_method(:name) { class_name }
+    c.class_eval(&block) if block
+    c
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_properties
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.1
 platform: ruby
 authors:
 - Konstantin Tennhard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-15 00:00:00.000000000 Z
+date: 2015-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -57,8 +57,15 @@ files:
 - Rakefile
 - lib/smart_properties.rb
 - smart_properties.gemspec
-- spec/smart_properties_spec.rb
+- spec/acceptance_checking_spec.rb
+- spec/base_spec.rb
+- spec/configuration_error_spec.rb
+- spec/conversion_spec.rb
+- spec/default_values_spec.rb
+- spec/inheritance_spec.rb
+- spec/required_values_spec.rb
 - spec/spec_helper.rb
+- spec/support/dummy_class.rb
 - spec/support/smart_property_matcher.rb
 homepage: ''
 licenses: []
@@ -84,7 +91,14 @@ signing_key:
 specification_version: 4
 summary: SmartProperties – Ruby accessors on steroids
 test_files:
-- spec/smart_properties_spec.rb
+- spec/acceptance_checking_spec.rb
+- spec/base_spec.rb
+- spec/configuration_error_spec.rb
+- spec/conversion_spec.rb
+- spec/default_values_spec.rb
+- spec/inheritance_spec.rb
+- spec/required_values_spec.rb
 - spec/spec_helper.rb
+- spec/support/dummy_class.rb
 - spec/support/smart_property_matcher.rb
 has_rdoc: