datamapa 0.0.5 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e7cce387f3abe430cd8e4ee35617732e25e92e39
+  data.tar.gz: 0d6378a3d032543f8d498e25fb403ed3107b36be
+SHA512:
+  metadata.gz: abbc9b71aeb881fd50b48db2ff7de09d45426f4f65d968c34ab1e7cd9955c2515cbbd86125a0352161b4be6fab791b8cb65666a74f5575da7595f1b8258f0498
+  data.tar.gz: f352af17f79fb6bc50571ad3ce023c8e7d76b968b4961bac62972f8799e0cbb66ea9bead7396a6b4ac20b4a7e738e4d0d21a3d9acb446d2b1108c00e714e5d5d

data/datamapa.gemspec

@@ -18,6 +18,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency 'minitest'
-  spec.add_development_dependency 'mocha'
+  spec.add_runtime_dependency 'activerecord', '~> 4.0.2'
+
+  spec.add_development_dependency 'rake', '~> 10.1.1'
+  spec.add_development_dependency 'minitest', '~> 4.2'
+  spec.add_development_dependency 'mocha', '~> 0.14.0'
+  spec.add_development_dependency 'bourne', '~> 1.5.0'
+  spec.add_development_dependency 'byebug', '~> 2.6.0'
 end

data/lib/datamapa/version.rb

@@ -1,3 +1,3 @@
 module DataMapa
-  VERSION = "0.0.5"
+  VERSION = "1.0.0"
 end

data/lib/datamapa.rb

@@ -1,4 +1,5 @@
-require "datamapa/version"
+require 'datamapa/version'
+require 'active_record'
 
 module DataMapa
   def self.included(base)
@@ -6,13 +7,19 @@ module DataMapa
   end
 
   module ClassMethods
+
     # Declarative methods
+    
     def active_record_class(klass)
       @ar_class = klass
     end
 
-    def model_constructor(method)
-      @model_constructor = method
+    def creates_model_with(&block)
+      @create_model_proc = block
+    end
+
+    def semantic_key(key)
+      @semantic_key = key
     end
 
     def simple_attr(attributes)
@@ -23,52 +30,153 @@ module DataMapa
       @ref_attr = attributes
     end
 
-    def collection_attr(attributes)
-      @collection_attr = attributes
+    def aggregates(components)
+      @aggregates = components
     end
 
-    # Public methods
-    def to_ar(model, options={})
-      ar = model.id ? @ar_class.find(model.id) : @ar_class.new
-
-      o2r_attr(model, ar)
-      o2r_ref(model, ar)
-      o2r_collection(model, ar, options[:include]) if options[:include]
-
-      ar
+    def composed_of(parts)
+      @composed_of = parts
     end
 
-    def to_model(ar, options={})
-      model = @model_constructor.call
-
-      r2o_simple(ar, model)
-      r2o_ref(ar, model)
-      r2o_collection(ar, model, options[:include]) if options[:include]
-
-      model
+    def composes(parent)
+      @composes = parent
     end
 
+    # Public methods
+    
     def find!(id)
       begin
-        relational = @ar_class.find(id)
-        to_model(relational)
+        ar = @ar_class.find(id)
+        model_for(ar)
       rescue ActiveRecord::RecordNotFound
         raise DataMapa::RecordNotFoundError
       end
     end
 
-    def save!(model)
+    def where(clause)
+      records = @ar_class.where(clause) 
+      records.map do |ar|
+        model_for(ar)
+      end
+    end
+
+    def create!(model, extras={})
       begin
-        ar = to_ar(model)
-        ar.save!
+        attributes = attribute_hash(model, extras)
+
+        ar = @ar_class.create!(attributes)
         model.send(:id=, ar.id)
-      rescue ActiveRecord::StatementInvalid
-        raise DataMapa::DuplicateKeyError
+
+        @composed_of.each do |parts, mapper|
+          mapper.create_parts!(model.send(parts), model.id)
+        end if @composed_of
+      rescue ActiveRecord::StatementInvalid => e
+        raise DataMapa::PersistenceError, e.message
       end
     end
 
