modis 1.1.0 → 1.2.0

data/lib/modis.rb

@@ -2,15 +2,16 @@ require 'redis'
 require 'connection_pool'
 require 'active_model'
 require 'active_support/all'
-require 'multi_json'
+require 'yaml'
 
 require 'modis/version'
 require 'modis/configuration'
-require 'modis/attributes'
+require 'modis/attribute'
 require 'modis/errors'
 require 'modis/persistence'
 require 'modis/transaction'
-require 'modis/finders'
+require 'modis/finder'
+require 'modis/index'
 require 'modis/model'
 
 module Modis
@@ -18,7 +19,7 @@ module Modis
 
   class << self
     attr_accessor :connection_pool, :redis_options, :connection_pool_size,
-      :connection_pool_timeout
+                  :connection_pool_timeout
   end
 
   self.redis_options = {}

data/lib/tasks/quality.rake

@@ -0,0 +1,34 @@
+begin
+  require 'cane/rake_task'
+
+  desc 'Run cane to check quality metrics'
+  Cane::RakeTask.new(:cane_quality) do |cane|
+    cane.add_threshold 'coverage/covered_percent', :>=, 99
+    cane.no_style = false
+    cane.style_measure = 1000
+    cane.no_doc = true
+    cane.abc_max = 25
+  end
+
+  namespace :spec do
+    task cane: %w(spec cane_quality)
+  end
+rescue LoadError
+  warn "cane not available."
+
+  namespace :spec do
+    task cane: ['spec']
+  end
+end
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  warn 'rubocop not available.'
+  task rubocop: ['spec']
+end
+
+namespace :spec do
+  task quality: %w(cane rubocop)
+end

data/spec/attribute_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+module AttributeSpec
+  class MockModel
+    include Modis::Model
+
+    attribute :name, :string, default: 'Janet'
+    attribute :age, :integer, default: 60
+    attribute :percentage, :float
+    attribute :created_at, :timestamp
+    attribute :flag, :boolean
+    attribute :array, :array
+    attribute :hash, :hash
+  end
+end
+
+describe Modis::Attribute do
+  let(:model) { AttributeSpec::MockModel.new }
+
+  it 'defines attributes' do
+    model.name = 'bar'
+    expect(model.name).to eq('bar')
+  end
+
+  it 'applies an default value' do
+    expect(model.name).to eq('Janet')
+    expect(model.age).to eq(60)
+  end
+
+  it 'does not mark an attribute with a default as dirty' do
+    expect(model.name_changed?).to be false
+  end
+
+  it 'raises an error for an unsupported attribute type' do
+    expect do
+      module AttributeSpec
+        class MockModel
+          attribute :unsupported, :symbol
+        end
+      end.to raise_error(Modis::UnsupportedAttributeType)
+    end
+  end
+
+  it 'assigns attributes' do
+    model.assign_attributes(name: 'bar')
+    expect(model.name).to eq 'bar'
+  end
+
+  it 'does not attempt to assign attributes that are not defined on the model' do
+    model.assign_attributes(missing_attr: 'derp')
+    expect(model.respond_to?(:missing_attrexpect)).to be false
+  end
+
+  it 'allows an attribute to be nilled' do
+    model.name = nil
+    model.save!
+    expect(model.class.find(model.id).name).to be_nil
+  end
+
+  it 'allows an attribute to be a blank string' do
+    model.name = ''
+    model.save!
+    expect(model.class.find(model.id).name).to eq('')
+  end
+
+  describe ':string type' do
+    it 'is coerced' do
+      model.name = 'Ian'
+      model.save!
+      found = AttributeSpec::MockModel.find(model.id)
+      expect(found.name).to eq('Ian')
+    end
+  end
+
+  describe ':integer type' do
+    it 'is coerced' do
+      model.age = 18
+      model.save!
+      found = AttributeSpec::MockModel.find(model.id)
+      expect(found.age).to eq(18)
+    end
+  end
+
+  describe ':float type' do
+    it 'is coerced' do
+      model.percentage = 18.6
+      model.save!
+      found = AttributeSpec::MockModel.find(model.id)
+      expect(found.percentage).to eq(18.6)
+    end
+  end
+
+  describe ':timestamp type' do
+    it 'is coerced' do
+      now = Time.now
+      model.created_at = now
+      model.save!
+      found = AttributeSpec::MockModel.find(model.id)
+      expect(found.created_at).to be_kind_of(Time)
+      expect(found.created_at.to_s).to eq(now.to_s)
+    end
+  end
+
+  describe ':boolean type' do
+    describe true do
+      it 'is coerced' do
+        model.flag = true
+        model.save!
+        found = AttributeSpec::MockModel.find(model.id)
+        expect(found.flag).to be true
+      end
+    end
+
+    describe false do
+      it 'is coerced' do
+        model.flag = false
+        model.save!
+        found = AttributeSpec::MockModel.find(model.id)
+        expect(found.flag).to be false
+      end
+    end
+
+    it 'raises an error if assigned a non-boolean value' do
+      expect { model.flag = 'unf!' }.to raise_error(Modis::AttributeCoercionError)
+    end
+  end
+
+  describe ':array type' do
+    it 'is coerced' do
+      model.array = [1, 2, 3]
+      model.save!
+      found = AttributeSpec::MockModel.find(model.id)
+      expect(found.array).to eq([1, 2, 3])
+    end
+
+    it 'raises an error when assigned another type' do
+      expect { model.array = { foo: :bar } }.to raise_error(Modis::AttributeCoercionError)
+    end
+  end
+
+  describe ':hash type' do
+    it 'is coerced' do
+      model.hash = { foo: :bar }
+      model.save!
+      found = AttributeSpec::MockModel.find(model.id)
+      expect(found.hash).to eq(foo: :bar)
+    end
+
+    it 'raises an error when assigned another type' do
+      expect { model.hash = [] }.to raise_error(Modis::AttributeCoercionError)
+    end
+  end
+end

