origin 0.0.0.alpha

data/Rakefile

@@ -0,0 +1,32 @@
+require "rake"
+require "rspec"
+require "rspec/core/rake_task"
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "origin/version"
+
+task :gem => :build
+task :build do
+  system "gem build origin.gemspec"
+end
+
+task :install => :build do
+  system "sudo gem install origin-#{Origin::VERSION}.gem"
+end
+
+task :release => :build do
+  system "git tag -a v#{Origin::VERSION} -m 'Tagging #{Origin::VERSION}'"
+  system "git push --tags"
+  system "gem push origin-#{Origin::VERSION}.gem"
+end
+
+RSpec::Core::RakeTask.new("spec") do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new("spec:progress") do |spec|
+  spec.rspec_opts = %w(--format progress)
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec

data/lib/origin.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+module Origin
+  autoload :Queryable, "origin/queryable"
+  autoload :Version, "origin/version"
+end

data/lib/origin/ext.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+require "origin/ext/array"
+require "origin/ext/hash"
+require "origin/ext/nil"
+require "origin/ext/object"

data/lib/origin/ext/array.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+class Array
+
+  def _add(object)
+    if object.is_a?(Hash)
+      object[object.keys.first] = _add(object.values.first)
+      object
+    else
+      concat(Array(object)).uniq
+    end
+  end
+
+  def _intersect(object)
+    if object.is_a?(Hash)
+      object[object.keys.first] = _intersect(object.values.first)
+      object
+    else
+      self & Array(object)
+    end
+  end
+end

data/lib/origin/ext/hash.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+class Hash
+
+  def _add(object)
+    apply_strategy(:_add, object)
+  end
+
+  def _intersect(object)
+    apply_strategy(:_intersect, object)
+  end
+
+  def _union(object)
+    apply_strategy(:_union, object)
+  end
+
+  def deep_copy
+    inject({}) do |copy, (key, value)|
+      copy.tap do |clone|
+        case value
+        when Array, String then clone.store(key, value.dup)
+        when Hash then clone.store(key, value.deep_copy)
+        else
+          clone.store(key, value)
+        end
+      end
+    end
+  end
+
+  private
+
+  def apply_strategy(strategy, object)
+    tap do |hash|
+      object.each_pair do |key, value|
+        hash.store(key, hash[key].send(strategy, value))
+      end
+    end
+  end
+end

data/lib/origin/ext/nil.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+class NilClass
+
+  def _add(object); object end
+
+  def _intersect(object); object end
+
+  def _union(object); object end
+end

data/lib/origin/ext/object.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+class Object
+
+  def _add(object)
+    object == self ? self : [ self, object ].flatten.uniq
+  end
+
+  def _intersect(object)
+    if object.is_a?(Hash)
+      object[object.keys.first] = _intersect(object.values.first)
+      object
+    else
+      Array(self) & Array(object)
+    end
+  end
+
+  def _union(object)
+    if object.is_a?(Hash)
+      object[object.keys.first] = _union(object.values.first)
+      object
+    else
+      (Array(self) + Array(object)).uniq
+    end
+  end
+end

data/lib/origin/optional.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module Origin
+  module Optional
+
+    autoload :BatchSize, "origin/optional/batch_size"
+    autoload :Hint, "origin/optional/hint"
+    autoload :Limit, "origin/optional/limit"
+    autoload :MaxScan, "origin/optional/max_scan"
+    autoload :NoTimeout, "origin/optional/no_timeout"
+    autoload :Only, "origin/optional/only"
+    autoload :Read, "origin/optional/read"
+    autoload :ReturnKey, "origin/optional/return_key"
+    autoload :ShowDiskLoc, "origin/optional/show_disk_loc"
+    autoload :Skip, "origin/optional/skip"
+    autoload :Slice, "origin/optional/slice"
+    autoload :Snapshot, "origin/optional/snapshot"
+    autoload :Transformer, "origin/optional/transformer"
+    autoload :Without, "origin/optional/without"
+
+    include BatchSize
+    include Hint
+    include Limit
+    include MaxScan
+    include NoTimeout
+    include Only
+    include Read
+    include ReturnKey
+    include ShowDiskLoc
+    include Skip
+    include Slice
+    include Snapshot
+    include Transformer
+    include Without
+  end
+end