+    def update(model, extras={})
+      begin
+        attributes = attribute_hash(model, extras)
+
+        @ar_class.update(model.id, attributes)
+
+        @composed_of.each do |parts, mapper|
+          mapper.update_parts!(model.send(parts), model.id)
+        end if @composed_of
+      rescue ActiveRecord::StatementInvalid => e
+        raise DataMapa::PersistenceError, e.message
+      end
+    end
+
+    def save!(model, extras={})
+      load_id_with_semantic_key(model) unless @semantic_key.nil?
+      if model.id.nil?
+        create!(model)
+      else
+        update(model)
+      end
+    end
+
+    def delete!(id)
+      @composed_of.each do |part, mapper|
+        mapper.delete_children_of(id)
+      end
+
+      count = @ar_class.delete(id)
+    end
+
+    def model_for(ar)
+      model = @create_model_proc.call(ar)
+      r2o(ar, model)
+      model.id = ar.id
+      model
+    end
+
+    protected
+
+    def create_parts!(parts, parent_id)
+      parts.each_with_index do |item, i|
+        create!(item, "#{@composes}_id".to_sym => parent_id, :index => i)
+      end
+    end
+
+    def update_parts!(parts, parent_id)
+      existing_ids = parts.map(&:id).reject { |id| id.nil? }
+      @ar_class.where(composes_column => parent_id).where.not(id: existing_ids).delete_all
+
+      parts.each_with_index do |item, i|
+        if item.id.nil?
+          create!(item, composes_column => parent_id, :index => i)
+        else
+          update(item, composes_column => parent_id, :index => i)
+        end
+      end
+    end
+
+    def delete_children_of(id)
+      @ar_class.delete_all(["#{@composes}_id = ?", id])
+    end
+
     private
 
+    def attribute_hash(model, extras)
+      attributes = {}
+
+      @simple_attr.each do |attr|
+        attributes[:"#{attr.to_s.chomp('?')}"] = model.send(attr)
+      end if @simple_attr
+
+      @ref_attr.each_key do |attr|
+        ref = model.send(attr)
+        attributes[:"#{attr.to_s.chomp('?')}_id"] = ref.id unless ref.nil?
+      end if @ref_attr
+
+      extras.each_pair { |key, value| attributes[:"#{key}"] = value }
+
+      attributes
+    end
+
+    def load_id_with_semantic_key(model)
+      clause = @semantic_key.inject({}) do |memo, attr|
+        memo[attr] = model.send(attr)
+        memo
+      end
+      ar = @ar_class.find_by(clause)
+      model.id = ar.id unless ar.nil?
+    end
+
+    def composes_column
+      "#{@composes}_id".to_sym
+    end
+
+    def r2o(ar, model)
+      r2o_simple(ar, model)
+      r2o_ref(ar, model)
+      r2o_collection(ar, model, @composed_of) if @composed_of
+      model
+    end
+
     def r2o_simple(relational, object)
       @simple_attr.each do |attr|
         setter = "#{attr.to_s.chomp('?')}="
@@ -76,47 +184,37 @@ module DataMapa
       end if @simple_attr
     end
 
-    def r2o_ref(relational, object)
+    def r2o_ref(ar, object)
       @ref_attr.each do |attr, mapper|
+        model = mapper.find!(ar.send("#{attr}_id"))
+
         setter = "#{attr}="
-        object.send(setter, mapper.to_model(relational.send(attr)))
+        object.send(setter, model)
       end if @ref_attr
     end
 
+    def where_clause_for_references_to(id)
+      {"#{model_name}_id".to_sym => id}
+    end
+
     def r2o_collection(ar, model, attributes)
-      attributes.each do |attr|
-        ar_items = ar.send(attr)
-        model_items = ar_items.map {|i| @collection_attr[attr].to_model(i)}
+      attributes.each do |attr, mapper|
+        model_items = mapper.where(where_clause_for_references_to(ar.id))
         model.send("#{attr}=", model_items)
       end
     end
 
-    def o2r_attr(object, relational)
-      @simple_attr.each do |attr|
-        relational.send("#{attr.to_s.chomp('?')}=", object.send(attr))
-      end if @simple_attr
-    end
-
-    def o2r_ref(object, relational)
-      @ref_attr.each_key do |attr|
-        ref = object.send(attr)
-        relational.send("#{attr.to_s.chomp('?')}_id=", ref.id) unless ref.nil?
-      end if @ref_attr
+    def model_name
+      name.chomp('Mapper').downcase
     end
+  end
 
