modis 1.1.0 → 1.2.0

data/spec/validations_spec.rb

@@ -11,24 +11,24 @@ describe 'validations' do
 
   it 'responds to valid?' do
     model.name = nil
-    model.valid?.should be_false
+    expect(model.valid?).to be false
   end
 
   it 'sets errors on the model' do
     model.name = nil
     model.valid?
-    model.errors[:name].should eq ["can't be blank"]
+    expect(model.errors[:name]).to eq(["can't be blank"])
   end
 
   describe 'save' do
     it 'returns true if the model is valid' do
       model.name = "Ian"
-      model.save.should be_true
+      expect(model.save).to be true
     end
 
     it 'returns false if the model is invalid' do
       model.name = nil
-      model.save.should be_false
+      expect(model.save).to be false
     end
   end
 
@@ -36,7 +36,7 @@ describe 'validations' do
     it 'raises an error if the model is invalid' do
       model.name = nil
       expect do
-        model.save!.should be_false
+        expect(model.save!).to be false
       end.to raise_error(Modis::RecordInvalid)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modis
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Ian Leitch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2014-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -75,27 +75,31 @@ extra_rdoc_files: []
 files:
 - ".coveralls.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/modis.rb
-- lib/modis/attributes.rb
+- lib/modis/attribute.rb
 - lib/modis/configuration.rb
 - lib/modis/errors.rb
-- lib/modis/finders.rb
+- lib/modis/finder.rb
+- lib/modis/index.rb
 - lib/modis/model.rb
 - lib/modis/persistence.rb
 - lib/modis/transaction.rb
 - lib/modis/version.rb
-- lib/tasks/spec.rake
+- lib/tasks/quality.rake
 - modis.gemspec
-- spec/attributes_spec.rb
+- spec/attribute_spec.rb
 - spec/errors_spec.rb
-- spec/finders_spec.rb
+- spec/finder_spec.rb
+- spec/index_spec.rb
 - spec/persistence_spec.rb
 - spec/spec_helper.rb
 - spec/support/simplecov_helper.rb
@@ -126,9 +130,10 @@ signing_key:
 specification_version: 4
 summary: ActiveModel + Redis
 test_files:
-- spec/attributes_spec.rb
+- spec/attribute_spec.rb
 - spec/errors_spec.rb
-- spec/finders_spec.rb
+- spec/finder_spec.rb
+- spec/index_spec.rb
 - spec/persistence_spec.rb
 - spec/spec_helper.rb
 - spec/support/simplecov_helper.rb

data/lib/modis/attributes.rb

