constructable 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.2-p180@constructable

data/.travis.yml

@@ -0,0 +1,2 @@
+rvm:
+ - 1.9.2

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.0"
+  gem 'simplecov'
+  gem 'yard'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Manuel Korfmann
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,56 @@
+# Constructable [![Build Status](http://travis-ci.org/mkorfmann/constructable.png)](http://travis-ci.org/mkorfmann/constructable)
+
+Provides a powerful class macro for defining and configuring constructable attributes of a class.
+
+## Facts
+
+* Doesn't break default initialize behaviour(see test/constructable/test_constructable 'should not break the initialize behaviour')
+* Only does what you expect it to do (no real magic involved)
+* Validates your attributes
+* Provides a granular control on how accessible your attributes are(no need to define attr_* yourself)
+
+## Usage
+<pre><code>
+class Foo
+  constructable [:bar, :readable => true], [:baz, :required => true, :readable => true]
+end
+
+foo = Foo.new(bar: 5)
+\# raises AttributeError, ':baz is a required attribute'
+
+foo = Foo.new(baz: 7, bar: 5)
+
+foo.bar
+\# => 5
+foo.baz
+\# => 7
+
+class ProgrammingLanguage
+  constructable [:paradigms,
+    readable: true,
+    required: true,
+    validate_type: Array]
+end
+
+c = ProgrammingLanguage.new(paradigms: :functional)
+\#  raises AttributeError, ':paradigms needs to be of type Array'
+
+ruby = ProgrammingLanguage.new(paradigms: [:object_oriented, :functional])
+ruby.paradigms
+\# => [:object_oriented, :functional]
+</pre></code>
+
+
+## Contributing to constructable
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+Copyright (c) 2011 Manuel Korfmann. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "constructable"
+  gem.homepage = "http://github.com/mkorfmann/constructable"
+  gem.license = "MIT"
+  gem.summary = %Q{Makes constructing objects through an attributes hash easier}
+  gem.description = %Q{
+Adds the class macro Class#constructable to easily define what attributes a Class accepts provided as a hash to Class#new.
+Attributes can be configured in their behaviour in case they are not provided or are in the wrong format.
+Their default value can also be defined and you have granular control on how accessible your attribute is.
+See the documentation for Constructable::Constructable#constructable or the README for more information.
+  }
+  gem.email = "manu@korfmann.info"
+  gem.authors = ["Manuel Korfmann"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/constructable/attribute.rb

@@ -0,0 +1,65 @@
+module Constructable
+  class Attribute
+    ATTRIBUTES = [:writable, :readable, :accessible, :required, :validate, :default, :validate_type, :converter]
+    attr_accessor *ATTRIBUTES, :name
+
+    REQUIRED_REQUIREMENT = {
+      name: :required,
+      message: proc {":#{self.name} is a required attribute"},
+      check: ->(hash) { hash.has_key?(self.name) }
+    }
+
+    REQUIREMENTS = [
+      {
+        name: :validate,
+        message: proc {":#{self.name} did not pass validation"},
+        check: ->(hash) { self.validate.call(hash[self.name])}
+      },
+      {
+        name: :validate_type,
+        message: proc {":#{self.name} needs to be of type #{self.validate_type}"},
+        check: ->(hash) { hash[self.name].is_a? self.validate_type }
+      }
+    ]
+
+    def initialize(name, options = {})
+      @name = name
+      options.each do |option, value|
+        self.send(:"#{option}=", value )
+      end
+    end
+
+    def accessible=(boolean)
+      if boolean
+        self.readable = true
+        self.writable = true
+      end
+    end
+
+    def ivar_symbol
+      ('@' + self.name.to_s).to_sym
+    end
+
+    def check_for_requirement(requirement, constructor_hash)
+      if self.send requirement[:name]
+        unless self.instance_exec(constructor_hash,&requirement[:check])
+          raise AttributeError, instance_eval(&requirement[:message])
+        end
+      end
+    end
+    private :check_for_requirement
+
+    def process(constructor_hash)
+      if constructor_hash.has_key?(self.name)
+        REQUIREMENTS.each do |requirement|
+          check_for_requirement(requirement, constructor_hash)
+        end
+        value = constructor_hash[self.name]
+        self.converter ? converter.(value) : value
+      else
+        check_for_requirement(REQUIRED_REQUIREMENT, constructor_hash)
+        self.default
+      end
+    end
+  end
+end

data/lib/constructable/constructable.rb

@@ -0,0 +1,40 @@
+module Constructable
+  module Constructable
+    # @example
+    #
+    #  class Foo
+    #    constructable [:bar, :readable => true], [:baz, :required => true, :readable => true]
+    #  end
+    #
+    #  foo = Foo.new(bar: 5)
+    #  # raises AttributeError, ':baz is a required attribute'
+    #
+    #  foo = Foo.new(baz: 7, bar: 5)
+    #
+    #  foo.bar
+    #  # => 5
+    #  foo.baz
+    #  # => 7
+    #
+    #  class ProgrammingLanguage
+    #    constructable [:paradigms,
+    #      readable: true,
+    #      required: true,
+    #      validate: ->(value) { value.is_a?(Array) }]
+    #  end
+    #
+    #  c = ProgrammingLanguage.new(paradigms: :functional)
+    #  #  raises AttributeError, ':paradigms did not pass validation'
+    #
+    #  ruby = ProgrammingLanguage.new(paradigms: [:object_oriented, :functional])
+    #  ruby.paradigms
+    #  # => [:object_oriented, :functional]
+    #
+    # @param [Array<[Array<Symbol, Hash>]>] args an array of symbols or arrays: the name of the attribute and it's configuration
+    def constructable(*args)
+      @__constructor ||= Constructor.new(self)
+      @__constructor.define_attributes(args)
+      return nil
+    end
+  end
+end

data/lib/constructable/constructor.rb

@@ -0,0 +1,37 @@
+module Constructable
+  class Constructor
+    def initialize(klass)
+      @attributes = []
+      @klass = klass
+      constructor = self
+      @klass.define_singleton_method(:new) do |*args, &block|
+        obj = self.allocate
+        constructor_hash = Hash === args.last ? args.pop : {}
+        constructor.construct(constructor_hash, obj)
+        obj.send :initialize, *args, &block
+        obj
+      end
+    end
+
+
+    def define_attributes(attributes)
+      @attributes.concat attributes.map! { |c| Attribute.new(*c) }
+      attributes.each do |attribute|
+        @klass.class_eval do
+          setter = :"#{attribute.name}="
+          define_method(attribute.name) { instance_variable_get attribute.ivar_symbol }
+          private attribute.name unless attribute.readable
+          define_method(setter) { |value| instance_variable_set attribute.ivar_symbol, attribute.process({ attribute.name => value}) }
+          private setter unless attribute.writable
+        end
+      end
+    end
+
+    def construct(constructor_hash, obj)
+      constructor_hash ||= {}
+      @attributes.each do |attributes|
+        obj.instance_variable_set(attributes.ivar_symbol, attributes.process(constructor_hash))
+      end
+    end
+  end
+end

data/lib/constructable/core_ext.rb

@@ -0,0 +1,3 @@
+module Constructable
+  ::Module.send :include, Constructable
+end

data/lib/constructable/exceptions.rb

@@ -0,0 +1,3 @@
+module Constructable
+  AttributeError = Class.new(ArgumentError)
+end

data/lib/constructable.rb

@@ -0,0 +1,7 @@
+require 'constructable/exceptions'
+require 'constructable/constructor'
+require 'constructable/constructable'
+require 'constructable/core_ext'
+require 'constructable/attribute'
+module Constructable
+end

data/test/constructable/test_attribute.rb

@@ -0,0 +1,97 @@
+require 'helper'
+include Constructable
+describe 'Attribute' do
+  describe 'name' do
+    it 'returns the name' do
+      attribute = Attribute.new(:attribute)
+      assert_equal :attribute, attribute.name
+    end
+  end
+
+  describe 'ivar_symbol' do
+    it 'should return @<name>' do
+      attribute = Attribute.new(:foo)
+      assert_equal :@foo, attribute.ivar_symbol
+    end
+  end
+
+  describe 'process' do
+    it 'should raise nothing if no attributes are specified' do
+      attribute = Attribute.new(:foo)
+      assert_equal 'bar', attribute.process({foo: 'bar'})
+    end
+
+    describe 'required attribute' do
+      it 'should raise an AttributeError if required is set to true' do
+        attribute = Attribute.new(:foo, required: true)
+        begin
+          attribute.process(bar: 'blab')
+        rescue Exception => e
+          assert AttributeError === e
+          assert_equal ':foo is a required attribute', e.message
+        else
+          assert false, 'AttributeError was not raised'
+        end
+      end
+    end
+
+    describe 'attribute is neither required nor provided' do
+      it 'does not check for further requirements' do
+        attribute = Attribute.new(:foo, validate_type: Integer)
+        refute_raises do
+          attribute.process({})
+        end
+      end
+    end
+
+    describe 'validator' do
+      it 'should raise an AttributeError if the validator doesn\'t pass' do
+        attribute = Attribute.new(:foo, validate: ->(number) { number < 5 })
+        begin
+          attribute.process(foo: 6)
+        rescue Exception => e
+          assert AttributeError === e, "[#{e.class},#{e.message}] was not expected"
+          assert_equal ':foo did not pass validation', e.message
+        else
+          assert false, 'AttributeError was not raised'
+        end
+      end
+    end
+
+    describe 'validate_type check' do
+      it 'should raise an AttributeError if the value has not the wanted validate_type' do
+        attribute = Attribute.new(:foo, validate_type: Integer)
+        begin
+          attribute.process(foo: 'notanumber')
+        rescue Exception => e
+          assert AttributeError === e, "[#{e.class},#{e.message}] was not expected"
+          assert_equal ':foo needs to be of type Integer', e.message
+        else
+          assert false, 'AttributeError was not raised'
+        end
+      end
+    end
+
+    describe 'default value' do
+      it 'should be possible to provide a default value' do
+        attribute = Attribute.new(:foo, default: :bar)
+        assert_equal :bar, attribute.process({})
+      end
+    end
+
+    describe 'convert value' do
+      it 'is possible to define a converter(proc) which converts attribute values' do
+        attribute = Attribute.new(:number, converter: ->(value) { value.to_i })
+        assert_equal 5, attribute.process({number: '5'})
+      end
+    end
+  end
+
+  describe 'permission' do
+    it 'should detect accessible attributes' do
+      attribute = Attribute.new( :readable_and_writable, accessible: true)
+      assert_equal true, attribute.readable
+      assert_equal true, attribute.writable
+    end
+  end
+end

data/test/constructable/test_constructable.rb

@@ -0,0 +1,68 @@
+require 'helper'
+describe 'integration' do
+  describe 'Class' do
+    describe 'constructable' do
+      it 'should define attr_accessors' do
+        klass = Class.new
+        klass.constructable([:foo, accessible: true])
+        assert_respond_to klass.new, :foo
+        assert_respond_to klass.new, :foo=
+      end
+
+      it 'should assign values found in the constructer hash' do
+        klass = Class.new
+        klass.constructable([:foo, readable: true])
+        instance = klass.new(foo: :bar)
+        assert_equal :bar, instance.foo
+      end
+
+      it 'should work with inheritance' do
+        klass = Class.new
+        klass.constructable([:bar, readable: true])
+        inherited_klass = Class.new(klass)
+        instance = inherited_klass.new(bar: 1)
+        assert_equal 1, instance.bar
+      end
+
+      it 'should be possible to make attributes required' do
+        klass = Class.new
+        klass.constructable([:bar, required: true])
+        assert_raises AttributeError do
+          klass.new
+        end
+      end
+
+      describe 'should not break the initalize behaviour' do
+        it 'works for methods with arguments + options provided' do
+          klass = Class.new
+          klass.constructable [:bar, accessible: true]
+          klass.class_eval do
+            def initialize
+              self.bar = 20
+            end
+          end
+          instance = klass.new(bar: 5)
+          assert_equal 20, instance.bar
+        end
+
+        it 'works for methods with only arguments provided' do
+          klass = Class.new
+          klass.constructable [:bar, accessible: true]
+          klass.class_eval do
+            def initialize(bar)
+              self.bar = bar
+            end
+          end
+
+          instance = klass.new(1)
+          assert_equal 1, instance.bar
+        end
+      end
+
+      it 'should return nil' do
+        klass = Class.new
+        assert_equal nil, klass.constructable(:bar)
+      end
+    end
+  end
+end

data/test/constructable/test_constructor.rb

@@ -0,0 +1,39 @@
+require 'helper'
+describe 'Constructor' do
+  before do
+    @klass = Class.new
+  end
+
+  describe 'define_attributes' do
+    it 'defines public setters validating like in the constructor' do
+      @klass.constructable [:integer, validate_type: Integer, writable: true]
+      instance = @klass.new
+      assert_raises AttributeError do
+        instance.integer = 6.6
+      end
+    end
+  end
+
+  describe 'permission' do
+    it 'should allow writable attributes' do
+      @klass.constructable [:writable_attribute, writable: true]
+      instance = @klass.new
+      instance.writable_attribute = "hello"
+      assert_equal "hello", instance.instance_variable_get(:@writable_attribute)
+    end
+
+    it 'should allow readable attributes' do
+      @klass.constructable [:readable_attribute, readable: true]
+      instance = @klass.new
+      instance.instance_variable_set(:@readable_attribute, "hello")
+      assert_equal "hello", instance.readable_attribute
+    end
+
+    it 'should allow accessible attributes' do
+      @klass.constructable [:accessible_attribute, accessible: true]
+      instance = @klass.new
+      instance.accessible_attribute = 'hello'
+      assert_equal 'hello', instance.accessible_attribute
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'test'
+end
+
+require 'minitest/autorun'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'constructable'
+
+class MiniTest::Unit::TestCase
+	def refute_raises
+		test = -> do
+			begin	
+				yield
+			rescue => e
+				return false, e
+			else
+				true
+			end
+		end
+		boolean, exception = test.call
+		assert boolean, "Expected no exception, but got #{exception}"
+	end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: constructable
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Manuel Korfmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-08 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: yard
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+description: "\n\
+  Adds the class macro Class#constructable to easily define what attributes a Class accepts provided as a hash to Class#new.\n\
+  Attributes can be configured in their behaviour in case they are not provided or are in the wrong format.\n\
+  Their default value can also be defined and you have granular control on how accessible your attribute is.\n\
+  See the documentation for Constructable::Constructable#constructable or the README for more information.\n  "
+email: manu@korfmann.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.markdown
+files: 
+- .document
+- .rvmrc
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- lib/constructable.rb
+- lib/constructable/attribute.rb
+- lib/constructable/constructable.rb
+- lib/constructable/constructor.rb
+- lib/constructable/core_ext.rb
+- lib/constructable/exceptions.rb
+- test/constructable/test_attribute.rb
+- test/constructable/test_constructable.rb
+- test/constructable/test_constructor.rb
+- test/helper.rb
+has_rdoc: true
+homepage: http://github.com/mkorfmann/constructable
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 2461341662544041366
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Makes constructing objects through an attributes hash easier
+test_files: []
+