-    def o2r_collection(object, relational, attributes)
-      attributes.each do |attr|
-        collection = object.send(attr).map do |item| 
-          @collection_attr[attr].to_ar(item)
-        end
-        relational.send("#{attr}=", collection)
-      end
-    end
+  class PersistenceError < StandardError
   end
 
-  class RecordNotFoundError < StandardError
+  class RecordNotFoundError < PersistenceError
   end
 
-  class DuplicateKeyError < StandardError
+  class DuplicateKeyError < PersistenceError
   end
 end

data/spec/datamapa/datamapa_spec.rb

@@ -2,181 +2,403 @@ require 'rubygems'
 gem 'minitest'
 require 'minitest/autorun'
 require 'mocha/setup'
+require 'bourne'
 require 'datamapa'
 
 describe DataMapa do
 
+  class MapperStub
+  end
+
+  def ar_class_with_attributes(attributes)
+    Class.new do
+      attributes.each do |attr|
+        attr_accessor attr
+      end
+
+      def initialize(id=nil)
+        @id = id
+      end
+
+      def self.update(id, hash)
+      end
+    end
+  end
+
   def class_with_attributes(attributes)
     Class.new do
       attributes.each do |attr|
         attr_accessor attr
       end
+
+      def initialize(id=nil)
+        @id = id
+      end
     end
   end
 
-  def mapper_class(ar_class, model_class, attributes)
+  def mapper_class(class_name, attributes)
     Class.new do
       include DataMapa
 
-      active_record_class ar_class
-      model_constructor model_class.method(:new)
-      simple_attr attributes[:simple] if attributes[:simple]
-      ref_attr attributes[:ref] if attributes[:ref]
-      collection_attr attributes[:collection] if attributes[:collection]
+      active_record_class attributes[:active_record_class]
+      creates_model_with &attributes[:creates_model_with]
+      simple_attr attributes[:simple_attr] if attributes[:simple_attr]
+      ref_attr attributes[:ref_attr] if attributes[:ref_attr]
+      semantic_key attributes[:semantic_key] if attributes[:semantic_key]
+      composed_of attributes[:composed_of] if attributes[:composed_of]
+      composes attributes[:composes] if attributes[:composes]
+      aggregates attributes[:aggregates] if attributes[:aggregates]
+
+      # Provide name because this mapper class is anonymous
+      define_singleton_method :name do
+        class_name
+      end
     end
   end
 
+  let (:any_id) { 1 }
   let (:any_object) { Object.new }
 
   describe "simple attribute" do
-    let(:ar_class) { class_with_attributes([:id, :a1]) }
-    let(:model_class) { class_with_attributes([:id, :a1]) }
-    let(:mapper) { mapper_class(
-      ar_class, model_class,
-      simple: [:id, :a1]
-    ) }
+    let(:ar_class) { ar_class_with_attributes([:id, :attribute]) }
+    let(:model_class) { class_with_attributes([:id, :attribute]) }
+    let(:mapper) do
+      mapper_class(
+        'SimpleMapper',
+        active_record_class: ar_class,
+        creates_model_with: lambda { |rec| model_class.new },
+        simple_attr: [:attribute]
+      )
+    end
 
-    it "converts to model" do
-      ar = stub(id: 1, a1: 'any string')
+    it "finds model" do
+      id = any_id
+      result_ar = ar_class.new(id)
+      result_ar.attribute = 'any string'
 
-      model = mapper.to_model(ar)
+      ar_class.stubs(:find).with(id).returns(result_ar)
 
-      model.id.must_equal ar.id
-      model.a1.must_equal ar.a1
+      model = mapper.find!(id)
+
+      model.id.must_equal result_ar.id
+      model.attribute.must_equal result_ar.attribute
     end
 
-    it "converts to ar" do
-      model = stub(id: nil, a1: 'any string')
+    it "creates object" do
+      model = model_class.new
+      model.attribute = 'any string'
 
-      ar = mapper.to_ar(model)
+      id = any_id
+      ar = ar_class.new(id)
+      ar_class.expects(:create!).with(attribute: model.attribute).returns(ar)
 
-      ar.id.must_equal model.id
-      ar.a1.must_equal model.a1
+      mapper.create!(model)
+
+      model.id.must_equal id
     end
-  end
 
