attributed_object 0.2.1

data/lib/attributed_object/base.rb

@@ -0,0 +1,106 @@
+module AttributedObject
+  module Base
+    module ClassExtension
+      def attributed_object(options={})
+        @attributed_object_options = attributed_object_options.merge(options)
+      end
+
+      def attributed_object_options
+        return @attributed_object_options if !@attributed_object_options.nil?
+
+        parent_ops = self.superclass.respond_to?(:attributed_object_options) ? self.superclass.attributed_object_options : {}
+
+        @attributed_object_options = {
+          default_to: Unset,
+          ignore_extra_keys: false,
+          coerce_blanks_to_nil: false
+        }.merge(parent_ops)
+      end
+
+      def attribute_defs
+        return @attribute_defs if @attribute_defs
+        parent_defs = {}
+        parent_defs = self.superclass.attribute_defs if self.superclass.respond_to?(:attribute_defs)
+        @attribute_defs = parent_defs.clone
+      end
+
+      def attribute(attr_name, type_info = Unset, default: Unset, disallow: Unset)
+        if default == Unset
+          default_to = attributed_object_options.fetch(:default_to)
+
+          if default_to != Unset
+            default = default_to.is_a?(TypeDefaults) ? default_to.fetch(type_info) : default_to
+          end
+        end
+
+        _attributed_object_check_type_supported!(type_info)
+
+        attribute_defs[attr_name] = {
+          type_info: type_info,
+          default: default,
+          disallow: disallow,
+        }
+
+        attr_writer attr_name
+        attr_reader attr_name
+      end
+    end
+
+    module InstanceMethods
+      def initialize(args={})
+        initialize_attributes(args)
+      end
+
+      def attributes
+        Hash[self.class.attribute_defs.map { |name, _|
+          [name, self.send(name)]
+        }]
+      end
+
+      def initialize_attributes(args)
+        symbolized_args = AttributedObjectHelpers::HashUtil.symbolize_keys(args)
+        if !self.class.attributed_object_options.fetch(:ignore_extra_keys)
+          symbolized_args.keys.each do |key|
+            if !self.class.attribute_defs.keys.include?(key)
+              raise UnknownAttributeError.new(self.class, key, args)
+            end
+          end
+        else
+          symbolized_args = AttributedObjectHelpers::HashUtil.slice(symbolized_args, self.class.attribute_defs.keys)
+        end
+
+        self.class.attribute_defs.each { |name, opts|
+          if !symbolized_args.has_key?(name)
+            default = opts[:default]
+            default = default.call if default.respond_to?(:call)
+            symbolized_args[name] = default unless default == Unset
+          end
+
+          if !symbolized_args.has_key?(name)
+            raise MissingAttributeError.new(self.class, name, args)
+          end
+
+          if opts[:disallow] != Unset && symbolized_args[name] == opts[:disallow]
+            raise DisallowedValueError.new(self.class, name, args)
+          end
+
+          if opts[:type_info] != Unset && symbolized_args[name] != nil
+            symbolized_args[name] = _attributed_object_on_init_attribute(opts[:type_info], symbolized_args[name], name: name, args: args)
+          end
+          self.send("#{name}=", symbolized_args[name])
+        }
+      end
+
+      def ==(other)
+        self.class == other.class && self.attributes == other.attributes
+      end
+
+      def as_json(options=nil)
+        attrs = self.attributes
+        return attrs.as_json(options) if attrs.respond_to?(:as_json)
+        {}.merge(attrs)
+      end
+    end
+  end
+end
+

data/lib/attributed_object/coerce.rb

@@ -0,0 +1,30 @@
+module AttributedObject
+  module Coerce
+    def self.included(descendant)
+      super
+      descendant.send(:extend, ClassExtension)
+      descendant.send(:include, InstanceMethods)
+    end
+
+    module ClassExtension
+      include AttributedObject::Base::ClassExtension
+
+      def _attributed_object_check_type_supported!(type_info)
+        AttributedObjectHelpers::TypeCoerce.check_type_supported!(type_info)
+      end
+    end
+
+    module InstanceMethods
+      include AttributedObject::Base::InstanceMethods
+
+      def _attributed_object_on_init_attribute(type_info, value, name:, args:)
+        return AttributedObjectHelpers::TypeCoerce.coerce(
+          type_info,
+          value,
+          coerce_blanks_to_nil: self.class.attributed_object_options.fetch(:coerce_blanks_to_nil)
+        )
+      end
+    end
+  end
+end
+

data/lib/attributed_object/strict.rb