data/spec/errors_spec.rb

@@ -13,6 +13,6 @@ describe Modis::Errors do
 
   it 'adds errors' do
     model.errors.add(:name, 'is not valid')
-    model.errors[:name].should eq ['is not valid']
+    expect(model.errors[:name]).to eq(['is not valid'])
   end
 end

data/spec/{finders_spec.rb → finder_spec.rb}

@@ -16,14 +16,14 @@ module FindersSpec
   end
 end
 
-describe Modis::Finders do
+describe Modis::Finder do
   let!(:model) { FindersSpec::User.create!(name: 'Ian', age: 28) }
   let(:found) { FindersSpec::User.find(model.id) }
 
   it 'finds by ID' do
-    found.id.should eq model.id
-    found.name.should eq model.name
-    found.age.should eq model.age
+    expect(found.id).to eq(model.id)
+    expect(found.name).to eq(model.name)
+    expect(found.age).to eq(model.age)
   end
 
   it 'raises an error if the record could not be found' do
@@ -33,33 +33,32 @@ describe Modis::Finders do
   end
 
   it 'does not flag an attribute as dirty on a found instance' do
-    found.id_changed?.should be_false
+    expect(found.id_changed?).to be false
   end
 
   describe 'all' do
     it 'returns all records' do
       m2 = FindersSpec::User.create!(name: 'Tanya', age: 30)
       m3 = FindersSpec::User.create!(name: 'Kyle', age: 32)
-
-      FindersSpec::User.all.should == [model, m2, m3]
+      expect(FindersSpec::User.all).to eq([model, m2, m3])
     end
 
     it 'does not return a destroyed record' do
       model.destroy
-      FindersSpec::User.all.should == []
+      expect(FindersSpec::User.all).to eq([])
     end
   end
 
   it 'identifies a found record as not being new' do
-    found.new_record?.should be_false
+    expect(found.new_record?).to be false
   end
 
   describe 'Single Table Inheritance' do
     it 'returns the correct namespace' do
-      FindersSpec::Consumer.namespace.should eq 'users'
-      FindersSpec::Consumer.absolute_namespace.should eq 'modis:users'
-      FindersSpec::Producer.namespace.should eq 'users'
-      FindersSpec::Producer.absolute_namespace.should eq 'modis:users'
+      expect(FindersSpec::Consumer.namespace).to eq('users')
+      expect(FindersSpec::Consumer.absolute_namespace).to eq('modis:users')
+      expect(FindersSpec::Producer.namespace).to eq('users')
+      expect(FindersSpec::Producer.absolute_namespace).to eq('modis:users')
     end
 
     it 'returns instances of the correct class' do