-  describe "ref attribute" do
-    let(:ar_class) { class_with_attributes([:id, :a1_id]) }
-    let(:model_class) { class_with_attributes([:id, :a1]) }
-    let(:a1_model) { any_object }
-    let(:mapper) { mapper_class(
-      ar_class, model_class,
-      simple: [:id],
-      ref: { a1: stub(to_model: a1_model) }
-    ) }
-    
-    it "converts to model without option" do
-      ar = stub(id: 1, a1: nil)
+    it "updates object" do
+      id = any_id
+      model = model_class.new(id)
+      model.attribute = 'any string'
 
-      model = mapper.to_model(ar)
+      ar_class.expects(:update).with(id, attribute: model.attribute)
 
-      model.id.must_equal ar.id
-      model.a1.must_equal a1_model
+      mapper.update(model)
     end
 
-    it "converts to AR" do
-      model = stub(id: nil, a1: stub(id: 10))
+    it "saves new object" do
+      model = model_class.new
+      model.attribute = 'any string'
 
-      ar = mapper.to_ar(model)
+      id = any_id
+      ar = ar_class.new(id)
+      ar_class.expects(:create!).with(attribute: model.attribute).returns(ar)
 
-      ar.id.must_equal model.id
-      ar.a1_id.must_equal model.a1.id
+      mapper.save!(model)
+
+      model.id.must_equal id
+    end
+
+    it "saves existing object" do
+      model = model_class.new(any_id)
+      model.attribute = 'any string'
+
+      ar_class.expects(:update).with(model.id, attribute: model.attribute)
+
+      mapper.save!(model)
     end
   end
 
-  describe "collection attribute" do
-    let(:ar_class) { class_with_attributes([:id, :a1]) }
-    let(:model_class) { class_with_attributes([:id, :a1]) }
-    let(:a1_model) { any_object }
-    let(:a1_ar) { any_object }
-    let(:mapper) { mapper_class(
-      ar_class, model_class, 
-      simple: [:id],
-      collection: {a1: stub(to_model: a1_model, to_ar: a1_ar)}
-    ) }
+  describe "ref attribute" do
+    let(:model_class) { class_with_attributes([:id, :object   ]) }
+    let(:ar_class)    { ar_class_with_attributes([:id, :object_id]) }
+    let(:ref_mapper) { MapperStub }
+    let(:mapper) do
+      mapper_class(
+        'RefMapper',
+        active_record_class: ar_class,
+        creates_model_with: lambda { |rec| model_class.new },
+        ref_attr: { object: ref_mapper }
+      )
+    end
     
-    it "converts to model with option" do
-      ar = stub(id: 1, a1: [Object.new, Object.new])
+    it "creates model from ar" do
+      object = any_object
+      ref_mapper.stubs(:find!).returns(object)
+
+      ar = ar_class.new(any_id)
 
-      model = mapper.to_model(ar, include: [:a1])
+      model = mapper.model_for(ar)
 
       model.id.must_equal ar.id
-      model.a1[0].must_equal a1_model
-      model.a1[1].must_equal a1_model
+      model.object.must_equal object
     end
 
-    it "does not convert to model without option" do
-      ar = stub(id: 1, a1: [Object.new, Object.new])
+    it "maps when creating object" do
+      model = model_class.new
+      model.object = stub(id: 10)
 
-      model = mapper.to_model(ar)
+      id = any_id
+      ar = ar_class.new(id)
 
-      model.id.must_equal ar.id
-      model.a1.must_equal nil
+      ar_class.expects(:create!).with(object_id: model.object.id).returns(ar)
+
+      mapper.create!(model)
+
+      model.id.must_equal id
     end
+  end
+
+  describe "aggregation" do
+    let(:ar_class) { ar_class_with_attributes([:id, :components]) }
+    let(:model_class) { class_with_attributes([:id, :components]) }
+    let(:mapper) do
+      mapper_class(
+        'AggregateMapper',
+        active_record_class: ar_class,
+        creates_model_with: lambda { |rec| model_class.new },
+        aggregates: { components: MapperStub }
+      )
+    end 
 
-    it "converts to AR with option" do
-      model = stub(id: nil, a1: [Object.new, Object.new])
+    it "instantiates model without components" do
+      ar = ar_class.new(any_id)
+      ar.components = [any_object]
 
-      ar = mapper.to_ar(model, include: [:a1])
+      model = mapper.model_for(ar)
 
