modis 1.4.1-java

data/benchmark/redis/connection/fakedis.rb

@@ -0,0 +1,90 @@
+# rubocop:disable all
+
+require 'fileutils'
+require 'redis/connection/hiredis'
+
+class Redis
+  module Connection
+    class Fakedis < ::Redis::Connection::Hiredis
+      class << self
+        attr_accessor :reads, :read_indicies, :replaying, :recording
+        alias_method :replaying?, :replaying
+        alias_method :recording?, :recording
+      end
+
+      @reads = []
+      @read_indicies = []
+
+      def self.start_replay(name)
+        puts "Fakedis replaying."
+        self.replaying = true
+
+        @reads = Marshal.load(File.read(reads_path(name)))
+        @read_indicies = Marshal.load(File.read(read_indicies_path(name)))
+      end
+
+      def self.start_recording
+        puts "Fakedis recording."
+        self.recording = true
+      end
+
+      def self.stop_recording(name)
+        self.recording = false
+
+        puts "\nFakedis:"
+        puts " * #{reads.size} unique reads recorded"
+
+        FileUtils.mkdir_p("tmp/fakedis")
+
+        File.open(reads_path(name), 'w') { |fd| fd.write(Marshal.dump(reads)) }
+        File.open(read_indicies_path(name), 'w') { |fd| fd.write(Marshal.dump(read_indicies)) }
+      end
+
+      def self.reads_path(name)
+        "tmp/fakedis/#{name}_reads.dump"
+      end
+
+      def self.read_indicies_path(name)
+        "tmp/fakedis/#{name}_read_indicies.dump"
+      end
+
+      def initialize(*args)
+        super
+        @reads_idx = -1
+        @read_depth = 0
+      end
+
+      def read
+        if self.class.recording?
+          @read_depth += 1
+          v = super
+          @read_depth -= 1
+          return v if @read_depth > 0
+          i = self.class.reads.index(v)
+
+          if i
+            self.class.read_indicies << i
+          else
+            self.class.reads << v
+            self.class.read_indicies << self.class.reads.size - 1
+          end
+
+          v
+        elsif self.class.replaying?
+          @reads_idx += 1
+          self.class.reads[self.class.read_indicies[@reads_idx]]
+        else
+          super
+        end
+      end
+
+      def write(v)
+        if self.class.replaying?
+          # Do nothing.
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/modis.rb

@@ -0,0 +1,41 @@
+require 'redis'
+require 'connection_pool'
+require 'active_model'
+require 'active_support/all'
+require 'yaml'
+require 'msgpack'
+
+require 'modis/version'
+require 'modis/configuration'
+require 'modis/attribute'
+require 'modis/errors'
+require 'modis/persistence'
+require 'modis/transaction'
+require 'modis/finder'
+require 'modis/index'
+require 'modis/model'
+
+module Modis
+  @mutex = Mutex.new
+
+  class << self
+    attr_accessor :connection_pool, :redis_options, :connection_pool_size,
+                  :connection_pool_timeout
+  end
+
+  self.redis_options = { driver: :hiredis }
+  self.connection_pool_size = 5
+  self.connection_pool_timeout = 5
+
+  def self.connection_pool
+    return @connection_pool if @connection_pool
+    @mutex.synchronize do
+      options = { size: connection_pool_size, timeout: connection_pool_timeout }
+      @connection_pool = ConnectionPool.new(options) { Redis.new(redis_options) }
+    end
+  end
+
+  def self.with_connection
+    connection_pool.with { |connection| yield(connection) }
+  end
+end

data/lib/modis/attribute.rb

