mince 2.0.0.pre.4 → 2.0.1

data/lib/mince/data_model.rb

@@ -8,7 +8,7 @@ require_relative 'config'
 module Mince # :nodoc:
   # = DataModel
   #
-  # Mince::DataModel is used as a mixin to easily mixin behavior into an object that 
+  # Mince::DataModel is used as a mixin to easily mixin behavior into an object that
   # you wish to act as a data model and interact with mince data interfaces.
   #
   # Simply mixin this module in order to get a wrapper class to interact with a mince
@@ -103,7 +103,7 @@ module Mince # :nodoc:
 
       # Increments a field by a given amount
       #
-      # Some databases provide very efficient algorithms for incrementing or decrementing a 
+      # Some databases provide very efficient algorithms for incrementing or decrementing a
       # value.
       #
       # @param [id] id the id of the record to update
@@ -119,7 +119,7 @@ module Mince # :nodoc:
       # @param [Symbol] field the field to update
       # @param [*] value the value to update the field with
       def remove_from_array(id, field, value)
-        interface.remove_from_array(data_collection, interface.primary_key, id, field, value)
+        interface.remove_from_array(data_collection, id, field, value)
       end
 
       # Pushes a value to an array field
@@ -128,7 +128,7 @@ module Mince # :nodoc:
       # @param [Symbol] field the field to update
       # @param [*] value the value to update the field with
       def push_to_array(id, field, value)
-        interface.push_to_array(data_collection, interface.primary_key, id, field, value)
+        interface.push_to_array(data_collection, id, field, value)
       end
 
       # Returns a record that has the given id
@@ -138,7 +138,7 @@ module Mince # :nodoc:
       # @param [id] id the id of the record to find
       # @returns [HashWithIndifferentAccess, nil] a hash with the data for the record
       def find(id)
-        translate_from_interface interface.find(data_collection, interface.primary_key, id)
+        translate_from_interface interface.find(data_collection, id)
       end
 
       # Deletes a field from all records in the collection
@@ -149,7 +149,7 @@ module Mince # :nodoc:
       end
 
 
-      # Deletes a field from all records that matches the field / value key pairs in the 
+      # Deletes all records that matches the field / value key pairs in the
       # params provided in the collection
       #
       # This will only delete records that match all key/value pairs in the params hash.
@@ -225,11 +225,23 @@ module Mince # :nodoc:
         interface.delete_collection(data_collection)
       end
 
-      private
+      # Generates a new id to be used for a primary key
+      def generate_unique_id(seed)
+        interface.generate_unique_id(seed)
+      end
+
+      # Adds a new record with provided data hash
+      #
+      # @param [Hash] data to add to the data collection
+      # @returns [Hash] the data that was added to the data collection, including the uniquely generated id
+      def add(hash)
+        hash = HashWithIndifferentAccess.new(hash.merge(primary_key => generate_unique_id(hash)))
+        interface.add(data_collection, hash).first
+      end
 
       def translate_from_interface(hash)
         if hash
-          hash["id"] = hash[primary_key] if hash[primary_key]
+          hash["id"] = hash[primary_key] if hash[primary_key] && (primary_key != :id || primary_key != 'id')
           HashWithIndifferentAccess.new hash
         end
       end
@@ -238,6 +250,8 @@ module Mince # :nodoc:
         data.collect {|d| translate_from_interface(d) }
       end
 
+      private
+
       def primary_key
         @primary_key ||= interface.primary_key
       end
@@ -293,7 +307,7 @@ module Mince # :nodoc:
     end
 
     def generated_id
-      interface.generate_unique_id(model)
+      self.class.generate_unique_id(model)
     end
 
     def model_has_id?

data/lib/mince/model.rb

@@ -1,9 +1,9 @@
-require 'active_support'
-require 'active_model'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/object/instance_variables'
-
 module Mince
+  require_relative 'model/fields'
+  require_relative 'model/persistence'
+  require_relative 'model/finders'
+  require_relative 'model/data_model'
+
   # = Model
   #
   # The mince model is a module that provides standard model to data behavior to the Mince data model mixing for a specific model.
@@ -31,131 +31,29 @@ module Mince
   #   book = Book.new title: 'The World In Photographs', publisher: 'National Geographic'
   #   book.save
   #
