pq-wsm 0.0.1

data/lib/pc_queues/queue_item.rb

@@ -0,0 +1,58 @@
+#
+# This source file is part of project: PcQueues
+#
+# A Proctoring Workflow Platform
+#
+# Copyright (c) ProctorCam Inc. 2014 All rights reserved
+#
+module PcQueues
+  # QueueItems are the container for object instances that are
+  # enqueued and dequeued from a Queue
+  class QueueItem < ActiveRecord::Base
+# <<<<<<< HEAD
+    # attr_accessible :enqueued_time, :position, :queue, :type, :enqueable
+    def self.accessible_attributes
+      [:enqueued_time, :position, :queue, :type, :enqueable]
+    end
+# =======
+#     attr_accessible :enqueued_time, :position, :queue, :type, :enqueable
+
+#     attr_accessor :cur_position
+    
+# >>>>>>> 5a7112729e02a8228e3591999ec3a5d0b912b86f
+    belongs_to :queue, :class_name => 'PcQueues::Queue'
+    belongs_to :enqueable, :polymorphic => true
+
+    # Ensure there are no duplicate enqueables within any queue
+    validates_uniqueness_of :enqueable_id, :scope => :queue_id
+    
+    # Attributes include
+    # :position -> the 1-based position when added to the queue
+    # :equeued_time -> the seconds since the epoch when the item was added
+    # to the queue
+    
+    def stats
+      { :position => cur_position, estimated_time_left: time_remaining }
+    end
+    
+    # The advancement rate for this item
+    # -> round to nearest thousandth digit
+    def rate()
+      @rate ||= (wait_time > 0 && advancement / wait_time.to_f) || 0
+    end
+
+    # number of positions this item has travelled
+    def advancement()
+      position - cur_position
+    end
+    
+    # The wait time in seconds for this item
+    def wait_time()
+      Time.now.to_i - enqueued_time
+    end
+    
+    def time_remaining()
+      rate * position || wait_time
+    end
+  end
+end

data/lib/pc_queues/queue_rule.rb

@@ -0,0 +1,32 @@
+#
+# This source file is part of project: PcQueues
+#
+# Copyright (c) ProctorCam Inc. 2014 All rights reserved
+#
+module PcQueues
+  # QueueRule is the base class (STI) for Rules that are evaluated as part of a QueueRuleSet
+  # There must be at least one implmentor of the passes? method in the hierachy of QueueRule
+  # being stored in a QueueRuleSet.
+  class QueueRule < ActiveRecord::Base
+    # attr_accessible :numeric_value, :string_value, :bool_value, :type
+    def self.accessible_attributes
+      [:numeric_value, :string_value, :bool_value, :type]
+    end
+    belongs_to :queue_rule_set
+    
+    # A convenience method for creating QueueRule instances with more declaritive
+    # code. Derived classes can implement and super to this.
+    #
+    # Eg. rule_set.queue_rules.create(MyNewRule.options special_opt1: value)
+    #
+    def self.options(opts = {})
+      opts[:type] = self.name
+      opts
+    end
+    
+    # All derived classes must implement this method and it must return a Boolean
+    def passes?(enqueable, *args)
+      raise NotImplementedError, "The class: #{self.class.name} requires an implementation of #{__method__}"
+    end
+  end
+end

data/lib/pc_queues/queue_rule_set.rb

@@ -0,0 +1,40 @@
+#
+# This source file is part of project: PcQueues
+#
+# A Proctoring Workflow Platform
+#
+# Copyright (c) ProctorCam Inc. 2014 All rights reserved
+#
+module PcQueues
+  # A QueueRuleSet is a collection of QueueRules that can is evaluated
+  # as an AND/OR clause depending on the value of is_any which indicates
+  # an OR
+  class QueueRuleSet < ActiveRecord::Base
+    # attr_accessible :is_any
+    def self.accessible_attributes
+      [:is_any]
+    end
+    belongs_to :queue
+
+    has_many :queue_rules, dependent: :destroy
+
+    def passes?(enqueuable, *args)
+      if is_any
+        any_pass?(enqueuable, *args)
+      else
+        all_pass?(enqueuable, *args)
+      end
+    end
+
+    def any_pass?(enqueuable, *args)
+      queue_rules.all.each { |rule| return true if rule.passes?(enqueuable, *args) }
+      false
+    end
+
+    def all_pass?(enqueuable, *args)
+      queue_rules.all.each { |rule| return false unless rule.passes?(enqueuable, *args) }
+      true
+    end
+    
+  end
+end

data/lib/pc_queues/queue_rules/boolean_queue_rule.rb

