bound 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46590308f9cc175507cdd528e744b43d72013d82
-  data.tar.gz: b98915c9a3be4b1a1fe2895862ae4987c83c2fcf
+  metadata.gz: 73b43370b97701af8bc883f5d99ce0ccea3b69ff
+  data.tar.gz: 89d1eb9d1131a6162d3dcf6926839051752a654c
 SHA512:
-  metadata.gz: 1d58eb39f202864c80d0e0edf7b32ba15b1d45cdb7c3ca6f61a2f880b4b21890677fc21e98b72edfedd1ba8ff703690b252374dfd7ef891f8d2350bc0f21358b
-  data.tar.gz: f934f47ce58bad2dd8cddea11877fba384a24112e152bab5b447788707ee66d9d8efb64b6bcb9a2c637cc59f8d8c349e8c07def4bb4bb68d7cd3095a6fb1f9b8
+  metadata.gz: 44ca00d9fe5935c8c38050b8f6486e31e662593633214b935949d322b5d2ca21e9095c2a571defb2574b516d98f80b700f14ac0c4827355993444b9acb501f31
+  data.tar.gz: 325cd7b686ec4f7e65821c087a7a8229a02e82a22518b6ac21d5db2813213030eced4b8d13f09ded4635aeea2b63107656f069183ce6860baeb263a7ca31fe30

data/bound.gemspec

@@ -20,4 +20,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest", "~> 5.0.7"
+
+  spec.add_development_dependency "simplecov" 
 end

data/lib/bound.rb

@@ -13,6 +13,16 @@ class Bound
     new_bound_class.optional(*args)
   end
 
+  def self.required(*args)
+    bound = new_bound_class
+
+    if args.last.kind_of? Hash
+      bound.nested(args.pop)
+    end
+
+    bound.set_attributes(*args)
+  end
+
   private
 
   def self.new_bound_class
@@ -22,13 +32,97 @@ class Bound
   end
 
   class BoundClass
+    class Attribute
+      attr_reader :name, :value
+      attr_accessor :nested_class
+
+      def initialize(name)
+        @name = name
+      end
+
+      def assign(value)
+        @assigned = true
+        if nested_class
+          @value = assign_nested(value)
+        else
+          @value = value
+        end
+      end
+
+      def assign_nested(value)
+        nested_attribute = NestedAttribute.new(nested_class)
+        nested_attribute.resolve(value)
+      end
+
+      def call_on(object)
+        object.public_send @name
+      end
+
+      def valid?
+        !required? || is_assigned?
+      end
+
+      def required?
+        false
+      end
+
+      def is_assigned?
+        !!@assigned
+      end
+
+      def inspect
+        "#{@name}=#{@value.inspect}"
+      end
+    end
+
+    class RequiredAttribute < Attribute
+      def required?; true; end
+    end
+
+    class NestedAttribute
+      def initialize(bound_definition)
+        if bound_definition.kind_of?(Array)
+          @assigner = ArrayAssigner.new(bound_definition)
+        else
+          @assigner = ValueAssigner.new(bound_definition)
+        end
+      end
+
+      def resolve(bound_arguments)
+        @assigner.resolve(bound_arguments)
+      end
+
+      class ArrayAssigner
+        def initialize(definitions)
+          @bound_class = definitions.first
+        end
+
+        def resolve(arguments_list)
+          raise ArgumentError.new("Expected #{arguments_list.inspect} to be an array") unless arguments_list.kind_of? Array
+          arguments_list.map do |arguments|
+            @bound_class.new(arguments)
+          end
+        end
+      end
+
+      class ValueAssigner
+        def initialize(definition)
+          @bound_class = definition
+        end
+
+        def resolve(arguments)
+          @bound_class.new(arguments)
+        end
+      end
+    end
+
+
     class << self
-      attr_accessor :attributes, :optional_attributes, :nested_attributes
+      attr_accessor :attrs, :nested_attr_classes
 
       def initialize_values
-        self.attributes = []
-        self.optional_attributes = []
-        self.nested_attributes = []
+        self.attrs = {}
+        self.nested_attr_classes = {}
       end
 
       def set_attributes(*attributes)
@@ -36,8 +130,11 @@ class Bound
           raise ArgumentError.new("Invalid list of attributes: #{attributes.inspect}")
         end
 
