modelish 0.1.2 → 0.1.3

data/.yardopts

@@ -0,0 +1 @@
+--no-private --markup markdown lib/**/*.rb - CHANGELOG.md LICENSE

data/CHANGELOG.md

@@ -1,9 +1,17 @@
-## O.1.2 (2011-03-31)
+# CHANGELOG
+
+## 0.1.3 (2011-10-25)
+
+* Added configuration option to ignore unknown properties. The default behavior continues
+  to be raising an error when an unknown property name is encountered in an initialization
+  hash.
+
+## 0.1.2 (2011-03-31)
 
 * Fixed SystemStackError when a typed property with the same name is defined multiple times.
 * Use explicit path when loading modelish classes.
 
-## O.1.1 (2011-03-28)
+## 0.1.1 (2011-03-28)
 
 * Add DateTime to standard supported property types.
 

data/README.md

@@ -3,6 +3,8 @@
 When a real modeling framework is too heavy, sometimes you want something just 
 a little modelish.
 
+## Overview ##
+
 If a Hash or OpenStruct almost suits your needs, but you need bits of 
 model-like behavior such as simple validation and typed values, modelish can 
 help.
@@ -10,18 +12,20 @@ help.
 If you need persistence or anything but the most basic functionality, modelish 
 will frustrate you to no end.
 
-## Installation ##
+## Documentation ##
 
-For the especially foolhardy, you can:
+See the [rdocs][docs].
 
-1. Add this to your Gemfile:
+## Installation ##
 
-         gem 'modelish', :git => 'git://github.com/maeve/modelish.git'
+modelish is available on [Rubygems][rubygems] and can be installed via:
 
-2. Execute `bundle install`
+         $ gem install modelish
 
 ## Basics ##
 
+### Property Types ###
+
 The modelish syntax is very similar to some of the classes provided by 
 [hashie]. In fact, the initial implementation simply extended 
 [Hashie::Trash][trash] to add property types:
@@ -44,21 +48,23 @@ key-mappings:
                    :my_simple_property => 'bar')
 
        f.my_date
-         => #<Date: 2011-03-10 (4911261/2,0,2299161)> 
+       # => #<Date: 2011-03-10 (4911261/2,0,2299161)> 
        f.my_float
-         => 0.0 
+       # => 0.0 
        f.my_funky_id
-         => 42 
+       # => 42 
        f.my_simple_property
-         => "bar" 
+       # => "bar" 
+
+### Property Validation ###
 
 modelish also supports defining simple property validations:
 
         class Bar < Modelish::Base
-            property :important_field, :required => true
-            property :state, :max_length => 2
-            property :my_int, :type => Integer, :validate_type => true
-            property :another_field, :validator => lambda { |val| "val must respond to []" unless val.respond_to?(:[]) }
+          property :important_field, :required => true
+          property :state, :max_length => 2
+          property :my_int, :type => Integer, :validate_type => true
+          property :another_field, :validator => lambda { |val| "val must respond to []" unless val.respond_to?(:[]) }
         end
 
 Validations can be run using methods that return an error map (keyed on property name), raise errors, or return a boolean value to indicate validation outcome.
@@ -68,28 +74,67 @@ Validations can be run using methods that return an error map (keyed on property
                             :my_int => 42, 
                             :another_field => Hash.new)
         valid_bar.valid?
-          => true
+        # => true
 
         valid_bar.validate
-          => {}
+        # => {}
 
         valid_bar.validate!
-          => nil
+        # => nil
 
 
         invalid_bar = Bar.new(:state => 'a value that is too long',
                               :my_int => 'this is not an integer',
                               :another_field => Object.new)
         invalid_bar.valid?
-          => false
+        # => false
 
         invalid_bar.validate
