mongery 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3aeb64347aabfea21e8a23c2160e10256404f948
-  data.tar.gz: 60d53661a827f430c4dfe6bd34466deab7b1168f
+  metadata.gz: fe6385d3fabb1f17ebd5637f248fab8b776d7718
+  data.tar.gz: 1acfe3b40ce8de1d187fa43b7ad4277cc6cf534e
 SHA512:
-  metadata.gz: 6e3a644c5a6c6409c2923f7c1a228fd5f287011f94134b460b4adcff86076fecc4ce990fd0d38e04263b61e6166627f739dbb73c558af6018371677eef40c858
-  data.tar.gz: 2112b7028f0c874bc3e8024d668ae0b254e34116ca1464b8fe4fecc09c8ac5fd6ae33e61e3ef9f874218391f019fd328b7eae02f2321608b28cfeb24d1fa47c3
+  metadata.gz: 21a99f928bd828a80391a10d90a0db8c8bd2401cebc8538df8d5d309fddd5d4bddd96c870bb3c99a1464a59889c786887aad59536f67bbf042c96f6bcf47bde6
+  data.tar.gz: bb095b44a1482056496e3a209169f27f3d6c255f621717d065a9be4132cd060281723f8f390dd1368420010d32ca6fb5c049d1f6fd1681fdd53c22a9a8e6ead9

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 1.0.4 (2015/01/19)
+- Support custom operators
+
 ## 1.0.3 (2015/01/09)
 - Support index method to create expression indexes
 

data/lib/mongery.rb

@@ -5,12 +5,14 @@ require "arel"
 module Mongery
   class Builder
     attr_reader :model, :table, :schema, :mapped_properties
+    attr_accessor :custom_operators
 
     def initialize(model, engine = ActiveRecord::Base, schema = nil)
       @model = model
       @table = Arel::Table.new(model, engine)
       @schema = Schema.new(schema) if schema
       @mapped_properties = {}
+      @custom_operators = {}
     end
 
     def mapped_properties=(value)
@@ -23,25 +25,32 @@ module Mongery
     end
 
     def find(*args)
-      Query.new(table, schema, mapped_properties).where(*args)
+      build_query.where(*args)
     end
 
     def insert(*args)
-      Query.new(table, schema, mapped_properties).insert(*args)
+      build_query.insert(*args)
     end
 
     def index(*args)
-      Query.new(table, schema, mapped_properties).index(*args)
+      build_query.index(*args)
+    end
+
+    private
+
+    def build_query
+      Query.new(table, schema, mapped_properties, custom_operators)
     end
   end
 
   class Query
-    attr_reader :table, :schema, :mapped_properties
+    attr_reader :table, :schema, :mapped_properties, :custom_operators
 
-    def initialize(table, schema, mapped_properties)
+    def initialize(table, schema, mapped_properties, custom_operators)
       @table = table
       @schema = schema
       @mapped_properties = mapped_properties
+      @custom_operators = custom_operators
       @condition = nil
     end
 