-        self.attributes += attributes
-        attr_accessor *attributes
+        attributes.each do |attribute|
+          self.attrs[attribute] = RequiredAttribute
+        end
+
+        define_attribute_accessors attributes
 
         self
       end
@@ -47,104 +144,108 @@ class Bound
           raise ArgumentError.new("Invalid list of optional attributes: #{optionals.inspect}")
         end
 
-        self.optional_attributes += optionals
-        attr_accessor *optionals
+        optionals.each do |attribute|
+          self.attrs[attribute] = Attribute
+        end
+
+        define_attribute_accessors optionals
 
         self
       end
 
       def nested(nested_attributes)
         attributes = nested_attributes.keys
-        self.nested_attributes += attributes
-        self.attributes += attributes
-        attr_reader *attributes
 
         attributes.each do |attribute|
-          define_method :"#{attribute}=" do |initial_values|
-            nested_target = nested_attributes[attribute]
-            value = extract_values_for_nested_attribute(nested_target, initial_values)
-
-            instance_variable_set :"@#{attribute}", value
-          end
+          self.attrs[attribute]               = RequiredAttribute
+          self.nested_attr_classes[attribute] = nested_attributes[attribute]
         end
 
+        define_attribute_accessors attributes
+
         self
       end
 
       alias :build :new
+
+      private
+
+      def define_attribute_accessors(attributes)
+        define_attribute_readers attributes
+        define_attribute_writers attributes
+      end
+
+      def define_attribute_readers(attributes)
+        attributes.each do |attribute|
+          define_method attribute do
+            get_attribute(attribute).value
+          end
+        end
+      end
+
+      def define_attribute_writers(attributes)
+        attributes.each do |attribute|
+          define_method :"#{attribute}=" do |value|
+            get_attribute(attribute).assign value
+          end
+        end
+      end
     end
 
     def initialize(hash_or_object = {})
-      build_hash(hash_or_object)
+      seed hash_or_object
       validate!
-      seed
-    end
-    
-    def __attributes__
-      self.class.attributes + self.class.optional_attributes
     end
 
+
     def method_missing(meth, *args, &blk)
       attribute = meth.to_s.gsub(/=$/, '')
       raise ArgumentError.new("Unknown attribute: #{attribute}")
     end
 
-    def inspect
-      class_name = self.class.name
-      id = '%0#16x' % (object_id << 1)
-      values = (self.class.attributes + self.class.optional_attributes).map do |attr|
-        "#{attr}=#{public_send(attr).inspect}"
+    def get_attributes
+      self.class.attrs.keys.map do |attribute_name|
+        get_attribute(attribute_name)
       end
+    end
 
-      (["#<#{class_name}:#{id}"] + values + [">"]).join(" ")
+    def __attributes__
+      puts "DEPRECATED: use get_attributes"
+      get_attributes.map(&:name)
     end
 
     private
 
-    def build_nested_value(bound_class, init)
-      bound_class.new(init)
-    end
+    def get_attribute(attribute_name)
+      attribute_class = self.class.attrs[attribute_name]
+      nested_class = self.class.nested_attr_classes[attribute_name]
 
-    def extract_values_for_nested_attribute(nested_target, initial_values)
-      if nested_target.kind_of? Array
-        raise ArgumentError.new("Expected #{initial_values.inspect} to be an array") unless initial_values.kind_of? Array
+      var = :"@#{attribute_name}"
+      attribute = instance_variable_get(var)
 
-        initial_values.map do |initial_value|
-          build_nested_value(nested_target.first, initial_value)
-        end
-      else
-        build_nested_value(nested_target, initial_values)
+      unless attribute
+        attribute = instance_variable_set(var, attribute_class.new(attribute_name))
+        attribute.nested_class = nested_class if nested_class
       end
+
+      attribute
     end
 
     def validate!
-      self.class.attributes.each do |attribute|
-        raise ArgumentError.new("Missing attribute: #{attribute}") unless @hash.key?(attribute)
+      get_attributes.each do |attribute|
+        raise ArgumentError.new("Missing attribute: #{attribute.name}") unless attribute.valid?
       end
     end
 
-    def seed
-      HashSeeder.new(self).seed(@hash)
-    end
-
-    def build_hash(hash_or_object)
+    def seed(hash_or_object)
       case hash_or_object
       when Hash
-        @hash = hash_or_object
+        seeder = HashSeeder.new(self)
       else