@@ -0,0 +1,28 @@
+module AttributedObject
+  module Strict
+    def self.included(descendant)
+      super
+      descendant.send(:extend, ClassExtension)
+      descendant.send(:include, InstanceMethods)
+    end
+
+    module ClassExtension
+      include AttributedObject::Base::ClassExtension
+
+      def _attributed_object_check_type_supported!(type_info)
+        AttributedObjectHelpers::TypeCheck.check_type_supported!(type_info)
+      end
+    end
+
+    module InstanceMethods
+      include AttributedObject::Base::InstanceMethods
+
+      def _attributed_object_on_init_attribute(type_info, value, name:, args:)
+        type_matches = AttributedObjectHelpers::TypeCheck.check(type_info, value)
+        raise TypeError.new(self.class, name, args) if !type_matches
+        return value
+      end
+    end
+  end
+end
+

data/lib/attributed_object/type.rb

@@ -0,0 +1,11 @@
+module AttributedObject
+  class Type
+    def strict_check(value)
+      raise 'implement me'
+    end
+
+    def coerce(value)
+      raise 'implement me'
+    end
+  end
+end

data/lib/attributed_object/types/array_of.rb

@@ -0,0 +1,25 @@
+module AttributedObject
+  module Types
+    class ArrayOf < AttributedObject::Type
+      def initialize(type_info)
+        @type_info = type_info
+      end
+
+      def strict_check(array)
+        return false if !array.is_a?(Array)
+        array.all?{ |e| AttributedObjectHelpers::TypeCheck.check(@type_info, e) }
+      end
+
+      def coerce(array)
+        raise AttributedObject::UncoercibleValueError.new("Trying to coerce into Array but value is not an array") if !array.is_a?(Array)
+        array.map { |e| AttributedObjectHelpers::TypeCoerce.coerce(@type_info, e) }
+      end
+    end
+  end
+end
+
+module AttributedObject::Base::ClassExtension
+  def ArrayOf(type_info)
+    AttributedObject::Types::ArrayOf.new(type_info)
+  end
+end

data/lib/attributed_object/types/hash_of.rb

@@ -0,0 +1,28 @@
+module AttributedObject
+  module Types
+    class HashOf < AttributedObject::Type
+      def initialize(key_type_info, value_type_info)
+        @key_type_info = key_type_info
+        @value_type_info = value_type_info
+      end
+
+      def strict_check(hash)
+        return false if !hash.is_a?(Hash)
+        hash.all? do |k,v|
+          AttributedObjectHelpers::TypeCheck.check(@key_type_info, k) && AttributedObjectHelpers::TypeCheck.check(@value_type_info, v)
+        end
+      end
+
+      def coerce(hash)
+        raise AttributedObject::UncoercibleValueError.new("Trying to coerce into Hash but value is not an hash") if !hash.is_a?(Hash)
+        hash.map { |k,v| [AttributedObjectHelpers::TypeCoerce.coerce(@key_type_info, k), AttributedObjectHelpers::TypeCoerce.coerce(@value_type_info, v)] }
+      end
+    end
+  end
+end
+
+module AttributedObject::Base::ClassExtension
+  def HashOf(key_type_info, value_type_info)
+    AttributedObject::Types::HashOf.new(key_type_info, value_type_info)
+  end
+end

data/lib/attributed_object/version.rb

@@ -0,0 +1,3 @@
+module AttributedObject
+  VERSION = "0.2.1"
+end

data/lib/attributed_object_helpers/hash_util.rb

@@ -0,0 +1,21 @@
+module AttributedObjectHelpers
+  class HashUtil
+    def self.symbolize_keys(hash)
+      new_hash = {}
+
+      hash.each { |k, v|
+        if k.respond_to?(:to_sym)
+          new_hash[k.to_sym] = v
+        else
+          new_hash[k] = v
+        end
+      }
+
+      return new_hash
+    end
+    
+    def self.slice(hash, keys)
+      Hash[ [keys, hash.values_at(*keys)].transpose]
+    end
+  end
+end

data/lib/attributed_object_helpers/type_check.rb

@@ -0,0 +1,46 @@
+module AttributedObjectHelpers
+  class TypeCheck
+    def self.check_type_supported!(type_info)
+      supported = type_info.is_a?(Class) || [
+        :string,
+        :boolean,
+        :integer,
+        :float,
+        :numeric,
+        :symbol,
+        :array,
+        :hash
+      ].include?(type_info)
+      supported = type_info.is_a?(AttributedObject::Type) if !supported
+      raise AttributedObject::ConfigurationError.new("Unknown Type for type checking #{type_info}") unless supported
+    end
+
+    def self.check(type_info, value)
+      return value.is_a?(type_info) if type_info.is_a?(Class)
+
+      case type_info
+      when :string
+        return value.is_a?(String)
+      when :boolean
+        return value == true || value == false
+      when :integer
+        return value.is_a?(Integer)
+      when :float
+        return value.is_a?(Float)
+      when :numeric
+        return value.is_a?(Numeric)
+      when :symbol
+        return value.is_a?(Symbol)
+      when :array
+        return value.is_a?(Array)
+      when :hash
+        return value.is_a?(Hash)
+      else
+        if type_info.is_a?(AttributedObject::Type)
+          return type_info.strict_check(value)
+        end
+        raise AttributedObject::ConfigurationError.new("Unknown Type for type checking #{type_info}")
+      end
+    end
+  end
+end