-  # View the docs for each method available
+  # By including this module, you are including DataModel, Fields, Persistence, and Finders.
+  #
+  # However, you can choose which modules you would like by including those modules individually 
+  # so that you can have flexibility an lighter weight help to implement your models.
+  #
+  #   class AvailableBook
+  #     include Mince::Model::DataModel
+  #
+  #     data_collection :books
+  #
+  #     def self.all
+  #       data_collection.all_by_fields(library: "St. Louis - Downtown", available: true).map{ |a| new(a) }
+  #     end
+  #   end
+  #
   module Model
     extend ActiveSupport::Concern
 
     included do
-      include ActiveModel::Conversion
-      extend ActiveModel::Naming
-
-      attr_accessor :id
-    end
-
-    module ClassMethods
-      # Sets or returns the data model class for the model
-      def data_model(model=nil)
-        @data_model = model if model
-        @data_model
-      end
-
-      # Returns all models from the data model
-      def all
-        data_model.all.map{|a| new a }
-      end
-
-      # Returns a model that matches a given id, returns nil if none found
-      def find(id)
-        a = data_model.find(id)
-        new a if a
-      end
-
-      # Adds a field to the object.  Takes options to indicate assignability.  If `assignable`
-      # is set, the field will be assignable via 
-      #   model.field = 'foo'
-      #   model.attributes = { field: 'foo' }
-      #
-      def field(field_name, options={})
-        if options[:assignable]
-          add_assignable_field(field_name)
-        else
-          add_readonly_field(field_name)
-        end
-      end
-
-      # Adds a read only field, values for these fields can only be set in the class itself
-      # or from the hash sent in to the initializer
-      def add_readonly_field(field_name)
-        fields << field_name
-        readonly_fields << field_name
-        attr_reader field_name
-      end
-
-      # Adds an assignable field, values for these fields can be set using the field writer
-      # or from the `attributes=` method.
-      def add_assignable_field(field_name)
-        fields << field_name
-        assignable_fields << field_name
-        attr_accessor field_name
-      end
-
-      # Adds multiple readonly fields to the fields array, and returns the current list
-      # of fields.  If no fields are given, it just returns the current list of fields
-      def fields(*field_names)
-        @fields ||= []
-        field_names.each {|field_name| field(field_name) }
-        @fields
-      end
-
-      # Returns the list of assignable fields
-      def assignable_fields
-        @assignable_fields ||= []
-      end
-
-      # Returns the list of readonly fields
-      def readonly_fields
-        @readonly_fields ||= []
-      end
-    end
-
-    delegate :data_model, :assignable_fields, :readonly_fields, :fields, to: 'self.class'
-
-    # Sets values (for fields defined by calling .field or .fields) in the hash to the object 
-    # includes assignable and non-assignable fields
-    def initialize(hash={})
-      @id = hash[:id]
-      readonly_fields.each do |field_name|
-        self.instance_variable_set("@#{field_name}", hash[field_name]) if hash[field_name]
-      end
-      self.attributes = hash
-    end
-
-    # Returns true if the record indicates that it has been persisted to a data model.
-    # Returns false otherwise.
-    def persisted?
-      !!id
-    end
-
-    # Saves the object to the data model.  Stores if new, updates previous entry if it has already
-    # been saved.
-    def save
-      ensure_no_extra_fields
-      if persisted?
-        data_model.update(self)
-      else
-        @id = data_model.store(self)
-      end
-    end
-
-    # Sets values (for assignable fields only, defined by calling .field or .fields) in the hash
-    # to the object.
-    #
-    # Allows the proxy to have whitelisted attributes to be assigned from http requests.
-    def attributes=(hash={})
-      assignable_fields.each do |field|
-        send("#{field}=", hash[field]) if hash[field]
-      end
-    end
-
-    private
-
-    # Ensures that the data model has all of the fields that are trying to be saved. Raises an
-    # exception if the data model does not.
-    def ensure_no_extra_fields
-      extra_fields = (fields - data_model.data_fields)
-      if extra_fields.any?
-        raise "Tried to save a #{self.class.name} with fields not specified in #{data_model.name}: #{extra_fields.join(', ')}"
-      end
+      include DataModel
+      include Fields
+      include Persistence
+      include Finders
     end
   end
 end

data/lib/mince/model/data_model.rb