data/lib/origin/optional/batch_size.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module BatchSize
+
+      def batch_size(value = nil)
+        option(value) { |options| options.store(:batch_size, value) }
+      end
+    end
+  end
+end

data/lib/origin/optional/hint.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module Hint
+
+      def hint(*args)
+        option(*args) do |options|
+          options.store(
+            :hint, args.inject({}){ |sub, field| sub.tap { sub[field] = 1 }}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/origin/optional/limit.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module Limit
+
+      def limit(value = nil)
+        option(value) { |options| options.store(:limit, value) }
+      end
+    end
+  end
+end

data/lib/origin/optional/max_scan.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module MaxScan
+
+      def max_scan(value = nil)
+        option(value) { |options| options.store(:max_scan, value) }
+      end
+    end
+  end
+end

data/lib/origin/optional/no_timeout.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module NoTimeout
+
+      def no_timeout
+        clone.tap { |query| query.options.store(:timeout, false) }
+      end
+    end
+  end
+end

data/lib/origin/optional/only.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module Only
+
+      def only(*args)
+        option(*args) do |options|
+          options.store(
+            :fields, args.inject({}){ |sub, field| sub.tap { sub[field] = 1 }}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/origin/optional/read.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module Read
+
+      def read(node = nil)
+        option(node) { |options| options.store(:read, node) }
+      end
+    end
+  end
+end

data/lib/origin/optional/return_key.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module ReturnKey
+
+      def return_key
+        clone.tap { |query| query.options.store(:return_key, true) }
+      end
+    end
+  end
+end

data/lib/origin/optional/show_disk_loc.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module ShowDiskLoc
+
+      def show_disk_loc
+        clone.tap { |query| query.options.store(:show_disk_loc, true) }
+      end
+    end
+  end
+end

data/lib/origin/optional/skip.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module Skip
+
+      def skip(value = nil)
+        option(value) { |options| options.store(:skip, value) }
+      end
+    end
+  end
+end

data/lib/origin/optional/slice.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module Slice
+
+      def slice(criterion = nil)
+        option(criterion) do |options|
+          options._union(
+            :fields => criterion.inject({}) do |option, (field, val)|
+              option.tap { |opt| opt.store(field, { "$slice" => val }) }
+            end
+          )
+        end
+      end
+    end
+  end
+end

data/lib/origin/optional/snapshot.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module Snapshot
+
+      def snapshot
+        clone.tap do |query|
+          query.options.store(:snapshot, true)
+        end
+      end
+    end
+  end
+end

data/lib/origin/optional/transformer.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module Transformer
+
+      def transformer(block = nil)
+        option(block) { |options| options.store(:transformer, block) }
+      end
+    end
+  end
+end

data/lib/origin/optional/without.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Origin
+  module Optional
+    module Without
+
+      def without(*args)
+        option(*args) do |options|
+          options.store(
+            :fields, args.inject({}){ |sub, field| sub.tap { sub[field] = -1 }}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/origin/options.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+module Origin
+  class Options < Hash
+  end
+end

data/lib/origin/queryable.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+require "origin/ext"
+
+module Origin
+
+  autoload :Optional, "origin/optional"
+  autoload :Options, "origin/options"
+  autoload :Selection, "origin/selection"
+  autoload :Selector, "origin/selector"
+
+  module Queryable
+    include Optional
+    include Selection
+
+    attr_reader :options, :selector
+
+    def ==(other)
+      return false unless other.is_a?(Query)
+      selector == other.selector && options == other.options
+    end
+
+    def initialize
+      @options, @selector = Options.new, Selector.new
+      yield(self) if block_given?
+    end
+
+    def initialize_copy(other)
+      @options, @selector = other.options.deep_copy, other.selector.deep_copy
+    end
+  end
+end

data/lib/origin/selection.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Origin
+  module Selection
+
+    autoload :All, "origin/selection/all"
+    autoload :And, "origin/selection/and"
+    autoload :Between, "origin/selection/between"
+    autoload :ElemMatch, "origin/selection/elem_match"
+    autoload :Exists, "origin/selection/exists"
+    autoload :Gt, "origin/selection/gt"
+    autoload :Gte, "origin/selection/gte"
+    autoload :In, "origin/selection/in"
+    autoload :Key, "origin/selection/key"
+    autoload :Lt, "origin/selection/lt"
+    autoload :Lte, "origin/selection/lte"
+    autoload :MaxDistance, "origin/selection/max_distance"
+    autoload :Mod, "origin/selection/mod"
+    autoload :Ne, "origin/selection/ne"
+    autoload :Near, "origin/selection/near"
+    autoload :NearSphere, "origin/selection/near_sphere"
+    autoload :Nin, "origin/selection/nin"
+    autoload :Nor, "origin/selection/nor"
+    autoload :Or, "origin/selection/or"
+    autoload :Size, "origin/selection/size"
+    autoload :Strategies, "origin/selection/strategies"
+    autoload :Type, "origin/selection/type"
+    autoload :Where, "origin/selection/where"
+    autoload :WithinBox, "origin/selection/within_box"
+    autoload :WithinCircle, "origin/selection/within_circle"
+    autoload :WithinSphericalCircle, "origin/selection/within_spherical_circle"
+
+    include All
+    include And
+    include Between
+    include ElemMatch
+    include Exists
+    include Gt
+    include Gte
+    include In
+    include Lt
+    include Lte
+    include MaxDistance
+    include Mod
+    include Ne
+    include Near
+    include NearSphere
+    include Nin
+    include Nor
+    include Or
+    include Size
+    include Strategies
+    include Type
+    include Where
+    include WithinBox
+    include WithinCircle
+    #include WithinPolygon
+    include WithinSphericalCircle
+  end
+end

data/lib/origin/selection/all.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module All
+
+      def all(criterion = nil)
+        send(strategy || :_override, criterion, "$all")
+      end
+
+      ::Symbol.class_eval do
+
+        def all
+          Key.new(self, "$all")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/and.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module And
+
+      def and(*criterion)
+        multi!(criterion, "$and")
+      end
+    end
+  end
+end

data/lib/origin/selection/between.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Between
+
+      def between(criterion = nil)
+        selection(criterion) do |selector, field, value|
+          selector.store(
+            field,
+            { "$gte" => value.min, "$lte" => value.max }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/elem_match.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module ElemMatch
+
+      def elem_match(criterion = nil)
+        _override(criterion, "$elemMatch")
+      end
+
+      ::Symbol.class_eval do
+
+        def elem_match
+          Key.new(self, "$elemMatch")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/exists.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Exists
+
+      def exists(criterion = nil)
+        _override(criterion, "$exists")
+      end
+
+      ::Symbol.class_eval do
+
+        def exists
+          Key.new(self, "$exists")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/gt.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Gt
+
+      def gt(criterion = nil)
+        _override(criterion, "$gt")
+      end
+
+      ::Symbol.class_eval do
+
+        def gt
+          Key.new(self, "$gt")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/gte.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Gte
+
+      def gte(criterion = nil)
+        _override(criterion, "$gte")
+      end
+
+      ::Symbol.class_eval do
+
+        def gte
+          Key.new(self, "$gte")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/in.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module In
+
+      def in(criterion = nil)
+        send(strategy || :_intersect, criterion, "$in")
+      end
+
+      ::Symbol.class_eval do
+
+        def in
+          Key.new(self, "$in")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/key.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    class Key
+      attr_reader :name, :operator, :expanded
+
+      def initialize(name, operator, expanded = nil)
+        @name, @operator, @expanded = name, operator, expanded
+      end
+
+      def specify(value)
+        if expanded
+          { name => { operator => { expanded => value }}}
+        else
+          { name => { operator => value }}
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/lt.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Lt
+
+      def lt(criterion = nil)
+        _override(criterion, "$lt")
+      end
+
+      ::Symbol.class_eval do
+
+        def lt
+          Key.new(self, "$lt")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/lte.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Lte
+
+      def lte(criterion = nil)
+        _override(criterion, "$lte")
+      end
+
+      ::Symbol.class_eval do
+
+        def lte
+          Key.new(self, "$lte")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/max_distance.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module MaxDistance
+
+      def max_distance(criterion = nil)
+        _add(criterion, "$maxDistance")
+      end
+    end
+  end
+end

data/lib/origin/selection/mod.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Mod
+
+      def mod(criterion = nil)
+        _override(criterion, "$mod")
+      end
+
+      ::Symbol.class_eval do
+
+        def mod
+          Key.new(self, "$mod")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/ne.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Ne
+
+      def ne(criterion = nil)
+        _override(criterion, "$ne")
+      end
+
+      ::Symbol.class_eval do
+
+        def ne
+          Key.new(self, "$ne")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/near.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Near
+
+      def near(criterion = nil)
+        _override(criterion, "$near")
+      end
+
+      ::Symbol.class_eval do
+
+        def near
+          Key.new(self, "$near")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/near_sphere.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module NearSphere
+
+      def near_sphere(criterion = nil)
+        _override(criterion, "$nearSphere")
+      end
+
+      ::Symbol.class_eval do
+
+        def near_sphere
+          Key.new(self, "$nearSphere")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/nin.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Nin
+
+      def nin(criterion = nil)
+        send(strategy || :_intersect, criterion, "$nin")
+      end
+
+      ::Symbol.class_eval do
+
+        def nin
+          Key.new(self, "$nin")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/nor.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Nor
+
+      def nor(*criterion)
+        multi!(criterion, "$nor")
+      end
+    end
+  end
+end

data/lib/origin/selection/or.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Or
+
+      def or(*criterion)
+        multi!(criterion, "$or")
+      end
+    end
+  end
+end

data/lib/origin/selection/size.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Size
+
+      def with_size(criterion = nil)
+        _override(criterion, "$size")
+      end
+
+      ::Symbol.class_eval do
+
+        def with_size
+          Key.new(self, "$size")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/strategies.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+require "origin/selection/strategies/add"
+require "origin/selection/strategies/expanded"
+require "origin/selection/strategies/intersect"
+require "origin/selection/strategies/multi"
+require "origin/selection/strategies/override"
+require "origin/selection/strategies/union"
+
+module Origin
+  module Selection
+    module Strategies
+      include Add
+      include Expanded
+      include Intersect
+      include Multi
+      include Override
+      include Union
+
+      attr_accessor :strategy
+
+      def selection(criterion = nil)
+        clone.tap do |query|
+          if criterion
+            criterion.each_pair do |field, value|
+              yield(query.selector, field, value)
+            end
+          end
+        end
+      end
+
+      def option(*args)
+        clone.tap do |query|
+          unless args.compact.empty?
+            yield(query.options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/strategies/add.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Strategies
+      module Add
+
+        def _add(criterion, operator)
+          selection(criterion) do |selector, field, value|
+            selector.store(
+              field,
+              selector[field]._add({ operator => value })
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/strategies/expanded.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Strategies
+      module Expanded
+
+        def _expanded(criterion, outer, inner)
+          selection(criterion) do |selector, field, value|
+            selector.store(field, { outer => { inner => value }})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/strategies/intersect.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Strategies
+      module Intersect
+
+        def intersect
+          tap { |query| query.strategy = :_intersect }
+        end
+
+        def _intersect(criterion, operator)
+          selection(criterion) do |selector, field, value|
+            selector.store(
+              field,
+              selector[field]._intersect({ operator => value })
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/strategies/multi.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Strategies
+      module Multi
+
+        private
+
+        def multi!(criterion, operator)
+          clone.tap do |query|
+            sel = query.selector
+            criterion.each do |expr|
+              next unless expr
+              sel.fetch(operator){ |key| sel.store(operator, []) }.push(expr)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/strategies/override.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Strategies
+      module Override
+
+        def override
+          tap { |query| query.strategy = :_override }
+        end
+
+        def _override(criterion, operator)
+          selection(criterion) do |selector, field, value|
+            selector.store(field, { operator => value })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/strategies/union.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Strategies
+      module Union
+
+        def union
+          tap { |query| query.strategy = :_union }
+        end
+
+        def _union(criterion, operator)
+          selection(criterion) do |selector, field, value|
+            selector.store(
+              field,
+              selector[field]._union({ operator => value })
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/type.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Type
+
+      def type(criterion = nil)
+        _override(criterion, "$type")
+      end
+
+      ::Symbol.class_eval do
+
+        def type
+          Key.new(self, "$type")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/where.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module Where
+
+      def where(criterion = nil)
+        criterion.is_a?(String) ? js_query(criterion) : expr_query(criterion)
+      end
+
+      private
+
+      def expr_query(criterion)
+        selection(criterion) do |selector, field, value|
+          if field.is_a?(Key)
+            selector.merge!(field.specify(value))
+          else
+            selector.store(field, value)
+          end
+        end
+      end
+
+      def js_query(criterion)
+        clone.tap do |query|
+          query.selector.merge!("$where" => criterion)
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/within_box.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module WithinBox
+
+      def within_box(criterion = nil)
+        _expanded(criterion, "$within", "$box")
+      end
+
+      ::Symbol.class_eval do
+
+        def within_box
+          Key.new(self, "$within", "$box")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/within_circle.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module WithinCircle
+
+      def within_circle(criterion = nil)
+        _expanded(criterion, "$within", "$center")
+      end
+
+      ::Symbol.class_eval do
+
+        def within_circle
+          Key.new(self, "$within", "$center")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selection/within_spherical_circle.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Origin
+  module Selection
+    module WithinSphericalCircle
+
+      def within_spherical_circle(criterion = nil)
+        _expanded(criterion, "$within", "$centerSphere")
+      end
+
+      ::Symbol.class_eval do
+
+        def within_spherical_circle
+          Key.new(self, "$within", "$centerSphere")
+        end
+      end
+    end
+  end
+end

data/lib/origin/selector.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+module Origin
+  class Selector < Hash
+  end
+end

data/lib/origin/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Origin
+  VERSION = "0.0.0.alpha"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: origin
+version: !ruby/object:Gem::Version
+  version: 0.0.0.alpha
+  prerelease: 6
+platform: ruby
+authors:
+- Durran Jordan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70272334463460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70272334463460
+- !ruby/object:Gem::Dependency
+  name: watchr
+  requirement: &70272334462920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70272334462920
+description: Origin is a simple DSL for generating MongoDB selectors and options
+email:
+- durran@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/origin/ext/array.rb
+- lib/origin/ext/hash.rb
+- lib/origin/ext/nil.rb
+- lib/origin/ext/object.rb
+- lib/origin/ext.rb
+- lib/origin/optional/batch_size.rb
+- lib/origin/optional/hint.rb
+- lib/origin/optional/limit.rb
+- lib/origin/optional/max_scan.rb
+- lib/origin/optional/no_timeout.rb
+- lib/origin/optional/only.rb
+- lib/origin/optional/read.rb
+- lib/origin/optional/return_key.rb
+- lib/origin/optional/show_disk_loc.rb
+- lib/origin/optional/skip.rb
+- lib/origin/optional/slice.rb
+- lib/origin/optional/snapshot.rb
+- lib/origin/optional/transformer.rb
+- lib/origin/optional/without.rb
+- lib/origin/optional.rb
+- lib/origin/options.rb
+- lib/origin/queryable.rb
+- lib/origin/selection/all.rb
+- lib/origin/selection/and.rb
+- lib/origin/selection/between.rb
+- lib/origin/selection/elem_match.rb
+- lib/origin/selection/exists.rb
+- lib/origin/selection/gt.rb
+- lib/origin/selection/gte.rb
+- lib/origin/selection/in.rb
+- lib/origin/selection/key.rb
+- lib/origin/selection/lt.rb
+- lib/origin/selection/lte.rb
+- lib/origin/selection/max_distance.rb
+- lib/origin/selection/mod.rb
+- lib/origin/selection/ne.rb
+- lib/origin/selection/near.rb
+- lib/origin/selection/near_sphere.rb
+- lib/origin/selection/nin.rb
+- lib/origin/selection/nor.rb
+- lib/origin/selection/or.rb
+- lib/origin/selection/size.rb
+- lib/origin/selection/strategies/add.rb
+- lib/origin/selection/strategies/expanded.rb
+- lib/origin/selection/strategies/intersect.rb
+- lib/origin/selection/strategies/multi.rb
+- lib/origin/selection/strategies/override.rb
+- lib/origin/selection/strategies/union.rb
+- lib/origin/selection/strategies.rb
+- lib/origin/selection/type.rb
+- lib/origin/selection/where.rb
+- lib/origin/selection/within_box.rb
+- lib/origin/selection/within_circle.rb
+- lib/origin/selection/within_spherical_circle.rb
+- lib/origin/selection.rb
+- lib/origin/selector.rb
+- lib/origin/version.rb
+- lib/origin.rb
+- Rakefile
+homepage: http://mongoid.org
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: origin
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Simple DSL for MongoDB query generation
+test_files: []