mongoid-casino 0.0.1

data/lib/casino/intersection/match/all.rb

@@ -0,0 +1,29 @@
+module Casino
+  class Intersection
+    module Match
+      class All < Equivalence
+
+        def eligible?
+          key == '$and'
+        end
+
+        def evaluate
+          matchers.map(&:evaluate).all?
+        end
+
+        private
+
+        def matchers
+          field.reduce(Array.new) do |list, element|
+            list + build_bases_with_element_keys(element)
+          end
+        end
+
+        def build_bases_with_element_keys(element)
+          element.keys.map { |key| Base.new(document, key, element, value) }
+        end
+
+      end
+    end
+  end
+end

data/lib/casino/intersection/match/base.rb

@@ -0,0 +1,49 @@
+module Casino
+  class Intersection
+    module Match
+      class Base
+        attr_accessor :document, :field, :key, :selector, :value
+
+        def initialize(document, key, selector, value = nil)
+          self.document = document
+          self.field    = selector[key]
+          self.key      = key
+          self.selector = selector
+          self.value    = document_value || value
+        end
+
+        def evaluate
+          matcher.evaluate
+        end
+
+        def match_arguments
+          [ key, value, document, field ]
+        end
+
+        def matchers
+          matcher_classes.map { |class_name| matcher_for class_name }
+        end
+
+        def matcher
+          matchers.find { |matcher| matcher.eligible? }
+        end
+
+        def matcher_for(class_name)
+          class_name = String(class_name).humanize
+          Match.const_get(class_name).new(*match_arguments)
+        end
+
+        private
+
+        def matcher_classes
+          %w(all include recurse greater lesser expression equivalence)
+        end
+
+        def document_value
+          document.send(key) if document.respond_to?(key)
+        end
+
+      end
+    end
+  end
+end

data/lib/casino/intersection/match/equivalence.rb

@@ -0,0 +1,25 @@
+module Casino
+  class Intersection
+    module Match
+      class Equivalence
+        attr_accessor :document, :field, :key, :value
+
+        def initialize(key, value, document, field)
+          self.key = key
+          self.document = document
+          self.field = field
+          self.value = value
+        end
+
+        def eligible?
+          true
+        end
+
+        def evaluate
+          value == field
+        end
+
+      end
+    end
+  end
+end

data/lib/casino/intersection/match/expression.rb

@@ -0,0 +1,15 @@
+module Casino
+  class Intersection
+    module Match
+      class Expression < Equivalence
+        def eligible?
+          field.is_a? Regexp
+        end
+
+        def evaluate
+          !(value =~ field).nil?
+        end
+      end
+    end
+  end
+end

data/lib/casino/intersection/match/greater.rb

@@ -0,0 +1,43 @@
+module Casino
+  class Intersection
+    module Match
+      class Greater < Equivalence
+
+        def eligible?
+          %w($gt $gte).include? key
+        end
+
+        def evaluate
+          greater_than? ? greater_than! : greater_than_or_equal!
+        end
+
+        private
+
+        def greater_than?
+          key == '$gt'
+        end
+
+        def greater_than!
+          evolved_value > evolved_field
+        end
+
+        def greater_than_or_equal!
+          evolved_value >= evolved_field
+        end
+
+        def evolved_value
+          evolve value
+        end
+
+        def evolved_field
+          evolve field
+        end
+
+        def evolve(instance)
+          instance.class.evolve(instance)
+        end
+
+      end
+    end
+  end
+end

data/lib/casino/intersection/match/include.rb

@@ -0,0 +1,15 @@
+module Casino
+  class Intersection
+    module Match
+      class Include < Equivalence
+        def eligible?
+          key == "$in"
+        end
+
+        def evaluate
+          field.include?(value)
+        end
+      end
+    end
+  end
+end

data/lib/casino/intersection/match/lesser.rb

@@ -0,0 +1,31 @@
+module Casino
+  class Intersection
+    module Match
+      class Lesser < Greater
+
+        def eligible?
+          %w($lt $lte).include? key
+        end
+
+        def evaluate
+          lesser_than? ? lesser_than! : lesser_than_or_equal!
+        end
+
+        private
+
+        def lesser_than?
+          key == '$lt'
+        end
+
+        def lesser_than!
+          evolved_value < evolved_field
+        end
+
+        def lesser_than_or_equal!
+          evolved_value <= evolved_field
+        end
+
+      end
+    end
+  end
+end

data/lib/casino/intersection/match/recurse.rb

@@ -0,0 +1,19 @@
+module Casino
+  class Intersection
+    module Match
+      class Recurse < Equivalence
+
+        def eligible?
+          field.is_a? Hash
+        end
+
+        def evaluate
+          keys = field.keys
+          bases = keys.map { |key| Base.new(document, key, field, value) }
+          bases.map(&:evaluate).all?
+        end
+
+      end
+    end
+  end
+end

data/lib/casino/lobby.rb