@@ -0,0 +1,31 @@
+module Mince
+  module Model
+    require 'active_support'
+
+    module DataModel
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Sets or returns the data model class for the model
+        def data_model(model=nil)
+          @data_model = model if model
+          @data_model
+        end
+      end
+
+      protected
+
+      # Ensures that the data model has all of the fields that are trying to be saved. Raises an
+      # exception if the data model does not.
+      #
+      # Not sure if this is where this method should live, it requires both
+      # Mince::Model::DataModel and Mince::Model::Fields.
+      def ensure_no_extra_fields
+        extra_fields = (fields - data_model.data_fields)
+        if extra_fields.any?
+          raise "Tried to save a #{self.class.name} with fields not specified in #{data_model.name}: #{extra_fields.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/mince/model/fields.rb

@@ -0,0 +1,89 @@
+module Mince
+  module Model
+    require 'active_support'
+    require 'active_support/core_ext/module/delegation'
+    require 'active_support/core_ext/object/instance_variables'
+    require_relative 'data_model'
+
+    module Fields
+      extend ActiveSupport::Concern
+
+      included do
+        include Mince::Model::DataModel
+
+        attr_accessor :id
+      end
+
+      module ClassMethods
+        # Adds a field to the object.  Takes options to indicate assignability.  If `assignable`
+        # is set, the field will be assignable via 
+        #   model.field = 'foo'
+        #   model.attributes = { field: 'foo' }
+        #
+        def field(field_name, options={})
+          if options[:assignable]
+            add_assignable_field(field_name)
+          else
+            add_readonly_field(field_name)
+          end
+        end
+
+        # Adds a read only field, values for these fields can only be set in the class itself
+        # or from the hash sent in to the initializer
+        def add_readonly_field(field_name)
+          fields << field_name
+          readonly_fields << field_name
+          attr_reader field_name
+        end
+
+        # Adds an assignable field, values for these fields can be set using the field writer
+        # or from the `attributes=` method.
+        def add_assignable_field(field_name)
+          fields << field_name
+          assignable_fields << field_name
+          attr_accessor field_name
+        end
+
+        # Adds multiple readonly fields to the fields array, and returns the current list
+        # of fields.  If no fields are given, it just returns the current list of fields
+        def fields(*field_names)
+          @fields ||= []
+          field_names.each {|field_name| field(field_name) }
+          @fields
+        end
+
+        # Returns the list of assignable fields
+        def assignable_fields
+          @assignable_fields ||= []
+        end
+
+        # Returns the list of readonly fields
+        def readonly_fields
+          @readonly_fields ||= []
+        end
+      end
+
+      delegate :assignable_fields, :readonly_fields, :fields, to: 'self.class'
+
+      # Sets values (for fields defined by calling .field or .fields) in the hash to the object 
+      # includes assignable and non-assignable fields
+      def initialize(hash={})
+        @id = hash[:id]
+        readonly_fields.each do |field_name|
+          self.instance_variable_set("@#{field_name}", hash[field_name]) if hash[field_name]
+        end
+        self.attributes = hash
+      end
+
+      # Sets values (for assignable fields only, defined by calling .field or .fields) in the hash
+      # to the object.
+      #
+      # Allows the proxy to have whitelisted attributes to be assigned from http requests.
+      def attributes=(hash={})
+        assignable_fields.each do |field|
+          send("#{field}=", hash[field]) if hash[field]
+        end
+      end
+    end
+  end
+end

data/lib/mince/model/finders.rb

@@ -0,0 +1,32 @@
+module Mince
+  module Model
+    require 'active_support'
+    require_relative 'data_model'
+
+    module Finders
+      extend ActiveSupport::Concern
+
+      included do
+        include Mince::Model::DataModel
+      end
+
+      module ClassMethods
+        # Sets or returns the data model class for the model
+        def find_by_fields(*fields)
+          raise 'not implemented'
+        end
+
+        # Returns all models from the data model
+        def all
+          data_model.all.map{|a| new a }
+        end
+
+        # Returns a model that matches a given id, returns nil if none found
+        def find(id)
+          a = data_model.find(id)
+          new a if a
+        end
+      end
+    end
+  end
+end

data/lib/mince/model/persistence.rb

