active_entity 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1072bc0bff5756103e46f5e88ca83b624b43c7a2
-  data.tar.gz: 14e335691227ad6abd7045a4f33f6c0f89859966
+  metadata.gz: 7f64f30d78308e4f5887107685f1c7801485138f
+  data.tar.gz: 477079a529608f27cc99ed5be0e6da67edfddd65
 SHA512:
-  metadata.gz: c2243185908d2889faa3ee05d8feb5dbe5b95e96a507a8bba191ce40784ad3637353d2587c2147757fab0c7f094644f5d9560f4179d1d6fd255008a7de4f7a20
-  data.tar.gz: aaea48011b23cb87fbe1a3140051aac64e6366799f64619dfaa34bb861cf2dc7b5439040a5e9ca1420278e670871380436ebac9ef7248eca3bbbe18cd8c1fed1
+  metadata.gz: cd7a1b494c16cd2c2fcc0717f1eebe40310abfed70e340e2ecccd650ee3fadcd1ec8fc1d65d04c7f45feecce50f0d7d3c1ac94a6fcbd1ba11f3e8cc07b938f16
+  data.tar.gz: 8f6cadc7b710a9de8a3c4d839fdd123b754ef85c77dccb32765eb58b4cf24899f8177c4d5571fd8911721d3b1eaa2e4e765cc7642c085ed1d32b7cf3d461b581

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 0.2.0
+* Introduce explicit type conversion and implicit coercion extension.

data/README.md

@@ -1,6 +1,6 @@
 # ActiveEntity
 
