zermelo 1.0.1 → 1.1.0

data/spec/lib/zermelo/records/influxdb_record_spec.rb

@@ -13,11 +13,11 @@ describe Zermelo::Records::InfluxDBRecord, :influxdb => true do
 
       validates :name, :presence => true
 
-      has_many :children, :class_name => 'Zermelo::InfluxDBExampleChild'
-
+      has_many :children, :class_name => 'Zermelo::InfluxDBChild'
+      has_sorted_set :sorted, :class_name => 'Zermelo::InfluxDBSorted'
     end
 
-    class InfluxDBExampleChild
+    class InfluxDBChild
       include Zermelo::Records::InfluxDBRecord
 
       define_attributes :name => :string,
@@ -27,6 +27,17 @@ describe Zermelo::Records::InfluxDBRecord, :influxdb => true do
 
       validates :name, :presence => true
     end
+
+    class InfluxDBSorted
+      include Zermelo::Records::InfluxDBRecord
+
+      define_attributes :name => :string,
+                        :important => :boolean
+
+      belongs_to :example, :class_name => 'Zermelo::InfluxDBExample', :inverse_of => :sorted
+
+      validates :name, :presence => true
+    end
   end
 
   def create_example(attrs = {})
@@ -193,6 +204,22 @@ describe Zermelo::Records::InfluxDBRecord, :influxdb => true do
       expect(example.map(&:id)).to eq(['1'])
     end
 
+    it "allows multiple attributes in an intersect filter" do
+      create_example(:id => '1', :name => 'Jane Doe', :email => 'jdoe@example.com',
+        :active => 'true')
+      create_example(:id => '2', :name => 'John Smith',
+        :email => 'jsmith@example.com', :active => 'false')
+      create_example(:id => '3', :name => 'Fred Bloggs',
+        :email => 'fbloggs@example.com', :active => 'true')
+
+      example = Zermelo::InfluxDBExample.intersect(:active => true,
+        :name => 'Jane Doe').all
+      expect(example).not_to be_nil
+      expect(example).to be_an(Array)
+      expect(example.size).to eq(1)
+      expect(example.map(&:id)).to eq(['1'])
+    end
+
     it "chains an intersect and a union filter together" do
       create_example(:id => '1', :name => 'Jane Doe', :email => 'jdoe@example.com',
         :active => 'true')
@@ -227,19 +254,14 @@ describe Zermelo::Records::InfluxDBRecord, :influxdb => true do
 
   context 'has_many association' do
 
-    # def create_child(attrs = {})
-    #   Zermelo.influxdb.write_point('influx_db_example_child', attrs)
-    # end
-
     it "sets a parent/child has_many relationship between two records in influxdb" do
       create_example(:id => '8', :name => 'John Jones',
                      :email => 'jjones@example.com', :active => 'true')
+      example = Zermelo::InfluxDBExample.find_by_id('8')
 
-      child = Zermelo::InfluxDBExampleChild.new(:id => '3', :name => 'Abel Tasman')
+      child = Zermelo::InfluxDBChild.new(:id => '3', :name => 'Abel Tasman')
       expect(child.save).to be_truthy
 
-      example = Zermelo::InfluxDBExample.find_by_id('8')
-
       children = example.children.all
 
       expect(children).to be_an(Array)
@@ -253,6 +275,160 @@ describe Zermelo::Records::InfluxDBRecord, :influxdb => true do
       expect(children.size).to eq(1)
     end
 
+    it "applies an intersect filter to a has_many association" do
+      create_example(:id => '8', :name => 'John Jones',
+                     :email => 'jjones@example.com', :active => 'true')
+      example = Zermelo::InfluxDBExample.find_by_id('8')
+
+      child_1 = Zermelo::InfluxDBChild.new(:id => '3', :name => 'John Smith')
+      expect(child_1.save).to be_truthy
+
+      child_2 = Zermelo::InfluxDBChild.new(:id => '4', :name => 'Jane Doe')
+      expect(child_2.save).to be_truthy
+
+      example.children.add(child_1, child_2)
+      expect(example.children.count).to eq(2)
+
+      result = example.children.intersect(:name => 'John Smith').all
+      expect(result).to be_an(Array)
+      expect(result.size).to eq(1)
+      expect(result.map(&:id)).to eq(['3'])
+    end
+
+    it "applies chained intersect and union filters to a has_many association" do
+      create_example(:id => '8', :name => 'John Jones',
+                     :email => 'jjones@example.com', :active => 'true')
+      example = Zermelo::InfluxDBExample.find_by_id('8')
+
+      child_1 = Zermelo::InfluxDBChild.new(:id => '3', :name => 'John Smith')
+      expect(child_1.save).to be_truthy
+
+      child_2 = Zermelo::InfluxDBChild.new(:id => '4', :name => 'Jane Doe')
+      expect(child_2.save).to be_truthy
+
+      example.children.add(child_1, child_2)
+      expect(example.children.count).to eq(2)
+
+      result = example.children.intersect(:name => 'John Smith').union(:id => '4').all
+      expect(result).to be_an(Array)
+      expect(result.size).to eq(2)
+      expect(result.map(&:id)).to eq(['3', '4'])
+    end
+
+  end
+
+  context 'has_sorted_set association' do
+
+    let(:time_i) { Time.now.to_i }
+
+    it "sets a parent/child has_sorted_set relationship between two records in influxdb" do
+      create_example(:id => '8', :name => 'John Jones',
+                     :email => 'jjones@example.com', :active => 'true')
+      example = Zermelo::InfluxDBExample.find_by_id('8')
+
+      sorted_1 = Zermelo::InfluxDBSorted.new(:id => '3', :name => 'Abel Tasman', :time => time_i)
+      expect(sorted_1.save).to be_truthy
+
+      sorted_2 = Zermelo::InfluxDBSorted.new(:id => '4', :name => 'Joe Smith', :time => time_i - 60)
+      expect(sorted_2.save).to be_truthy
+
+      sorted = example.sorted.all
+
+      expect(sorted).to be_an(Array)
+      expect(sorted).to be_empty
+
+      example.sorted.add(sorted_1, sorted_2)
+
+      sorted = example.sorted.all
+
+      expect(sorted).to be_an(Array)
+      expect(sorted.size).to eq(2)
+      expect(sorted.map(&:id)).to eq(['3', '4'])
+    end
+
+    it "applies an intersect filter to a has_sorted_set association" do
+      create_example(:id => '8', :name => 'John Jones',
+                     :email => 'jjones@example.com', :active => 'true')
+      example = Zermelo::InfluxDBExample.find_by_id('8')
+
+      sorted_1 = Zermelo::InfluxDBSorted.new(:id => '3', :name => 'Abel Tasman', :time => time_i)
+      expect(sorted_1.save).to be_truthy
+
+      sorted_2 = Zermelo::InfluxDBSorted.new(:id => '4', :name => 'Joe Smith', :time => time_i - 60)
+      expect(sorted_2.save).to be_truthy
+
+      example.sorted.add(sorted_1, sorted_2)
+
+      result = example.sorted.intersect(:id => '3').all
+      expect(result).to be_an(Array)
+      expect(result.size).to eq(1)
+      expect(result.map(&:id)).to eq(['3'])
+    end
+
+    it "applies an intersect_range filter to a has_sorted_set association" do
+      create_example(:id => '8', :name => 'John Jones',
+                     :email => 'jjones@example.com', :active => 'true')
+      example = Zermelo::InfluxDBExample.find_by_id('8')
+
+      sorted_1 = Zermelo::InfluxDBSorted.new(:id => '3', :name => 'Abel Tasman', :time => time_i)
+      expect(sorted_1.save).to be_truthy
+
+      sorted_2 = Zermelo::InfluxDBSorted.new(:id => '4', :name => 'Joe Smith', :time => time_i - 60)
+      expect(sorted_2.save).to be_truthy
+
+      example.sorted.add(sorted_1, sorted_2)
+
+      result = example.sorted.intersect_range(time_i - 30, time_i + 30).all
+      expect(result).to be_an(Array)
+      expect(result.size).to eq(1)
+      expect(result.map(&:id)).to eq(['3'])
+    end
+
+    it "applies chained intersect and union filters to a has_sorted_set association" do
+      create_example(:id => '8', :name => 'John Jones',
+                     :email => 'jjones@example.com', :active => 'true')
+      example = Zermelo::InfluxDBExample.find_by_id('8')
+
+      sorted_1 = Zermelo::InfluxDBSorted.new(:id => '3', :name => 'Abel Tasman', :time => time_i)
+      expect(sorted_1.save).to be_truthy
+
+      sorted_2 = Zermelo::InfluxDBSorted.new(:id => '4', :name => 'Joe Smith', :time => time_i - 60)
+      expect(sorted_2.save).to be_truthy
+
+      sorted_3 = Zermelo::InfluxDBSorted.new(:id => '5', :name => 'John Trugg', :time => time_i - 90)
+      expect(sorted_3.save).to be_truthy
+
+      example.sorted.add(sorted_1, sorted_2, sorted_3)
+
+      result = example.sorted.intersect(:name => 'Abel Tasman').union(:id => '4').all
+      expect(result).to be_an(Array)
+      expect(result.size).to eq(2)
+      expect(result.map(&:id)).to eq(['3', '4'])
+    end
+
+    # # See https://github.com/flapjack/zermelo/issues/15
+    # it "applies chained intersect_range and union filters to a has_sorted_set association" do
+    #   create_example(:id => '8', :name => 'John Jones',
+    #                  :email => 'jjones@example.com', :active => 'true')
+    #   example = Zermelo::InfluxDBExample.find_by_id('8')
+
+    #   sorted_1 = Zermelo::InfluxDBSorted.new(:id => '3', :name => 'Abel Tasman', :time => time_i - 30)
+    #   expect(sorted_1.save).to be_truthy
+
+    #   sorted_2 = Zermelo::InfluxDBSorted.new(:id => '4', :name => 'Joe Smith', :time => time_i - 60)
+    #   expect(sorted_2.save).to be_truthy
+
+    #   sorted_3 = Zermelo::InfluxDBSorted.new(:id => '5', :name => 'John Trugg', :time => time_i - 90)
+    #   expect(sorted_3.save).to be_truthy
+
+    #   example.sorted.add(sorted_1, sorted_2, sorted_3)
+
+    #   result = example.sorted.intersect_range(time_i - 45, time_i - 15).union(:id => '4').all
+    #   expect(result).to be_an(Array)
+    #   expect(result.size).to eq(2)
+    #   expect(result.map(&:id)).to eq(['3', '4'])
+    # end
+
   end
 
 end

data/spec/lib/zermelo/records/redis_record_spec.rb

@@ -395,6 +395,12 @@ describe Zermelo::Records::RedisRecord, :redis => true do
       expect(example.map(&:id)).to eq(['9', '8'])
     end
 
+    it "does not return a spurious record count when records don't exist" do
+      scope = Zermelo::RedisExample.intersect(:id => ['3000', '5000'])
+      expect(scope.all).to be_empty
+      expect(scope.count).to eq 0
+    end
+
   end
 
 
@@ -825,7 +831,7 @@ describe Zermelo::Records::RedisRecord, :redis => true do
       create_datum(example, :id => '6', :summary => 'aaargh', :timestamp => time.to_i + 20,
         :emotion => 'upset')
 
-      data = example.data.intersect_range(0, 1, :desc => true).all
+      data = example.data.intersect_range(1, 2).sort(:id, :desc => true).all
 
       expect(data).not_to be_nil
       expect(data).to be_an(Array)
@@ -869,7 +875,7 @@ describe Zermelo::Records::RedisRecord, :redis => true do
         :emotion => 'upset')
 
       data = example.data.intersect_range(time.to_i - 1, time.to_i + 15,
-              :desc => true, :by_score => true).all
+              :by_score => true).sort(:timestamp, :desc => true).all
       expect(data).not_to be_nil
       expect(data).to be_an(Array)
       expect(data.size).to eq(2)
@@ -935,7 +941,7 @@ describe Zermelo::Records::RedisRecord, :redis => true do
       create_datum(example, :id => '6', :summary => 'aaargh', :timestamp => time.to_i + 20,
         :emotion => 'upset')
 
-      data = example.data.diff_range(0, 0, :desc => true).all
+      data = example.data.diff_range(2, 2).sort(:id, :desc => true).all
       expect(data).not_to be_nil
       expect(data).to be_an(Array)
       expect(data.size).to eq(2)
@@ -977,7 +983,8 @@ describe Zermelo::Records::RedisRecord, :redis => true do
       create_datum(example, :id => '6', :summary => 'aaargh', :timestamp => time.to_i + 20,
         :emotion => 'upset')
 
-      data = example.data.diff_range(time.to_i - 1, time.to_i + 8, :by_score => true, :desc => true).all
+      data = example.data.diff_range(time.to_i - 1, time.to_i + 8, :by_score => true).
+        sort(:timestamp, :desc => true).all
       expect(data).not_to be_nil
       expect(data).to be_an(Array)
       expect(data.size).to eq(2)

data/spec/spec_helper.rb

@@ -38,26 +38,28 @@ RSpec.configure do |config|
   #     --seed 1234
   config.order = 'random'
 
-  config.around(:each, :redis => true) do |example|
-    # Zermelo.logger = ::Logger.new('tmp/spec.log')
+  config.before(:all, :redis => true) do
     Zermelo.redis = ::Redis.new(:db => 14)
+  end
+
+  config.before(:each, :redis => true) do
+    Zermelo.redis.select(14)
     Zermelo.redis.flushdb
-    example.run
+  end
+
+  config.after(:all, :redis => true) do
     Zermelo.redis.quit
-    # Zermelo.logger.debug('----')
-    # Zermelo.logger = nil
   end
 
-  config.around(:each, :influxdb => true) do |example|
-    # Zermelo.logger = ::Logger.new('tmp/spec.log')
+  config.before(:all, :influxdb => true) do
     Zermelo.influxdb = InfluxDB::Client.new('zermelo_test',
       :username => 'zermelo', :password => 'zermelo', :retry => false)
+  end
+
+  config.before(:each, :influxdb => true) do
     Zermelo.influxdb.query('list series')['list_series_result'].each do |ser|
       Zermelo.influxdb.query("DELETE FROM \"#{ser['name']}\"")
     end
-    example.run
-    # Zermelo.logger.debug('----')
-    # Zermelo.logger = nil
   end
 
   config.after(:each, :time => true) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zermelo
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Ali Graham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -85,20 +85,14 @@ files:
 - lib/zermelo/filters/influxdb_filter.rb
 - lib/zermelo/filters/redis_filter.rb
 - lib/zermelo/filters/steps/base_step.rb
-- lib/zermelo/filters/steps/diff_range_step.rb
-- lib/zermelo/filters/steps/diff_step.rb
-- lib/zermelo/filters/steps/intersect_range_step.rb
-- lib/zermelo/filters/steps/intersect_step.rb
-- lib/zermelo/filters/steps/limit_step.rb
-- lib/zermelo/filters/steps/offset_step.rb
+- lib/zermelo/filters/steps/list_step.rb
+- lib/zermelo/filters/steps/set_step.rb
 - lib/zermelo/filters/steps/sort_step.rb
-- lib/zermelo/filters/steps/union_range_step.rb
-- lib/zermelo/filters/steps/union_step.rb
+- lib/zermelo/filters/steps/sorted_set_step.rb
 - lib/zermelo/locks/no_lock.rb
 - lib/zermelo/locks/redis_lock.rb
 - lib/zermelo/records/base.rb
 - lib/zermelo/records/class_methods.rb
-- lib/zermelo/records/collection.rb
 - lib/zermelo/records/errors.rb
 - lib/zermelo/records/influxdb_record.rb
 - lib/zermelo/records/instance_methods.rb

data/lib/zermelo/filters/steps/diff_range_step.rb

@@ -1,17 +0,0 @@
-require 'zermelo/filters/steps/base_step'
-
-module Zermelo
-  module Filters
-    class Steps
-      class DiffRangeStep < Zermelo::Filters::Steps::BaseStep
-        def self.accepted_types
-          [:sorted_set]
-        end
-
-        def self.returns_type
-          :sorted_set
-        end
-      end
-    end
-  end
-end

data/lib/zermelo/filters/steps/diff_step.rb

@@ -1,17 +0,0 @@
-require 'zermelo/filters/steps/base_step'
-
-module Zermelo
-  module Filters
-    class Steps
-      class DiffStep < Zermelo::Filters::Steps::BaseStep
-        def self.accepted_types
-          [:set, :sorted_set]
-        end
-
-        def self.returns_type
-          :set
-        end
-      end
-    end
-  end
-end

data/lib/zermelo/filters/steps/intersect_range_step.rb

@@ -1,17 +0,0 @@
-require 'zermelo/filters/steps/base_step'
-
-module Zermelo
-  module Filters
-    class Steps
-      class IntersectRangeStep < Zermelo::Filters::Steps::BaseStep
-        def self.accepted_types
-          [:sorted_set]
-        end
-
-        def self.returns_type
-          :sorted_set
-        end
-      end
-    end
-  end
-end

data/lib/zermelo/filters/steps/intersect_step.rb

@@ -1,17 +0,0 @@
-require 'zermelo/filters/steps/base_step'
-
-module Zermelo
-  module Filters
-    class Steps
-      class IntersectStep < Zermelo::Filters::Steps::BaseStep
-        def self.accepted_types
-          [:set, :sorted_set]
-        end
-
-        def self.returns_type
-          :set
-        end
-      end
-    end
-  end
-end

data/lib/zermelo/filters/steps/limit_step.rb

@@ -1,17 +0,0 @@
-require 'zermelo/filters/steps/base_step'
-
-module Zermelo
-  module Filters
-    class Steps
-      class LimitStep < Zermelo::Filters::Steps::BaseStep
-        def self.accepted_types
-          [:list]
-        end
-
-        def self.returns_type
-          :list
-        end
-      end
-    end
-  end
-end

data/lib/zermelo/filters/steps/offset_step.rb

@@ -1,17 +0,0 @@
-require 'zermelo/filters/steps/base_step'
-
-module Zermelo
-  module Filters
-    class Steps
-      class OffsetStep < Zermelo::Filters::Steps::BaseStep
-        def self.accepted_types
-          [:list]
-        end
-
-        def self.returns_type
-          :list
-        end
-      end
-    end
-  end
-end

data/lib/zermelo/filters/steps/union_range_step.rb

@@ -1,17 +0,0 @@
-require 'zermelo/filters/steps/base_step'
-
-module Zermelo
-  module Filters
-    class Steps
-      class UnionRangeStep < Zermelo::Filters::Steps::BaseStep
-        def self.accepted_types
-          [:sorted_set]
-        end
-
-        def self.returns_type
-          :sorted_set
-        end
-      end
-    end
-  end
-end

data/lib/zermelo/filters/steps/union_step.rb

@@ -1,17 +0,0 @@
-require 'zermelo/filters/steps/base_step'
-
-module Zermelo
-  module Filters
-    class Steps
-      class UnionStep < Zermelo::Filters::Steps::BaseStep
-        def self.accepted_types
-          [:set, :sorted_set]
-        end
-
-        def self.returns_type
-          :set
-        end
-      end
-    end
-  end
-end

data/lib/zermelo/records/collection.rb

@@ -1,14 +0,0 @@
-module Zermelo
-  module Records
-    # high-level abstraction for a set or list of record ids
-    class Collection
-      attr_reader :klass, :name, :type
-
-      def initialize(opts = {})
-        @klass  = opts[:class]
-        @name   = opts[:name]
-        @type   = opts[:type]
-      end
-    end
-  end
-end