@@ -72,13 +71,13 @@ describe Modis::Finders do
       kyle = models.find { |model| model.name == 'Kyle' }
       tanya = models.find { |model| model.name == 'Tanya' }
 
-      ian.should be_kind_of(FindersSpec::User)
-      kyle.should be_kind_of(FindersSpec::Consumer)
-      tanya.should be_kind_of(FindersSpec::Producer)
+      expect(ian).to be_kind_of(FindersSpec::User)
+      expect(kyle).to be_kind_of(FindersSpec::Consumer)
+      expect(tanya).to be_kind_of(FindersSpec::Producer)
 
-      FindersSpec::User.find(ian.id).should be_kind_of(FindersSpec::User)
-      FindersSpec::User.find(kyle.id).should be_kind_of(FindersSpec::Consumer)
-      FindersSpec::User.find(tanya.id).should be_kind_of(FindersSpec::Producer)
+      expect(FindersSpec::User.find(ian.id)).to be_kind_of(FindersSpec::User)
+      expect(FindersSpec::User.find(kyle.id)).to be_kind_of(FindersSpec::Consumer)
+      expect(FindersSpec::User.find(tanya.id)).to be_kind_of(FindersSpec::Producer)
     end
   end
 end

data/spec/index_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module IndexSpec
+  class MockModel
+    include Modis::Model
+
+    attribute :name, :string
+    index :name
+  end
+end
+
+describe Modis::Index do
+  let!(:model) { IndexSpec::MockModel.create!(name: 'Ian') }
+
+  describe 'create' do
+    it 'adds a new model to the index' do
+      index = IndexSpec::MockModel.index_for(:name, 'Ian')
+      expect(index).to include(model.id)
+    end
+  end
+
+  describe 'update' do
+    before do
+      model.name = 'Kyle'
+      model.save!
+    end
+
+    it 'adds the model to the new index' do
+      index = IndexSpec::MockModel.index_for(:name, 'Kyle')
+      expect(index).to include(model.id)
+    end
+
+    it 'removes the model from the old index' do
+      index = IndexSpec::MockModel.index_for(:name, 'Ian')
+      expect(index).to_not include(model.id)
+    end
+  end
+
+  describe 'destroy' do
+    it 'removes a destroyed model id from the index' do
+      model.destroy
+      index = IndexSpec::MockModel.index_for(:name, 'Ian')
+      expect(index).to_not include(model.id)
+    end
+
+    it 'does not find a destroyed model' do
+      model.destroy
+      models = IndexSpec::MockModel.where(name: 'Ian')
+      expect(models).to be_empty
+    end
+  end
+
+  it 'finds by index' do
+    models = IndexSpec::MockModel.where(name: 'Ian')
+    expect(models.first.name).to eq('Ian')
+  end
+
+  it 'finds multiple matches' do
+    IndexSpec::MockModel.create!(name: 'Ian')
+    models = IndexSpec::MockModel.where(name: 'Ian')
+    expect(models.count).to eq(2)
+  end
+
+  it 'returns an empty array if there are no results' do
+    expect(IndexSpec::MockModel.where(name: 'Foo')).to be_empty
+  end
+
+  it 'raises an error when trying to query against multiple indexes' do
+    expect { IndexSpec::MockModel.where(name: 'Ian', age: 29) }.to raise_error(Modis::IndexError, 'Queries using multiple indexes is not currently supported.')
+  end
+
+  it 'indexes a nil value' do
+    model.name = nil
+    model.save!
+    expect(IndexSpec::MockModel.where(name: nil)).to include(model)
+  end
+
+  it 'distinguishes between nil and blank string values' do
+    model1 = IndexSpec::MockModel.create!(name: nil)
+    model2 = IndexSpec::MockModel.create!(name: "")
+    expect(IndexSpec::MockModel.where(name: nil)).to eq([model1])
+    expect(IndexSpec::MockModel.where(name: "")).to eq([model2])
+  end
+end

data/spec/persistence_spec.rb

@@ -52,16 +52,16 @@ describe Modis::Persistence do
 
   describe 'namespaces' do
     it 'returns the namespace' do
-      PersistenceSpec::MockModel.namespace.should eq 'persistence_spec:mock_model'
+      expect(PersistenceSpec::MockModel.namespace).to eq('persistence_spec:mock_model')
     end
 
     it 'returns the absolute namespace' do