@@ -1,138 +0,0 @@
-module Modis
-  module Attributes
-    TYPES = [:string, :integer, :float, :timestamp, :boolean, :array, :hash]
-
-    def self.included(base)
-      base.extend ClassMethods
-
-      base.instance_eval do
-        bootstrap_attributes
-      end
-    end
-
-    module ClassMethods
-      def bootstrap_attributes
-        class << self
-          attr_accessor :attributes
-        end
-
-        self.attributes = {}
-
-        attribute :id, :integer
-      end
-
-      def attribute(name, type = :string, options = {})
-        name = name.to_s
-        return if attributes.keys.include?(name)
-        raise UnsupportedAttributeType.new(type) unless TYPES.include?(type)
-
-        attributes[name] = options.update({ :type => type })
-        define_attribute_methods [name]
-        class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}
-            attributes['#{name}']
-          end
-
-          def #{name}=(value)
-            value = coerce_to_type('#{name}', value)
-            #{name}_will_change! unless value == attributes['#{name}']
-            attributes['#{name}'] = value
-          end
-        EOS
-      end
-    end
-
-    def attributes
-      @attributes ||= Hash[self.class.attributes.keys.zip]
-    end
-
-    def assign_attributes(hash)
-      hash.each do |k, v|
-        setter = "#{k}="
-        send(setter, v) if respond_to?(setter)
-      end
-    end
-
-    def write_attribute(key, value)
-      attributes[key.to_s] = value
-    end
-
-    protected
-
-    def set_sti_type
-      if self.class.sti_child?
-        assign_attributes(type: self.class.name)
-      end
-    end
-
-    def reset_changes
-      @changed_attributes.clear if @changed_attributes
-    end
-
-    def apply_defaults
-      defaults = {}
-      self.class.attributes.each do |attribute, options|
-        defaults[attribute] = options[:default] if options[:default]
-      end
-      assign_attributes(defaults)
-    end
-
-    def coerce_to_string(attribute, value)
-      attribute = attribute.to_s
-      return if value.blank?
-      type = self.class.attributes[attribute][:type]
-      if type == :array || type == :hash
-        MultiJson.encode(value) if value
-      elsif type == :timestamp
-        value.iso8601
-      else
-        value.to_s
-      end
-    end
-
-    def coerce_to_type(attribute, value)
-      # TODO: allow an attribute to be set to nil
-      return if value.blank?
-      attribute = attribute.to_s
-      type = self.class.attributes[attribute][:type]
-      strict = self.class.attributes[attribute][:strict] != false
-
-      if type == :string
-        value.to_s
-      elsif type == :integer
-        value.to_i
-      elsif type == :float
-        value.to_f
-      elsif type == :timestamp
-        return value if value.kind_of?(Time)
-        Time.parse(value)
-      elsif type == :boolean
-        return true if [true, 'true'].include?(value)
-        return false if [false, 'false'].include?(value)
-        raise AttributeCoercionError.new("'#{value}' cannot be coerced to a :boolean.")
-      elsif type == :array
-        decode_json(value, Array, attribute, strict)
-      elsif type == :hash
-        decode_json(value, Hash, attribute, strict)
-      else
-        value
-      end
-    end
-
-    def decode_json(value, type, attribute, strict)
-      return value if value.kind_of?(type)
-      begin
-        value = MultiJson.decode(value) if value.kind_of?(String)
-      rescue MultiJson::ParseError
-        raise if strict
-      else
-        value = value.to_s unless strict
-      end
-      if strict
-        return value if value.kind_of?(type)
-        raise AttributeCoercionError.new("Expected #{attribute} to be an #{type}, got #{value.class} instead.")
-      end
-      value
-    end
-  end
-end

data/lib/modis/finders.rb

@@ -1,48 +0,0 @@
-module Modis
-  module Finders
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def find(id)
-        record = attributes_for(id)
-        model_class(record).new(record, new_record: false)
-      end
-
-      def all
-        records = []
-
-        Modis.with_connection do |redis|
-          ids = redis.smembers(key_for(:all))
-          records = redis.pipelined do
-            ids.map { |id| redis.hgetall(key_for(id)) }
-          end
-        end
-
-        records.map do |record|
-          klass = model_class(record)
-          klass.new(record, new_record: false)
-        end
-      end
-
-      def attributes_for(id)
-        if id.nil?
-          raise RecordNotFound, "Couldn't find #{name} without an ID"
-        end
-        values = Modis.with_connection { |redis| redis.hgetall(key_for(id)) }
-        unless values['id'].present?
-          raise RecordNotFound, "Couldn't find #{name} with id=#{id}"
-        end
-        values
-      end
-
-      private
-
-      def model_class(record)
-        return self if record["type"].blank?
-        return record["type"].constantize
-      end
-    end
-  end
-end

data/lib/tasks/spec.rake

