zermelo 1.1.0 → 1.2.0

data/lib/zermelo/record.rb

@@ -0,0 +1,53 @@
+require 'monitor'
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+require 'active_support/inflector'
+require 'active_model'
+
+require 'zermelo/associations/class_methods'
+
+require 'zermelo/records/instance_methods'
+require 'zermelo/records/class_methods'
+require 'zermelo/records/type_validator'
+
+module Zermelo
+
+  module Record
+
+    extend ActiveSupport::Concern
+
+    include Zermelo::Records::InstMethods
+
+    included do
+      include ActiveModel::AttributeMethods
+      extend ActiveModel::Callbacks
+      extend ActiveModel::Naming
+      include ActiveModel::Dirty
+      include ActiveModel::Validations
+      include ActiveModel::Validations::Callbacks
+
+      extend Zermelo::Records::Attributes
+
+      # include ActiveModel::MassAssignmentSecurity
+
+      @lock = Monitor.new
+
+      extend Zermelo::Records::ClassMethods
+      extend Zermelo::Associations::ClassMethods
+
+      attr_accessor :attributes
+
+      define_model_callbacks :create, :update, :destroy
+
+      attribute_method_suffix  "="  # attr_writers
+      # attribute_method_suffix  ""   # attr_readers # DEPRECATED
+
+      validates_with Zermelo::Records::TypeValidator
+
+      define_attributes :id => :string
+    end
+
+  end
+
+end

data/lib/zermelo/records/attributes.rb

@@ -0,0 +1,32 @@
+require 'zermelo'
+
+module Zermelo
+  module Records
+    module Attributes
+
+      def attribute_types
+        ret = nil
+        @lock.synchronize do
+          ret = (@attribute_types ||= {}).dup
+        end
+        ret
+      end
+
+      protected
+
+      def define_attributes(options = {})
+        options.each_pair do |key, value|
+          raise "Unknown attribute type ':#{value}' for ':#{key}'" unless
+            Zermelo.valid_type?(value)
+          self.define_attribute_methods([key])
+        end
+        @lock.synchronize do
+          (@attribute_types ||= {}).update(options)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/zermelo/records/class_methods.rb

@@ -3,9 +3,11 @@ require 'securerandom'
 
 require 'zermelo'
 
-require 'zermelo/backends/influxdb_backend'
-require 'zermelo/backends/redis_backend'
+require 'zermelo/backends/influxdb'
+require 'zermelo/backends/redis'
+require 'zermelo/backends/stub'
 
+require 'zermelo/records/attributes'
 require 'zermelo/records/key'
 
 module Zermelo
@@ -14,6 +16,8 @@ module Zermelo
 
     module ClassMethods
 
+      include Zermelo::Records::Attributes
+
       extend Forwardable
 
       def_delegators :filter, :intersect, :union, :diff, :sort,
@@ -40,14 +44,6 @@ module Zermelo
         backend.delete(ids_key, id.to_s)
       end
 
-      def attribute_types
-        ret = nil
-        @lock.synchronize do
-          ret = (@attribute_types ||= {}).dup
-        end
-        ret
-      end
-
       def lock(*klasses, &block)
         klasses += [self] unless klasses.include?(self)
         backend.lock(*klasses, &block)
@@ -62,8 +58,8 @@ module Zermelo
           yield
         rescue Exception => e
           backend.abort_transaction
-          p e.message
-          puts e.backtrace.join("\n")
+          # p e.message
+          # puts e.backtrace.join("\n")
           failed = true
         ensure
           backend.commit_transaction unless failed
@@ -80,23 +76,14 @@ module Zermelo
 
       protected
 
-      def define_attributes(options = {})
-        options.each_pair do |key, value|
-          raise "Unknown attribute type ':#{value}' for ':#{key}'" unless
-            Zermelo.valid_type?(value)
-          self.define_attribute_methods([key])
-        end
-        @lock.synchronize do
-          (@attribute_types ||= {}).update(options)
-        end
-      end
-
       def set_backend(backend_type)
         @backend ||= case backend_type.to_sym
         when :influxdb
-          Zermelo::Backends::InfluxDBBackend.new
+          Zermelo::Backends::InfluxDB.new
         when :redis
-          Zermelo::Backends::RedisBackend.new
+          Zermelo::Backends::Redis.new
+        when :stub
+          Zermelo::Backends::Stub.new
         end
       end
 

data/lib/zermelo/records/{influxdb_record.rb → influxdb.rb}

@@ -1,6 +1,6 @@
 require 'active_support/concern'
 
-require 'zermelo/records/base'
+require 'zermelo/record'
 
 # a record is a row in a time series (named for the record class)
 
@@ -21,17 +21,16 @@ require 'zermelo/records/base'
 
 module Zermelo
   module Records
-    module InfluxDBRecord
+    module InfluxDB
       extend ActiveSupport::Concern
 
-      include Zermelo::Records::Base
+      include Zermelo::Record
 
       included do
         set_backend :influxdb
 
         define_attributes :time => :timestamp
       end
-
     end
   end
 end

data/lib/zermelo/records/instance_methods.rb

@@ -7,11 +7,11 @@ module Zermelo
     # module renamed to avoid ActiveSupport::Concern deprecation warning
     module InstMethods
 
-      def initialize(attributes = {})
+      def initialize(attrs = {})
         @is_new = true