@@ -0,0 +1,103 @@
+module Modis
+  module Attribute
+    TYPES = { string: [String],
+              integer: [Fixnum],
+              float: [Float],
+              timestamp: [Time],
+              hash: [Hash],
+              array: [Array],
+              boolean: [TrueClass, FalseClass] }.freeze
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.instance_eval do
+        bootstrap_attributes
+      end
+    end
+
+    module ClassMethods
+      def bootstrap_attributes(parent = nil)
+        attr_reader :attributes
+
+        class << self
+          attr_accessor :attributes, :attributes_with_defaults
+        end
+
+        self.attributes = parent ? parent.attributes.dup : {}
+        self.attributes_with_defaults = parent ? parent.attributes_with_defaults.dup : {}
+
+        attribute :id, :integer unless parent
+      end
+
+      def attribute(name, type, options = {})
+        name = name.to_s
+        raise AttributeError, "Attribute with name '#{name}' has already been specified." if attributes.key?(name)
+
+        type_classes = Array(type).map do |t|
+          raise UnsupportedAttributeType, t unless TYPES.key?(t)
+          TYPES[t]
+        end.flatten
+
+        attributes[name] = options.update(type: type)
+        attributes_with_defaults[name] = options[:default]
+        define_attribute_methods([name])
+
+        value_coercion = type == :timestamp ? 'value = Time.new(*value) if value && value.is_a?(Array) && value.count == 7' : nil
+        predicate = type_classes.map { |cls| "value.is_a?(#{cls.name})" }.join(' || ')
+
+        type_check = <<-RUBY
+        if value && !(#{predicate})
+          raise Modis::AttributeCoercionError, "Received value of type '\#{value.class}', expected '#{type_classes.join("', '")}' for attribute '#{name}'."
+        end
+        RUBY
+
+        class_eval <<-RUBY, __FILE__, __LINE__
+          def #{name}
+            attributes['#{name}']
+          end
+
+          def #{name}=(value)
+            #{value_coercion}
+
+            # ActiveSupport's Time#<=> does not perform well when comparing with NilClass.
+            if (value.nil? ^ attributes['#{name}'].nil?) || (value != attributes['#{name}'])
+              #{type_check}
+              #{name}_will_change!
+              attributes['#{name}'] = value
+            end
+          end
+        RUBY
+      end
+    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
+
+    def read_attribute(key)
+      attributes[key.to_s]
+    end
+
+    protected
+
+    def set_sti_type
+      return unless self.class.sti_child?
+      write_attribute(:type, self.class.name)
+    end
+
+    def reset_changes
+      @changed_attributes = nil
+    end
+
+    def apply_defaults
+      @attributes = Hash[self.class.attributes_with_defaults]
+    end
+  end
+end

data/lib/modis/configuration.rb

@@ -0,0 +1,14 @@
+module Modis
+  def self.configure
+    yield config
+  end
+
+  class Configuration < Struct.new(:namespace)
+  end
+
+  class << self
+    attr_reader :config
+  end
+
+  @config = Configuration.new
+end

data/lib/modis/errors.rb

@@ -0,0 +1,16 @@
+module Modis
+  class ModisError < StandardError; end
+  class RecordNotSaved < ModisError; end
+  class RecordNotFound < ModisError; end
+  class RecordInvalid < ModisError; end
+  class UnsupportedAttributeType < ModisError; end
+  class AttributeCoercionError < ModisError; end
+  class AttributeError < ModisError; end
+  class IndexError < ModisError; end
+
+  module Errors
+    def errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
+  end
+end

data/lib/modis/finder.rb

@@ -0,0 +1,76 @@
+module Modis
+  module Finder
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def find(*ids)
+        models = find_all(ids)
+        ids.count == 1 ? models.first : models
+      end
+
+      def all
+        records = Modis.with_connection do |redis|
+          ids = redis.smembers(key_for(:all))
+          redis.pipelined do
+            ids.map { |id| record_for(redis, id) }
+          end
+        end
+
+        records_to_models(records)
+      end
+
+      def attributes_for(redis, id)
+        raise RecordNotFound, "Couldn't find #{name} without an ID" if id.nil?
+
+        attributes = deserialize(record_for(redis, id))
+
+        unless attributes['id'].present?
+          raise RecordNotFound, "Couldn't find #{name} with id=#{id}"
+        end
+
+        attributes
+      end
+
+      def find_all(ids)
+        raise RecordNotFound, "Couldn't find #{name} without an ID" if ids.empty?
+
+        records = Modis.with_connection do |redis|
+          blk = proc { |id| record_for(redis, id) }
+          ids.count == 1 ? ids.map(&blk) : redis.pipelined { ids.map(&blk) }
+        end
+
+        models = records_to_models(records)
+
+        if models.count < ids.count
+          missing = ids - models.map(&:id)
+          raise RecordNotFound, "Couldn't find #{name} with id=#{missing.first}"
+        end
+
+        models
+      end
+
+      private
+
+      def records_to_models(records)
+        records.map do |record|
+          model_for(deserialize(record)) unless record.blank?
+        end.compact
+      end
+
+      def model_for(attributes)
+        model_class(attributes).new(attributes, new_record: false)
+      end
+
+      def record_for(redis, id)
+        redis.hgetall(key_for(id))
+      end
+
+      def model_class(record)
+        return self if record["type"].blank?
+        record["type"].constantize
+      end
+    end
+  end
+end

data/lib/modis/index.rb

@@ -0,0 +1,84 @@
+module Modis
+  module Index
+    def self.included(base)
+      base.extend ClassMethods
+      base.instance_eval do
+        bootstrap_indexes
+      end
+    end
+
+    module ClassMethods
+      def bootstrap_indexes(parent = nil)
+        class << self
+          attr_accessor :indexed_attributes
+        end
+
+        self.indexed_attributes = parent ? parent.indexed_attributes.dup : []
+      end
+
+      def index(attribute)
+        attribute = attribute.to_s
+        raise IndexError, "No such attribute '#{attribute}'" unless attributes.key?(attribute)
+        indexed_attributes << attribute
+      end
+
+      def where(query)
+        raise IndexError, 'Queries using multiple indexes is not currently supported.' if query.keys.size > 1
+        attribute, value = query.first
+        ids = index_for(attribute, value)
+        return [] if ids.empty?
+        find_all(ids)
+      end
+
+      def index_for(attribute, value)
+        Modis.with_connection do |redis|
+          key = index_key(attribute, value)
+          redis.smembers(key).map(&:to_i)
+        end
+      end
+
+      def index_key(attribute, value)
+        "#{absolute_namespace}:index:#{attribute}:#{value.inspect}"
+      end
+    end
+
+    private
+
+    def indexed_attributes
+      self.class.indexed_attributes
+    end
+
+    def index_key(attribute, value)
+      self.class.index_key(attribute, value)
+    end
+
+    def add_to_indexes(redis)
+      return if indexed_attributes.empty?
+
+      indexed_attributes.each do |attribute|
+        key = index_key(attribute, read_attribute(attribute))
+        redis.sadd(key, id)
+      end
+    end
+
+    def remove_from_indexes(redis)
+      return if indexed_attributes.empty?
+
+      indexed_attributes.each do |attribute|
+        key = index_key(attribute, read_attribute(attribute))
+        redis.srem(key, id)
+      end
+    end
+
+    def update_indexes(redis)
+      return if indexed_attributes.empty?
+
+      (changes.keys & indexed_attributes).each do |attribute|
+        old_value, new_value = changes[attribute]
+        old_key = index_key(attribute, old_value)
+        new_key = index_key(attribute, new_value)
+        redis.smove(old_key, new_key, id)
+      end
+    end
+  end
+end

data/lib/modis/model.rb

@@ -0,0 +1,47 @@
+module Modis
+  module Model
+    def self.included(base)
+      base.instance_eval do
+        include ActiveModel::Dirty
+        include ActiveModel::Validations
+        include ActiveModel::Serialization
+
+        extend ActiveModel::Naming
+        extend ActiveModel::Callbacks
+
+        define_model_callbacks :save, :create, :update, :destroy
+
+        include Modis::Errors
+        include Modis::Transaction
+        include Modis::Persistence
+        include Modis::Finder
+        include Modis::Attribute
+        include Modis::Index
+
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def inherited(child)
+        super
+        bootstrap_sti(self, child)
+      end
+    end
+
+    def initialize(record = nil, options = {})
+      apply_defaults
+      set_sti_type
+      assign_attributes(record) if record
+      reset_changes
+
+      return unless options.key?(:new_record)
+      instance_variable_set('@new_record', options[:new_record])
+    end
+
+    def ==(other)
+      super || other.instance_of?(self.class) && id.present? && other.id == id
+    end
+    alias_method :eql?, :==
+  end
+end