@@ -1,18 +0,0 @@
-begin
-  require 'cane/rake_task'
-
-  desc "Run cane to check quality metrics"
-  Cane::RakeTask.new(: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 => ['spec', 'quality']
-  end
-rescue LoadError
-  warn "cane not available, quality task not provided."
-end

data/spec/attributes_spec.rb

@@ -1,182 +0,0 @@
-require 'spec_helper'
-
-module AttributesSpec
-  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
-    attribute :hash_strict, :hash, strict: true
-    attribute :hash_not_strict, :hash, strict: false
-  end
-end
-
-describe Modis::Attributes do
-  let(:model) { AttributesSpec::MockModel.new }
-
-  it 'defines attributes' do
-    model.name = 'bar'
-    model.name.should == 'bar'
-  end
-
-  it 'applies an default value' do
-    model.name.should eq 'Janet'
-    model.age.should eq 60
-  end
-
-  it 'does not mark an attribute with a default as dirty' do
-    model.name_changed?.should be_false
-  end
-
-  it 'raises an error for an unsupported attribute type' do
-    expect do
-      class AttributesSpec::MockModel
-        attribute :unsupported, :symbol
-      end
-    end.to raise_error(Modis::UnsupportedAttributeType)
-  end
-
-  it 'assigns attributes' do
-    model.assign_attributes(name: 'bar')
-    model.name.should eq 'bar'
-  end
-
-  it 'does not attempt to assign attributes that are not defined on the model' do
-    model.assign_attributes(missing_attr: 'derp')
-    model.respond_to?(:missing_attr).should be_false
-  end
-
-  it 'allows an attribute to be nilled' do
-    model.name = nil
-    model.save!
-    model.class.find(model.id).name.should be_nil
-  end
-
-  describe ':string type' do
-    it 'is coerced' do
-      model.name = 'Ian'
-      model.save!
-      found = AttributesSpec::MockModel.find(model.id)
-      found.name.should eq 'Ian'
-    end
-  end
-
-  describe ':integer type' do
-    it 'is coerced' do
-      model.age = 18
-      model.save!
-      found = AttributesSpec::MockModel.find(model.id)
-      found.age.should eq 18
-    end
-  end
-
-  describe ':float type' do
-    it 'is coerced' do
-      model.percentage = 18.6
-      model.save!
-      found = AttributesSpec::MockModel.find(model.id)
-      found.percentage.should eq 18.6
-    end
-
-    it 'coerces a string representation to Float' do
-      model.percentage = '18.6'
-      model.save!
-      found = AttributesSpec::MockModel.find(model.id)
-      found.percentage.should eq 18.6
-    end
-  end
-
-  describe ':timestamp type' do
-    it 'is coerced' do
-      now = Time.now
-      model.created_at = now
-      model.save!
-      found = AttributesSpec::MockModel.find(model.id)
-      found.created_at.should be_kind_of(Time)
-      found.created_at.to_s.should eq now.to_s
-    end
-
-    it 'coerces a string representation to Time' do
-      now = Time.now
-      model.created_at = now.to_s
-      model.save!
-      found = AttributesSpec::MockModel.find(model.id)
-      found.created_at.should be_kind_of(Time)
-      found.created_at.to_s.should eq now.to_s
-    end
-  end
-
-  describe ':boolean type' do
-    it 'is coerced' do
-      model.flag = 'true'
-      model.save!
-      found = AttributesSpec::MockModel.find(model.id)
-      found.flag.should eq true
-    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 = AttributesSpec::MockModel.find(model.id)
-      found.array.should 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
-
-    it 'does not raise an error when assigned a JSON array string' do
-      expect { model.array = "[1,2,3]" }.to_not raise_error
-    end
-
-    it 'does not raise an error when a JSON string does not deserialize to an Array' 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 = AttributesSpec::MockModel.find(model.id)
-      found.hash.should eq({'foo' => 'bar'})
-    end
-
-    describe 'strict: true' do
-      it 'raises an error if the value cannot be decoded on assignment' do
-        expect { model.hash_strict = "test" }.to raise_error(MultiJson::ParseError)
-      end
-
-      it 'does not raise an error if the value can be decoded on assignment' do
-        expect { model.hash_strict = "{\"foo\":\"bar\"}" }.to_not raise_error
-      end
-    end
-
-    describe 'strict: false' do
-      it 'returns the value if it cannot be decoded' do
-        model.write_attribute(:hash_not_strict, "test")
-        model.save!
-        found = AttributesSpec::MockModel.find(model.id)
-        found.hash_not_strict.should eq "test"
-      end
-
-      it 'returns an integer as a string' do
-        model.hash_not_strict = 1
-        model.save!
-        found = AttributesSpec::MockModel.find(model.id)
-        found.hash_not_strict.should eq "1"
-      end
-    end
-  end
-end