@@ -179,7 +188,9 @@ module Mongery
       when Hash
         if has_operator?(value)
           chain(:and, value.map {|op, val|
-                  if OPERATOR_MAP.key?(op)
+                  if custom_operators[op]
+                    operator(col, custom_operators[op], val)
+                  elsif OPERATOR_MAP.key?(op)
                     col.send(OPERATOR_MAP[op], val)
                   else
                     raise UnsupportedQuery, "Unknown operator #{op}"
@@ -193,36 +204,6 @@ module Mongery
       end
     end
 
-    def translate_value_dynamic(col, value)
-      case value
-      when String, TrueClass, FalseClass
-        compare(col, value.to_s, :eq)
-      when Numeric, NilClass
-        compare(col, value, :eq)
-      when Hash
-        if has_operator?(value)
-          chain(:and, value.map {|op, val|
-                  case op
-                  when "$in"
-                    if val.all? {|v| v.is_a? Numeric }
-                      wrap(col, val.first).in(val)
-                    else
-                      col.in(val.map(&:to_s))
-                    end
-                  when "$eq", "$ne", "$gt", "$gte", "$lt", "$lte"
-                    compare(col, val, OPERATOR_MAP[op])
-                  else
-                    raise UnsupportedQuery, "Unknown operator #{op}"
-                  end
-                })
-        else
-          col.eq(value.to_json)
-        end
-      else
-        col.eq(value.to_json)
-      end
-    end
-
     def translate_value_schema(column, col, value)
       type = schema.column_type(column.to_s)
       case value
@@ -237,8 +218,10 @@ module Mongery
                     else
                       compare_schema(col, val, type, :in)
                     end
+                  when *(custom_operators.keys)
+                    compare_schema(col, val, type, custom_operators[op])
                   when "$eq", "$ne", "$gt", "$gte", "$lt", "$lte"
-                     compare_schema(col, val, type, OPERATOR_MAP[op])
+                    compare_schema(col, val, type, OPERATOR_MAP[op])
                   else
                     raise UnsupportedQuery, "Unknown operator #{op}"
                   end
@@ -269,6 +252,8 @@ module Mongery
                     else
                       col.in(val.map(&:to_s))
                     end
+                  when *(custom_operators.keys)
+                    compare(col, val, custom_operators[op])
                   when "$eq", "$ne", "$gt", "$gte", "$lt", "$lte"
                     compare(col, val, OPERATOR_MAP[op])
                   else
@@ -288,7 +273,7 @@ module Mongery
     end
 
     def compare(col, val, op)
-      wrap(col, val).send(op, val)
+      operator(wrap(col, val), op, val)
     end
 
     def wrap(col, val)
@@ -312,19 +297,28 @@ module Mongery
     def compare_schema(col, val, type, op)
       case type
       when "string"
-        Arel.sql("(#{col})").send(op, val)
+        operator(Arel.sql("(#{col})"), op, val)
       when "number", "integer"
-        Arel.sql("(#{col})::numeric").send(op, val)
+        operator(Arel.sql("(#{col})::numeric"), op, val)
       else
         case val
         when Numeric
-          Arel.sql("(#{col})").send(op, val.to_s)
+          operator(Arel.sql("(#{col})"), op, val.to_s)
         else
-          Arel.sql("(#{col})").send(op, val)
+          operator(Arel.sql("(#{col})"), op, val)
         end
       end
     end
 
+    def operator(col, op, val)
+      case op
+      when Symbol
+        col.send(op, val)
+      else
+        op.call(col, val)
+      end
+    end
+
     def sql_json_path(col)
       paths = col.to_s.split('.')
       Arel.sql("data#>>#{json_pathize(paths)}")

data/lib/mongery/version.rb

@@ -1,3 +1,3 @@
 module Mongery
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/spec/mongery/builder_schema_spec.rb

@@ -23,6 +23,10 @@ describe Mongery::Builder do
       /WHERE \(data#>>'{height}'\) IN \('6\.1', '6\.2'\)$/ ],
     [ { height: nil },
       /WHERE \(data#>>'{height}'\) IS NULL$/ ],
+    [ { name: { "$as" => "miyagawa" } },
+      /WHERE \(data#>>'{name}'\) = 'miyagawa'$/ ],
+    [ { name: { "$land" => "foo" } },
+      /WHERE \(data#>>'{name}'\) && 'foo'$/ ],
   ]
 
   schema = JsonSchema.parse!(JSON.parse(<<-EOF))
@@ -49,6 +53,12 @@ describe Mongery::Builder do
   EOF
 
   builder = Mongery::Builder.new(:test, ActiveRecord::Base, schema)
+  builder.custom_operators  = {
+    "$as" => :eq,
+    "$land" => ->(col, val) {
+      Arel::Nodes::InfixOperation.new("&&", col, val)
+    }
+  }
 
   queries.each do |query, sql|
     context "with query #{query}" do

data/spec/mongery/builder_spec.rb

@@ -70,6 +70,10 @@ describe Mongery::Builder do
       /WHERE data#>>'{bar}' = '{"foo":"bar","baz":\[1,2,3\]}'$/ ],
     [ { "foo.bar" => true }, { },
       /WHERE data#>>'{foo,bar}' = 'true'$/ ],
+    [ { bar: {"$as" => 1} }, { },
+      /WHERE \(data#>>'{bar}'\)::numeric = 1$/ ],
+    [ { bar: {"$land" => 'foo'} }, { },
+      /WHERE data#>>'{bar}' && 'foo'$/ ],
   ]
 
   bad_queries = [
@@ -80,6 +84,12 @@ describe Mongery::Builder do
   ]
 
   builder = Mongery::Builder.new(:test)
+  builder.custom_operators  = {
+    "$as" => :eq,
+    "$land" => ->(col, val) {
+      Arel::Nodes::InfixOperation.new("&&", col, val)
+    }
+  }
 
   queries.each do |query, condition, sql|
     context "with query #{query}" do

data/spec/mongery/mapped_properties_spec.rb

@@ -4,6 +4,12 @@ describe "#mapped_properties" do
   let(:builder) {
     Mongery::Builder.new(:test).tap do |builder|
       builder.mapped_properties = [:user_id, :created_at, :updated_at]
+      builder.custom_operators  = {
+        "$as" => :eq,
+        "$land" => ->(col, val) {
+          Arel::Nodes::InfixOperation.new("&&", col, val)
+        }
+      }
     end
   }
 
@@ -31,4 +37,14 @@ describe "#mapped_properties" do
     expect(builder.find("created_at" => {'$in' => ['2014-01-01', '2015-01-01']}, "foo" => "bar").to_sql)
       .to match /WHERE "test"\."created_at" IN \('2014-01-01', '2015-01-01'\) AND data#>>'{foo}' = 'bar'/;
   end
+
+  it 'does custom operators' do
+    expect(builder.find(user_id: { "$as" => 2 }).to_sql)
+      .to match /WHERE "test"\."user_id" = 2/;
+  end
+
+  it 'does custom operators with proc' do
+    expect(builder.find(user_id: { "$land" => 'foo' }).to_sql)
+      .to match /WHERE "test"\."user_id" && 'foo'/;
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongery
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Tatsuhiko Miyagawa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-09 00:00:00.000000000 Z
+date: 2015-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arel