attributed_object 0.2.1

data/spec/attributed_object/strict_spec.rb

@@ -0,0 +1,129 @@
+require 'attributed_object'
+
+describe AttributedObject::Strict do
+  class SimpleFoo
+    include AttributedObject::Strict
+    attribute :bar
+  end
+
+  class TypedFoo
+    include AttributedObject::Strict
+    attribute :a_string, :string, default: 'its a string'
+    attribute :a_boolean, :boolean, default: false
+    attribute :a_integer, :integer, default: 77
+    attribute :a_float, :float, default: 98.12
+    attribute :a_numeric, :numeric, default: 12.12
+    attribute :a_symbol, :symbol, default: :some_default_symbol
+    attribute :a_string_by_class, String, default: 'some default string'
+    attribute :another_class, SimpleFoo, default: nil
+    attribute :a_array, :array, default: nil
+    attribute :a_array_of, ArrayOf(:integer), default: nil
+    attribute :a_hash, :hash, default: nil
+    attribute :a_hash_of, HashOf(:string, :integer), default: nil
+  end
+
+  class TypedFooWithOption
+    include AttributedObject::Strict
+    attributed_object type_check: :strict
+    attribute :a_string, :string, default: 'its a string'
+  end
+
+  it 'can be set with option' do
+    expect { TypedFooWithOption.new(a_string: :its_a_symbol) }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'can handle primitive ruby types' do
+    f = TypedFoo.new(
+      a_boolean: true,
+      a_integer: 12,
+      a_float: 42.7,
+      a_numeric: 35.9,
+      a_symbol: :my_symbol,
+      a_string_by_class: 'my class string check',
+      another_class: SimpleFoo.new(bar: 'hi'),
+      a_array: ['1'],
+      a_array_of: [1],
+      a_hash: {foo: 'bar'},
+      a_hash_of: { 'hello' => 1 },
+    )
+
+    expect(f.a_string).to eq('its a string')
+    expect(f.a_boolean).to eq(true)
+    expect(f.a_integer).to eq(12)
+    expect(f.a_float).to eq(42.7)
+    expect(f.a_numeric).to eq(35.9)
+    expect(f.a_symbol).to eq(:my_symbol)
+    expect(f.a_string_by_class).to eq('my class string check')
+    expect(f.another_class).to eq(SimpleFoo.new(bar: 'hi'))
+    expect(f.a_array).to eq(['1'])
+    expect(f.a_array_of).to eq([1])
+    expect(f.a_hash).to eq({foo: 'bar'})
+    expect(f.a_hash_of).to eq({'hello' => 1})
+  end
+
+  it 'raises error on non-string' do
+    expect { TypedFoo.new(a_string: :its_a_symbol) }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on non-bool' do
+    expect { TypedFoo.new(a_boolean: 42) }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on non-integer' do
+    expect { TypedFoo.new(a_integer: '42') }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on non-float' do
+    expect { TypedFoo.new(a_float: 42) }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on non-symbol' do
+    expect { TypedFoo.new(a_symbol: 'its a string') }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on non-numeric' do
+    expect { TypedFoo.new(a_numeric: 'its a string') }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on non-strings when string is defined by class' do
+    expect { TypedFoo.new(a_string_by_class: 42) }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on non SimpleFoos' do
+    expect { TypedFoo.new(another_class: 42) }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on non-array' do
+    expect { TypedFoo.new(a_array: 'its a string') }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on array with wrong contents' do
+    expect { TypedFoo.new(a_array_of: 'its a string') }.to raise_error(AttributedObject::TypeError)
+    expect { TypedFoo.new(a_array_of: ['its a string']) }.to raise_error(AttributedObject::TypeError)
+    expect { TypedFoo.new(a_array_of: [1]) }.not_to raise_error
+  end
+
+  it 'raises error on non-hash' do
+    expect { TypedFoo.new(a_hash: 'its a string') }.to raise_error(AttributedObject::TypeError)
+  end
+
+  it 'raises error on hash with wrong contents' do
+    expect { TypedFoo.new(a_hash_of: 'its a string') }.to raise_error(AttributedObject::TypeError)
+    expect { TypedFoo.new(a_hash_of: { 'foo' => '1' }) }.to raise_error(AttributedObject::TypeError)
+    expect { TypedFoo.new(a_hash_of: { 1 => 1 }) }.to raise_error(AttributedObject::TypeError)
+    expect { TypedFoo.new(a_hash_of: { 'foo' => 1 }) }.not_to raise_error
+  end
+
+  it 'raises no errors for nil values' do
+    expect { TypedFoo.new(a_string: nil) }.not_to raise_error
+  end
+
+  it 'raises on unknown type' do
+    expect do
+      class Miau
+        include AttributedObject::Strict
+        attribute :something, :does_not_exist
+      end
+    end.to raise_error(AttributedObject::ConfigurationError)
+  end
+end

data/spec/attributed_object_spec.rb

@@ -0,0 +1,228 @@
+require 'attributed_object'
+
+describe AttributedObject do
+  class SimpleFoo
+    include AttributedObject::Strict
+    attribute :bar
+  end
+
+  class DisallowingNil
+    include AttributedObject::Strict
+    attribute :bar, disallow: nil
+  end
+
+  class DefaultFoo
+    include AttributedObject::Strict
+    attribute :bar, default: "my default"
+    attribute :dynamic, default: -> { count }
+
+    def self.reset
+      @count = 0
+    end
+
+    def self.count
+      @count ||= 0
+      @count += 1
+    end
+  end
+
+  class ChildFoo < DefaultFoo
+    attribute :lollipop, default: "lecker"
+  end
+
+  it 'requires attributes by default' do
+    expect { SimpleFoo.new }.to raise_error(AttributedObject::MissingAttributeError)
+    expect(SimpleFoo.new(bar: 1).bar).to eq(1)
+  end
+
+  describe 'nil control' do
+    it 'allows explicit nil values' do
+      expect(SimpleFoo.new(bar: nil).bar).to eq(nil)
+    end
+
+    it 'can be controlled to not allow explicit nil' do
+      expect { DisallowingNil.new(bar: nil).bar }.to raise_error(AttributedObject::DisallowedValueError)
+    end
+  end
+
+  describe 'default value' do
+    before { DefaultFoo.reset }
+
+    it 'can specify a default value' do
+      expect(DefaultFoo.new.bar).to eq("my default")
+      expect(DefaultFoo.new(bar: 'other').bar).to eq("other")
+    end
+
+    it 'can specify a lambda as default value' do
+      expect(DefaultFoo.new.dynamic).to eq(1)
+      expect(DefaultFoo.new.dynamic).to eq(2)
+    end
+  end
+
+  describe 'extra_options' do
+    context 'inheritance' do
+      it 'is passed to the children' do
+        class Papa
+          include AttributedObject::Strict
+          attributed_object default_to: nil
+
+          attribute :foo
+          attribute :bar, default: 'hi'
+        end
+
+        class Sohn < Papa
+          attribute :something_else
+        end
+
+        expect(Sohn.new.something_else).to eq(nil)
+        expect(Sohn.new.bar).to eq('hi')
+      end
+    end
+
+    describe 'default_to' do
+      it 'allows changing default for all fields' do
+        class Defaulting
+          include AttributedObject::Strict
+          attributed_object default_to: nil
+
+          attribute :foo
+          attribute :bar, default: 'hi'
+        end
+
+        expect(Defaulting.new.foo).to eq(nil)
+        expect(Defaulting.new.bar).to eq('hi')
+      end
+
+      it 'allows type defaulting' do
+        class TypeDefaulting
+          include AttributedObject::Strict
+          attributed_object default_to: AttributedObject::TypeDefaults.new
+
+          attribute :a_string, :string
+          attribute :a_boolean, :boolean
+          attribute :a_integer, :integer
+          attribute :a_float, :float
+          attribute :a_numeric, :numeric
+          attribute :a_symbol, :symbol
+          attribute :a_string_by_class, String
+          attribute :another_class, SimpleFoo
+          attribute :a_array, :array
+          attribute :a_hash, :hash
+          attribute :something_with_default, :string, default: 'foobar'
+          attribute :something_without_type
+        end
+
+        expect(TypeDefaulting.new.a_string).to eq('')
+        expect(TypeDefaulting.new.a_boolean).to eq(false)
+        expect(TypeDefaulting.new.a_integer).to eq(0)
+        expect(TypeDefaulting.new.a_float).to eq(0.0)
+        expect(TypeDefaulting.new.a_numeric).to eq(0)
+        expect(TypeDefaulting.new.a_symbol).to eq(nil)
+        expect(TypeDefaulting.new.a_string_by_class).to eq(nil)
+        expect(TypeDefaulting.new.another_class).to eq(nil)
+        expect(TypeDefaulting.new.a_array).to eq([])
+        expect(TypeDefaulting.new.a_hash).to eq({})
+        expect(TypeDefaulting.new.something_with_default).to eq('foobar')
+        expect(TypeDefaulting.new.something_without_type).to eq(nil)
+      end
+
+      it 'is possible to overwrite and add type defaults' do
+        class TypeDefaultingOverwrites
+          include AttributedObject::Strict
+          attributed_object default_to: AttributedObject::TypeDefaults.new(
+            :string => 'my_default_string',
+            SimpleFoo => SimpleFoo.new(bar: 'kekse')
+          )
+
+          attribute :a_string, :string
+          attribute :a_integer, :integer
+          attribute :foo, SimpleFoo
+        end
+
+        expect(TypeDefaultingOverwrites.new.a_string).to eq('my_default_string')
+        expect(TypeDefaulting.new.a_integer).to eq(0)
+        expect(TypeDefaultingOverwrites.new.foo).to eq(SimpleFoo.new(bar: 'kekse'))
+      end
+    end
+
+    describe 'ignore_extra_keys' do
+      it 'allows extra_keys' do
+        class FooWithExtra
+          include AttributedObject::Strict
+          attributed_object ignore_extra_keys: true
+          attribute :bar, :integer
+        end
+
+        expect { FooWithExtra.new(bar: 12, not_defined: 'asd') }.not_to raise_error
+        expect(FooWithExtra.new(bar: 12, not_defined: 'asd').attributes).to eq(bar: 12)
+      end
+    end
+  end
+
+  it 'throws an error for unknown attributes' do
+    expect { SimpleFoo.new(whatever: 'xxx') }.to raise_error(AttributedObject::UnknownAttributeError)
+  end
+
+  it 'inherits the attributes from its superclass' do
+    f = ChildFoo.new
+    expect(f.bar).to eq("my default")
+    expect(f.lollipop).to eq("lecker")
+  end
+
+  it 'does not modify the args' do
+    args = {bar: "asd"}
+    f = SimpleFoo.new(args)
+    f.bar = 'different'
+    expect(f.bar).to eq('different')
+    expect(args[:bar]).to eq('asd')
+  end
+
+  describe '#==' do
+    it 'is equals for same attributes' do
+      expect(SimpleFoo.new(bar: 12)).to eq(SimpleFoo.new(bar: 12))
+    end
+
+    it 'is not equal for different attributes' do
+      expect(SimpleFoo.new(bar: 77)).to_not eq(SimpleFoo.new(bar: 12))
+    end
+  end
+  
+  describe 'attribute storage' do
+    class InnerStructureFoo
+      include AttributedObject::Coerce
+      attribute :bar, :string, default: 'default'
+      attribute :foo, :string, default: 'default'
+      attribute :number, :integer, default: 0
+      
+      def foo=(f)
+        @foo = "prefix-#{f}-suffix"
+      end
+      
+      def number=(n)
+        @number = n+1
+      end
+    end
+    
+    describe '#attributes' do
+      it 'returns the attributes as hash' do
+        expect(InnerStructureFoo.new(bar: 'hi').attributes).to eq(
+          bar: 'hi',
+          foo: 'prefix-default-suffix',
+          number: 1
+        )
+      end
+    end
+    
+    it 'stores the data in instance vars' do
+      expect(InnerStructureFoo.new(bar: 'hi').instance_variable_get('@bar')).to eq('hi')
+    end
+    
+    it 'uses setters' do
+      expect(InnerStructureFoo.new(foo: 'middel').foo).to eq('prefix-middel-suffix')
+    end
+    
+    it 'uses setters after coercion' do
+      expect(InnerStructureFoo.new(number: '42').number).to eq(43)
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: attributed_object
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Jaap Groeneveld
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: Simple and fast module for named arguments in model initializers
+email:
+- jgroeneveld@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- attributed_object.gemspec
+- benchmark_attributed_object.rb
+- lib/attributed_object.rb
+- lib/attributed_object/base.rb
+- lib/attributed_object/coerce.rb
+- lib/attributed_object/strict.rb
+- lib/attributed_object/type.rb
+- lib/attributed_object/types/array_of.rb
+- lib/attributed_object/types/hash_of.rb
+- lib/attributed_object/version.rb
+- lib/attributed_object_helpers/hash_util.rb
+- lib/attributed_object_helpers/type_check.rb
+- lib/attributed_object_helpers/type_coerce.rb
+- spec/attributed_object/coerce_spec.rb
+- spec/attributed_object/strict_spec.rb
+- spec/attributed_object_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Simple and fast module for named arguments in model initializers
+test_files:
+- spec/attributed_object/coerce_spec.rb
+- spec/attributed_object/strict_spec.rb
+- spec/attributed_object_spec.rb