attributed_object 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 56c23aeb644434fb80ca843707575c2ca7d0ca43
+  data.tar.gz: 2d53c23bed6cd5ad8672dafd1259540b06005f30
+SHA512:
+  metadata.gz: 75886da44a0f01840c505f8b0802efbc26f22cf3dd6bef8357dd8001afb9b241d53640652c9d88a99737c9fe7e3f2b0cb590c080fede5cfa7ce676009ce9e8d8
+  data.tar.gz: 95f1d048ab42905178e3536957933c18cfedee6eca3ca458b40b9aa71b4e51b7219cf9a89e4674f3194211bab3692bfdb34383900027c32972eaf64ede5603b1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+.ruby-version

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jg.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jaap Groeneveld
+
+MIT License
+
+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.md

@@ -0,0 +1,222 @@
+# AttributedObject
+
+AttributedObject gives easy, dependency free attributes to objects making sure the interface is clean.
+It behaves largely like named arguments. Its possible to have disallowed values (usecase: `disallow: nil`), simple, strict typechecking, default values
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'attributed_object'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install attributed_object
+
+## Usage
+
+### Basic Usage and Errors
+```ruby
+require 'attributed_object'
+
+class MyAttributedObject
+  include AttributedObject::Strict
+
+  attribute :first
+  attribute :second, disallow: nil
+  attribute :third, default: "my default"
+  attribute :forth, default: ->{ Time.now }
+end
+
+# This works
+MyAttributedObject.new(
+  first:  'value',
+  second: 'value',
+  third:  'value',
+  forth:  'value'
+)
+
+# Throws DisallowedValueError
+MyAttributedObject.new(
+  first:  'value',
+  second: nil,
+  third:  'value',
+  forth:  'value'
+)
+
+# Throws MissingAttributeError
+MyAttributedObject.new(
+  second: 'value',
+  third:  'value',
+  forth:  'value'
+)
+
+# Throws UnknownAttributeError
+MyAttributedObject.new(
+  something_unknown: 'value',
+  first:             'value',
+  second:            'value',
+  third:             'value',
+  forth:             'value'
+)
+```
+
+### Equality
+```ruby
+SimpleFoo.new(bar: 12) == SimpleFoo.new(bar: 12)
+```
+
+### Strict Type Checking
+```ruby
+class MyTypedAttributedObject
+  include AttributedObject::Strict
+
+  attribute :first, :string, disallow: nil
+  attribute :second, MyAttributedObject, default: nil 
+end
+
+# Works
+
+MyTypedAttributedObject.new(
+  first: 'hello world',
+  second: MyAttributedObject.new(
+    first:  'value',
+    second: 'value',
+    third:  'value',
+    forth:  'value'
+  )
+)
+
+# Throws TypeError
+
+MyTypedAttributedObject.new(
+  first: 12,
+  second: MyAttributedObject.new(
+    first:  'value',
+    second: 'value',
+    third:  'value',
+    forth:  'value'
+  )
+)
+
+# Supported Types: 
+# :string
+# :boolean
+# :integer
+# :float
+# :numeric
+# :symbol
+# :array
+# :hash
+# ArrayOf(:integer)
+# HashOf(:symbol, :string)
+# Instances of AttributedObject::Type (example: lib/attributed_object/types/array_of.rb)
+# any Class 
+```
+
+## Coercion
+Instead of raising error when the wrong type is passed, AttributedObject can be configured to use a simple coercion mechanim.
+An example use case is the boundary to web forms.
+
+It is also possible to coerce into AttributedObject Structures.
+
+For custom coercion see AttributedObject::Type (example: lib/attributed_object/types/array_of.rb)
+
+```ruby
+class Coercable
+  include AttributedObject::Coerce
+
+  attribute :foo, :integer
+end
+Coercable.new(foo: '1').foo # => 1
+```
+
+Example Form Object
+```ruby
+class FormObject
+  include ActiveModel::Model # for validations
+  include AttributedObject::Coerce # for attributes
+  attributed_object(
+    default_to: AttributedObject::TypeDefaults.new, # or default_to: nil if you want to more AR like behavior
+    coerce_blanks_to_nil: true # this might be interesting if you dont want to have fields set with values when nothing was entered
+  )
+end
+```
+
+## Extra Options
+
+```ruby
+# defaults:
+{
+    default_to: AttributedObject::Unset, # AttributedObject::Unset | any value | AttributedObject::TypeDefaults
+    ignore_extra_keys: false, # false | true
+    coerce_blanks_to_nil: false, # false | true
+}
+```
+
+### default_to: nil
+If you want to be able to initialze an AttributedObject without any params, you can change the general default for all fields.
+This also can be set to an instance of AttributedObject::TypeDefaults
+```ruby
+class Defaulting
+  include AttributedObject::Strict
+  attributed_object default_to: nil
+
+  attribute :foo 
+end
+Defaulting.new.foo # => nil
+
+class TypeDefaulting
+  include AttributedObject::Strict
+  attributed_object default_to: AttributedObject::TypeDefaults.new
+
+  attribute :a_string, :string
+  attribute :a_integer, :integer
+  attrobite :a_class, SimpleFoo
+end
+TypeDefaulting.new.a_string # => ''
+TypeDefaulting.new.a_integer # => 0
+TypeDefaulting.new.a_class # => nil
+
+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
+
+TypeDefaultingOverwrites.new.a_string # => 'my_default_string'
+TypeDefaultingOverwrites.new.a_integer # => 0
+TypeDefaultingOverwrites.new.foo # => SimpleFoo.new(bar: 'kekse')
+```
+
+### ignore_extra_keys: true
+```ruby
+class WithExtraOptions
+  include AttributedObject::Strict
+  attributed_object ignore_extra_keys: true
+
+  attribute :foo 
+end
+WithExtraOptions.new(foo: 'asd', something: 'bar') # this will not throw an error, usually it would
+```
+
+### coerce_blanks_to_nil: true
+This will cause blank strings to equal nil after coercion for all non-string types.
+For example an integer will not become '' => 0, but instead '' => nil.
+
+## Benchmark
+
+Of course the other gems can do quite a bit more, but this is interesting anyway.
+(see benchmark_attributed_object.rb)
+Result: Attributed Object is quite a bit fast (2-3x) than other gems for the specific use cases.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/attributed_object.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'attributed_object/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "attributed_object"
+  spec.version       = AttributedObject::VERSION
+  spec.authors       = ["Jaap Groeneveld"]
+  spec.email         = ["jgroeneveld@me.com"]
+  spec.summary       = %q{Simple and fast module for named arguments in model initializers}
+  spec.description   = %q{Simple and fast module for named arguments in model initializers}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/benchmark_attributed_object.rb