-        @attributes = {}
-        attributes.each_pair do |k, v|
-          self.send("#{k}=".to_sym, v)
+        @attributes = self.class.attribute_types.keys.inject({}) do |memo, ak|
+          memo[ak.to_s] = attrs[ak]
+          memo
         end
       end
 
@@ -46,6 +46,7 @@ module Zermelo
           class_key = self.class.send(:class_key)
 
           # TODO: check for record existence in backend-agnostic fashion
+          # TODO fail if id not found
           @is_new = false
 
           attr_types = self.class.attribute_types.reject {|k, v| k == :id}
@@ -55,11 +56,11 @@ module Zermelo
               :id => self.id, :name => name, :type => type, :object => :attribute)
           end
 
-          attrs = backend.get_multiple(*attrs_to_load)[class_key][self.id]
+          result = backend.get_multiple(*attrs_to_load)
+          attrs = result[class_key][self.id] unless result.empty?
         end
 
-        return false unless attrs.present?
-        @attributes.update(attrs)
+        @attributes.update(attrs) unless attrs.nil? || attrs.empty?
         true
       end
 
@@ -109,7 +110,7 @@ module Zermelo
             attr_keys = attribute_keys
 
             if creating
-              attribute_keys.each_pair do |att, attr_key|
+              attr_keys.each_pair do |att, attr_key|
                 apply_attribute.call(att, attr_key, [nil, @attributes[att]])
               end
             else

data/lib/zermelo/records/key.rb

@@ -6,7 +6,9 @@ module Zermelo
       # id       / if nil, it's a class variable
       # object   / :association, :attribute or :index
       # accessor / if a complex type, some way of getting sub-value
-      attr_reader :klass, :id, :name, :accessor, :type, :object
+      attr_reader :klass, :name, :accessor, :type, :object
+
+      attr_accessor :id
 
       # TODO better validation of data, e.g. accessor valid for type, etc.
       def initialize(opts = {})

data/lib/zermelo/records/redis.rb

@@ -0,0 +1,17 @@
+require 'active_support/concern'
+
+require 'zermelo/record'
+
+module Zermelo
+  module Records
+    module Redis
+      extend ActiveSupport::Concern
+
+      include Zermelo::Record
+
+      included do
+        set_backend :redis
+      end
+    end
+  end
+end

data/lib/zermelo/records/stub.rb

@@ -0,0 +1,17 @@
+require 'active_support/concern'
+
+require 'zermelo/record'
+
+module Zermelo
+  module Records
+    module Stub
+      extend ActiveSupport::Concern
+
+      include Zermelo::Record
+
+      included do
+        set_backend :stub
+      end
+    end
+  end
+end

data/lib/zermelo/version.rb

@@ -1,3 +1,3 @@
 module Zermelo
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/spec/lib/zermelo/associations/index_spec.rb

@@ -1,6 +1,75 @@
 require 'spec_helper'
+require 'zermelo/records/redis'
 require 'zermelo/associations/index'
 
-describe Zermelo::Associations::Index, :redis => true do
+describe Zermelo::Associations::Index do
+
+  context 'redis', :redis => true do
+
+    let(:redis) { Zermelo.redis }
+
+    let(:time)  { Time.now }
+
+    module ZermeloExamples
+      class RedisIndex
+        include Zermelo::Records::Redis
+        define_attributes :emotion => :string
+        validates :emotion, :presence => true, :inclusion => {:in => %w(happy sad indifferent)}
+        index_by :emotion
+      end
+    end
+
+    it 'adds an entry to a set indexing an attribute' do
+      example = ZermeloExamples::RedisIndex.new(:id => '1',
+        :emotion => 'happy')
+      expect(example).to be_valid
+      expect(example.save).to be true
+
+      expect(redis.exists('redis_index::indices:by_emotion:string:happy')).to be true
+      expect(redis.smembers('redis_index::indices:by_emotion:string:happy')).to eq([
+        '1'
+      ])
+    end
+
+    it 'removes an entry from a sorted set indexing an attribute' do
+      example = ZermeloExamples::RedisIndex.new(:id => '1',
+        :emotion => 'happy')
+      example.save
+
+      example_2 = ZermeloExamples::RedisIndex.new(:id => '2',
+        :emotion => 'happy')
+      example_2.save
+
+      expect(redis.smembers('redis_index::indices:by_emotion:string:happy')).to eq([
+        '1', '2'
+      ])
+
+      example.destroy
+
+      expect(redis.smembers('redis_index::indices:by_emotion:string:happy')).to eq([
+        '2'
+      ])
+    end
+
+    it 'changes an entry in a sorted set indexing an attribute' do
+      example = ZermeloExamples::RedisIndex.new(:id => '1',
+        :emotion => 'happy')
+      example.save
+
+      expect(redis.smembers('redis_index::indices:by_emotion:string:happy')).to eq([
+        '1'
+      ])
+
+      example.emotion = 'sad'
+      example.save
+
+      expect(redis.exists('redis_index::indices:by_emotion:string:happy')).to be false
+      expect(redis.exists('redis_index::indices:by_emotion:string:sad')).to be true
+      expect(redis.smembers('redis_index::indices:by_emotion:string:sad')).to eq([
+        '1'
+      ])
+    end
+
+  end
 
 end