@@ -0,0 +1,34 @@
+#
+# This source file is part of project: PcQueues
+#
+# Copyright (c) ProctorCam Inc. 2014 All rights reserved
+#
+
+module PcQueues
+  module QueueRules
+    ###
+    # A BooleanQueueRule is a QueueRule that returns true when
+    # the value matches the bool_value attribute
+    #
+    class BooleanQueueRule < QueueRule
+      
+      def self.options(opts = {})
+        opts[:bool_value] ||= opts[:value]
+        opts[:bool_value] = true if opts[:bool_value].nil?
+        opts.except! :value
+        super
+      end
+  
+      # Implementors must provide an implementation of this method that takes
+      # the args splat passed to the queue and returns a numberic value
+      def value(obj, *args)
+        raise NotImplementedError, "The class: #{self.class.name} requires an implementation of #{__method__}"
+      end
+  
+      def passes?(obj, *args)
+        value(obj, *args) == bool_value
+      end
+
+    end
+  end
+end

data/lib/pc_queues/queue_rules/numeric_queue_rule.rb

@@ -0,0 +1,42 @@
+#
+# This source file is part of project: PcQueues
+#
+# Copyright (c) ProctorCam Inc. 2014 All rights reserved
+#
+
+module PcQueues
+  module QueueRules
+    ###
+    # A NumericQueueRule is a QueueRule that returns true when
+    # comparing the value to the numeric_value using an operator
+    # stored as a string.
+    #
+    # These operators must be one of: <, >, ==, >=, <=
+    #
+    class NumericQueueRule < QueueRule
+      validates :string_value, inclusion: { in: %w[< > == <= >= !=] }
+  
+      def self.options(opts = {})
+        opts[:numeric_value] ||= opts[:value]
+        opts[:string_value] ||= opts[:operator]
+        opts.except! :operator, :value
+        super
+      end
+      
+      def operator
+        string_value
+      end
+  
+      # Implementors must provide an implementation of this method that takes
+      # the args splat passed to the queue and returns a numberic value
+      def value(obj, *args)
+        raise NotImplementedError, "The class: #{self.class.name} requires an implementation of #{__method__}"
+      end
+  
+      def passes?(obj, *args)
+        value(obj, *args).send(operator, numeric_value)
+      end
+
+    end
+  end
+end

data/lib/pc_queues/queue_rules/sample_queue_rule.rb

@@ -0,0 +1,36 @@
+#
+# This source file is part of project: PcQueues
+#
+# Copyright (c) ProctorCam Inc. 2014 All rights reserved
+#
+
+module PcQueues
+  module QueueRules
+    ###
+    # A SampleQueueRule is a QueueRule that will 'pass' for a perscribed
+    # sample of occurrences
+    #
+    # Sampling is random, so you many find slightly more or less than the perscribed
+    # number of items passing.
+    #
+    class SampleQueueRule < QueueRule
+
+      def self.options(opts = {})
+        opts[:numeric_value] ||= opts[:sample_percent]
+        opts.except! :sample_percent
+        super
+      end
+
+      @@die = Random.new
+  
+      def sample_percent
+        numeric_value
+      end
+  
+      def passes?(obj, *args)
+        sample_percent == 100 || @@die.rand(100) < sample_percent
+      end
+  
+    end
+  end
+end

data/lib/pc_queues/queue_rules/string_match_queue_rule.rb

@@ -0,0 +1,44 @@
+#
+# This source file is part of project: PcQueues
+#
+# Copyright (c) ProctorCam Inc. 2014 All rights reserved
+#
+
+module PcQueues
+  module QueueRules
+    ###
+    # A StringMatchQueueRule is a QueueRule that will 'pass' if the
+    # current value exactly matches a regular expression.
+    #
+    class StringMatchQueueRule < QueueRule
+
+      # Possible options for StringMatchQueueRule include:
+      #
+      # * _:regular_expression_ - an exact regular expression
+      # * _:contains_ - an exact string exists within the value
+      # * _:icontains_ - ignore case with string contained within the value
+      def self.options(opts = {})
+        opts[:string_value] ||= "/^#{opts[:regular_expression]}$/" if opts.key? :regular_expression
+        opts[:string_value] ||= "/#{opts[:contains]}/" if opts.key? :contains
+        opts[:string_value] ||= "/#{opts[:icontains]}/i" if opts.key? :icontains
+        opts.except! :regular_expression, :contains, :icontains
+        super
+      end      
+
+      def regular_expression
+        eval(string_value)
+      end
+  
+      # Implementors must provide an implementation of this method that takes
+      # the args splat passed to the queue and returns a String
+      def value(obj, *args)
+        raise NotImplementedError, "The class: #{self.class.name} requires an implementation of #{__method__}"
+      end
+  
+      def passes?(obj, *args)
+        !regular_expression.match(value(obj, *args)).nil?
+      end
+  
+    end
+  end
+end

data/lib/pc_queues/railtie.rb

@@ -0,0 +1,10 @@
+require 'active_record/railtie'
+require 'active_support/core_ext'
+
+module PcQueues
+  class Railtie < Rails::Railtie
+    if defined?(ActiveRecord::Base)
+      # Add anything we want to use to extend ActiveRecordBase
+    end
+  end
+end

data/lib/pc_queues/version.rb

@@ -0,0 +1,3 @@
+module PcQueues
+  VERSION = "0.0.1"
+end

data/lib/tasks/pc_queues_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :pc_queues do
+#   # Task goes here
+# end