-      ar.id.must_equal model.id
-      ar.a1[0].must_equal a1_ar
-      ar.a1[1].must_equal a1_ar
+      model.id.must_equal ar.id
+      model.components.must_equal nil
     end
 
-    it "does not convert to AR without option" do
-      model = stub(id: nil, a1: [Object.new, Object.new])
+    it "persists new model without components" do
+      model = model_class.new
+      model.components = [any_object]
+
+      id = any_id
+      ar = ar_class.new(id)
+      ar_class.expects(:create!).with({}).returns(ar)
 
-      ar = mapper.to_ar(model)
+      mapper.create!(model)
 
-      ar.id.must_equal model.id
-      ar.a1.must_equal nil
+      model.id.must_equal id
     end
   end
 
   describe "attribute in AR only" do
-    let(:ar_class) { class_with_attributes([:id, :a1]) }
+    let(:ar_class) { ar_class_with_attributes([:id, :attribute]) }
     let(:model_class) { class_with_attributes([:id]) }
-    let(:mapper) { mapper_class(ar_class, model_class, simple: [:id]) }
+    let(:mapper) do
+      mapper_class(
+        'AttributeMapper',
+        active_record_class: ar_class,
+        creates_model_with: lambda { |rec| model_class.new },
+      )
+    end
     
-    it "converts to model" do
-      ar = stub(id: 1, a1: 'any string')
+    it "instantiates model" do
+      ar = ar_class.new(any_id)
+      ar.attribute = 'any string'
 
-      model = mapper.to_model(ar)
+      model = mapper.model_for(ar)
 
       model.id.must_equal ar.id
     end
 
-    it "converts to AR" do
-      model = stub(id: nil)
+    it "creates model" do
+      model = model_class.new
 
-      ar = mapper.to_ar(model)
+      id = any_id
+      ar = ar_class.new(id)
+      ar_class.expects(:create!).with({}).returns(ar)
 
-      ar.id.must_equal model.id
-      ar.a1.must_equal nil
+      mapper.create!(model)
+
+      model.id.must_equal id
     end
   end
 
   describe "attribute in model only" do
-    let(:ar_class) { class_with_attributes([:id]) }
-    let(:model_class) { class_with_attributes([:id, :a1]) }
-    let(:mapper) { mapper_class(ar_class, model_class, simple: [:id]) }
+    let(:ar_class) { ar_class_with_attributes([:id]) }
+    let(:model_class) { class_with_attributes([:id, :attribute]) }
+    let(:mapper) do
+      mapper_class(
+        'AttributeMapper',
+        active_record_class: ar_class,
+        creates_model_with: lambda { |rec| model_class.new },
+      )
+    end
     
-    it "converts to model" do
-      ar = stub(id: 1)
+    it "instantiates model" do
+      ar = ar_class.new(any_id)
 
-      model = mapper.to_model(ar)
+      model = mapper.model_for(ar)
 
       model.id.must_equal ar.id
-      model.a1.must_equal nil
+      model.attribute.must_equal nil
     end
 