@@ -0,0 +1,45 @@
+module Mince
+  module Model
+    require 'active_support'
+    require 'active_model'
+    require 'active_support/core_ext/module/delegation'
+    require_relative 'data_model'
+
+    module Persistence
+      extend ActiveSupport::Concern
+
+      included do
+        include Mince::Model::DataModel
+        include ActiveModel::Conversion
+        extend ActiveModel::Naming
+      end
+
+      module ClassMethods
+        # Creates a record with the given field values
+        def create(data)
+          new(data).tap(&:save)
+        end
+      end
+
+      delegate :data_model, to: 'self.class'
+
+      # Returns true if the record indicates that it has been persisted to a data model.
+      # Returns false otherwise.
+      def persisted?
+        !!id
+      end
+
+      # Saves the object to the data model.  Stores if new, updates previous entry if it has already
+      # been saved.
+      def save
+        ensure_no_extra_fields if self.respond_to?(:ensure_no_extra_fields)
+
+        if persisted?
+          data_model.update(self)
+        else
+          @id = data_model.store(self)
+        end
+      end
+    end
+  end
+end

data/lib/mince/shared_examples/interface_example.rb

@@ -103,24 +103,19 @@ shared_examples_for 'a mince interface' do
       data2[:field_1] = 'value modified'
       interface.replace(:some_collection, data2)
 
-      convert(interface.find(:some_collection, primary_key, 2))[:field_1].should == 'value modified'
+      convert(interface.find(:some_collection, 2))[:field_1].should == 'value modified'
     end
 
     it 'can update a field with a value on a specific record' do
       interface.update_field_with_value(:some_collection, 3, :field_2, '10')
 
-      convert(interface.find(:some_collection, primary_key, 3))[:field_2].should == '10'
+      convert(interface.find(:some_collection, 3))[:field_2].should == '10'
     end
 
     it 'can increment a field with a given amount for a specific field' do
       interface.increment_field_by_amount(:some_collection, 1, :field_2, 3)
 
-      convert(interface.find(:some_collection, primary_key, 1))[:field_2].should == 6
-    end
-
-    it 'can get one document' do
-      convert(interface.find(:some_collection, :field_1, 'value 1')).should == convert(data1)
-      convert(interface.find(:some_collection, :field_2, 6)).should == convert(data2)
+      convert(interface.find(:some_collection, 1))[:field_2].should == 6
     end
 
     it 'can clear the data store' do
@@ -145,18 +140,18 @@ shared_examples_for 'a mince interface' do
     end
 
     it 'can push a value to an array for a specific record' do
-      interface.push_to_array(:some_collection, primary_key, 1, :field_3, 'add to existing array')
-      interface.push_to_array(:some_collection, primary_key, 1, :new_field, 'add to new array')
+      interface.push_to_array(:some_collection, 1, :field_3, 'add to existing array')
+      interface.push_to_array(:some_collection, 1, :new_field, 'add to new array')
 
-      record = convert(interface.find(:some_collection, primary_key, 1))
+      record = convert(interface.find(:some_collection, 1))
       record[:field_3].should include('add to existing array')
       record[:new_field].should == ['add to new array']
     end
 
     it 'can remove a value from an array for a specific record' do
-      interface.remove_from_array(:some_collection, primary_key, 1, :field_3, 2)
+      interface.remove_from_array(:some_collection, 1, :field_3, 2)
 
-      convert(interface.find(:some_collection, primary_key, 1))[:field_3].should_not include(2)
+      convert(interface.find(:some_collection, 1))[:field_3].should_not include(2)
     end
 
     it 'can get all records that match a given set of keys and values' do

data/lib/mince/version.rb

@@ -9,7 +9,7 @@ module Mince
     end
 
     def self.patch
-      '0.pre.4'
+      1
     end
   end
 

data/spec/integration/mince_data_model_spec.rb

@@ -0,0 +1,42 @@
+require 'mince'
+require 'hashy_db'
+
+describe 'A mince data model integration spec' do
+  let(:attributes) { { brand: brand, price: price, type: type, color: color } }
+  let(:brand) { mock }
+  let(:price) { mock }
+  let(:type) { mock }
+  let(:color) { mock }
+  let(:primary_key) { Mince::HashyDb::Interface.primary_key}
+
+  let(:data_model_klass) do
+    Class.new do
+      include Mince::DataModel
+
+      data_collection :guitars
+      data_fields :brand, :price, :type, :color
+    end
+  end
+
+  before do
+    Mince::Config.interface = Mince::HashyDb::Interface
+    Mince::HashyDb::Interface.clear
+  end
+
+  after do
+    Mince::HashyDb::Interface.clear
+  end
+
+  it 'can insert data directly to the data collection' do
+    result = data_model_klass.add attributes
+
+    all = data_model_klass.all
+    all.size.should == 1
+    [all.first, result].each do |object|
+      %w(brand price type color).each do |field|
+        object[field.to_sym].should == attributes[field.to_sym]
+      end
+      object[primary_key].should_not be_nil
+    end
+  end
+end

