bound 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 290d76f9ebce3f1b1b815ecbaac8f7b0320e7a7c
-  data.tar.gz: ea47e2f076c07eeaa1e45e14add1c5fc6683289b
+  metadata.gz: cb1d1bdcd67442312ce8e48fa04a1e202aca15a2
+  data.tar.gz: 1a506e8c642e84938a4f32ae8f97cf2ed579b05b
 SHA512:
-  metadata.gz: d42bb29fd3b7f5285e8278a12a23eb85ed4fd25960445f4d9cebb6f6c66e01e9fd76aa23f229c039004add07d6409e79bc41d21e8734a4454fae78ce7b016d7d
-  data.tar.gz: 269d4c1f5a82337aca2b520e82d614e50aae40183363c157dc30c06d56cfbb12c6bf980f991d0a09eed5010333221d49f89598c7ff68e289f388fdcc674857b7
+  metadata.gz: fa1024912a23354e5bb1ec42ee3518b6b2de5e5e8229eb2182c93f8b69783dc5dfc16e03d0f5da3d6f525ed4472b028f5787952848cc04795728786223df3cf3
+  data.tar.gz: a27f0003a78e6ad4fbc69362cb6da84707c6b5f5887e900cec0eccf0f23879b1bdf6cc393e4b7313c4e7644827e1faee1c42745bcbc0eb455e89f58c1534df5a

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+prof__*

data/.travis.yml

@@ -2,8 +2,7 @@ language: ruby
 rvm:
   - 2.0.0
   - 1.9.3
-  - jruby-18mode # JRuby in 1.8 mode
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx
   - 1.8.7
   - ree
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode

data/Rakefile

@@ -8,6 +8,5 @@ task :default => :spec
 Rake::TestTask.new(:spec) do |test|
   test.test_files = FileList["spec/**/*_spec.rb"]
   test.libs << "spec"
-  test.warning = true
   test.verbose = true
 end

data/benchmark.rb

@@ -2,10 +2,102 @@ $: << 'lib'
 require 'bound'
 require 'benchmark'
 