-    it "converts to AR" do
-      model = stub(id: nil, a1: 'any string')
+    it "creates model" do
+      model = model_class.new
+      model.attribute = 'any string'
+
+      id = any_id
+      ar = ar_class.new(id)
+      ar_class.expects(:create!).with({}).returns(ar)
+
+      mapper.create!(model)
+
+      model.id.must_equal id
+    end
+  end
+
+  describe "semantic keys" do
+    let(:ar_class)    { ar_class_with_attributes([:id, :key1, :key2, :field]) }
+    let(:model_class) { class_with_attributes([:id, :key1, :key2, :field]) }
+    let(:mapper) do
+      mapper_class(
+        'SemanticMapper',
+        active_record_class: ar_class,
+        creates_model_with: lambda { |ar| model_class.new },
+        simple_attr: [:key1, :key2, :field],
+        semantic_key: [:key1, :key2]
+      )
+    end
+    
+    it "saves new object" do
+      model = model_class.new
+      model.key1 = 10
+      model.key2 = 20
+      model.field = 'any string'
+
+      ar_class.stubs(:find_by)
+
+      id = any_id
+      ar = ar_class.new(id)
+      ar_class.expects(:create!).with(key1: model.key1, key2: model.key2, field: model.field).returns(ar)
+
+      mapper.save!(model)
+
+      model.id.must_equal id
+    end
+
+    it "saves existing object" do
+      model = model_class.new
+      model.key1 = 10
+      model.key2 = 20
+      model.field = 'any string'
+
+      id = any_id
+      ar = ar_class.new(id)
+
+      ar_class.stubs(:find_by).with(key1: model.key1, key2: model.key2).returns(ar)
+      ar_class.expects(:update).with(id, key1: model.key1, key2: model.key2, field: model.field)
+
+      mapper.save!(model)
+
+      model.id.must_equal id
+    end
+
+  end
+
+  describe "composition" do
+    let(:parts_ar_class)    { ar_class_with_attributes([:id, :simple]) }
+    let(:parts_model_class) { ar_class_with_attributes([:id, :simple]) }
+    let(:parts_mapper) do
+      mapper_class(
+        'PartsMapper',
+        active_record_class: parts_ar_class,
+        simple_attr: [:simple],
+        composes: 'composite'
+      )
+    end
+
+    let(:ar_class)    { ar_class_with_attributes([:id, :parts]) }
+    let(:model_class) { class_with_attributes([:id, :parts]) }
+    let(:mapper) do
+      mapper_class(
+        'CompositeMapper',
+        active_record_class: ar_class,
+        creates_model_with: lambda { |ar| model_class.new },
+        composed_of: { parts: parts_mapper }
+      )
+    end
+    
+    it "instantiates model with parts" do
+      id = any_id
+      part = any_object
+
+      ar = ar_class.new(id)
+
+      parts_mapper.stubs(:where).with(composite_id: id).returns([part])
+
+      model = mapper.model_for(ar)
+
+      model.id.must_equal id
+      model.parts.must_equal [part]
+    end
+
+    it "creates parts when creating object" do
+      part = parts_ar_class.new
+      part.simple = 'any string'
+
+      model = model_class.new
+      model.parts = [part]
+
+      id = any_id
+      ar = ar_class.new(id)
+      ar_class.stubs(:create!).returns(ar)
+
+      parts_ar = parts_ar_class.new(any_id)
+      parts_ar_class.expects(:create!).with(simple: part.simple, composite_id: id, index: 0).returns(parts_ar)
+
+      mapper.create!(model)
+    end
+
+    it "updates parts when updating object" do
+      part1 = parts_model_class.new(10)
+      part1.simple = 'existing part'
+
+      part2 = parts_model_class.new
+      part2.simple = 'new part'
+
+      id = any_id
+      model = model_class.new(id)
+      model.parts = [part1, part2]
+
+      parts_ar_class.expects(:where).with(composite_id: id).returns(parts_ar_class)
+      parts_ar_class.expects(:where).with().returns(parts_ar_class)
+      parts_ar_class.expects(:not).with(id: [part1.id]).returns(parts_ar_class)
+      parts_ar_class.expects(:delete_all)
+
+      parts_ar_class.expects(:update).with(part1.id, simple: part1.simple, composite_id: id, index: 0)
 
-      ar = mapper.to_ar(model)
+      ar = parts_ar_class.new(id)
+      parts_ar_class.expects(:create!).with(simple: part2.simple, composite_id: id, index: 1).returns(ar)
 
-      ar.id.must_equal model.id
+      mapper.update(model)
     end
   end
 end

metadata

@@ -1,58 +1,106 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: datamapa
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 5
-  version: 0.0.5
+version: !ruby/object:Gem::Version
+  version: 1.0.0
 platform: ruby
-authors: 
+authors:
 - Yosuke Doi
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-06-10 00:00:00 +09:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: minitest
+date: 2014-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
   name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :development
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+- !ruby/object:Gem::Dependency
+  name: bourne
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
   type: :development
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
 description: A minimalistic Data Mapper for removing model dependency on Active Record
-email: 
+email:
 - doinchi@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - LICENSE.txt
@@ -62,37 +110,29 @@ files:
 - lib/datamapa.rb
 - lib/datamapa/version.rb
 - spec/datamapa/datamapa_spec.rb
-has_rdoc: true
 homepage: https://github.com/doiyo/datamapa
-licenses: 
+licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+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: 1.3.7
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Data Mapper using Active Record
-test_files: 
+test_files:
 - spec/datamapa/datamapa_spec.rb