@@ -0,0 +1,21 @@
+module Casino
+  class Lobby
+    attr_accessor :collection
+
+    def initialize(klass)
+      self.collection = klass
+    end
+
+    def registry
+      @registry ||= Hash.new
+    end
+
+    def add_registry(object)
+      key = object.class.name.downcase.split("::").last.to_sym
+      registry[key] ||= Array.new
+      registry[key] << object
+      registry[key] = registry[key].uniq
+    end
+
+  end
+end

data/lib/casino/projection.rb

@@ -0,0 +1,76 @@
+module Casino
+  class Projection
+    attr_accessor :target, :pipeline
+
+    def initialize(klass, pipeline = [])
+      self.target = klass
+      self.pipeline = pipeline
+    end
+
+    def results
+      target.collection.aggregate(pipeline)
+    end
+
+    def mongoize(hash)
+      hash.keys.map { |key| build_mongoized_hash(hash, key) }.reduce(&:merge)
+    end
+
+    def group(conditions)
+      clone_with group: conditions
+    end
+    alias :pivot :group
+
+    def project(conditions)
+      clone_with project: conditions
+    end
+    alias :describe :project
+    alias :build :project
+
+    def unwind(conditions)
+      clone_with unwind: conditions
+    end
+    alias :expand :unwind
+
+    def match(conditions)
+      clone_with match: conditions
+    end
+    alias :where :match
+    alias :find :match
+
+    def sort(conditions)
+      clone_with sort: conditions
+    end
+    alias :order :sort
+
+    def skip(conditions)
+      clone_with skip: conditions
+    end
+    alias :offset :skip
+
+    def limit(conditions)
+      clone_with limit: conditions
+    end
+
+    private
+
+    def clone_with(condition)
+      self.class.new target, pipeline + [mongoize(condition)]
+    end
+
+    def build_mongoized_hash(hash, key)
+      new_key = mongo_ready(key)
+      value = hash[key]
+      value = value.is_a?(Hash) ? mongoize(value) : mongo_ready(value)
+      { new_key => evolve(value) }
+    end
+
+    def evolve(value)
+      value.class.respond_to?(:evolve) ? value.class.evolve(value) : value
+    end
+
+    def mongo_ready(object)
+      object.is_a?(Symbol) ? "$#{object}" : object
+    end
+
+  end
+end

data/lib/casino/query.rb

@@ -0,0 +1,23 @@
+module Casino
+  class Query
+    attr_accessor :label, :criteria, :conditions
+
+    def initialize(label, conditions, *criteria)
+      self.label = label
+      self.conditions = conditions
+      self.criteria = criteria
+    end
+
+    def merge(dimension)
+      self.class.new(label, build_conditions(dimension), *criteria)
+    end
+
+    def build_conditions(dimension)
+      criteria.map do |condition|
+        [ dimension.approach[:operator],
+          { dimension.field => condition } ]
+      end
+    end
+
+  end
+end

data/lib/casino/question.rb

@@ -0,0 +1,9 @@
+module Casino
+  class Question
+    attr_accessor :name, :answer
+    def initialize(name, answer)
+      self.name = name
+      self.answer = answer
+    end
+  end
+end

data/lib/casino/store.rb

@@ -0,0 +1,49 @@
+module Casino
+  class Store
+    attr_accessor :collection_name
+
+    delegate :drop, :find, :indexes, :insert, to: :collection
+
+    delegate :count, :distinct, :each, :first, :limit, :remove, :remove_all,
+      :select, :skip, :sort, :update, :update_all, :upsert, to: :query
+
+    delegate :where, :in, to: :criteria
+
+    def initialize(collection_name)
+      self.collection_name = collection_name
+    end
+
+    def collection
+      @collection ||= session[collection_name.to_sym]
+    end
+
+    def query
+      @query ||= collection.find
+    end
+
+    def merge(*documents)
+      documents.each do |document|
+        criteria = find _id: document['_id']
+        criteria.upsert document
+      end
+    end
+
+    def criteria
+      @criteria ||= build_criteria
+    end
+
+    private
+
+    def session
+      @session ||= Mongoid.default_session
+    end
+
+    def build_criteria
+      klass = Class.new
+      klass.send(:include, Mongoid::Document)
+      klass.store_in collection: collection_name
+      klass.scoped
+    end
+
+  end
+end

data/lib/casino/version.rb

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

data/spec/fabricators/model_fabricator.rb

@@ -0,0 +1,12 @@
+random_number = -> { rand(3) + 1 }
+
+Fabricator(:model) do
+  created_at { Date.today }
+  source { %w(Google Facebook Twitter).shuffle.first }
+end
+
+Fabricator(:model_with_notes, from: :model) do
+  after_create do |model|
+    random_number.call.times { model.notes << Fabricate(:note, model: model) }
+  end
+end

data/spec/fabricators/note_fabricator.rb

@@ -0,0 +1,3 @@
+Fabricator(:note) do
+  views { rand(3) + 1 }
+end