modis 1.4.1-java

data/lib/modis/persistence.rb

@@ -0,0 +1,233 @@
+module Modis
+  module Persistence
+    def self.included(base)
+      base.extend ClassMethods
+      base.instance_eval do
+        class << self
+          attr_reader :sti_child
+          alias_method :sti_child?, :sti_child
+        end
+      end
+    end
+
+    module ClassMethods
+      # :nodoc:
+      def bootstrap_sti(parent, child)
+        child.instance_eval do
+          parent.instance_eval do
+            class << self
+              attr_accessor :sti_parent
+            end
+            attribute :type, :string unless attributes.key?('type')
+          end
+
+          @sti_child = true
+          @sti_parent = parent
+
+          bootstrap_attributes(parent)
+          bootstrap_indexes(parent)
+        end
+      end
+
+      def namespace
+        return sti_parent.namespace if sti_child?
+        @namespace ||= name.split('::').map(&:underscore).join(':')
+      end
+
+      def namespace=(value)
+        @namespace = value
+        @absolute_namespace = nil
+      end
+
+      def absolute_namespace
+        @absolute_namespace ||= [Modis.config.namespace, namespace].compact.join(':')
+      end
+
+      def key_for(id)
+        "#{absolute_namespace}:#{id}"
+      end
+
+      def create(attrs)
+        model = new(attrs)
+        model.save
+        model
+      end
+
+      def create!(attrs)
+        model = new(attrs)
+        model.save!
+        model
+      end
+
+      YAML_MARKER = '---'.freeze
+      def deserialize(record)
+        values = record.values
+        values = MessagePack.unpack(msgpack_array_header(values.size) + values.join)
+        keys = record.keys
+        values.each_with_index { |v, i| record[keys[i]] = v }
+        record
+      rescue MessagePack::MalformedFormatError
+        found_yaml = false
+
+        record.each do |k, v|
+          if v.start_with?(YAML_MARKER)
+            found_yaml = true
+            record[k] = YAML.load(v)
+          else
+            record[k] = MessagePack.unpack(v)
+          end
+        end
+
+        if found_yaml
+          id = record['id']
+          STDERR.puts "#{self}(id: #{id}) contains attributes serialized as YAML. As of Modis 1.4.0, YAML is no longer used as the serialization format. To improve performance loading this record, you can force the record to new serialization format (MessagePack) with: #{self}.find(#{id}).save!(yaml_sucks: true)"
+        end
+
+        record
+      end
+
+      private
+
+      def msgpack_array_header(n)
+        if n < 16
+          [0x90 | n].pack("C")
+        elsif n < 65536
+          [0xDC, n].pack("Cn")
+        else
+          [0xDD, n].pack("CN")
+        end.force_encoding(Encoding::UTF_8)
+      end
+    end
+
+    def persisted?
+      true
+    end
+
+    def key
+      new_record? ? nil : self.class.key_for(id)
+    end
+
+    def new_record?
+      defined?(@new_record) ? @new_record : true
+    end
+
+    def save(args = {})
+      create_or_update(args)
+    rescue Modis::RecordInvalid
+      false
+    end
+
+    def save!(args = {})
+      create_or_update(args) || (raise RecordNotSaved)
+    end
+
+    def destroy
+      self.class.transaction do |redis|
+        run_callbacks :destroy do
+          redis.pipelined do
+            remove_from_indexes(redis)
+            redis.srem(self.class.key_for(:all), id)
+            redis.del(key)
+          end
+        end
+      end
+    end
+
+    def reload
+      new_attributes = Modis.with_connection { |redis| self.class.attributes_for(redis, id) }
+      initialize(new_attributes)
+      self
+    end
+
+    def update_attribute(name, value)
+      assign_attributes(name => value)
+      save(validate: false)
+    end
+
+    def update_attributes(attrs)
+      assign_attributes(attrs)
+      save
+    end
+
+    def update_attributes!(attrs)
+      assign_attributes(attrs)
+      save!
+    end
+
+    private
+
+    def coerce_for_persistence(value)
+      value = [value.year, value.month, value.day, value.hour, value.min, value.sec, value.strftime("%:z")] if value.is_a?(Time)
+      MessagePack.pack(value)
+    end
+
+    def create_or_update(args = {})
+      validate(args)
+      future = persist(args[:yaml_sucks])
+
+      if future && (future == :unchanged || future.value == 'OK')
+        reset_changes
+        @new_record = false
+        true
+      else
+        false
+      end
+    end
+
+    def validate(args)
+      skip_validate = args.key?(:validate) && args[:validate] == false
+      return if skip_validate || valid?
+      raise Modis::RecordInvalid, errors.full_messages.join(', ')
+    end
+
+    def persist(persist_all)
+      future = nil
+      set_id if new_record?
+      callback = new_record? ? :create : :update
+
+      self.class.transaction do |redis|
+        run_callbacks :save do
+          run_callbacks callback do
+            redis.pipelined do
+              attrs = coerced_attributes(persist_all)
+              future = attrs.any? ? redis.hmset(self.class.key_for(id), attrs) : :unchanged
+
+              if new_record?
+                redis.sadd(self.class.key_for(:all), id)
+                add_to_indexes(redis)
+              else
+                update_indexes(redis)
+              end
+            end
+          end
+        end
+      end
+
+      future
+    end
+
+    def coerced_attributes(persist_all) # rubocop:disable Metrics/AbcSize
+      attrs = []
+
+      if new_record? || persist_all
+        attributes.each do |k, v|
+          if (self.class.attributes[k][:default] || nil) != v
+            attrs << k << coerce_for_persistence(v)
+          end
+        end
+      else
+        changed_attributes.each do |k, _|
+          attrs << k << coerce_for_persistence(attributes[k])
+        end
+      end
+
+      attrs
+    end
+
+    def set_id
+      Modis.with_connection do |redis|
+        self.id = redis.incr("#{self.class.absolute_namespace}_id_seq")
+      end
+    end
+  end
+end