-        @hash = {}
-        insert_into_hash(self.class.attributes, hash_or_object)
-        insert_into_hash(self.class.optional_attributes, hash_or_object)
+        seeder = ObjectSeeder.new(self)
       end
-    end
 
-    def insert_into_hash(attributes, object)
-      attributes.each_with_object(@hash) do |attr, h|
-        begin
-          h[attr] = object.public_send(attr)
-        rescue NoMethodError
-        end
-      end
+      seeder.seed(hash_or_object)
     end
   end
 
@@ -159,4 +260,23 @@ class Bound
       end
     end
   end
+
+  class ObjectSeeder
+    def initialize(receiver)
+      @receiver = receiver
+    end
+
+    def seed(object)
+      @receiver.get_attributes.each do |attribute|
+        begin
+          value = attribute.call_on(object)
+        rescue NoMethodError => e
+          value = nil
+          raise ArgumentError, "missing #{attribute.name}" if attribute.required?
+        end
+
+        @receiver.public_send "#{attribute.name}=", value
+      end
+    end
+  end
 end

data/lib/bound/version.rb

@@ -1,3 +1,3 @@
 class Bound
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/spec/bound_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe Bound do
-  User = Bound.new(:name, :age)
+  User = Bound.required(:name, :age)
 
   let(:object)  { HashObject.new(hash) }
   let(:hash)    { {:name => 'foo', :age => 23} }
 
   it 'sets all attributes' do
     [hash, object].each do |subject|
-      user = User.build(subject)
+      user = User.new(subject)
 
       assert_equal hash[:name], user.name
       assert_equal hash[:age], user.age
@@ -29,7 +29,7 @@ describe Bound do
 
     [hash, object].each do |subject|
       exception = assert_raises ArgumentError, subject.inspect do
-        User.build(subject)
+        User.new(subject)
       end
 
       assert_match(/missing.+age/i, exception.message)
@@ -40,7 +40,7 @@ describe Bound do
     hash[:age] = nil
 
     [hash, object].each do |subject|
-      User.build(subject)
+      User.new(subject)
     end
   end
 
@@ -49,37 +49,37 @@ describe Bound do
     subject = hash
 
     exception = assert_raises ArgumentError, subject.inspect do
-      User.build(subject)
+      User.new(subject)
     end
 
     assert_match(/unknown.+gender/i, exception.message)
   end
 
   it 'exposes an attributes method' do
-    user = User.build(hash)
+    user = User.new(hash)
 
-    assert_equal 2, user.__attributes__.size
-    assert_includes user.__attributes__, :name
-    assert_includes user.__attributes__, :age
+    assert_equal 2, user.get_attributes.size
+    assert_includes user.get_attributes.map(&:name), :name
+    assert_includes user.get_attributes.map(&:name), :age
   end
 
   describe 'wrong initialization' do
     it 'fails if new is not called with symbols' do
       assert_raises ArgumentError do
-        Bound.new(:events => [])
+        Bound.required(32, "a")
       end
     end
 
     it 'fails if optional is not called with symbols' do
       assert_raises ArgumentError do
-        Bound.new.optional(:events => [])
+        Bound.required(32, "a")
       end
     end
   end
 
   describe 'inspect' do
     let(:inspection) { user.inspect }
-    let(:user) { User.build(hash) }
+    let(:user) { User.new(hash) }
 
     it 'lists all attributes' do
       assert_match(/name="foo"/, inspection)
@@ -94,11 +94,11 @@ describe Bound do
   end
 
   describe 'optional attributes' do
-    UserWithoutAge = Bound.new(:name).optional(:age)
+    UserWithoutAge = Bound.required(:name).optional(:age)
 
     it 'sets optional attributes' do
       [hash, object].each do |subject|
-        user = UserWithoutAge.build(subject)
+        user = UserWithoutAge.new(subject)
 
         assert_equal hash[:age], user.age
       end
@@ -108,7 +108,7 @@ describe Bound do
       hash.delete :age
 
       [hash, object].each do |subject|
-        UserWithoutAge.build(subject)
+        UserWithoutAge.new(subject)
       end
     end
 
@@ -116,16 +116,16 @@ describe Bound do
       hash[:age] = nil
 
       [hash, object].each do |subject|