@@ -0,0 +1,108 @@
+require 'benchmark'
+# require 'virtus'
+# require 'dry/types'
+require 'attributed_object'
+
+# class VirtusValue
+#   include Virtus.value_object
+#
+#   values do
+#     attribute :id, Integer
+#     attribute :claimed, Boolean
+#     attribute :pro_coach, Boolean
+#     attribute :url, String
+#   end
+# end
+#
+# class VirtusModel
+#   include Virtus.model(:strict => true)
+#
+#   attribute :id, Integer
+#   attribute :claimed, Boolean
+#   attribute :pro_coach, Boolean
+#   attribute :url, String
+# end
+#
+class AttrObj
+  include AttributedObject::Strict
+
+  attribute :id, :integer, disallow: nil
+  attribute :claimed, :boolean, disallow: nil
+  attribute :pro_coach, :boolean, disallow: nil
+  attribute :url, :string, disallow: nil
+end
+
+class AttrObjCoerce
+  include AttributedObject::Coerce
+
+  attribute :id, :integer, disallow: nil
+  attribute :claimed, :boolean, disallow: nil
+  attribute :pro_coach, :boolean, disallow: nil
+  attribute :url, :string, disallow: nil
+end
+#
+# class DryValue < Dry::Types::Value
+#   attribute :id, 'strict.int'
+#   attribute :claimed, "strict.bool"
+#   attribute :pro_coach, "strict.bool"
+#   attribute :url, "strict.string"
+# end
+
+class Poro
+  attr_reader :id
+  attr_reader :claimed
+  attr_reader :pro_coach
+  attr_reader :url
+
+  def initialize(id:, claimed:, pro_coach:, url:)
+    @id = id
+    @claimed = claimed
+    @pro_coach = pro_coach
+    @url = url
+  end
+end
+
+iterations = 10_000
+Benchmark.bm(27) do |bm|
+  # bm.report('Virtus Value') do
+  #   iterations.times do
+  #     VirtusValue.new(id: 1, claimed: true, pro_coach: true, url: 'http://google.de')
+  #   end
+  # end
+  #
+  # bm.report('DryValue') do
+  #   iterations.times do
+  #     DryValue.new(id: 1, claimed: true, pro_coach: true, url: 'http://google.de')
+  #   end
+  # end
+  #
+  # bm.report('Virtus Model') do
+  #   iterations.times do
+  #     VirtusModel.new(id: 1, claimed: true, pro_coach: true, url: 'http://google.de')
+  #   end
+  # end
+
+  bm.report('AttributedObject') do
+    iterations.times do
+      AttrObj.new(id: 1, claimed: true, pro_coach: true, url: 'http://google.de')
+    end
+  end
+
+  bm.report('AttributedObjectCoerce Match') do
+    iterations.times do
+      AttrObjCoerce.new(id: 1, claimed: true, pro_coach: true, url: 'http://google.de')
+    end
+  end
+
+  bm.report('AttributedObjectCoerce All Strings') do
+    iterations.times do
+      AttrObjCoerce.new(id: '1', claimed: '1', pro_coach: 'true', url: 'http://google.de')
+    end
+  end
+
+  bm.report('Poro') do
+    iterations.times do
+      Poro.new(id: 1, claimed: true, pro_coach: true, url: 'http://google.de')
+    end
+  end
+end