data/lib/attributed_object_helpers/type_coerce.rb

@@ -0,0 +1,52 @@
+module AttributedObjectHelpers
+  class TypeCoerce
+    def self.check_type_supported!(type_info)
+      supported = type_info.is_a?(Class) || [
+        :string,
+        :boolean,
+        :integer,
+        :float,
+        :numeric,
+        :symbol
+      ].include?(type_info)
+      supported = type_info.is_a?(AttributedObject::Type) if !supported
+      raise AttributedObject::ConfigurationError.new("Unknown Type for type coercion #{type_info}") unless supported
+    end
+
+    def self.coerce(type_info, value, coerce_blanks_to_nil: false)
+      return nil if value.nil?
+      return nil if coerce_blanks_to_nil && !(type_info == :string && value == '') # blank string stays blank
+
+      case type_info
+      when :string
+        return value.to_s
+      when :boolean
+        return [true, 1, 'true', '1'].include?(value)
+      when :integer
+        return value.to_i
+      when :float
+        return value.to_f
+      when :numeric
+        return (float = value.to_f) && (float % 1.0 == 0) ? float.to_i : float
+      when :symbol
+        return value.to_sym
+      else
+        if type_info.is_a?(Class) && type_info.respond_to?(:attributed_object)
+          return value if value.is_a?(type_info)
+          if !value.is_a?(Hash)
+            raise AttributedObject::UncoercibleValueError.new("Trying to coerce into #{type_info}, but value is not a hash, its #{value.class}")
+          end
+          return type_info.new(value)
+        end
+        if type_info.is_a?(Class)
+          return value if value.is_a?(type_info)
+          raise AttributedObject::UncoercibleValueError.new("Trying to coerce into #{type_info}, but no coercion is registered for #{type_info}->#{value.class}")
+        end
+        if type_info.is_a?(AttributedObject::Type)
+          return type_info.coerce(value)
+        end
+        raise AttributedObject::ConfigurationError.new("Unknown Type for type coerce #{type_info}")
+      end
+    end
+  end
+end

data/spec/attributed_object/coerce_spec.rb