-        UserWithoutAge.build(subject)
+        UserWithoutAge.new(subject)
       end
     end
 
     it 'are also included in attributes' do
       user = UserWithoutAge.build(hash)
 
-      assert_equal 2, user.__attributes__.size
-      assert_includes user.__attributes__, :name
-      assert_includes user.__attributes__, :age
+      assert_equal 2, user.get_attributes.size
+      assert_includes user.get_attributes.map(&:name), :name
+      assert_includes user.get_attributes.map(&:name), :age
     end
   end
 
@@ -135,23 +135,23 @@ describe Bound do
 
     it 'works without attributes' do
       [hash, object, nil].each do |subject|
-        UserWithoutAttributes.build(subject)
+        UserWithoutAttributes.new(subject)
       end
     end
 
     it 'works without argument' do
-      UserWithoutAttributes.build
+      UserWithoutAttributes.new
     end
   end
 
   describe 'nested attribute' do
-    Company       = Bound.new(:name).nested(:address => Bound.new(:street))
-    EmployedUser  = Bound.new(:uid).nested(:company => Company)
+    Company       = Bound.required(:name, :address => Bound.required(:street))
+    EmployedUser  = Bound.required(:uid, :company => Company)
     let(:hash) { {:uid => '1', :company => {:name => 'featurepoly', :address => {:street => 'Germany'}}} }
 
     it 'works with nested attributes' do
       [hash, object].each do |subject|
-        user = EmployedUser.build(subject)
+        user = EmployedUser.new(subject)
 
         assert_equal hash[:uid],                        user.uid
         assert_equal hash[:company][:name],             user.company.name
@@ -161,8 +161,8 @@ describe Bound do
   end
 
   describe 'array of nested attribute' do
-    Post          = Bound.new(:title)
-    BloggingUser  = Bound.new(:name).nested(:posts => [Post])
+    Post          = Bound.required(:title)
+    BloggingUser  = Bound.required(:name, :posts => [Post])
     let(:hash) do
       {
         :name => 'Steve',
@@ -175,7 +175,7 @@ describe Bound do
 
     it 'works with array of nested attributes' do
       [hash, object].each do |subject|
-        user = BloggingUser.build(subject)
+        user = BloggingUser.new(subject)
 
         assert_equal hash[:name],             user.name
         assert_equal hash[:posts][0][:title], user.posts[0].title
@@ -188,7 +188,7 @@ describe Bound do
 
       [hash, object].each do |subject|
         exception = assert_raises ArgumentError do
-          BloggingUser.build(subject)
+          BloggingUser.new(subject)
         end
 
         assert_match(/array/i, exception.message)
@@ -197,11 +197,11 @@ describe Bound do
     end
 
     it 'are also included in attributes' do
-      user = BloggingUser.build(hash)
+      user = BloggingUser.new(hash)
 
-      assert_equal 2, user.__attributes__.size
-      assert_includes user.__attributes__, :name
-      assert_includes user.__attributes__, :posts
+      assert_equal 2, user.get_attributes.size
+      assert_includes user.get_attributes.map(&:name), :name
+      assert_includes user.get_attributes.map(&:name), :posts
     end
   end
 
@@ -215,11 +215,26 @@ describe Bound do
   end
 
   describe 'allows nested as constructor' do
-    Car = Bound.nested(:producer => Bound.new(:name))
+    Car = Bound.required(:producer => Bound.required(:name))
 
     it 'works' do
       assert_raises(ArgumentError) { Car.new }
       assert_equal "VW", Car.new(:producer => {:name => 'VW'}).producer.name
     end
   end
+
+  describe '__attributes__' do
+    DeprecatedUser = Bound.required(:name)
+
+    it 'is deprecated' do
+      user = DeprecatedUser.new(:name => 'foo')
+
+      deprecation_warning, _ = capture_io do
+        user.__attributes__
+      end
+
+      assert_match(/DEPRECATED/, deprecation_warning)
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -1,3 +1,8 @@
+if ENV['coverage']
+  require 'simplecov'
+  SimpleCov.start
+end
+
 require 'minitest/autorun'
 require 'minitest/spec'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bound
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Jakob Holderbaum
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-25 00:00:00.000000000 Z
+date: 2013-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,6 +53,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 5.0.7
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: 
 email:
 - jh@neopoly.de
@@ -92,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.6
 signing_key: 
 specification_version: 4
 summary: Implements a nice helper for fast boundary definitions