data/spec/integration/mince_model_spec.rb

@@ -0,0 +1,106 @@
+require 'mince'
+require 'hashy_db'
+
+describe 'A mince model integration spec' do
+  subject { model_klass.new attributes }
+
+  let(:attributes) { { brand: brand, price: price, type: type, color: color } }
+  let(:brand) { mock }
+  let(:price) { mock }
+  let(:type) { mock }
+  let(:color) { mock }
+
+  before do
+    Mince::Config.interface = Mince::HashyDb::Interface
+    Mince::HashyDb::Interface.clear
+  end
+
+  after do
+    Mince::HashyDb::Interface.clear
+  end
+
+  describe 'a model with a limited set of mince model mixins' do
+    let(:model_klass) do
+      Class.new do
+        include Mince::Model::Fields
+
+        data_model(
+          Class.new do
+            include Mince::DataModel
+
+            data_collection :guitars
+            data_fields :brand, :price, :type, :color
+          end
+        )
+        fields :brand, :price, :type, :color
+      end
+    end
+
+    it 'is initialized with the correct data' do
+      subject.brand.should == brand
+      subject.price.should == price
+      subject.type.should == type
+      subject.color.should == color
+    end
+
+    it 'cannot be persisted to the mince data interface' do
+      subject.respond_to?(:save).should be_false
+    end
+  end
+
+  describe 'a model with all mince model mixins' do
+    let(:model_klass) do
+      Class.new do
+        include Mince::Model
+
+        data_model(
+          Class.new do
+            include Mince::DataModel
+
+            data_collection :guitars
+            data_fields :brand, :price, :type, :color
+          end
+        )
+        fields :brand, :price, :type, :color
+      end
+    end
+
+    it 'is initialized with the correct data' do
+      subject.brand.should == brand
+      subject.price.should == price
+      subject.type.should == type
+      subject.color.should == color
+    end
+
+    it 'can be persisted to the mince data interface' do
+      subject.save
+
+      raw_record = Mince::Config.interface.find(:guitars, subject.id)
+      model_record = model_klass.find(subject.id)
+      raw_record[:brand].should == brand
+      model_record.brand.should == brand
+    end
+
+    context 'when not all fields are defined in the data model' do
+      let(:model_klass) do
+        Class.new do
+          include Mince::Model
+
+          data_model(
+            Class.new do
+              include Mince::DataModel
+
+              data_collection :guitars
+              data_fields :brand, :price, :type
+            end
+          )
+          fields :brand, :price, :type, :color
+        end
+      end
+
+      it 'raises an exception to provide feedback about the missing field' do
+        expect { subject.save }.to raise_exception(RuntimeError, "Tried to save a  with fields not specified in : color")
+      end
+    end
+  end
+end

data/spec/support/shared_examples/modeL_data_model_example.rb

@@ -0,0 +1,16 @@
+shared_examples_for 'a model using mince model data model' do
+  before do
+    begin
+      klass
+    rescue NameError
+      raise "You must define a `klass` spec variable to use the mince model finders shared example"
+    end
+  end
+
+  it 'can set and get the data model' do
+    data_model = mock 'data model'
+    klass.data_model(data_model)
+    klass.data_model.should == data_model
+  end
+end
+

data/spec/support/shared_examples/model_finders_example.rb