@@ -0,0 +1,159 @@
+require 'attributed_object'
+
+describe AttributedObject::Coerce do
+  class CoercedFoo
+    include AttributedObject::Coerce
+    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 :any_class_without_coercer, Class, default: nil
+    attribute :untyped, default: nil
+  end
+
+  class BlankCoercedFoo < CoercedFoo
+    attributed_object coerce_blanks_to_nil: true
+  end
+
+  it 'coerces strings' do
+    expect(CoercedFoo.new(a_string: '12').a_string).to eq('12')
+    expect(CoercedFoo.new(a_string: 12).a_string).to eq('12')
+
+    expect(CoercedFoo.new(a_string: '').a_string).to eq('')
+    expect(CoercedFoo.new(a_string: nil).a_string).to eq(nil)
+    expect(BlankCoercedFoo.new(a_string: '').a_string).to eq('')
+    expect(BlankCoercedFoo.new(a_string: nil).a_string).to eq(nil)
+  end
+
+  it 'coerces booleans' do
+    expect(CoercedFoo.new(a_boolean: true).a_boolean).to eq(true)
+    expect(CoercedFoo.new(a_boolean: 1).a_boolean).to eq(true)
+    expect(CoercedFoo.new(a_boolean: 'true').a_boolean).to eq(true)
+    expect(CoercedFoo.new(a_boolean: '1').a_boolean).to eq(true)
+    expect(CoercedFoo.new(a_boolean: false).a_boolean).to eq(false)
+    expect(CoercedFoo.new(a_boolean: 0).a_boolean).to eq(false)
+    expect(CoercedFoo.new(a_boolean: 'false').a_boolean).to eq(false)
+    expect(CoercedFoo.new(a_boolean: '0').a_boolean).to eq(false)
+
+    expect(CoercedFoo.new(a_boolean: '').a_boolean).to eq(false)
+    expect(CoercedFoo.new(a_boolean: nil).a_boolean).to eq(nil)
+    expect(BlankCoercedFoo.new(a_boolean: '').a_boolean).to eq(nil)
+    expect(BlankCoercedFoo.new(a_boolean: nil).a_boolean).to eq(nil)
+  end
+
+  it 'coerces integers' do
+    expect(CoercedFoo.new(a_integer: 1).a_integer).to eq(1)
+    expect(CoercedFoo.new(a_integer: 1.1).a_integer).to eq(1)
+    expect(CoercedFoo.new(a_integer: '1').a_integer).to eq(1)
+    expect(CoercedFoo.new(a_integer: '01').a_integer).to eq(1)
+    expect(CoercedFoo.new(a_integer: '1.1').a_integer).to eq(1)
+    expect(CoercedFoo.new(a_integer: nil).a_integer).to eq(nil)
+    expect(BlankCoercedFoo.new(a_integer: '').a_integer).to eq(nil)
+    expect(BlankCoercedFoo.new(a_integer: nil).a_integer).to eq(nil)
+  end
+
+  it 'coerces floats' do
+    expect(CoercedFoo.new(a_float: 1).a_float).to eq(1.0)
+    expect(CoercedFoo.new(a_float: 1.1).a_float).to eq(1.1)
+    expect(CoercedFoo.new(a_float: '1').a_float).to eq(1.0)
+    expect(CoercedFoo.new(a_float: '01').a_float).to eq(1.0)
+    expect(CoercedFoo.new(a_float: '1.1').a_float).to eq(1.1)
+    expect(CoercedFoo.new(a_float: nil).a_float).to eq(nil)
+  end
+
+  it 'coerces numerics' do
+    expect(CoercedFoo.new(a_numeric: 1).a_numeric).to eq(1)
+    expect(CoercedFoo.new(a_numeric: 1.1).a_numeric).to eq(1.1)
+    expect(CoercedFoo.new(a_numeric: '1').a_numeric).to eq(1)
+    expect(CoercedFoo.new(a_numeric: '01').a_numeric).to eq(1)
+    expect(CoercedFoo.new(a_numeric: '1.1').a_numeric).to eq(1.1)
+    expect(CoercedFoo.new(a_numeric: nil).a_numeric).to eq(nil)
+  end
+
+  it 'coerces symbols' do
+    expect(CoercedFoo.new(a_symbol: :some_symbol).a_symbol).to eq(:some_symbol)
+    expect(CoercedFoo.new(a_symbol: 'something').a_symbol).to eq(:something)
+    expect(CoercedFoo.new(a_symbol: '1').a_symbol).to eq(:'1')
+    expect(CoercedFoo.new(a_symbol: nil).a_symbol).to eq(nil)
+  end
+
+  it 'does nothing without type' do
+    expect(CoercedFoo.new(untyped: '1').untyped).to eq('1')
+    expect(CoercedFoo.new(untyped: 1).untyped).to eq(1)
+    expect(CoercedFoo.new(untyped: nil).untyped).to eq(nil)
+  end
+
+  it 'only checks type for any class' do
+    expect(CoercedFoo.new(any_class_without_coercer: CoercedFoo).any_class_without_coercer).to eq(CoercedFoo)
+    expect{ CoercedFoo.new(any_class_without_coercer: 12) }.to raise_error(AttributedObject::UncoercibleValueError)
+  end
+
+  context 'coercing into AttributedObjects' do
+    class Toy
+      include AttributedObject::Coerce
+
+      attribute :kind, :symbol
+    end
+
+    class Child
+      include AttributedObject::Coerce
+
+      attribute :name, :string
+      attribute :age, :integer
+      attribute :toys, ArrayOf(Toy)
+    end
+
+    class Parent
+      include AttributedObject::Coerce
+
+      attribute :name, :string
+      attribute :child, Child
+      attribute :config, HashOf(:symbol, :boolean)
+    end
+
+    it 'coerces into AttributedObjects' do
+      parent = Parent.new({
+        name: 'Peter',
+        config: { one: '1', two: '0' },
+        child: {
+          name: 'Zelda',
+          age: 12,
+          toys: [
+            {
+              kind: 'teddybear'
+            },
+            {
+              kind: 'doll'
+            },
+          ]
+        }
+      })
+
+      expect(parent).to eq(Parent.new(
+        name: 'Peter',
+        config: { one: true, two: false },
+        child: Child.new(
+          name: 'Zelda',
+          age: 12,
+          toys: [
+            Toy.new(
+              kind: :teddybear
+            ),
+            Toy.new(
+              kind: :doll
+            )
+          ]
+        )
+      ))
+    end
+
+    it 'throws error if it can not be coerced (not a hash)' do
+      expect { Parent.new({
+        name: 'Peter',
+        child: 'a child'
+      }) }.to raise_error(AttributedObject::UncoercibleValueError)
+    end
+  end
+end