-TestBoundary = Bound.required(:abc, :def, :ged)
+if ENV['PROFILE']
+  require 'perftools'
+  def start_perf(name)
+    @_perf_name_ = 'prof__' + name
+    PerfTools::CpuProfiler.start @_perf_name_
+  end
+
+  def finish_perf
+    PerfTools::CpuProfiler.stop
+    system "pprof.rb --pdf #@_perf_name_ > #{@_perf_name_}.pdf"
+    system "rm -f ./#{@_perf_name_} ./#{@_perf_name_}.symbols"
+  ensure
+    @_perf_name_ = nil
+  end
+else
+  def start_perf(*);end
+  def finish_perf(*);end
+end
+
+
+
+TestBoundary = Bound.required(
+                              :foo,
+                              :bar => [Bound.required(:abc)],
+                              :baz => Bound.required(:gonzo)
+                             )
+
+StructBoundary = Struct.new(:foo, :bar, :baz)
+BarStructBoundary = Struct.new(:abc)
+BazStructBoundary = Struct.new(:gonzo)
+
+StaticBoundClass = Class.new do
+  def self.initialize_unvalidated
+    class_eval <<-EOR
+      def initialize(target, overwrite = nil)
+        @t, @o = target, overwrite
+      end
+    EOR
+  end
+
+  def self.define_delegate(attr, prefix = '')
+    class_eval <<-EOR
+      def #{prefix}#{attr}
+        return @o[:#{attr}] if @o && @o.key?(:#{attr})
+        @t.kind_of?(Hash)? @t[:#{attr}] : @t.#{attr}
+      end
+    EOR
+  end
+
+  def self.define_nested_delegate(attr, nested_class)
+    define_delegate attr, 'get_'
+    if nested_class.kind_of? Array
+      nested_class = nested_class.first
+      class_eval <<-EOR
+        def #{attr}
+          @#{attr} ||= get_#{attr}.map{|t| #{nested_class}.new t}
+        end
+        private :get_#{attr}
+      EOR
+    else
+      class_eval <<-EOR
+        def #{attr}
+          @#{attr} ||= #{nested_class}.new(get_#{attr})
+        end
+        private :get_#{attr}
+      EOR
+    end
+  end
+end
+
+BarStaticBoundary = Class.new(StaticBoundClass) do
+  initialize_unvalidated
+
+  define_delegate :abc
+end
+
+BazStaticBoundary = Class.new(StaticBoundClass) do
+  initialize_unvalidated
+
+  define_delegate :gonzo
+end
+
+StaticBoundary = Class.new(StaticBoundClass) do
+  initialize_unvalidated
+
+  define_delegate :foo
+  define_nested_delegate :bar, [BarStaticBoundary]
+  define_nested_delegate :baz, BazStaticBoundary
+end
 
-ManualBoundary = Provider = Class.new do
-  attr_accessor :abc, :def, :ged
+def assert_correctness(bound)
+  raise('foo is wrong') unless bound.foo == 'NOPE'
+  raise('bar size is wrong') unless bound.bar.size == 2
+  raise('bar[0] is wrong') unless bound.bar[0].abc == 'TRUE'
+  raise('bar[1] is wrong') unless bound.bar[1].abc == 'FALSE'
+  raise('baz.gonzo is wrong') unless bound.baz.gonzo == 22
 end
 
 def bench(key, &block)
@@ -17,36 +109,119 @@ def bench(key, &block)
   result
 end
 
-providers = 10_000.times.map do |i|
-  provider = Provider.new
-  provider.abc = "abc#{i}"
-  provider.def = "def#{i}"
-  provider.ged = "ged#{i}"
-  provider
+Provider = Class.new do
+  attr_accessor :foo, :bar, :baz
+  BarProvider = Class.new do
+    attr_accessor :abc
+  end
+  BazProvider = Class.new do
+    attr_accessor :gonzo
+  end
+end
+provider_objects = 100_000.times.map do |i|
+  Provider.new.tap do |p|
+    p.foo = 'YES'
+    p.bar = [
+             BarProvider.new.tap do |brp|
+               brp.abc = 'TRUE'
+             end,
+             BarProvider.new.tap do |brp|
+               brp.abc = 'FALSE'
+             end
+            ]
+    p.baz = BazProvider.new.tap do |bzp|
+      bzp.gonzo = 22
+    end
+  end
+end
+
+provider_hashes = 100_000.times.map do |i|
+  {
+   :foo => 'YES',
+   :bar => [{:abc => 'TRUE'}, {:abc => 'FALSE'}],
+   :baz => {:gonzo => 22}
+  }
+end
+
+overwrite = {:foo => 'NOPE'}
+
+
+start_perf 'bound.objt'
+bench '      bound w/ objt' do
+  provider_objects.each do |provider|
+    result = TestBoundary.new(provider, overwrite)
+    assert_correctness result
+  end
+end
+finish_perf
+
+start_perf 'bound.hash'
+bench '      bound w/ hash' do
+  provider_hashes.each do |provider|
+    result = TestBoundary.new(provider, overwrite)
+    assert_correctness result
+  end
+end
+finish_perf
+
+Bound.disable_validation
+
+start_perf 'bound.noval.objt'
+bench 'bound noval w/ objt' do
+  provider_objects.each do |provider|
+    result = TestBoundary.new(provider, overwrite)
+    assert_correctness result
+  end
+end
+finish_perf
+
+start_perf 'bound.noval.hash'
+bench 'bound noval w/ hash' do
+  provider_hashes.each do |provider|
+    result = TestBoundary.new(provider, overwrite)
+    assert_correctness result
+  end
+end
+finish_perf
+
+bench 'staticbound w/ objt' do
+  provider_objects.each do |provider|
+    result = StaticBoundary.new(provider, overwrite)
+    assert_correctness result
+  end
 end
 
-bench 'bound w/ objt' do
-  providers.map do |provider|
-    TestBoundary.new(provider)
+bench 'staticbound w/ hash' do
+  provider_hashes.each do |provider|
+    result = StaticBoundary.new(provider, overwrite)
+    assert_correctness result
   end
 end
 
-bench 'bound w/ hash' do
-  providers.map do |provider|
-    TestBoundary.new({
-      :abc => provider.abc,
-      :def => provider.def,
-      :ged => provider.ged
-    })
+bench 'structbound w/ objt' do
+  provider_objects.each do |provider|
+    result = StructBoundary.new(
+                                overwrite[:foo],
+                                [
+                                 BarStructBoundary.new(provider.bar[0].abc),
+                                 BarStructBoundary.new(provider.bar[1].abc),
+                                ],
+                                BazStructBoundary.new(provider.baz.gonzo)
+                               )
+    assert_correctness result
   end
 end
 
-bench 'plain' do
-  providers.map do |provider|
-    test = ManualBoundary.new
-    test.abc = provider.abc
-    test.def = provider.def
-    test.ged = provider.ged
-    test
+bench 'structbound w/ hash' do
+  provider_hashes.map do |provider|
+    result = StructBoundary.new(
+                                overwrite[:foo],
+                                [
+                                 BarStructBoundary.new(provider[:bar][0][:abc]),
+                                 BarStructBoundary.new(provider[:bar][1][:abc]),
+                                ],
+                                BazStructBoundary.new(provider[:baz][:gonzo])
+                               )
+    assert_correctness result
   end
 end

data/bound.gemspec

@@ -20,6 +20,7 @@ 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 "perftools.rb"
 
   spec.add_development_dependency "simplecov" 
 end

data/lib/bound.rb

@@ -14,292 +14,300 @@ class Bound
     new_bound_class.required(*args)
   end
 
+  def self.validate?
+    !@validation_disabled
+  end
+
+  def self.disable_validation
+    @validation_disabled = true
+    StaticBoundClass.define_initializer_without_validation
+  end
+
   private
 
   def self.new_bound_class
-    Class.new(BoundClass) do
-      initialize_values
+    Class.new(StaticBoundClass) do
     end
   end
 
-  class BoundClass
-    class Attribute
-      attr_reader :name, :value
-      attr_accessor :nested_class
-
-      def initialize(name)
-        @name = name
-        @assigned = false
-      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)
-        Caller.call(object, @name)
-      end
+  class BoundValidator
+    attr_accessor :attributes, :optional_attributes, :nested_array_attributes
 
-      def valid?
-        !required? || is_assigned?
-      end
-
-      def required?
-        false
-      end
+    def initialize(target, overwrite)
+      @target = target
+      @overwrite = overwrite
+    end
 
-      def is_assigned?
-        !!@assigned
+    def validate!
+      ensure_all_attributes_are_known!
+      attributes.each do |attribute|
+        ensure_present! attribute
       end
-
-      def inspect
-        @value.inspect
+      nested_array_attributes.each do |nested_array_attribute|
+        ensure_array! nested_array_attribute
       end
     end
 
-    class RequiredAttribute < Attribute
-      def required?; true; end
-    end
+    private
 
-    class NestedAttribute
-      def initialize(bound_definition)
-        if bound_definition.kind_of?(Array)
-          @assigner = ArrayAssigner.new(bound_definition)
-        else
-          @assigner = ValueAssigner.new(bound_definition)
+    def ensure_all_attributes_are_known!
+      (overwritten_attrs + target_attrs).each do |attr|
+        unless (attributes + optional_attributes).include? attr
+          message = "Unknown attribute: #{attr}"
+          raise ArgumentError, message
         end
       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
+    def ensure_present!(attribute)
+      if !overwritten?(attribute) && !target_has?(attribute)
+        message = "Missing attribute: #{attribute}"
+        raise ArgumentError, message
       end
+    end
 
-      class ValueAssigner
-        def initialize(definition)
-          @bound_class = definition
+    def ensure_array!(attribute)
+      message = "Expected %s to be an array"
+      if overwritten?(attribute)
+        unless val = overwritten(attribute).kind_of?(Array)
+          raise(ArgumentError, message % val.inspect)
         end
-
-        def resolve(arguments)
-          @bound_class.new(arguments)
+      elsif target_has?(attribute)
+        unless val = target(attribute).kind_of?(Array)
+          raise(ArgumentError, message % val.inspect)
         end
+      else
       end
     end
 
-
-    class << self
-      attr_accessor :attrs, :nested_attr_classes
-
-      def initialize_values
-        self.attrs = {}
-        self.nested_attr_classes = {}
+    def overwritten_attrs
+      if @overwrite
+        @overwrite.keys
+      else
+        []
       end
+    end
 
-      def optional(*attributes)
-        if attributes.last.kind_of? Hash
-          nested_attributes = attributes.pop
-        else
-          nested_attributes = {}
-        end
-
-        set_attributes :optional, attributes, nested_attributes
-
-        self
+    def target_attrs
+      if @target && @target.kind_of?(Hash)
+        @target.keys
+      else
+        []
       end
+    end
 
-      def required(*attributes)
-        if attributes.last.kind_of? Hash
-          nested_attributes = attributes.pop
-        else
-          nested_attributes = {}
-        end
+    def overwritten?(attr)
+      @overwrite && @overwrite.key?(attr)
+    end
 
-        set_attributes :required, attributes, nested_attributes
+    def overwritten(attr)
+      @overwrite && @overwrite[attr]
+    end
 
-        self
-      end
+    def target_has?(attr)
+      @target &&
+        @target.kind_of?(Hash)?@target.key?(attr):@target.respond_to?(attr)
+    end
 
-      private
+    def target(attr)
+      @target &&
+        @target.kind_of?(Hash)?@target[attr]:@target.send(attr)
+    end
+  end
 
-      def set_attributes(flag, attributes, nested_attributes = {})
-        is_optional = flag == :optional
+  class StaticBoundClass
+    def ==(other)
+      false unless other
+      true
+    end
 
-        if attributes.any? { |a| !a.kind_of? Symbol }
-          raise ArgumentError.new("Invalid list of attributes: #{attributes.inspect}")
-        end
+    def validate!
+    end
 
-        attribute_class = if is_optional
-                            Attribute
-                          else
-                            RequiredAttribute
-                          end
+    def self.define_initializer_without_validation
+      define_initializer(nil)
+    end
 
-        attributes.each do |attribute|
-          self.attrs[attribute] = attribute_class
+    def self.define_initializer(after_init = 'validate!')
+      code = <<-EOR
+        def initialize(target = nil, overwrite = nil)
+          @t, @o = target, overwrite
+          %s
         end
+      EOR
+      if after_init
+        code = code % " #{after_init}"
+      else
+        code = code % ''
+      end
 
-        define_attribute_accessors attributes
+      class_eval code
+    end
 
-        if nested_attributes.any?
-          set_attributes flag, nested_attributes.keys
-          nested_attributes.each do |attribute_name, nested_class|
-            self.nested_attr_classes[attribute_name] = nested_class
-          end
-        end
+    def self.define_attributes(*attributes)
+      if attributes.last.kind_of? Hash
+        nested_attributes = attributes.pop
+      else
+        nested_attributes = {}
       end
 
-      def define_attribute_accessors(attributes)
-        define_attribute_readers attributes
-        define_attribute_writers attributes
+      if nested_attributes.keys.any? { |a| !a.kind_of? Symbol }
+        message = "Invalid list of attributes: #{nested_attributes.inspect}"
+        raise ArgumentError, message
       end
 
-      def define_attribute_readers(attributes)
-        attributes.each do |attribute|
-          define_method attribute do
-            get_attribute(attribute).value
-          end
-        end
+      if attributes.any? { |a| !a.kind_of? Symbol }
+        message = "Invalid list of attributes: #{attributes.inspect}"
+        raise ArgumentError, message
       end
 
-      def define_attribute_writers(attributes)
-        attributes.each do |attribute|
-          define_method :"#{attribute}=" do |value|
-            get_attribute(attribute).assign value
-          end
-        end
+      nested_attributes.each do |attribute, nested_class|
+        define_nested_delegate attribute, nested_class
+        define_equality attribute
       end
-    end
-
-    def initialize(seed = nil, overwrite = nil)
-      @attributes = {}
-      raise('Overwrite with object') if overwrite && !overwrite.kind_of?(Hash)
-      seed_with overwrite if overwrite
-      seed_with seed if seed
-      validate!
-    end
-
-    def method_missing(meth, *args, &blk)
-      attribute = meth.to_s.gsub(/=$/, '')
-      raise ArgumentError.new("Unknown attribute: #{self.class}##{attribute}")
-    end
 
-    def get_attributes
-      self.class.attrs.keys.map do |attribute_name|
-        get_attribute(attribute_name)
+      attributes.each do |attribute|
+        define_delegate attribute
+        define_equality attribute
       end
     end
 
-    def has_attribute?(attr)
-      self.class.attrs.keys.include? attr
+    def self.define_validator
+      attributes = (@attributes || []).map do |attr|
+        ":#{attr.to_s}"
+      end.join(',')
+      optional_attributes = (@optional_attributes || []).map do |attr|
+        ":#{attr.to_s}"
+      end.join(',')
+      nested_array_attributes = (@nested_array_attributes || []).map do |attr|
+        ":#{attr.to_s}"
+      end.join(',')
+      code = <<-EOR
+        def validate!
+          v = Bound::BoundValidator.new(@t, @o)
+          v.attributes = [#{attributes}]
+          v.optional_attributes = [#{optional_attributes}]
+          v.nested_array_attributes = [#{nested_array_attributes}]
+          v.validate!
+        end
+        private :validate!
+      EOR
+      class_eval code
     end
 
-    def __attributes__
-      puts "BoundClass#__attributes__ is deprecated: use get_attributes"
-      get_attributes.map(&:name)
+    def self.set_required_attributes(attributes, nested_array_attributes)
+      @attributes ||= []
+      @attributes += attributes
+      @attributes += nested_array_attributes
+      @nested_array_attributes ||= []
+      @nested_array_attributes += nested_array_attributes
+      define_validator
     end
 
-    def get_attribute(attribute_name)
-      return @attributes[attribute_name] if @attributes.has_key? attribute_name
-
-      attribute_class = self.class.attrs[attribute_name]
-      return nil if attribute_class.nil?
-
-      nested_class = self.class.nested_attr_classes[attribute_name]
-
-      attribute = attribute_class.new(attribute_name)
-      attribute.nested_class = nested_class
-
-      @attributes[attribute_name] = attribute
+    def self.set_optional_attributes(attributes, nested_array_attributes)
+      @optional_attributes ||= []
+      @optional_attributes += attributes
+      @optional_attributes += nested_array_attributes
+      @nested_array_attributes ||= []
+      @nested_array_attributes += nested_array_attributes
+      define_validator
     end
 
-    def ==(other)
-      return false unless other
-
-      get_attributes.all? do |attribute|
-        attribute.value == Caller.call(other, attribute.name)
-      end
+    def self.define_equality(attr)
+      @equality ||= []
+      @equality << attr
+      code = <<-EOR
+        def==(other)
+          return false unless other
+          %w{#{@equality.join(' ')}}.all? do |attr|
+            other.respond_to?(attr) &&
+              other.send(attr) == send(attr)
+          end
+        end
+      EOR
+      class_eval code
     end
 
-    private
-
-    def validate!
-      get_attributes.each do |attribute|
-        raise ArgumentError.new("Missing attribute: #{self.class}##{attribute.name}") unless attribute.valid?
-      end
+    def self.define_delegate(attr, prefix = '')
+      code = <<-EOR
+        def #{prefix}#{attr}
+          return @o[:#{attr}] if @o && @o.key?(:#{attr})
+          return @t.kind_of?(Hash)? @t[:#{attr}] : @t.#{attr} if @t
+          nil
+        end
+      EOR
+      class_eval code
     end
 
-    def seed_with(seed)
-      case seed
-      when Hash
-        seeder = HashSeeder.new(self)
+    def self.define_nested_delegate(attr, nested_class)
+      define_delegate attr, 'get_'
+      code = <<-EOR
+        class << self
+          def get_#{attr}_class
+            @#{attr}_class
+          end
+          def set_#{attr}_class(arg)
+            @#{attr}_class = arg
+          end
+          private :set_#{attr}_class
+        end
+      EOR
+
+      if nested_class.kind_of? Array
+        nested_class = nested_class.first
+        code += <<-EOR
+          def #{attr}
+            return @#{attr} if defined? @#{attr}
+            return [] unless val = get_#{attr}
+            @#{attr} ||= val.map{|t| self.class.get_#{attr}_class.new t}
+          end
+          private :get_#{attr}
+        EOR
       else
-        seeder = ObjectSeeder.new(self)
+        code += <<-EOR
+          def #{attr}
+            return @#{attr} if defined? @#{attr}
+            return nil unless val = get_#{attr}
+            @#{attr} ||= self.class.get_#{attr}_class.new(val)
+          end
+          private :get_#{attr}
+        EOR
       end
-
-      seeder.seed(seed)
-    end
-  end
-
-  class HashSeeder
-    def initialize(receiver)
-      @receiver = receiver
+      class_eval code
+      self.send :"set_#{attr}_class", nested_class
     end
 
-    def seed(hash)
-      hash.each do |key, value|
-        attribute = @receiver.get_attribute(key)
-        next if attribute && attribute.is_assigned?
+    def self.required(*attributes)
+      self.define_attributes(*attributes)
 
-        method = "#{key}="
-        @receiver.send method, value
+      array_attributes = []
+      if attributes.last.kind_of? Hash
+        attributes.pop.each do |attr, nested_class|
+          array_attributes << attr if nested_class.kind_of? Array
+          attributes << attr
+        end
       end
-    end
-  end
 
-  class ObjectSeeder
-    def initialize(receiver)
-      @receiver = receiver
+      self.set_required_attributes(attributes, array_attributes)
+      self
     end
 
-    def seed(object)
-      @receiver.get_attributes.each do |attribute|
-        next if attribute.is_assigned?
+    def self.optional(*attributes)
+      self.define_attributes(*attributes)
 
-        begin
-          value = attribute.call_on(object)
-          assign_to_receiver attribute, value
-        rescue NoMethodError
+      array_attributes = []
+      if attributes.last.kind_of? Hash
+        attributes.pop.each do |attr, nested_class|
+          array_attributes << attr if nested_class.kind_of? Array
+          attributes << attr
         end
       end
-    end
 
-    private
-    def assign_to_receiver(attribute, value)
-      method = "#{attribute.name}="
-      @receiver.send(method, value)
+      self.set_optional_attributes(attributes, array_attributes)
+      self
     end
 
+    define_initializer
   end
+
 end

data/lib/bound/version.rb

@@ -1,3 +1,3 @@
 class Bound
-  VERSION = "1.1.1"
+  VERSION = "2.0.0"
 end

data/spec/bound_spec.rb

@@ -15,15 +15,6 @@ describe Bound do
     end
   end
 
-  it 'checks if attribute exists' do
-    [hash, object].each do |subject|
-      user = User.new(subject)
-
-      assert user.has_attribute?(:name)
-      assert user.has_attribute?(:age)
-    end
-  end
-
   it 'fails if attribute is missing' do
     hash.delete :age
 
@@ -55,14 +46,6 @@ describe Bound do
     assert_match(/unknown.+gender/i, exception.message)
   end
 
-  it 'exposes an attributes method' do
-    user = User.new(hash)
-
-    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 'equality' do
     let(:user) { User.new(hash) }
 
@@ -145,14 +128,6 @@ describe Bound do
         UserWithoutAge.new(subject)
       end
     end
-
-    it 'are also included in attributes' do
-      user = UserWithoutAge.new(hash)
-
-      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
 
   describe 'optional nested attributes' do
@@ -183,14 +158,6 @@ describe Bound do
         UserWithProfile.new(subject)
       end
     end
-
-    it 'are also included in attributes' do
-      user = UserWithProfile.new(hash)
-
-      assert_equal 2, user.get_attributes.size
-      assert_includes user.get_attributes.map(&:name), :id
-      assert_includes user.get_attributes.map(&:name), :profile
-    end
   end
 
   describe 'no attributes' do
@@ -273,14 +240,6 @@ describe Bound do
       end
 
     end
-
-    it 'are also included in attributes' do
-      user = BloggingUser.new(hash)
-
-      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
 
   describe 'allows optional as constructor' do
@@ -301,20 +260,6 @@ describe Bound do
     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
-
   describe 'questionmark suffix' do
     WonderingUser = Bound.required(:asked?)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bound
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Jakob Holderbaum
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-08 00:00:00.000000000 Z
+date: 2014-05-23 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: perftools.rb
+  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'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -111,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Implements a nice helper for fast boundary definitions