data/lib/attributed_object.rb

@@ -0,0 +1,67 @@
+require 'attributed_object/version'
+require 'attributed_object/base'
+require 'attributed_object/strict'
+require 'attributed_object/coerce'
+require 'attributed_object/type'
+require 'attributed_object/types/array_of'
+require 'attributed_object/types/hash_of'
+require 'attributed_object_helpers/hash_util'
+require 'attributed_object_helpers/type_check'
+require 'attributed_object_helpers/type_coerce'
+
+# A module to allow classes to have named attributes as initializing parameters
+# Attributes are required to be explicitely given
+# See Readme for all options
+
+module AttributedObject
+  # Unset makes the difference between nil and 'not given' possible
+  class Unset
+  end
+
+  # TypeDefaults is a option for default_to: - it will set defaults on the given type (integer: 0, boolean: false, string: '' etc)
+  class TypeDefaults
+    def initialize(args={})
+      @args = {
+        string: '',
+        boolean: false,
+        integer: 0,
+        float: 0.0,
+        numeric: 0,
+        symbol: nil,
+        array: [],
+        hash: {}
+      }.merge(args)
+    end
+
+    def fetch(type_info)
+      @args.fetch(type_info, nil)
+    end
+  end
+
+  class Error < StandardError
+  end
+
+  class KeyError < Error
+    def initialize(klass, key, args)
+      @klass, @key, @args = klass, key, args
+    end
+
+    def to_s
+      "#{self.class}: '#{@key}' for #{@klass} - args given: #{@args}"
+    end
+  end
+
+  class MissingAttributeError < KeyError
+  end
+  class UnknownAttributeError < KeyError
+  end
+  class DisallowedValueError < KeyError
+  end
+  class UncoercibleValueError < Error
+  end
+  class TypeError < KeyError
+  end
+  class ConfigurationError < Error
+  end
+end
+