data/spec/boolean_queue_rule_spec.rb

@@ -0,0 +1,34 @@
+require './spec/spec_helper'
+
+describe PcQueues::QueueRules::BooleanQueueRule do
+
+  before :each do
+    PcQueues.redis { |r| r.flushall }
+
+    @company = Company.create :name => "ProctorCam"
+    @company.create_hr_queue
+
+    @people = {
+      :john => Person.create(:name => "John", :age => 42, :is_female => false),
+      :sally => Person.create(:name => "Sally", :age => 29, :is_female => true),
+      :mildred => Person.create(:name => "Mildred", :age => 67, :is_female => true),
+      :lars => Person.create(:name => "Lars", :age => 34, :is_female => false)
+    }
+  end
+
+  after :each do
+    @company.hr_queue.destroy
+    @company.destroy
+  end
+
+  it "does not pass if the boolean provided is different from the value passed" do
+    queue_rule = GenderQueueRule.create GenderQueueRule.options({:is_female => true})
+    expect(queue_rule.passes? @people[:john]).to eq(false)
+  end
+
+  it "does should pass if the boolean provided is the same as the value passed" do
+    queue_rule = GenderQueueRule.create GenderQueueRule.options({:is_female => true})
+    expect(queue_rule.passes? @people[:mildred]).to eq(true)
+  end
+  
+end

data/spec/numeric_queue_rule_spec.rb

@@ -0,0 +1,123 @@
+require './spec/spec_helper'
+
+describe PcQueues::QueueRules::NumericQueueRule do
+
+  before :each do
+    PcQueues.redis { |r| r.flushall }
+
+    @company = Company.create :name => "ProctorCam"
+    @company.create_hr_queue
+
+    @people = {
+      :john => Person.create(:name => "John", :age => 42, :is_female => false),
+      :sally => Person.create(:name => "Sally", :age => 29, :is_female => true),
+      :mildred => Person.create(:name => "Mildred", :age => 67, :is_female => true),
+      :lars => Person.create(:name => "Lars", :age => 34, :is_female => false)
+    }
+  end
+
+  after :each do
+    @company.hr_queue.destroy
+    @company.destroy
+  end
+
+  it "passes if the numeric value does pass the assertion" do
+    queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:sally].age + 1, :operator => '>='})
+    expect(queue_rule.passes? @people[:john]).to eq(true)
+  end
+
+  it "does not pass if the numeric value does not pass the assertion" do
+    queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:sally].age + 1, :operator => '>='})
+    expect(queue_rule.passes? @people[:sally]).to eq(false)
+  end
+
+  describe "when using == operator" do
+
+    it "passes when values are the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age, :operator => '=='})
+      expect(queue_rule.passes? @people[:john]).to eq(true)
+    end
+
+    it "does not pass when values are not the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age + 1, :operator => '=='})
+      expect(queue_rule.passes? @people[:john]).to eq(false)
+    end
+
+  end
+
+  describe "when using != operator" do
+
+    it "passes when values are the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age + 3, :operator => '!='})
+      expect(queue_rule.passes? @people[:john]).to eq(true)
+    end
+
+    it "does not pass when values are not the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age, :operator => '!='})
+      expect(queue_rule.passes? @people[:john]).to eq(false)
+    end
+
+  end
+
+  describe "when using < operator" do
+
+    it "passes when values are the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age + 1, :operator => '<'})
+      expect(queue_rule.passes? @people[:john]).to eq(true)
+    end
+
+    it "does not pass when values are not the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age, :operator => '<'})
+      expect(queue_rule.passes? @people[:john]).to eq(false)
+    end
+
+  end
+
+  describe "when using <= operator" do
+
+    it "passes when values are the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age + 1, :operator => '<='})
+      expect(queue_rule.passes? @people[:john]).to eq(true)
+    end
+
+    it "does not pass when values are not the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age - 1, :operator => '<='})
+      expect(queue_rule.passes? @people[:john]).to eq(false)
+    end
+
+  end
+
+  describe "when using > operator" do
+
+    it "passes when values are the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age - 1, :operator => '>'})
+      expect(queue_rule.passes? @people[:john]).to eq(true)
+    end
+
+    it "does not pass when values are not the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age, :operator => '>'})
+      expect(queue_rule.passes? @people[:john]).to eq(false)
+    end
+
+  end
+
+  describe "when using >= operator" do
+
+    it "passes when values are the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age - 1, :operator => '>='})
+      expect(queue_rule.passes? @people[:john]).to eq(true)
+    end
+
+    it "does not pass when values are not the same" do
+      queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age + 1, :operator => '>='})
+      expect(queue_rule.passes? @people[:john]).to eq(false)
+    end
+
+  end
+
+  it "does not take arbitrary assignments for operator" do
+    queue_rule = AgeQueueRule.create AgeQueueRule.options({:value => @people[:john].age - 1, :operator => 'NOT A THING'})
+    expect(queue_rule.valid?).to eq(false)
+  end
+  
+end