-      PersistenceSpec::MockModel.absolute_namespace.should eq 'modis:persistence_spec:mock_model'
+      expect(PersistenceSpec::MockModel.absolute_namespace).to eq('modis:persistence_spec:mock_model')
     end
 
     it 'allows the namespace to be set explicitly' do
       PersistenceSpec::MockModel.namespace = 'other'
-      PersistenceSpec::MockModel.absolute_namespace.should eq 'modis:other'
+      expect(PersistenceSpec::MockModel.absolute_namespace).to eq('modis:other')
     end
 
     after { PersistenceSpec::MockModel.namespace = nil }
@@ -69,44 +69,44 @@ describe Modis::Persistence do
 
   it 'returns a key' do
     model.save!
-    model.key.should eq 'modis:persistence_spec:mock_model:1'
+    expect(model.key).to eq('modis:persistence_spec:mock_model:1')
   end
 
   it 'returns a nil key if not saved' do
-    model.key.should be_nil
+    expect(model.key).to be_nil
   end
 
   it 'works with ActiveModel dirty tracking' do
     expect { model.name = 'Kyle' }.to change(model, :changed).to(['name'])
-    model.name_changed?.should be_true
+    expect(model.name_changed?).to be true
   end
 
   it 'resets dirty tracking when saved' do
     model.name = 'Kyle'
-    model.name_changed?.should be_true
+    expect(model.name_changed?).to be true
     model.save!
-    model.name_changed?.should be_false
+    expect(model.name_changed?).to be false
   end
 
   it 'resets dirty tracking when created' do
     model = PersistenceSpec::MockModel.create!(name: 'Ian')
-    model.name_changed?.should be_false
+    expect(model.name_changed?).to be false
   end
 
   it 'is persisted' do
-    model.persisted?.should be_true
+    expect(model.persisted?).to be true
   end
 
   it 'does not track the ID if the underlying Redis command failed'
 
   it 'does not perform validation if validate: false' do
     model.name = nil
-    model.valid?.should be_false
+    expect(model.valid?).to be false
     expect { model.save!(validate: false) }.to_not raise_error
     model.reload
-    model.name.should be_nil
+    expect(model.name).to be_nil
 
-    model.save(validate: false).should be_true
+    expect(model.save(validate: false)).to be true
   end
 
   describe 'an existing record' do
@@ -125,9 +125,9 @@ describe Modis::Persistence do
     it 'resets dirty tracking' do
       model.save!
       model.name = 'Foo'
-      model.name_changed?.should be_true
+      expect(model.name_changed?).to be true
       model.reload
-      model.name_changed?.should be_false
+      expect(model.name_changed?).to be false
     end
 
     it 'raises an error if the record has not been saved' do
@@ -142,12 +142,12 @@ describe Modis::Persistence do
     describe 'a new record' do
       it 'calls the before_create callback' do
         model.save!
-        model.called_callbacks.should include(:test_before_create)
+        expect(model.called_callbacks).to include(:test_before_create)
       end
 
       it 'calls the after create callback' do
         model.save!
-        model.called_callbacks.should include(:test_after_create)
+        expect(model.called_callbacks).to include(:test_after_create)
       end
     end
 
@@ -156,30 +156,30 @@ describe Modis::Persistence do
 
       it 'calls the before_update callback' do
         model.save!
-        model.called_callbacks.should include(:test_before_update)
+        expect(model.called_callbacks).to include(:test_before_update)
       end
 
       it 'calls the after update callback' do
         model.save!
-        model.called_callbacks.should include(:test_after_update)
+        expect(model.called_callbacks).to include(:test_after_update)
       end
     end
 
     it 'calls the before_save callback' do
       model.save!
-      model.called_callbacks.should include(:test_before_save)
+      expect(model.called_callbacks).to include(:test_before_save)
     end
 
     it 'calls the after save callback' do
       model.save!
-      model.called_callbacks.should include(:test_after_save)
+      expect(model.called_callbacks).to include(:test_after_save)
     end
   end
 
   describe 'create' do
     it 'resets dirty tracking' do
       model = PersistenceSpec::MockModel.create(name: 'Ian')