-To make an entity with ease according to ActiveModel way.
+An extension for Active Model to encourage implementing entity.
 
 [![Build Status](https://travis-ci.org/taiki45/active_entity.svg?branch=master)](https://travis-ci.org/taiki45/active_entity) [![Coverage Status](https://coveralls.io/repos/taiki45/active_entity/badge.svg)](https://coveralls.io/r/taiki45/active_entity) [![Code Climate](https://codeclimate.com/github/taiki45/active_entity/badges/gpa.svg)](https://codeclimate.com/github/taiki45/active_entity) [![Gem Version](https://badge.fury.io/rb/active_entity.svg)](http://badge.fury.io/rb/active_entity)
 
@@ -23,9 +23,10 @@ Or install it yourself as:
 ## Synopsis
 
 ```ruby
+# = Define model attributes with accessor and define identities =
 class Message
   include ActiveModel::Model
-  include ActiveEntity::Attribute
+  include ActiveEntity::Accessor
   include ActiveEntity::Identity
 
   attribute :title
@@ -47,6 +48,40 @@ expect(message.attributes).to eq({ "title" => "A README of ActiveEntity", "body"
 
 another_messsage = Message.new(title: 'A README of ActiveEntity', body: '')
 expect(message).to eq(another_messsage)
+
+
+# = Coercion =
+class Person
+  include ActiveModel::Model
+  include ActiveEntity::Accessor
+  include ActiveEntity::Coercion
+
+  attribute :name, type: String
+  attribute :age, type: Integer
+end
+
+alice = Person.new(name: 'Alice', age: '1')
+expect(alice.name).to eq('Alice')
+expect(alice.age).to eq(1)
+
+
+# = Typecasting =
+class Recipe
+  include ActiveModel::Model
+  include ActiveEntity::Accessor
+  include ActiveEntity::Typecasting
+
+  attribute :title, type: String
+  attribute :steps, type: Integer
+  attribute :likes, type: Integer
+end
+
+waffle = Recipe.new(title: 'Waffle', steps: '12', likes: 'abc')
+expect { waffle.cast! }.to raise_error(ActiveEntity::CastError)
+
+expect(waffle.title).to eq('Waffle')
+expect(waffle.steps).to eq('12')  #=> rollbacks casted value on error
+expect(waffle.likes).to eq('abc')
 ```
 
 ## Contributing

data/lib/active_entity.rb

@@ -1,6 +1,16 @@
 require 'active_model'
 require 'active_support/concern'
+require 'active_support/core_ext/string'
 
 require 'active_entity/version'
+require 'active_entity/errors'
 require 'active_entity/attribute'
+require 'active_entity/accessor'
+require 'active_entity/typecasting'
+require 'active_entity/coercion'
 require 'active_entity/identity'
+
+# TODO: to_param
+
+require 'active_entity/conversion_definitions'
+require 'active_entity/default_definitions'

data/lib/active_entity/accessor.rb

@@ -0,0 +1,21 @@
+module ActiveEntity
+  module Accessor
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :defined_attributes, instance_writer: false, instance_predicate: false
+      self.defined_attributes = {}
+    end
+
+    class_methods do
+      def attribute(name, options = {})
+        defined_attributes[name] = Attribute.new(name, options)
+        attr_accessor(name)
+      end
+    end
+
+    def attributes
+      Hash[defined_attributes.keys.map {|name| [name.to_s, public_send(name)] }]
+    end
+  end
+end

data/lib/active_entity/attribute.rb

@@ -1,21 +1,69 @@
 module ActiveEntity
-  module Attribute
-    extend ActiveSupport::Concern
+  # @example Cast with given type option.
+  #   attr = ActiveEntity::Attribute.new(:user_id, type: Integer)
+  #   attr.cast!('12') #=> 12
+  #   attr.cast!('a') #=> raises ActiveEntity::CastError
+  #
+  # @example Cast with given casting procedure.
+  #   attr = ActiveEntity::Attribute.new(
+  #     :created_at,
+  #     cast_by: -> (value) do
+  #       case value
+  #       when Fixnum, Float
+  #         Time.at(value)
+  #       when String
+  #         Time.parse(value)
+  #       else
+  #         raise ActiveEntity::CastError.build(:Time, value)
+  #       end
+  #     end
+  #   )
+  #   attr.cast!(1420081200) #=> a Time object
+  #   attr.cast!('2015/01/01 12:00:00') #=> a Time object
+  class Attribute
+    attr_reader :name, :options
 
-    included do
-      class_attribute :defined_attributes, instance_writer: false, instance_predicate: false
-      self.defined_attributes = {}
+    # @param [Symbol] name
+    # @param [Hash{Symbol => Object}] options
+    def initialize(name, options = {})
+      raise ArgumentError unless options.is_a?(Hash)
+      @name, @options = name, options
     end
 
-    class_methods do
-      def attribute(name, options = {})
-        defined_attributes[name] = options
-        attr_accessor(name)
+    # @return [Class, Symbol, String]
+    def type
+      @options[:type]
+    end
+
+    # @return [Proc]
+    def cast_by
+      @options[:cast_by]
+    end
+
+    # @param [Object] value
+    # @return [Object] casted value
+    # @raise [ActiveEntity::CastError]
+    def cast!(value)
+      case
+      when type
+        cast_by_defined_type(value)
+      when cast_by
+        cast_by.call(value)
+      else
+        value
       end
     end
 
-    def attributes
-      Hash[defined_attributes.keys.map {|name| [name.to_s, public_send(name)] }]
+    private
+
+    def cast_by_defined_type(value)
+      procedure = ActiveEntity::ConversionDefinitions.get(type)
+
+      if procedure
+        procedure.call(value)
+      else
+        raise ConfigurationError.new("Can't find casting procedure for `#{type}`")
+      end
     end
   end
 end

data/lib/active_entity/coercion.rb

@@ -0,0 +1,10 @@
+module ActiveEntity
+  module Coercion
+    include Typecasting
+
+    def initialize(*)
+      super
+      cast
+    end
+  end
+end

data/lib/active_entity/conversion_definitions.rb

@@ -0,0 +1,62 @@
+module ActiveEntity
+  class ConversionDefinitions
+    class << self
+      # @param [Class, Symbol, String] type
+      # @return [Proc]
+      def get(type)
+        type_casting_procs.get(type)
+      end
+
+      # @param [Class, Symbol, String] type
+      # @return [Proc]
+      def set(type, &block)
+        type_casting_procs.set(type, &block)
+      end
+
+      # Run block with new type_casting_procs. For test purpose.
+      # @return [nil]
+      def run_with_new_then_restore
+        old, @type_casting_procs = type_casting_procs, MapWithNormalizing.new
+        yield
+        @type_casting_procs = old
+        nil
+      end
+
+      private
+
+      def type_casting_procs
+        @type_casting_procs ||= MapWithNormalizing.new
+      end
+    end
+
+    private
+
+    class MapWithNormalizing
+      def initialize
+        @map = {}
+      end
+
+      def get(type)
+        @map[normalize_type(type)]
+      end
+
+      def set(type, &block)
+        # TODO: block arity check
+        @map[normalize_type(type)] = block
+      end
+
+      def normalize_type(type)
+        case type
+        when Class
+          type.to_s
+        when String
+          type
+        when Symbol
+          type.to_s
+        else
+          raise ArgumentError.new("`type` must be a Class or String or Symbol, but #{type.class}")
+        end
+      end
+    end
+  end
+end

data/lib/active_entity/default_definitions.rb

@@ -0,0 +1,57 @@
+ActiveEntity::ConversionDefinitions.set(:Boolean) do |value|
+  case value
+  when 'true'
+    true
+  when 'false'
+    false
+  else
+    raise ActiveEntity::CastError.build(:Boolean, value)
+  end
+end
+
+ActiveEntity::ConversionDefinitions.set(Integer) do |value|
+  begin
+    Integer(value)
+  rescue
+    raise ActiveEntity::CastError.build(Integer, value)
+  end
+end
+
+ActiveEntity::ConversionDefinitions.set(Float) do |value|
+  begin
+    Float(value)
+  rescue
+    raise ActiveEntity::CastError.build(Float, value)
+  end
+end
+
+ActiveEntity::ConversionDefinitions.set(:'ActiveSupport::TimeWithZone') do |value|
+  begin
+    case value
+    when Fixnum, Float
+      Time.zone.at(value)
+    when String
+      Time.zone.parse(value)
+    else
+      raise ActiveEntity::CastError.build(:'ActiveSupport::TimeWithZone', value)
+    end
+  rescue ArgumentError
+    raise ActiveEntity::CastError.build(:'ActiveSupport::TimeWithZone', value)
+  end
+end
+
+ActiveEntity::ConversionDefinitions.set(String) do |value|
+  if value.respond_to? :to_s
+    value.to_s
+  else
+    raise ActiveEntity::CastError.build(String, value)
+  end
+end
+
+ActiveEntity::ConversionDefinitions.set(Symbol) do |value|
+  if value.respond_to? :to_sym
+    value.to_sym
+  else
+    raise ActiveEntity::CastError.build(Symbol, value)
+  end
+end

data/lib/active_entity/errors.rb

@@ -0,0 +1,13 @@
+module ActiveEntity
+  class Error < StandardError
+  end
+
+  class CastError < Error
+    def self.build(type, value)
+      new("Can't type cast #{value.inspect} as #{type}")
+    end
+  end
+
+  class ConfigurationError < Error
+  end
+end

data/lib/active_entity/identity.rb

@@ -3,8 +3,7 @@ module ActiveEntity
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :identity_attributes,
-        instance_writer: false, instance_predicate: false
+      class_attribute :identity_attributes, instance_writer: false, instance_predicate: false
       self.identity_attributes = []
     end
 
@@ -14,17 +13,14 @@ module ActiveEntity
 
         define_method(:==) do |other|
           return false unless self.class === other
-
-          names.all? do |name|
-            public_send(name) == other.public_send(name)
-          end
+          names.all? {|name| public_send(name) == other.public_send(name) }
         end
       end
     end
 
     # For ActiveModel::Conversion
     def to_key
-      indentity_attributes.empty? ? nil : identity_attributes
+      identity_attributes.empty? ? nil : identity_attributes.map {|name| public_send(name) }
     end
   end
 end

data/lib/active_entity/typecasting.rb

@@ -0,0 +1,37 @@
+module ActiveEntity
+  module Typecasting
+    # Try to cast attribute values. When fails to cast, raises the error and
+    # rollbacks all values.
+    #
+    # @return [nil]
+    # @raise [ActiveEntity::CastError]
+    def cast!
+      casted_values = defined_attributes.map do |name, attr|
+        value = public_send(name)
+        next [name, nil] if value.nil?
+        [name, attr.cast!(value)]
+      end
+
+      casted_values.each {|name, casted| public_send("#{name}=", casted) }
+      nil
+    end
+
+    # Try to cast attribute values. When fails to cast, ignores error and left
+    # attribute value as original one.
+    #
+    # @return [nil]
+    def cast
+      defined_attributes.each do |name, attr|
+        value = public_send(name)
+        next if value.nil?
+
+        begin
+          casted = attr.cast!(value)
+          public_send("#{name}=", casted)
+        rescue ActiveEntity::CastError
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/active_entity/version.rb

@@ -1,3 +1,3 @@
 module ActiveEntity
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/active_entity/accessor_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+RSpec.describe ActiveEntity::Accessor do
+  let(:test_class) do
+    Class.new do
+      include ActiveModel::Model
+      include ActiveEntity::Accessor
+
+      attribute :name, type: String
+      attribute :age, type: String
+    end
+  end
+
+  let(:test_attributes) { { name: 'Alice', age: 1 } }
+
+  describe '.defined_attributes' do
+    subject { test_class.defined_attributes }
+    it { is_expected.to be_kind_of(Hash) }
+
+    it 'returns all defined attributes' do
+      expect(subject.keys).to eq(%i(name age))
+      expect(subject[:name]).to be_kind_of(ActiveEntity::Attribute)
+      expect(subject[:age]).to be_kind_of(ActiveEntity::Attribute)
+    end
+  end
+
+  describe '#initialize' do
+    subject { test_class.new(test_attributes) }
+
+    it 'assigns attributes' do
+      expect(subject.name).to eq('Alice')
+      expect(subject.age).to eq(1)
+    end
+  end
+
+  describe '#attributes' do
+    subject { test_class.new(test_attributes).attributes }
+
+    it { is_expected.to be_kind_of(Hash) }
+
+    it "returns all attribute's name-value pairs" do
+      is_expected.to eq('name' => 'Alice', 'age' => 1)
+    end
+  end
+end

data/spec/active_entity/attribute_spec.rb

@@ -1,43 +1,83 @@
 require 'spec_helper'
 
 RSpec.describe ActiveEntity::Attribute do
-  let(:test_class) do
-    Class.new do
-      include ActiveModel::Model
-      include ActiveEntity::Attribute
+  describe 'typecasting' do
+    context 'with type option' do
+      let(:casting_proc) do
+        -> (value) {
+          begin
+            Integer(value)
+          rescue
+            raise ActiveEntity::CastError.build(Integer, value)
+          end
+        }
+      end
 
-      attribute :name
-      attribute :age
-    end
-  end
+      before do
+        allow(ActiveEntity::ConversionDefinitions).to receive(:get).
+          with(Integer).and_return(casting_proc)
+      end
 
-  let(:test_attributes) { { name: 'Alice', age: 1 } }
+      let(:attr) { ActiveEntity::Attribute.new(:user_id, type: Integer) }
 
-  describe '.defined_attributes' do
-    subject { test_class.defined_attributes }
-    it { is_expected.to be_kind_of(Hash) }
+      context 'with valid value' do
+        it 'converts given value' do
+          expect(attr.cast!('12')).to be_a(Integer)
+          expect(attr.cast!('12')).to eq(12)
+        end
+      end
 
-    it 'returns all defined attributes' do
-      is_expected.to eq(name: {}, age: {})
-    end
-  end
+      context 'with invalid value' do
+        it 'raises ActiveEntity::CastError' do
+          expect { attr.cast!('a') }.to raise_error(ActiveEntity::CastError)
+        end
+      end
 
-  describe '#initialize' do
-    subject { test_class.new(test_attributes) }
+      context 'with procedure of type is not defined' do
+        before do
+          allow(ActiveEntity::ConversionDefinitions).to receive(:get).
+            with(:UnknownType).and_return(nil)
+        end
 
-    it 'assigns attributes' do
-      expect(subject.name).to eq('Alice')
-      expect(subject.age).to eq(1)
+        let(:attr) { ActiveEntity::Attribute.new(:user_id, type: :UnknownType) }
+
+        it 'raises ConfigurationError' do
+          expect {
+            attr.cast!('12')
+          }.to raise_error(ActiveEntity::ConfigurationError, /UnknownType/)
+        end
+      end
     end
-  end
 
-  describe '#attributes' do
-    subject { test_class.new(test_attributes).attributes }
+    context 'with cast_by option' do
+     let(:attr) do
+       ActiveEntity::Attribute.new(
+        :created_at,
+        cast_by: -> (value) do
+          case value
+          when Fixnum, Float
+            Time.at(value)
+          when String
+            Time.parse(value)
+          else
+            raise ActiveEntity::CastError.build(:Time, value)
+          end
+        end
+       )
+     end
+
+     it 'converts given value' do
+       expect(attr.cast!(1420081200)).to be_a(Time)
+       expect(attr.cast!('2015/01/01 12:00:00')).to be_a(Time)
+     end
+    end
 
-    it { is_expected.to be_kind_of(Hash) }
+    context 'without typecasting options' do
+      let(:attr) { ActiveEntity::Attribute.new(:user_id) }
 
-    it "returns all attribute's name-value pairs" do
-      is_expected.to eq('name' => 'Alice', 'age' => 1)
+      it 'does nothing and returns original' do
+        expect(attr.cast!('12')).to eq('12')
+      end
     end
   end
 end

data/spec/active_entity/coercion_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe ActiveEntity::Coercion do
+  let(:test_class) do
+    Class.new do
+      include ActiveModel::Model
+      include ActiveEntity::Accessor
+      include ActiveEntity::Coercion
+
+      attribute :name, type: String
+      attribute :age, type: Integer
+    end
+  end
+
+  it 'automatically typecasts attribute values' do
+    person = test_class.new(name: 'Alice', age: '1')
+    expect(person.name).to eq('Alice')
+    expect(person.age).to eq(1)
+  end
+end

data/spec/active_entity/conversion_definitions_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+RSpec.describe ActiveEntity::ConversionDefinitions do
+  around do |example|
+    described_class.run_with_new_then_restore { example.run }
+  end
+
+  describe '.set and .get' do
+    type_as_class = ActiveSupport::TimeWithZone
+    type_as_symbol = :'ActiveSupport::TimeWithZone'
+    type_as_string = 'ActiveSupport::TimeWithZone'
+
+    [type_as_class, type_as_symbol, type_as_string].permutation(2).each do |a, b|
+      context "when set with #{a.class} and get with #{b.class}" do
+        it 'returns valid procedure' do
+          described_class.set(a) {}
+          expect(described_class.get(b)).not_to be_nil
+        end
+      end
+    end
+  end
+
+  context 'when given invalid type' do
+    it 'raises ArgumentError' do
+      expect { described_class.set(1) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/active_entity/default_definitions_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+RSpec.describe 'default type conversion definitions' do
+  shared_examples 'raising error' do
+    it 'raises ActiveEntity::CastError' do
+      expect { subject }.to raise_error(ActiveEntity::CastError, /#{type}/)
+    end
+  end
+
+  let(:procedure) { ActiveEntity::ConversionDefinitions.get(type) }
+  subject { procedure.call(value) }
+
+  describe 'Boolean conversion' do
+    let(:type) { :Boolean }
+
+    context 'with `true` string' do
+      let(:value) { 'true' }
+      it { is_expected.to eq(true) }
+    end
+
+    context 'with `false` string' do
+      let(:value) { 'false' }
+      it { is_expected.to eq(false) }
+    end
+
+    context 'with invalid value' do
+      let(:value) { 'True' }
+      include_examples 'raising error'
+    end
+  end
+
+  describe 'Integer conversion' do
+    let(:type) { :Integer }
+
+    context 'with valid value' do
+      let(:value) { '12' }
+      it { is_expected.to eq(12) }
+    end
+
+    context 'with invalid value' do
+      let(:value) { 'abc' }
+      include_examples 'raising error'
+    end
+  end
+
+  describe 'Float conversion' do
+    let(:type) { :Float }
+
+    context 'with valid value' do
+      let(:value) { '12.1' }
+      it { is_expected.to eq(12.1) }
+    end
+
+    context 'with invalid value' do
+      let(:value) { 'abc' }
+      include_examples 'raising error'
+    end
+  end
+
+  describe 'ActiveSupport::TimeWithZone conversion' do
+    around do |example|
+      back, Time.zone = Time.zone, 'UTC'
+      example.run
+      Time.zone = back
+    end
+
+    let(:type) { :'ActiveSupport::TimeWithZone' }
+
+    context 'with string expression' do
+      let(:value) { '2015/01/05 02:12:12' }
+      it { is_expected.to be_a(ActiveSupport::TimeWithZone) }
+    end
+
+    context 'with float expression' do
+      let(:value) { 1420081200.089 }
+      it { is_expected.to be_a(ActiveSupport::TimeWithZone) }
+    end
+
+    context 'with invalid string value' do
+      let(:value) { '1420081200.089' }
+      include_examples 'raising error'
+    end
+
+    context 'with invalid value' do
+      let(:value) { Time.now }
+      include_examples 'raising error'
+    end
+  end
+
+  describe 'String conversion' do
+    let(:type) { :String }
+
+    context 'with valid value' do
+      let(:value) { 12 }
+      it { is_expected.to eq('12') }
+    end
+
+    context 'with invalid value' do
+      let(:value) { Object.new.tap {|o| o.instance_eval { undef :to_s } } }
+      include_examples 'raising error'
+    end
+  end
+
+  describe 'Symbol conversion' do
+    let(:type) { :Symbol }
+
+    context 'with valid value' do
+      let(:value) { 'abc' }
+      it { is_expected.to eq(:abc) }
+    end
+
+    context 'with invalid value' do
+      let(:value) { 12 }
+      include_examples 'raising error'
+    end
+  end
+end

data/spec/active_entity/identity_spec.rb

@@ -41,4 +41,12 @@ RSpec.describe ActiveEntity::Identity do
       end
     end
   end
+
+  describe '#to_key' do
+    let(:person) { test_class.new('Alice', 1) }
+
+    it 'returns values of key' do
+      expect(person.to_key).to eq(['Alice', 1])
+    end
+  end
 end

data/spec/active_entity/typecasting_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+RSpec.describe ActiveEntity::Typecasting do
+  let(:test_class) do
+    Class.new do
+      include ActiveModel::Model
+      include ActiveEntity::Accessor
+      include ActiveEntity::Typecasting
+
+      attribute :name, type: String
+      attribute :age, type: Integer
+      attribute :item_count, type: Integer
+    end
+  end
+
+  let(:person) { test_class.new(assigned_values) }
+  let(:assigned_values) { { name: 'Alice', age: '1', item_count: '2' } }
+
+  describe '#cast!' do
+    context 'when assigned value is valid' do
+      it 'conversions its attributes' do
+        person.cast!
+        expect(person.name).to eq('Alice')
+        expect(person.age).to eq(1)
+        expect(person.item_count).to eq(2)
+      end
+    end
+
+    context 'when assigned value is invalid' do
+      let(:assigned_values) { { name: 'Alice', age: '1', item_count: 'a' } }
+
+      it 'raises ActiveEntity::CastError' do
+        expect { person.cast! }.to raise_error(ActiveEntity::CastError)
+      end
+
+      it 'rollbacks all values' do
+        expect { person.cast! }.to raise_error(ActiveEntity::CastError)
+        expect(person.age).to eq('1')
+      end
+    end
+
+    context 'when assigned value is nil' do
+      let(:assigned_values) { { name: nil, age: '1', item_count: nil } }
+
+      it 'skips nil values' do
+        expect { person.cast! }.not_to raise_error
+        expect(person.name).to be_nil
+        expect(person.age).to eq(1)
+        expect(person.item_count).to be_nil
+      end
+    end
+  end
+
+  describe '#cast' do
+    context 'when assigned value is valid' do
+      it 'conversions its attributes' do
+        person.cast
+        expect(person.name).to eq('Alice')
+        expect(person.age).to eq(1)
+        expect(person.item_count).to eq(2)
+      end
+    end
+
+    context 'when assigned value is invalid' do
+      let(:assigned_values) { { name: 'Alice', age: '1', item_count: 'a' } }
+
+      it 'skips invalid value' do
+        person.cast
+        expect(person.name).to eq('Alice')
+        expect(person.age).to eq(1)
+        expect(person.item_count).to eq('a')
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_entity
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Taiki Ono
@@ -147,17 +147,29 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - active_entity.gemspec
 - lib/active_entity.rb
+- lib/active_entity/accessor.rb
 - lib/active_entity/attribute.rb
+- lib/active_entity/coercion.rb
+- lib/active_entity/conversion_definitions.rb
+- lib/active_entity/default_definitions.rb
+- lib/active_entity/errors.rb
 - lib/active_entity/identity.rb
+- lib/active_entity/typecasting.rb
 - lib/active_entity/version.rb
+- spec/active_entity/accessor_spec.rb
 - spec/active_entity/attribute_spec.rb
+- spec/active_entity/coercion_spec.rb
+- spec/active_entity/conversion_definitions_spec.rb
+- spec/active_entity/default_definitions_spec.rb
 - spec/active_entity/identity_spec.rb
+- spec/active_entity/typecasting_spec.rb
 - spec/readme_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/taiki45/active_entity
@@ -185,8 +197,13 @@ signing_key:
 specification_version: 4
 summary: An Active Model extention for entity.
 test_files:
+- spec/active_entity/accessor_spec.rb
 - spec/active_entity/attribute_spec.rb
+- spec/active_entity/coercion_spec.rb
+- spec/active_entity/conversion_definitions_spec.rb
+- spec/active_entity/default_definitions_spec.rb
 - spec/active_entity/identity_spec.rb
+- spec/active_entity/typecasting_spec.rb
 - spec/readme_spec.rb
 - spec/spec_helper.rb
 has_rdoc: