cellect-server 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cd2bd7144a571ea98821b5f9e72054f6c562f4d
-  data.tar.gz: 5e596f14808744f601d070729a7d17bed24407fa
+  metadata.gz: 2e99eedbb031e30c30aa5a1115f3620f5e2e4cf3
+  data.tar.gz: 06dbf151721e9abdb0c3c518de248f8809e972a3
 SHA512:
-  metadata.gz: e42639b3c1d3ef1ee7ba5682f180b5ce426fa65493842654632ab919c6d1f96f011e6837891bf23d57585fd9a16ad43d010b06e1fcf2d30afababf26b11f286e
-  data.tar.gz: a0507f86c4bc0175c85afabf2d7543721b6057c0bb40cec134dc4d6403057641dca674b558a30ee1bc6737d8df0c449f1bc786316aeaee5f0b82e97db76250bd
+  metadata.gz: e4911bddd166a8258fa63fde6dd767159e848217c736d9c8390496150ba113cd9dbc35b092631a17d300b16670b73cd7e3a7e0bdfdb36052ff6c7c797d462816
+  data.tar.gz: 02043a81baca72f5d2a640a0d0d4909beae0751265e79bab6b4263ffd78661935b465ad16625c61ea6ad1bbadd051dff79c0ff7d0f20a5f7bfa5b54306999099

data/lib/cellect/server/adapters/postgres.rb

@@ -32,7 +32,7 @@ module Cellect
               FROM workflows w
               JOIN subject_sets_workflows ssw ON (ssw.workflow_id = w.id) 
               JOIN subject_sets ss ON (ss.id = ssw.subject_set_id) 
-              JOIN set_member_subjects sms ON (s.id = sms.subject_set_id)
+              JOIN set_member_subjects sms ON (ss.id = sms.subject_set_id)
               WHERE w.id = #{ workflow_name } 
             SQL
             pg.exec(statement).collect do |row|

data/lib/cellect/version.rb

@@ -1,3 +1,3 @@
 module Cellect
-  VERSION = '0.0.7'
+  VERSION = '0.0.8'
 end

data/spec/server/api/add_seen_spec.rb

@@ -14,10 +14,10 @@ module Cellect::Server
           
           it 'should add seen subjects' do
             async_workflow = double
-            workflow.should_receive(:async).and_return async_workflow
-            async_workflow.should_receive(:add_seen_for).with 123, 123
+            expect(workflow).to receive(:async).and_return async_workflow
+            expect(async_workflow).to receive(:add_seen_for).with 123, 123
             put "/workflows/#{ workflow_type }/users/123/add_seen", subject_id: 123
-            last_response.status.should == 200
+            expect(last_response.status).to eq 200
           end
         end
       end

data/spec/server/api/add_spec.rb

@@ -21,17 +21,17 @@ module Cellect::Server
           
           it 'should add subjects' do
             if workflow.grouped? && workflow.prioritized?
-              workflow.should_receive(:add).with subject_id: 123, group_id: 1, priority: 456.0
+              expect(workflow).to receive(:add).with subject_id: 123, group_id: 1, priority: 456.0
             elsif workflow.grouped?
-              workflow.should_receive(:add).with subject_id: 123, group_id: 1, priority: nil
+              expect(workflow).to receive(:add).with subject_id: 123, group_id: 1, priority: nil
             elsif workflow.prioritized?
-              workflow.should_receive(:add).with subject_id: 123, group_id: nil, priority: 456.0
+              expect(workflow).to receive(:add).with subject_id: 123, group_id: nil, priority: 456.0
             else
-              workflow.should_receive(:add).with subject_id: 123, group_id: nil, priority: nil
+              expect(workflow).to receive(:add).with subject_id: 123, group_id: nil, priority: nil
             end
             
             put "/workflows/#{ workflow_type }/add", opts
-            last_response.status.should == 200
+            expect(last_response.status).to eq 200
           end
         end
       end

data/spec/server/api/remove_spec.rb

@@ -20,13 +20,13 @@ module Cellect::Server
           
           it 'should remove subjects' do
             if workflow.grouped?
-              workflow.should_receive(:remove).with subject_id: 123, group_id: 1, priority: nil
+              expect(workflow).to receive(:remove).with subject_id: 123, group_id: 1, priority: nil
             else
-              workflow.should_receive(:remove).with subject_id: 123, group_id: nil, priority: nil
+              expect(workflow).to receive(:remove).with subject_id: 123, group_id: nil, priority: nil
             end
             
             put "/workflows/#{ workflow_type }/remove", opts
-            last_response.status.should == 200
+            expect(last_response.status).to eq 200
           end
         end
       end

data/spec/server/api/sample_spec.rb

@@ -13,19 +13,19 @@ module Cellect::Server
           before(:each){ pass_until workflow, is: :ready }
           
           it 'should sample without a user, limit, or group' do
-            workflow.should_receive(:sample).with(limit: 5, user_id: nil, group_id: nil).and_call_original
+            expect(workflow).to receive(:sample).with(limit: 5, user_id: nil, group_id: nil).and_call_original
             get "/workflows/#{ workflow_type }"
-            last_response.status.should == 200
-            json.should be_a Array
+            expect(last_response.status).to eq 200
+            expect(json).to be_a Array
           end
           
           shoulda = grouping ? 'limit, group, and user' : 'limit and user'
           it "should sample with a #{ shoulda }" do
             group_id = grouping ? 1 : nil
-            workflow.should_receive(:sample).with(limit: 3, user_id: 123, group_id: group_id).and_call_original
+            expect(workflow).to receive(:sample).with(limit: 3, user_id: 123, group_id: group_id).and_call_original
             get "/workflows/#{ workflow_type }?limit=3&user_id=123#{ grouping ? '&group_id=1' : '' }"
-            last_response.status.should == 200
-            json.should be_a Array
+            expect(last_response.status).to eq 200
+            expect(json).to be_a Array
           end
         end
       end

data/spec/server/api/user_load_spec.rb

@@ -13,10 +13,10 @@ module Cellect::Server
           
           it 'should load users' do
             async_workflow = double
-            workflow.should_receive(:async).and_return async_workflow
-            async_workflow.should_receive(:user).with 123
+            expect(workflow).to receive(:async).and_return async_workflow
+            expect(async_workflow).to receive(:user).with 123
             post "/workflows/#{ workflow_type }/users/123/load"
-            last_response.status.should == 201
+            expect(last_response.status).to eq 201
           end
         end
       end

data/spec/server/grouped_workflow_spec.rb

@@ -13,39 +13,39 @@ module Cellect::Server
         it 'should provide unseen from a random group for users' do
           workflow.groups = { }
           workflow.groups[1] = set_klass.new
-          workflow.groups[1].should_receive(:subtract).with user.seen, 3
+          expect(workflow.groups[1]).to receive(:subtract).with user.seen, 3
           workflow.unseen_for 123, limit: 3
         end
         
         it 'should provide unseen from a specific group for users' do
           3.times{ |i| workflow.groups[i] = set_klass.new }
-          workflow.group(1).should_receive(:subtract).with user.seen, 3
+          expect(workflow.group(1)).to receive(:subtract).with user.seen, 3
           workflow.unseen_for 123, group_id: 1, limit: 3
         end
         
         it 'should sample subjects from a random group without a user' do
           workflow.groups = { }
           workflow.groups[1] = set_klass.new
-          workflow.group(1).should_receive(:sample).with 3
+          expect(workflow.group(1)).to receive(:sample).with 3
           workflow.sample limit: 3
         end
         
         it 'should sample subjects from a specific group without a user' do
           3.times{ |i| workflow.groups[i] = set_klass.new }
-          workflow.group(1).should_receive(:sample).with 3
+          expect(workflow.group(1)).to receive(:sample).with 3
           workflow.sample group_id: 1, limit: 3
         end
         
         it 'should sample subjects from a random group for a user' do
           workflow.groups = { }
           workflow.groups[1] = set_klass.new
-          workflow.groups[1].should_receive(:subtract).with user.seen, 3
+          expect(workflow.groups[1]).to receive(:subtract).with user.seen, 3
           workflow.sample user_id: 123, limit: 3
         end
         
         it 'should sample subjects from a specific group for a user' do
           3.times{ |i| workflow.groups[i] = set_klass.new }
-          workflow.group(1).should_receive(:subtract).with user.seen, 3
+          expect(workflow.group(1)).to receive(:subtract).with user.seen, 3
           workflow.sample user_id: 123, group_id: 1, limit: 3
         end
         
@@ -53,22 +53,22 @@ module Cellect::Server
           workflow.groups[1] = set_klass.new
           
           if workflow.prioritized?
-            workflow.groups[1].should_receive(:add).with 123, 456
+            expect(workflow.groups[1]).to receive(:add).with 123, 456
             workflow.add subject_id: 123, group_id: 1, priority: 456
           else
-            workflow.groups[1].should_receive(:add).with 123
+            expect(workflow.groups[1]).to receive(:add).with 123
             workflow.add subject_id: 123, group_id: 1
           end
         end
         
         it 'should remove subjects' do
           workflow.groups[1] = set_klass.new
-          workflow.groups[1].should_receive(:remove).with 123
+          expect(workflow.groups[1]).to receive(:remove).with 123
           workflow.remove subject_id: 123, group_id: 1
         end
         
         it 'should be grouped' do
-          workflow.should be_grouped
+          expect(workflow).to be_grouped
         end
       end
     end

data/spec/server/node_set_spec.rb

@@ -6,8 +6,8 @@ module Cellect::Server
     let(:node_set){ Cellect::Server.node_set.actors.first }
     
     it 'should register this node' do
-      node_set.id.should == 'node0000000000'
-      node_set.zk.get('/nodes/node0000000000').first.should =~ /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+      expect(node_set.id).to eq 'node0000000000'
+      expect(node_set.zk.get('/nodes/node0000000000').first).to match /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
     end
   end
 end

data/spec/server/server_spec.rb

@@ -12,12 +12,12 @@ module Cellect::Server
       end
       
       it 'should return a workflow given a set of options' do
-        default.workflow_for('name' => 'a').should be_an_instance_of Workflow
-        default.workflow_for('name' => 'b', 'grouped' => true).should be_an_instance_of GroupedWorkflow
-        default.workflow_for('name' => 'c', 'pairwise' => true).should be_pairwise
-        default.workflow_for('name' => 'd', 'prioritized' => true).should be_prioritized
-        default.workflow_for('name' => 'e', 'pairwise' => true, 'prioritized' => true).should be_pairwise
-        default.workflow_for('name' => 'e', 'pairwise' => true, 'prioritized' => true).should be_prioritized
+        expect(default.workflow_for('name' => 'a')).to be_an_instance_of Workflow
+        expect(default.workflow_for('name' => 'b', 'grouped' => true)).to be_an_instance_of GroupedWorkflow
+        expect(default.workflow_for('name' => 'c', 'pairwise' => true)).to be_pairwise
+        expect(default.workflow_for('name' => 'd', 'prioritized' => true)).to be_prioritized
+        expect(default.workflow_for('name' => 'e', 'pairwise' => true, 'prioritized' => true)).to be_pairwise
+        expect(default.workflow_for('name' => 'e', 'pairwise' => true, 'prioritized' => true)).to be_prioritized
       end
     end
   end

data/spec/server/user_spec.rb

@@ -5,28 +5,28 @@ module Cellect::Server
     let(:user){ User.new 1, workflow_name: 'random' }
     
     it 'should store seen ids' do
-      user.seen.should be_a DiffSet::RandomSet
+      expect(user.seen).to be_a DiffSet::RandomSet
     end
     
     it 'should have a default ttl of 15 minutes' do
-      user.ttl.should == 900 # seconds
+      expect(user.ttl).to eq 900 # seconds
     end
     
     it 'should allow custom ttl' do
-      User.new(2, workflow_name: 'random', ttl: 123).ttl.should == 123
+      expect(User.new(2, workflow_name: 'random', ttl: 123).ttl).to eq 123
     end
     
     it 'should reset the ttl timer on activity' do
-      user.bare_object.should_receive(:restart_ttl_timer).at_least :once
+      expect(user.bare_object).to receive(:restart_ttl_timer).at_least :once
       user.seen
     end
     
     it 'should terminate on ttl expiry' do
       async_workflow = double
-      Workflow[user.workflow_name].should_receive(:async).and_return async_workflow
-      async_workflow.should_receive(:remove_user).with user.id
+      expect(Workflow[user.workflow_name]).to receive(:async).and_return async_workflow
+      expect(async_workflow).to receive(:remove_user).with user.id
       user.ttl_expired!
-      user.ttl_timer.should be_nil
+      expect(user.ttl_timer).to be_nil
     end
   end
 end

data/spec/server/workflow_spec.rb

@@ -10,51 +10,51 @@ module Cellect::Server
         before(:each){ pass_until workflow, is: :ready }
         
         it 'should provide unseen for users' do
-          workflow.subjects.should_receive(:subtract).with user.seen, 3
+          expect(workflow.subjects).to receive(:subtract).with user.seen, 3
           workflow.unseen_for 123, limit: 3
         end
         
         it 'should sample subjects without a user' do
-          workflow.subjects.should_receive(:sample).with 3
+          expect(workflow.subjects).to receive(:sample).with 3
           workflow.sample limit: 3
         end
         
         it 'should sample subjects with a user' do
-          workflow.subjects.should_receive(:subtract).with user.seen, 3
+          expect(workflow.subjects).to receive(:subtract).with user.seen, 3
           workflow.sample user_id: 123, limit: 3
         end
         
         it 'should add subjects' do
           if workflow.prioritized?
-            workflow.subjects.should_receive(:add).with 123, 456
+            expect(workflow.subjects).to receive(:add).with 123, 456
             workflow.add subject_id: 123, priority: 456
           else
-            workflow.subjects.should_receive(:add).with 123
+            expect(workflow.subjects).to receive(:add).with 123
             workflow.add subject_id: 123
           end
         end
         
         it 'should remove subjects' do
-          workflow.subjects.should_receive(:add).with 123
+          expect(workflow.subjects).to receive(:add).with 123
           workflow.add subject_id: 123
         end
         
         it 'should be notified of a user ttl expiry' do
           async_workflow = double
-          workflow.should_receive(:async).and_return async_workflow
-          async_workflow.should_receive(:remove_user).with user.id
+          expect(workflow).to receive(:async).and_return async_workflow
+          expect(async_workflow).to receive(:remove_user).with user.id
           user.ttl_expired!
         end
         
         it 'should remove users when their ttl expires' do
           id = user.id
           workflow.remove_user id
-          workflow.users.should_not have_key id
+          expect(workflow.users).to_not have_key id
           expect{ user.id }.to raise_error
         end
         
         it 'should not be grouped' do
-          workflow.should_not be_grouped
+          expect(workflow).to_not be_grouped
         end
       end
     end

data/spec/spec_helper.rb

@@ -8,6 +8,7 @@ end
 Bundler.require :test, :development
 
 ENV['CELLECT_POOL_SIZE'] = '3'
+SPAWN_ZK = !ENV['ZK_URL']
 
 require 'pry'
 require 'oj'
@@ -24,7 +25,6 @@ Cellect::Server.adapter = SpecAdapter.new
 SET_TYPES = %w(random priority pairwise_random pairwise_priority)
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
   config.order = 'random'
@@ -37,6 +37,6 @@ RSpec.configure do |config|
   end
   
   config.after(:suite) do
-    `zkServer stop #{ CELLECT_ZK_CONFIG } > /dev/null 2>&1`
+    `zkServer stop #{ CELLECT_ZK_CONFIG } > /dev/null 2>&1` if SPAWN_ZK
   end
 end

data/spec/support/shared_examples_for_node_set.rb

@@ -2,24 +2,24 @@ shared_examples_for 'node set' do
   let(:node_set){ Cellect::NodeSet.new }
   
   it 'should connect to zoo keeper' do
-    node_set.zk.should be_nil
+    expect(node_set.zk).to be_nil
     pass_until node_set, is: :ready
-    node_set.zk.should be_connected
+    expect(node_set.zk).to be_connected
   end
   
   it 'should know the connection state' do
-    node_set.state.should be :initializing
+    expect(node_set.state).to be :initializing
     pass_until node_set, is: :ready
-    node_set.should be_ready
+    expect(node_set).to be_ready
   end
   
   it 'should accept a connection string' do
     begin
       pass_until node_set, is: :ready
       ENV['ZK_URL'] = 'foobar'
-      node_set.send(:zk_url).should == 'foobar'
+      expect(node_set.send(:zk_url)).to eq 'foobar'
       ENV.delete 'ZK_URL'
-      node_set.send(:zk_url).should == 'localhost:2181'
+      expect(node_set.send(:zk_url)).to eq 'localhost:2181'
     ensure
       ENV['ZK_URL'] = 'localhost:21811'
     end

data/spec/support/shared_examples_for_set.rb

@@ -1,11 +1,11 @@
 shared_examples_for 'a set' do
   it 'should convert to an Array' do
-    set.to_a.should =~ (1..5).to_a
+    expect(set.to_a).to eq (1..5).to_a
   end
   
   it 'should add elements' do
     set.add 100
-    set.to_a.should include 100
+    expect(set.to_a).to include 100
   end
   
   it 'should remove elements' do
@@ -14,7 +14,7 @@ shared_examples_for 'a set' do
   end
   
   it 'should sample elements' do
-    set.sample(2).length.should == 2
+    expect(set.sample(2).length).to eq 2
   end
   
   it 'should not include removed elements in samples' do
@@ -29,6 +29,6 @@ shared_examples_for 'a set' do
   it 'should know if it contains an element' do
     set.should_not include 100
     set.add 100
-    set.should include 100
+    expect(set).to include 100
   end
 end

data/spec/support/shared_examples_for_workflow.rb

@@ -6,21 +6,21 @@ shared_examples_for 'workflow' do |name|
   end
   
   it 'should add singleton instances to the registry' do
-    obj.class[:foo].should be_a_kind_of Cellect::Server::Workflow
-    obj.class[:foo].object_id.should == obj.class[:foo].object_id
+    expect(obj.class[:foo]).to be_a_kind_of Cellect::Server::Workflow
+    expect(obj.class[:foo].object_id).to eq obj.class[:foo].object_id
   end
   
   it 'should initialize empty' do
-    obj.name.should be_a String
-    obj.users.should be_a Hash
+    expect(obj.name).to be_a String
+    expect(obj.users).to be_a Hash
     
     set_klass = obj.prioritized? ? DiffSet::PrioritySet : DiffSet::RandomSet
-    obj.subjects.should be_a set_klass
+    expect(obj.subjects).to be_a set_klass
   end
   
   it 'should provide a user lookup' do
-    obj.user(1).should be_a Cellect::Server::User
-    obj.user(1).object_id.should == obj.user(1).object_id
-    obj.users.keys.should include 1
+    expect(obj.user(1)).to be_a Cellect::Server::User
+    expect(obj.user(1).object_id).to eq obj.user(1).object_id
+    expect(obj.users.keys).to include 1
   end
 end

data/spec/support/zk_setup.rb

@@ -1,26 +1,28 @@
-zk_dir = File.join CELLECT_ROOT, 'tmp/zookeeper'
-
-`rm -rf #{ zk_dir }; mkdir -p #{ zk_dir }`
-
-CELLECT_ZK_CONFIG = "#{ zk_dir }/zoo.cfg"
-File.open(CELLECT_ZK_CONFIG, 'w') do |out|
-  out.puts <<-TEXT
-    tickTime=2000
-    initLimit=10
-    syncLimit=5
-    dataDir=#{ zk_dir }
-    clientPort=21811
-    forceSync=no
-    snapCount=1000000
-  TEXT
+if SPAWN_ZK
+  zk_dir = File.join CELLECT_ROOT, 'tmp/zookeeper'
+  CELLECT_ZK_CONFIG = "#{ zk_dir }/zoo.cfg"
+  
+  `rm -rf #{ zk_dir }; mkdir -p #{ zk_dir }`
+  
+  File.open(CELLECT_ZK_CONFIG, 'w') do |out|
+    out.puts <<-TEXT
+      tickTime=2000
+      initLimit=10
+      syncLimit=5
+      dataDir=#{ zk_dir }
+      clientPort=21811
+      forceSync=no
+      snapCount=1000000
+    TEXT
+  end
+  
+  if `echo ruok | nc 127.0.0.1 21811`.chomp == 'imok'
+    pid = `ps aux | grep -e 'Cellect[\/]tmp[\/]zookeeper'`.split[1]
+    puts "Killing rogue zookeeper process: #{ pid }..."
+    `kill -s TERM #{ pid }`
+    sleep 1
+  end
+  
+  `zkServer start #{ CELLECT_ZK_CONFIG } > /dev/null 2>&1`
+  ENV['ZK_URL'] = 'localhost:21811'
 end
-
-if `echo ruok | nc 127.0.0.1 21811`.chomp == 'imok'
-  pid = `ps aux | grep -e 'Cellect[\/]tmp[\/]zookeeper'`.split[1]
-  puts "Killing rogue zookeeper process: #{ pid }..."
-  `kill -s TERM #{ pid }`
-  sleep 1
-end
-
-`zkServer start #{ CELLECT_ZK_CONFIG } > /dev/null 2>&1`
-ENV['ZK_URL'] = 'localhost:21811'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cellect-server
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Michael Parrish
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-03 00:00:00.000000000 Z
+date: 2014-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -302,7 +302,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
 summary: ''