-      model.name_changed?.should be_false
+      expect(model.name_changed?).to be false
     end
 
     describe 'a valid model' do
@@ -194,48 +194,48 @@ describe Modis::Persistence do
   describe 'update_attribute' do
     it 'does not perform validation' do
       model.name = nil
-      model.valid?.should be_false
+      expect(model.valid?).to be false
       model.name = 'Test'
       model.update_attribute(:name, nil)
     end
 
     it 'invokes callbacks' do
       model.update_attribute(:name, 'Derp')
-      model.called_callbacks.should_not be_empty
+      expect(model.called_callbacks).to_not be_empty
     end
 
     it 'updates all dirty attributes' do
       model.age = 29
       model.update_attribute(:name, 'Derp')
       model.reload
-      model.age.should eq 29
+      expect(model.age).to eq 29
     end
   end
 
   describe 'update_attributes!' do
-it 'updates the given attributes' do
+    it 'updates the given attributes' do
       model.update_attributes!(name: 'Derp', age: 29)
       model.reload
-      model.name.should eq 'Derp'
-      model.age.should eq 29
+      expect(model.name).to eq 'Derp'
+      expect(model.age).to eq 29
     end
 
     it 'invokes callbacks' do
       model.update_attributes!(name: 'Derp')
-      model.called_callbacks.should_not be_empty
+      expect(model.called_callbacks).to_not be_empty
     end
 
     it 'updates all dirty attributes' do
       model.age = 29
       model.update_attributes!(name: 'Derp')
       model.reload
-      model.age.should eq 29
+      expect(model.age).to eq 29
     end
 
     it 'raises an error if the model is invalid' do
       expect do
-        model.update_attributes!(name: nil).should be_false
-        end.to raise_error(Modis::RecordInvalid)
+        model.update_attributes!(name: nil).to be false
+      end.to raise_error(Modis::RecordInvalid)
     end
   end
 
@@ -243,24 +243,24 @@ it 'updates the given attributes' do
     it 'updates the given attributes' do
       model.update_attributes(name: 'Derp', age: 29)
       model.reload
-      model.name.should eq 'Derp'
-      model.age.should eq 29
+      expect(model.name).to eq('Derp')
+      expect(model.age).to eq(29)
     end
 
     it 'invokes callbacks' do
       model.update_attributes(name: 'Derp')
-      model.called_callbacks.should_not be_empty
+      expect(model.called_callbacks).to_not be_empty
     end
 
     it 'updates all dirty attributes' do
       model.age = 29
       model.update_attributes(name: 'Derp')
       model.reload
-      model.age.should eq 29
+      expect(model.age).to eq(29)
     end
 
     it 'returns false if the model is invalid' do
-      model.update_attributes(name: nil).should be_false
+      expect(model.update_attributes(name: nil)).to be false
     end
   end
 end

data/spec/spec_helper.rb

@@ -16,7 +16,7 @@ RSpec.configure do |config|
   config.after :each do
     Modis.with_connection do |connection|
       keys = connection.keys "#{Modis.config.namespace}:*"
-      connection.del *keys unless keys.empty?
+      connection.del(*keys) unless keys.empty?
     end
   end
 end

data/spec/support/simplecov_quality_formatter.rb

@@ -1,8 +1,12 @@
-class SimpleCov::Formatter::QualityFormatter
-  def format(result)
-    SimpleCov::Formatter::HTMLFormatter.new.format(result)
-    File.open("coverage/covered_percent", "w") do |f|
-      f.puts result.source_files.covered_percent.to_f
+module SimpleCov
+  module Formatter
+    class QualityFormatter
+      def format(result)
+        SimpleCov::Formatter::HTMLFormatter.new.format(result)
+        File.open("coverage/covered_percent", "w") do |f|
+          f.puts result.source_files.covered_percent.to_f
+        end
+      end
     end
   end
 end

data/spec/transaction_spec.rb

@@ -9,8 +9,8 @@ end
 describe Modis::Transaction do
   it 'yields the block in a transaction' do
     redis = double.as_null_object
-    Modis.stub(:with_connection).and_yield(redis)
-    redis.should_receive(:multi)
+    allow(Modis).to receive(:with_connection).and_yield(redis)
+    expect(redis).to receive(:multi)
     TransactionSpec::MockModel.transaction {}
   end
 end