data/lib/modis/transaction.rb

@@ -0,0 +1,13 @@
+module Modis
+  module Transaction
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def transaction
+        Modis.with_connection { |redis| redis.multi { yield(redis) } }
+      end
+    end
+  end
+end

data/lib/modis/version.rb

@@ -0,0 +1,3 @@
+module Modis
+  VERSION = '1.4.1'
+end

data/lib/tasks/quality.rake

@@ -0,0 +1,41 @@
+begin
+  if ENV['TRAVIS']
+    namespace :spec do
+      task cane: ['spec']
+    end
+  else
+    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
+  end
+rescue LoadError
+  warn "cane not available."
+
+  namespace :spec do
+    task cane: ['spec']
+  end
+end
+
+begin
+  require 'rubocop/rake_task'
+  t = RuboCop::RakeTask.new
+  t.options << '-D'
+rescue LoadError
+  warn 'rubocop not available.'
+  task rubocop: ['spec']
+end
+
+namespace :spec do
+  task quality: %w(cane rubocop)
+end

data/modis.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'modis/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "modis"
+  gem.version       = Modis::VERSION
+  gem.authors       = ["Ian Leitch"]
+  gem.email         = ["port001@gmail.com"]
+  gem.description   = "ActiveModel + Redis"
+  gem.summary       = "ActiveModel + Redis"
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency 'activemodel', '>= 3.0'
+  gem.add_runtime_dependency 'activesupport', '>= 3.0'
+  gem.add_runtime_dependency 'redis', '>= 3.0'
+  gem.add_runtime_dependency 'hiredis', '>= 0.5'
+  gem.add_runtime_dependency 'connection_pool', '>= 2'
+
+  if defined? JRUBY_VERSION
+    gem.platform = 'java'
+    gem.add_runtime_dependency 'msgpack-jruby'
+  else
+    gem.add_runtime_dependency 'msgpack', '>= 0.5'
+  end
+end

data/spec/attribute_spec.rb

@@ -0,0 +1,172 @@
+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
+    attribute :string_or_hash, [:string, :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
+      time = Time.new(2014, 12, 11, 17, 31, 50, '-02:00')
+      model.created_at = time
+      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(time.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, "Received value of type 'String', expected 'TrueClass', 'FalseClass' for attribute 'flag'.")
+    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, "Received value of type 'Hash', expected 'Array' for attribute 'array'.")
+    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, "Received value of type 'Array', expected 'Hash' for attribute 'hash'.")
+    end
+  end
+
+  describe 'variable type' do
+    it 'is coerced' do
+      model.string_or_hash = { foo: :bar }
+      model.save!
+      found = AttributeSpec::MockModel.find(model.id)
+      expect(found.string_or_hash).to eq('foo' => 'bar')
+
+      model.string_or_hash = 'test'
+      model.save!
+      found = AttributeSpec::MockModel.find(model.id)
+      expect(found.string_or_hash).to eq('test')
+    end
+
+    it 'raises an error when assigned another type' do
+      expect { model.string_or_hash = [] }.to raise_error(Modis::AttributeCoercionError, "Received value of type 'Array', expected 'String', 'Hash' for attribute 'string_or_hash'.")
+    end
+  end
+end