-          => {:important_field=>[#<ArgumentError: important_field must not be nil or blank>], :my_int=>[#<ArgumentError: my_int must be of type Integer, but got "this is not an integer">], :another_field=>[#<ArgumentError: val must respond to []>], :state=>[#<ArgumentError: state must be less than 2 characters>]}
+        # => {:important_field=>[#<ArgumentError: important_field must not be nil or blank>],
+        # :my_int=>[#<ArgumentError: my_int must be of type Integer, but got "this is not an integer">],
+        # :another_field=>[#<ArgumentError: val must respond to []>], 
+        # :state=>[#<ArgumentError: state must be less than 2 characters>]}
 
         invalid_bar.validate!
-          ArgumentError: important_field must not be nil or blank
-                  from /Users/maeverevels/projects/modelish/lib/modelish/validations.rb:31:in `validate!'
-                  ...
+        # ArgumentError: important_field must not be nil or blank
+
+## Configuration ##
+
+By default, modelish will raise an error when it encounters unknown property names in an initialization hash. If you'd prefer modelish to ignore unknown properties, you can override this default behavior for all of your modelish models:
+
+        require 'modelish'
+
+        Modelish.configure do |config|
+          config.ignore_unknown_properties = true
+        end
+
+        class MyModel < Modelish::Base
+          property :foo
+        end
+
+        m = MyModel.new(:foo => 'value', :bar => true)
+        # => <#MyModel foo="value">
+
+Or you can selectively enable the setting for a particular model:
+
+        require 'modelish'
+
+        class MyPermissiveModel < Modelish::Base
+          property :foo
+          ignore_unknown_properties!
+        end
+
+        class MyStrictModel < Modelish::Base
+          property :foo
+        end
+
+        p = MyPermissiveModel.new(:foo => 'value', :bar => true)
+        # => <#MyPermissiveModel foo="value">
+
+        s = MyStrictModel.new(:foo => 'value', :bar => true)
+        # NoMethodError: The property 'bar' is not defined for this Modelish object
 
  [hashie]: https://github.com/intridea/hashie
  [trash]: http://rdoc.info/github/intridea/hashie/master/Hashie/Trash
+ [rubygems]: https://rubygems.org/gems/modelish
+ [docs]: http://rubydoc.info/gems/modelish

data/Rakefile

@@ -9,7 +9,7 @@ task :default => :spec
 namespace :doc do
   require 'yard'
   YARD::Rake::YardocTask.new do |task|
-    task.files   = ['README.md', 'lib/**/*.rb']
+    task.files   = ['README.md', 'CHANGELOG.md', 'LICENSE', 'lib/**/*.rb']
     task.options = [
       '--markup', 'markdown',
     ]

data/lib/modelish.rb

@@ -2,7 +2,8 @@ $:.unshift(File.expand_path('modelish',File.dirname(__FILE__)))
 
 require 'modelish/version'
 require 'modelish/base'
+require 'modelish/configuration'
 
 module Modelish
-  # Your code goes here...
+  extend Configuration
 end

data/lib/modelish/base.rb

@@ -1,11 +1,13 @@
 require 'hashie'
-require 'property_types'
-require 'validations'
+require 'modelish/property_types'
+require 'modelish/validations'
+require 'modelish/configuration'
 
 module Modelish
   class Base < Hashie::Trash
     include PropertyTypes
     include Validations
+    extend Configuration
 
     # Creates a new attribute.
     #
@@ -19,14 +21,14 @@ module Modelish
     # @option opts [Class,Proc] :type the type of the property value. For
     #                                 a list of accepted types, see
     #                                 {Modelish::PropertyTypes}
-    # @options opts [true,false] :required enables validation for the property
+    # @option opts [true,false] :required enables validation for the property
     #                                      value's presence; nil or blank values
     #                                      will cause validation methods to fail
-    # @options opts [Integer] :max_length the maximum allowable length for a valid
+    # @option opts [Integer] :max_length the maximum allowable length for a valid
     #                                     property value
-    # @options opts [true,false] :validate_type enables validation for the property value's
+    # @option opts [true,false] :validate_type enables validation for the property value's
     #                                           type based on the :type option
-    # @options opts [Proc] :validator A block that accepts a value and validates it;
+    # @option opts [Proc] :validator A block that accepts a value and validates it;
     #                                 should return nil if validation passes, or an error
     #                                 message or error object if validation fails.
     #                                 See {Modelish::Validations}
@@ -40,5 +42,17 @@ module Modelish
       add_validator(name, &options[:validator]) if options[:validator]
       add_validator(name) { |val| validate_type(name, val, options[:type]) } if options[:validate_type]
     end
+
+    private
+    def property_exists?(property)
+      if self.class.property?(property.to_sym)
+        true
+      elsif self.class.ignore_unknown_properties || 
+            (self.class.ignore_unknown_properties.nil? && Modelish.ignore_unknown_properties)
+        false
+      else
+        raise NoMethodError, "The property '#{property}' is not defined for this Modelish object."
+      end
+    end
   end
 end

data/lib/modelish/configuration.rb

@@ -0,0 +1,50 @@
+module Modelish
+  module Configuration
+    # If true, ignore unknown property names when initializing new models;
+    # otherwise, raise an error when an unknown property is encountered.
+    # Defaults to false.
+    attr_accessor :ignore_unknown_properties
+
+    # When set, unknown property names will be ignored during modelish initialization
+    # and property setting.
+    #
+    # @see {raise_errors_on_unknown_properties!}
+    def ignore_unknown_properties!
+      self.ignore_unknown_properties = true
+    end
+
+    # When set, unknown property names will cause errors to be raised when encountered
+    # during modelish initialization and property setting. This is the default behavior.
+    #
+    # @see {ignore_unknown_properties!}
+    def raise_errors_on_unknown_properties!
+      self.ignore_unknown_properties = false
+    end
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset
+    end
+
+    # Configures this module through the given +block+.
+    # Default configuration options will be applied unless
+    # they are explicitly overridden in the +block+.
+    #
+    # @example Disable raising errors on unknown property names
+    #   Modelish.configure do |config|
+    #     config.ignore_unknown_properties = true
+    #   end
+    def configure
+      if block_given?
+        yield self
+      end
+
+      self
+    end
+
+    # Resets this module's configuration.
+    def reset
+      self.ignore_unknown_properties = false
+    end
+  end
+end

data/lib/modelish/version.rb

@@ -1,3 +1,3 @@
 module Modelish
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/modelish.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rspec','~> 2.5')
   s.add_development_dependency('yard', '~> 0.6')
   s.add_development_dependency('bluecloth','~> 2.0.11')
-  s.add_development_dependency('autotest')
 
   s.has_rdoc = true
 end

data/spec/modelish/base_spec.rb

@@ -10,6 +10,45 @@ describe Modelish::Base do
 
   it { should respond_to(:property) }
 
+  context 'without any properties' do
+    subject { model }
+
+    context 'when the model is initialized with an unknown property' do
+      let(:init_options) { {unknown_prop => 'whatever'} }
+      let(:unknown_prop) { :foo }
+
+      context 'when ignore_unknown_properties is configured at the class level' do
+        before { model_class.ignore_unknown_properties = ignore_unknown_props }
+        after { model_class.reset }
+
+        it_should_behave_like 'an unknown property handler'
+      end
+
+      context "when ignore_unknown_properties is configured globally" do
+        before { Modelish.configure { |c| c.ignore_unknown_properties = ignore_unknown_props } }
+        after { Modelish.reset }
+
+        it_should_behave_like 'an unknown property handler'
+
+        context 'when ignore_unknown_properties is configured differently at the class level' do
+          before { Modelish.configure { |c| c.ignore_unknown_properties = !ignore_unknown_props } }
+          after { Modelish.reset }
+
+          before { model_class.ignore_unknown_properties = ignore_unknown_props }
+          after { model_class.reset }
+
+          it_should_behave_like 'an unknown property handler'
+        end
+      end
+
+      context 'when ignore_unknown_properties has not been configured' do
+        it 'should raise an error' do
+          expect { subject }.to raise_error(NoMethodError)
+        end
+      end
+    end
+  end
+
   context "with simple property" do
     before { model_class.property(property_name) }
 

data/spec/modelish/configuration_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Modelish::Configuration do
+  let(:test_module) do
+    module TestModule
+      extend Modelish::Configuration
+    end
+  end
+
+  subject { test_module }
+
+  after { test_module.reset }
+
+  it { should respond_to(:configure) }
+
+  context 'with default configuration' do
+    its(:ignore_unknown_properties) { should be_false }
+  end
+
+  describe '.configure' do
+    subject { test_module.configure(&config_block) }
+
+    context 'with full configuration' do
+      let(:config_block) do
+        lambda do |config|
+          config.ignore_unknown_properties = ignore_unknown_props
+        end
+      end
+
+      context 'when ignore_unknown_properties is true' do
+        let(:ignore_unknown_props) { true }
+        its(:ignore_unknown_properties) { should be_true }
+      end
+
+      context 'when ignore_unknown_properties is false' do
+        let(:ignore_unknown_props) { false }
+        its(:ignore_unknown_properties) { should be_false }
+      end
+    end
+  end
+
+  describe '.reset' do
+    subject { test_module.reset }
+
+    before { test_module.configure { |c| c.ignore_unknown_properties = true } }
+
+    it 'should reset the value of ignore_unknown_properties' do
+      expect { subject }.to change { test_module.ignore_unknown_properties }.from(true).to(false)
+    end
+  end
+
+  describe 'ignore_unknown_properties!' do
+    before { test_module.ignore_unknown_properties = ignore_unknown_props }
+
+    subject { test_module.ignore_unknown_properties! }
+
+    context 'when ignore_unknown_properties is true' do
+      let(:ignore_unknown_props) { true }
+
+      it 'should not change the setting' do
+        expect { subject }.to_not change { test_module.ignore_unknown_properties }
+      end
+    end 
+
+    context 'when ignore_unknown_properties is false' do
+      let(:ignore_unknown_props) { false }
+
+      it 'should change the setting' do
+        expect { subject }.to change { test_module.ignore_unknown_properties }.from(false).to(true)
+      end
+    end
+
+    context 'when ignore_unknown_properties is nil' do
+      let(:ignore_unknown_props) { nil }
+
+      it 'should change the setting' do
+        expect { subject }.to change { test_module.ignore_unknown_properties }.from(nil).to(true)
+      end
+    end
+  end
+
+  describe 'raise_errors_on_unknown_properties!' do
+    before { test_module.ignore_unknown_properties = ignore_unknown_props }
+
+    subject { test_module.raise_errors_on_unknown_properties! }
+
+    context 'when ignore_unknown_properties is true' do
+      let(:ignore_unknown_props) { true }
+
+      it 'should change the setting' do
+        expect { subject }.to change { test_module.ignore_unknown_properties }.from(true).to(false)
+      end
+    end 
+
+    context 'when ignore_unknown_properties is false' do
+      let(:ignore_unknown_props) { false }
+
+      it 'should not change the setting' do
+        expect { subject }.to_not change { test_module.ignore_unknown_properties }
+      end
+    end
+
+    context 'when ignore_unknown_properties is nil' do
+      let(:ignore_unknown_props) { nil }
+
+      it 'should change the setting' do
+        expect { subject }.to change { test_module.ignore_unknown_properties }.from(nil).to(false)
+      end
+    end
+  end
+end

data/spec/support/unknown_property_examples.rb

@@ -0,0 +1,19 @@
+shared_examples_for 'an unknown property handler' do
+  context 'when ignore_unknown_properties is set to false' do
+    let(:ignore_unknown_props) { false }
+
+    it 'should raise an error' do
+      expect { subject }.to raise_error(NoMethodError)
+    end
+  end
+
+  context 'when ignore_unknown_properties is set to true' do
+    let(:ignore_unknown_props) { true }
+
+    it 'should not raise an error' do
+      expect { subject }.to_not raise_error
+    end
+
+    it { should_not respond_to(unknown_prop) }
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: modelish
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: 
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Maeve Revels
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-31 00:00:00 -07:00
+date: 2011-10-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -79,20 +79,6 @@ dependencies:
         version: 2.0.11
   type: :development
   version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: autotest
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id005
 description: Sometimes you need something just a little modelish.
 email: 
 - maeve.revels@g5platform.com
@@ -106,6 +92,7 @@ files:
 - .gitignore
 - .rspec
 - .rvmrc
+- .yardopts
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -113,17 +100,20 @@ files:
 - Rakefile
 - lib/modelish.rb
 - lib/modelish/base.rb
+- lib/modelish/configuration.rb
 - lib/modelish/property_types.rb
 - lib/modelish/validations.rb
 - lib/modelish/version.rb
 - modelish.gemspec
 - spec/modelish/base_spec.rb
+- spec/modelish/configuration_spec.rb
 - spec/modelish/property_types_spec.rb
 - spec/modelish/validations_spec.rb
 - spec/modelish_spec.rb
 - spec/spec_helper.rb
 - spec/support/property_examples.rb
 - spec/support/typed_property_examples.rb
+- spec/support/unknown_property_examples.rb
 - spec/support/validation_examples.rb
 has_rdoc: true
 homepage: http://github.com/maeve/modelish
@@ -161,10 +151,12 @@ specification_version: 3
 summary: A lightweight pseudo-modeling not-quite-framework
 test_files: 
 - spec/modelish/base_spec.rb
+- spec/modelish/configuration_spec.rb
 - spec/modelish/property_types_spec.rb
 - spec/modelish/validations_spec.rb
 - spec/modelish_spec.rb
 - spec/spec_helper.rb
 - spec/support/property_examples.rb
 - spec/support/typed_property_examples.rb
+- spec/support/unknown_property_examples.rb
 - spec/support/validation_examples.rb