@@ -0,0 +1,59 @@
+shared_examples_for 'a model using mince model finders' do
+  before do
+    begin
+      klass
+    rescue NameError
+      raise "You must define a `klass` spec variable to use the mince model finders shared example"
+    end
+  end
+
+  describe 'getting all models' do
+    subject { klass.all }
+
+    let(:model) { mock }
+    let(:models) { [model] }
+    let(:data) { [datum] }
+    let(:datum) { mock }
+
+    before do
+      klass.data_model.stub(all: data)
+      klass.stub(:new).with(datum).and_return(model)
+    end
+
+    it 'returns an array of all models' do
+      subject.should == models
+    end
+  end
+
+  describe 'finding a model by id' do
+    subject { klass.find(id) }
+
+    let(:id) { mock 'id' }
+
+    before do
+      klass.data_model.stub(:find).with(id).and_return(data)
+    end
+
+    context 'when it exists' do
+      let(:data) { mock 'data' }
+      let(:model) { mock 'model' }
+
+      before do
+        klass.stub(:new).with(data).and_return(model)
+      end
+
+      it 'returns the model' do
+        subject.should == model
+      end
+    end
+
+    context 'when it does not exist' do
+      let(:data) { nil }
+
+      it 'returns nothing' do
+        subject.should be_nil
+      end
+    end
+  end
+end
+

data/spec/units/mince/data_model_spec.rb

@@ -31,6 +31,21 @@ describe Mince::DataModel, 'Mixin' do
     Mince::Config.stub(:interface => interface)
   end
 
+  describe "inserting data" do
+    let(:expected_hash) { data_field_attributes.merge(primary_key => unique_id) }
+
+    before do
+      interface.stub(:add).and_return([expected_hash])
+      interface.stub(:generate_unique_id).with(data_field_attributes).and_return(unique_id)
+    end
+
+    it 'adds the data to the db store with the generated id' do
+      interface.should_receive(:add).with(collection_name, HashWithIndifferentAccess.new(expected_hash)).and_return([expected_hash])
+
+      described_class.add(data_field_attributes).should == expected_hash
+    end
+  end
+
   describe "storing a data model" do
     let(:model) { mock 'a model', instance_values: data_field_attributes }
 
@@ -53,7 +68,7 @@ describe Mince::DataModel, 'Mixin' do
 
   it 'can delete the collection' do
     interface.should_receive(:delete_collection).with(collection_name)
-    
+
     described_class.delete_collection
   end
 
@@ -90,7 +105,7 @@ describe Mince::DataModel, 'Mixin' do
 
   describe 'updating a specific field for a data model' do
     let(:data_model_id) { '1234567' }
-    
+
     it 'has the data store update the field' do
       interface.should_receive(:update_field_with_value).with(collection_name, data_model_id, :some_field, 'some value')
 
@@ -112,7 +127,7 @@ describe Mince::DataModel, 'Mixin' do
     let(:data_model_id) { '1234567' }
 
     it 'replaces the data model in the db store' do
-      interface.should_receive(:push_to_array).with(collection_name, primary_key, data_model_id, :array_field, 'some value')
+      interface.should_receive(:push_to_array).with(collection_name, data_model_id, :array_field, 'some value')
 
       described_class.push_to_array(data_model_id, :array_field, 'some value')
     end
@@ -135,7 +150,7 @@ describe Mince::DataModel, 'Mixin' do
     let(:data_model_id) { '1234567' }
 
     it 'removes the value from the array' do
-      interface.should_receive(:remove_from_array).with(collection_name, primary_key, data_model_id, :array_field, 'some value')
+      interface.should_receive(:remove_from_array).with(collection_name, data_model_id, :array_field, 'some value')
 
       described_class.remove_from_array(data_model_id, :array_field, 'some value')
     end
@@ -220,7 +235,7 @@ describe Mince::DataModel, 'Mixin' do
     let(:data_model) { {primary_key => 'id', :id => 'id' } }
 
     it 'returns the data model from the data store' do
-      interface.should_receive(:find).with(collection_name, primary_key, 'id').and_return(data_model)
+      interface.should_receive(:find).with(collection_name, 'id').and_return(data_model)
 
       described_class.find(data_model[:id]).should == HashWithIndifferentAccess.new(data_model)
     end

data/spec/units/mince/model/data_model_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../../../../lib/mince/model/data_model'
+require_relative '../../../support/shared_examples/model_data_model_example'
+
+describe Mince::Model::DataModel do
+  let(:klass) do
+    Class.new do
+      include Mince::Model::DataModel
+
+      data_model Class.new
+    end
+  end
+
+  it_behaves_like 'a model using mince model data model'
+end

data/spec/units/mince/model/finders_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../../../../lib/mince/model/finders'
+require_relative '../../../support/shared_examples/model_finders_example'
+
+describe Mince::Model::Finders do
+  let(:klass) do
+    Class.new do
+      include Mince::Model::Finders
+
+      data_model Class.new
+    end
+  end
+
+  it_behaves_like 'a model using mince model finders'
+end

data/spec/units/mince/model_spec.rb

@@ -94,6 +94,15 @@ describe Mince::Model do
   end
 
   describe "Query Methods:" do
+    it 'provides a way to easily create a new record' do
+      model = mock 'model'
+      data = mock 'data'
+      klass.stub(:new).with(data).and_return(model)
+      model.should_receive(:save)
+
+      klass.create(data)
+    end
+
     describe 'finding a model by id' do
       subject { klass.find(id) }
 
@@ -126,3 +135,4 @@ describe Mince::Model do
     end
   end
 end
+

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: mince
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.4
-  prerelease: 6
+  version: 2.0.1
+  prerelease: 
 platform: ruby
 authors:
 - Matt Simpson
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-02 00:00:00.000000000 Z
+date: 2013-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -145,17 +145,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 2.0.0.pre
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 2.0.0.pre
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rb-fsevent
   requirement: !ruby/object:Gem::Requirement
@@ -180,16 +180,25 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/mince.rb
-- lib/mince/version.rb
 - lib/mince/config.rb
 - lib/mince/data_model.rb
 - lib/mince/model.rb
+- lib/mince/version.rb
 - lib/mince/shared_examples/interface_example.rb
+- lib/mince/model/data_model.rb
+- lib/mince/model/fields.rb
+- lib/mince/model/finders.rb
+- lib/mince/model/persistence.rb
+- spec/integration/mince_data_model_spec.rb
+- spec/integration/mince_model_spec.rb
+- spec/support/shared_examples/modeL_data_model_example.rb
+- spec/support/shared_examples/model_finders_example.rb
+- spec/units/mince/model/data_model_spec.rb
+- spec/units/mince/model/finders_spec.rb
 - spec/units/mince/config_spec.rb
 - spec/units/mince/interface_example_spec.rb
 - spec/units/mince/data_model_spec.rb
 - spec/units/mince/model_spec.rb
-- spec/integration/simple_mince_data_model_spec.rb
 homepage: https://github.com/coffeencoke/mince
 licenses: []
 post_install_message: 
@@ -205,19 +214,24 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: mince
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Library to interact with mince interfacing data libraries
 test_files:
+- spec/integration/mince_data_model_spec.rb
+- spec/integration/mince_model_spec.rb
+- spec/support/shared_examples/modeL_data_model_example.rb
+- spec/support/shared_examples/model_finders_example.rb
+- spec/units/mince/model/data_model_spec.rb
+- spec/units/mince/model/finders_spec.rb
 - spec/units/mince/config_spec.rb
 - spec/units/mince/interface_example_spec.rb
 - spec/units/mince/data_model_spec.rb
 - spec/units/mince/model_spec.rb
-- spec/integration/simple_mince_data_model_spec.rb
 has_rdoc: true

data/spec/integration/simple_mince_data_model_spec.rb

@@ -1,55 +0,0 @@
-require 'mince'
-require 'hashy_db'
-
-describe 'A simple mince data model integration spec' do
-  before do
-    Mince::Config.interface = Mince::HashyDb::Interface
-    Mince::HashyDb::Interface.clear
-  end
-
-  after do
-    Mince::HashyDb::Interface.clear
-  end
-
-  describe 'a model' do
-    subject { model_klass.new attributes }
-
-    let(:model_klass) do
-      Class.new do
-        include Mince::Model
-
-        data_model(
-          Class.new do
-            include Mince::DataModel
-
-            data_collection :guitars
-            data_fields :brand, :price, :type, :color
-          end
-        )
-        fields :brand, :price, :type, :color
-      end
-    end
-
-    let(:attributes) { { brand: brand, price: price, type: type, color: color } }
-    let(:brand) { mock }
-    let(:price) { mock }
-    let(:type) { mock }
-    let(:color) { mock }
-
-    it 'is initialized with the correct data' do
-      subject.brand.should == brand
-      subject.price.should == price
-      subject.type.should == type
-      subject.color.should == color
-    end
-
-    it 'can be persisted to the mince data interface' do
-      subject.save
-
-      raw_record = Mince::Config.interface.find(:guitars, Mince::HashyDb::Interface.primary_key, subject.id)
-      model_record = model_klass.find(subject.id)
-      raw_record[:brand].should == brand
-      model_record.brand.should == brand
-    end
-  end
-end