groovy 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a5a7078b71e609451ea64d58ee47e7573f7570563118c1b1fdf62078617ce8d
-  data.tar.gz: 7444d38fc53884cb3540c0ab73efd91f296fcfa96828890cc29509831e6ae656
+  metadata.gz: e12ec33808ce635a4cc1d18432daab18f075fdd6112d41be94c4b3d81039cfb9
+  data.tar.gz: 72fc2666d2c87469399e7c3297fa69a613e194f95ba22a51f1f4306a7123b36d
 SHA512:
-  metadata.gz: c20a741e4074aae0e28164ed307080229257d9c1fb6e00bd9fbe50f7b558b0189c1172cadc0ecd9b56484724b442a9bdd5bd59e67fbf748bdee9f4c39642fbd0
-  data.tar.gz: e6481be3ce2ae9fc87071bf1865e1672e7da9b3af0eee39a69dc718be6c4ef39b5dbb942cdd466fe26ccc2035fa5aba70037c12a2f373b44de42d88e3d7cc4b6
+  metadata.gz: 31599509b743b69e7b0da3f1348da0bbd029b81003685bddc3ce6b95100e8c11f7ad2524ba7b3600925cbd50b5468bae09eba0126d5e8b0072dc032e990be9f4
+  data.tar.gz: 0f73afaab9eb391731d864aaace675755c713ef32bfa2c045bc1760d5eda25cd67d3f2b395562d31a5bbf7affff0e50ec9c5d923a8f222516a21dec4dfef34f6

data/.gitignore

@@ -4,3 +4,5 @@ test
 log
 pkg
 example/db
+tmp
+Gemfile.lock

data/example/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    groovy (0.1.2)
+    groovy (0.1.3)
       rroonga (~> 7.1)
 
 GEM

data/example/basic.rb

@@ -11,6 +11,9 @@ class Product
     t.integer :price
     t.timestamps
   end
+
+  scope :by_price, -> { sort_by(price: :asc) }
+  scope :named, -> (name) { where(name: name) if name }
 end
 
 def populate

data/example/relations.rb

@@ -23,6 +23,8 @@ class Category
     t.string :name
     t.timestamps
   end
+
+  scope :named, -> (name) { where(name: name) if name }
 end
 
 class Place
@@ -34,6 +36,8 @@ class Place
     t.string :description, index: true
     t.timestamps
   end
+
+  scope :recent, -> { sort_by(created_at: :desc) }
 end
 
 class Location

data/groovy.gemspec

@@ -14,9 +14,12 @@ Gem::Specification.new do |s|
   # s.required_rubygems_version = ">= 1.3.6"
   # s.rubyforge_project         = "groovy"
 
-  s.add_development_dependency "bundler", ">= 1.0.0"
   s.add_runtime_dependency "rroonga", "~> 7.1"
 
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", '~> 3.0', '>= 3.0.0'
+  s.add_development_dependency "fuubar", '>= 2.3.2'
+
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
   s.require_path = 'lib'

data/lib/groovy.rb

@@ -3,14 +3,18 @@ require File.expand_path(File.dirname(__FILE__)) + '/groovy/model'
 
 module Groovy
 
+  class Error < StandardError; end
+  class ContextNotFound < Error; end
+  class ContextAlreadyClosed < Error; end
+
   class << self
 
     def contexts
       @contexts ||= {}
     end
 
-    def [](key)
-      contexts[key.to_sym]
+    def [](name)
+      contexts[name.to_sym]
     end
     
     def first_context_name
@@ -18,7 +22,14 @@ module Groovy
     end
 
     def open(db_path, name = :default, opts = {})
-      raise "Context already defined: #{name}" if contexts[name.to_sym]
+      unless db_path.is_a?(String)
+        raise ArgumentError, "Invalid db_path: #{db_path}" 
+      end
+
+      if contexts[name.to_sym]
+        raise ArgumentError, "Context already defined: #{name}" 
+      end
+
       contexts[name.to_sym] = if name == :default
         Groonga::Context.default.tap { |ctx| open_or_create_db(ctx, db_path) }
       else
@@ -26,6 +37,14 @@ module Groovy
       end
     end
 
+    def close(name = :default)
+      ctx = contexts[name.to_sym] or raise ContextNotFound.new(name)
+      contexts.delete(name.to_sym)
+      ctx.close 
+    rescue Groonga::Closed => e
+      raise ContextAlreadyClosed
+    end
+
     def logger=(obj)
       @logger = obj
     end

data/lib/groovy/model.rb

@@ -39,6 +39,7 @@ module Groovy
       end
 
       def table
+        # raise "Table name not set: #{table_name}" if table_name.nil?
         db_context[table_name]
       end
 
@@ -47,7 +48,11 @@ module Groovy
       end
 
       def schema(options = {}, &block)
-        @schema ||= begin
+        @schema ||= load_schema(options, &block)
+      end
+
+      def load_schema(options = {}, &block)
+        @schema = begin
           self.context_name = options[:context] || Groovy.first_context_name
           self.table_name = options[:table_name] if options[:table_name]
 
@@ -66,7 +71,8 @@ module Groovy
       def scope(name, obj)
         define_singleton_method(name) do |*args|
           res = obj.respond_to?(:call) ? obj.call(*args) : obj
-          self
+          # res = obj.respond_to?(:call) ? self.instance_exec(*args) { |a| obj.call(*a) } : obj
+          self # return self instead of query, so we can call other scopes
         end
       end
 
@@ -75,6 +81,19 @@ module Groovy
         new(record.attributes, record)
       end
 
+      def find_and_init_record(id)
+        if found = table[id]
+          new_from_record(found)
+        end
+      end
+
+      def find_records(&block)
+        records = table.select(&block)
+        records.map do|r| 
+          find_and_init_record(r.attributes['_key']['_id'])
+        end
+      end
+
       def find(id)
         if record = table[id] and record.id
           new_from_record(record)
@@ -109,9 +128,10 @@ module Groovy
         # table.select("#{col}:#{q}", operator: Groonga::Operation::SIMILAR)
       end
 
-      def unique_values_for(column, limit: -1)
+      def unique_values_for(column, limit: -1, cache: false)
         cols = [column]
         opts = { drill_down: cols, drill_down_limit: limit, drilldown_sortby: '_key' }
+        opts[:cache] = cache ? 'yes' : 'no'
         resp = table.context.select(table_name, opts) # drill_down_output_columns: cols
         arr  = resp.body[1] # or resp.drilldowns
         arr.slice(2..-1) # .flatten
@@ -143,11 +163,11 @@ module Groovy
         where(params).limit(1).first
       end
 
-      def in_batches(of: 1000, from: nil, &block)
-        all.in_batches(of: of, from: from, &block)
-      end
+      # def in_batches(of: 1000, from: nil, &block)
+      #   all.in_batches(of: of, from: from, &block)
+      # end
 
-      [:search, :where, :not, :sort_by, :limit, :offset].each do |scope_method|
+      [:search, :where, :not, :sort_by, :limit, :offset, :paginate, :in_batches].each do |scope_method|
         define_method scope_method do |*args|
           query.public_send(scope_method, *args)
         end
@@ -179,7 +199,7 @@ module Groovy
       private
 
       def db_context
-        Groovy.contexts[context_name] or raise "Context not defined: #{context_name}"
+        Groovy.contexts[context_name.to_sym] or raise "Context not defined: #{context_name}"
       end
 
       def add_attr_accessors(col)
@@ -269,11 +289,16 @@ module Groovy
 
     def update_attributes(obj)
       set_attributes(obj)
+      return false if respond_to?(:invalid?) and invalid?
       update
     end
 
+    def update_attributes!(obj)
+      update_attributes or raise "Invalid!"
+    end
+
     def save(options = {})
-      return false if respond_to?(:invalid) and invalid?
+      return false if respond_to?(:invalid?) and invalid?
       new_record? ? create : update
     end
 
@@ -304,6 +329,10 @@ module Groovy
       attributes
     end
 
+    def ==(other)
+      self.id == other.id
+    end
+
     private
 
     # def _key

data/lib/groovy/query.rb

@@ -17,9 +17,12 @@ module Groovy
     end
 
     def merge_with!(another)
+      # puts "merging #{parameters.inspect} with #{another.parameters.inspect}"
       # parameters.merge!(another.parameters)
-      parameters.concat(another.parameters)
-      sorting.merge!(another.sorting)
+      @parameters = another.parameters
+      @sorting = another.sorting
+      # parameters.concat(another.parameters)
+      # sorting.merge!(another.sorting)
       self
     end
 
@@ -42,21 +45,25 @@ module Groovy
     def where(conditions = nil)
       case conditions
         when String # "foo:bar"
-          parameters.push(AND + "(#{map_operator(conditions)})")
+          add_param(AND + "(#{map_operator(conditions)})")
         when Hash # { foo: 'bar' } or { views: 1..100 }
           conditions.each do |key, val|
             if val.is_a?(Range)
-              parameters.push(AND + [key, val.min].join(':>=')) if val.min # lte
-              parameters.push(AND + [key, val.max].join(':<=')) if val.max # gte
+              add_param(AND + [key, val.min].join(':>=')) if val.min # lte
+              add_param(AND + [key, val.max].join(':<=')) if val.max # gte
+
             elsif val.is_a?(Regexp)
-              str = val.source.gsub(/[^a-z]/, '')
-              param = val.source[0] == '^' ? ':^' : ':~' # starts with or regexp
-              parameters.push(AND + [key, str].join(param))
+              str = val.source.gsub(/[^a-zA-Z0-9\s_\.,-]/, '')
+              param = val.source[0] == '^' ? ':^' : val.source[-1] == '$' ? ':$' : ':~' # starts with or regexp
+              add_param(AND + [key, str.downcase].join(param)) # regex must be downcase
+
             elsif val.is_a?(Array) # { foo: [1,2,3] }
               str = "#{key}:#{val.join(" OR #{key}:")}"
-              parameters.push(AND + str)
+              add_param(AND + str)
+
             else
-              parameters.push(AND + [key, val.to_s].join(':'))
+              str = val.nil? || val.to_s.strip == '' ? '\\' : val.to_s
+              add_param(AND + [key, str].join(':'))
             end
           end
         # when Array # ["foo:?", val]
@@ -76,13 +83,21 @@ module Groovy
         when Hash # { foo: 'bar' }
           conditions.each do |key, val|
             if val.is_a?(Range)
-              parameters.push(AND + [key, val.min].join(':<=')) if val.min > 0 # gte
-              parameters.push(AND + [key, val.max].join(':>=')) if val.max # lte, nil if range.max is -1
+              add_param(AND + [key, val.min].join(':<=')) if val.min > 0 # gte
+              add_param(AND + [key, val.max].join(':>=')) if val.max # lte, nil if range.max is -1
+
+            elsif val.is_a?(Regexp)
+              str = val.source.gsub(/[^a-zA-Z0-9\s_\.,-]/, '')
+              param = val.source[0] == '^' ? ':^' : val.source[-1] == '$' ? ':$' : ':~' # starts with or regexp
+              add_param(NOT + [key, str.downcase].join(param)) # regex must be downcase
+
             elsif val.is_a?(Array) # { foo: [1,2,3] }
-              str = "#{key}:!#{val.join(" OR #{key}:!")}"
-              parameters.push(AND + str)
+              str = "#{key}:!#{val.join(" #{AND}#{key}:!")}"
+              add_param(AND + str)
+
             else
-              parameters.push(AND + [key, val.to_s].join(':!')) # not
+              str = val.nil? || val.to_s.strip == '' ? '\\' : val.to_s
+              add_param(AND + [key, str].join(':!')) # not
             end
           end
         # when Array # ["foo:?", val]
@@ -171,11 +186,10 @@ module Groovy
     end
 
     def records
-      @records ||= results.map do |r| 
+      @records ||= results.map do |r|
         # FIXME: figure out the right way to do this.
-        # model.new(r.value.attributes['_key'], r)
         id = r.attributes['_value']['_key']['_id']
-        model.new_from_record(table[id])
+        model.find_and_init_record(id)
       end
     end
 
@@ -186,6 +200,11 @@ module Groovy
       model.clear_query # sets @query to nil
     end
 
+    def add_param(param)
+      raise "Duplicate param: #{param}" if parameters.include?(param)
+      parameters.push(param)
+    end
+
     def results
       @results ||= execute
     rescue Groonga::TooLargeOffset
@@ -198,12 +217,14 @@ module Groovy
     def execute
       set = if parameters.any?
         query = prepare_query
-        puts query if ENV['DEBUG']
+        puts "Finding records with query: #{query}" if ENV['DEBUG']
         table.select(query, options)
       else
         table.select(options)
       end
 
+      puts set.expression.inspect
+
       @total_entries = set.size
 
       puts "Sorting with #{sort_key_and_order}, #{sorting.inspect}" if ENV['DEBUG']
@@ -232,7 +253,7 @@ module Groovy
     def prepare_query
       query = parameters.join(" ").split(/ or /i).map do |part|
         part.gsub(/\s(\w)/, '\ \1')
-      end.join(' OR ')
+      end.join(' OR ').sub(/^-/, '_id:>0 -') #.gsub(' OR -', ' -')
     end
 
     def method_missing(name, *args)

data/lib/groovy/version.rb

@@ -1,3 +1,3 @@
 module Groovy
-  VERSION = '0.1.3'.freeze
+  VERSION = '0.1.4'.freeze
 end

data/spec/groovy_spec.rb

@@ -1,61 +1,66 @@
-require './lib/groovy'
-require 'rspec/mocks'
-
-describe Groovy::Model do
-
-  describe '.schema' do
-  end
-
-  describe '.scope' do
-  end
-
-  describe '.create' do
-  end
-
-  describe '.find' do
-  end
-
-  describe '.find_by' do
-  end
-
-  describe '.delete_all' do
-  end
-
-  describe '#[]' do
-  end
-
-  describe '#[]=' do
-  end
-
-  describe '#increment' do
-  end
-
-  describe '#dirty' do
-  end
-
-  describe '#update_attributes' do
-  end
-
-  describe '#save' do
-  end
-
-  describe '#delete' do
-  end
-
-  describe '#reload' do
-  end
-
-  describe 'attributes accessors' do
-
-  end
-
-  describe 'singular refs' do
-
-  end
-
-  describe 'plural refs' do
-
-  end
-
-end
-
+require_relative './spec_helper'
+
+describe Groovy do
+  before :each do
+    Groonga::Context.default = nil
+  end
+
+  describe '.open' do
+    it 'explodes if called with no params' do
+      expect do
+        Groovy.open
+      end.to raise_error(ArgumentError)
+    end
+
+    it 'explodes if called with nil db_path' do
+      expect do
+        Groovy.open(nil)
+      end.to raise_error(ArgumentError)
+    end
+
+    context 'if no context given' do
+      it 'sets up database for default context' do
+        expect(Groonga::Context.default.database).to be_nil
+        Groovy.open('tmp/foo1')
+        expect(Groonga::Context.default.database).to be_a(Groonga::Database)
+        Groovy.close # default
+      end
+    end
+
+    context 'if context given' do
+      it 'sets up database for default context' do
+        expect(Groonga::Context.default.database).to be_nil
+        Groovy.open('tmp/foo2', :test)
+        expect(Groonga::Context.default.database).to be_nil
+
+        expect(Groovy['test']).to be_a(Groonga::Context)
+        expect(Groovy[:test].database).to be_a(Groonga::Database)
+
+        Groovy.close(:test)
+      end
+    end
+  end
+
+  describe '.close' do
+    it 'thows if not opened (default)' do
+      expect { Groovy.close }.to raise_error(Groovy::ContextNotFound)
+    end
+
+    it 'thows if context does not exist' do
+      expect { Groovy.close(:foo) }.to raise_error(Groovy::ContextNotFound)
+    end
+
+    it 'thows if already closed' do
+      Groovy.open('tmp/foo')
+      Groovy.close
+      expect do
+        Groovy.close
+      end.to raise_error(Groovy::ContextNotFound)
+    end
+
+    it 'works if ctx exists and open' do
+      Groovy.open('tmp/foo', :test)
+      expect(Groovy.close(:test)).to eq(nil)
+    end
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,104 @@
+require_relative './spec_helper'
+
+describe Groovy::Model do
+
+  before :all do
+    Groovy.open('tmp/model', 'model_spec')
+    load_schema! 'model_spec'
+  end
+
+  after :all do
+    Groovy.close('model_spec')
+  end
+
+  after :each do
+    TestProduct.clear_query # otherwise next test will fail
+  end
+
+  describe '.schema' do
+  end
+
+  describe '.scope' do
+
+    before :all do
+      TestProduct.class_eval do 
+        scope :with_name, -> (name) { where(name: name) if name }
+        scope :by_price_asc, -> { sort_by(price: :asc) }
+        scope :cheapest, -> { by_price_asc }
+      end
+    end
+
+    it 'does not perform query by default' do
+      expect(TestProduct.table).not_to receive(:select)
+      TestProduct.with_name('foo')
+    end
+
+    describe 'chaining' do
+
+      it 'allow chaining (even if methods dont return the query)' do
+        expect do
+          TestProduct.with_name('foo').by_price_asc.cheapest
+        end.not_to raise_error
+      end
+
+      it 'does not duplicate params' do
+        res = TestProduct.with_name('foo').by_price_asc.cheapest
+        res.query
+        expect(res.query.parameters).to eq(["+name:foo"])
+        expect(res.query.sorting).to eq(:by=>[{:key=>"price", :order=>:asc}], :limit=>-1, :offset=>0)
+      end
+
+    end
+
+  end
+
+  describe '.create' do
+  end
+
+  describe '.find' do
+  end
+
+  describe '.find_by' do
+  end
+
+  describe '.delete_all' do
+  end
+
+  describe '#[]' do
+  end
+
+  describe '#[]=' do
+  end
+
+  describe '#increment' do
+  end
+
+  describe '#dirty' do
+  end
+
+  describe '#update_attributes' do
+  end
+
+  describe '#save' do
+  end
+
+  describe '#delete' do
+  end
+
+  describe '#reload' do
+  end
+
+  describe 'attributes accessors' do
+
+  end
+
+  describe 'singular refs' do
+
+  end
+
+  describe 'plural refs' do
+
+  end
+
+end
+

data/spec/query_spec.rb

@@ -0,0 +1,204 @@
+require_relative './spec_helper'
+
+describe Groovy::Query do
+
+  before :all do
+    Groovy.open('tmp/querying', 'query_spec')
+    load_schema! 'query_spec'
+    @p1 = TestProduct.create!(name: "Product 1", visible: true, price: 10, tag_list: 'one, number two, and three')
+    @p2 = TestProduct.create!(name: "Product 2", visible: false, price: 20, tag_list: 'number two, three')
+    @p3 = TestProduct.create!(name: "Product 3", visible: true, price: 30, tag_list: nil)
+    @p4 = TestProduct.create!(name: "Product 4", visible: false, price: 40, tag_list: 'one, number two')
+    @p5 = TestProduct.create!(name: "Product 5", visible: true, price: 50, tag_list: '')
+  end
+
+  after :all do
+    Groovy.close('query_spec')
+  end
+
+  describe '#where' do
+    describe 'nil value' do
+      it 'finds expected records' do
+        res = TestProduct.where(tag_list: nil)
+        expect(res.map(&:id)).to eq([@p3.id, @p5.id])
+      end
+      it 'works with other args too' do
+        res = TestProduct.where(name: 'Product 5').where(tag_list: nil)
+        expect(res.map(&:id)).to eq([@p5.id])
+      end
+    end
+
+    describe 'empty string value' do
+      it 'finds expected records' do
+        res = TestProduct.where(tag_list: '')
+        expect(res.map(&:id)).to eq([@p3.id, @p5.id])
+      end
+      it 'works with other args too' do
+        res = TestProduct.where(name: 'Product 5').where(tag_list: '')
+        expect(res.map(&:id)).to eq([@p5.id])
+      end
+    end
+
+    describe 'exact search' do
+      it 'finds expected records' do
+        res = TestProduct.where(name: 'Product 2')
+        expect(res.map(&:id)).to eq([@p2.id])
+      end
+    end
+
+    context 'basic regex' do
+      it 'finds expected records' do
+        res = TestProduct.where(tag_list: /two/)
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p4.id])
+      end
+
+      it 'is not case-sensitive' do
+        res = TestProduct.where(tag_list: /TWO/)
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p4.id])
+      end
+    end
+
+    describe 'starts with regex' do
+      it 'finds expected records' do
+        res = TestProduct.where(name: /^product/)
+        # expect(res.map(&:id)).to eq([])
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p3.id, @p4.id, @p5.id])
+
+        res = TestProduct.where(name: /^Product/)
+        # expect(res.map(&:id)).to eq([])
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p3.id, @p4.id, @p5.id])
+      end
+    end
+
+    describe 'ends with regex' do
+      it 'finds expected records' do
+        res = TestProduct.where(tag_list: /three$/)
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id])
+
+        # res = TestProduct.where(name: /THREE$/)
+        # expect(res.map(&:id)).to eq([])
+        # expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p3.id])
+        # expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p3.id, @p4.id, @p5.id])
+      end
+    end
+
+    context 'regex with spaces' do
+      it 'finds expected records' do
+        res = TestProduct.where(tag_list: /number two/)
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p4.id])
+      end
+
+      xit 'handles escaped chars correctly' do
+        res = TestProduct.where(tag_list: /number\stwo/)
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p4.id])
+      end
+    end
+
+    context 'array value' do
+      it 'finds expected records' do
+        res = TestProduct.where(_id: [@p1.id, @p3.id, @p5.id])
+        expect(res.map(&:id)).to eq([@p1.id, @p3.id, @p5.id])
+      end
+    end
+  end
+
+  describe '#not' do
+    describe 'nil value' do
+      it 'finds expected records' do
+        res = TestProduct.where.not(tag_list: nil)
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p4.id])
+      end
+      it 'works with other args too' do
+        res = TestProduct.where.not(name: 'Product 2').where.not(tag_list: nil)
+        expect(res.map(&:id)).to eq([@p1.id, @p4.id])
+      end
+    end
+
+    describe 'empty string value' do
+      it 'finds expected records' do
+        res = TestProduct.where.not(tag_list: '')
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p4.id])
+      end
+      it 'works with other args too' do
+        res = TestProduct.where.not(name: 'Product 2').where.not(tag_list: '')
+        expect(res.map(&:id)).to eq([@p1.id, @p4.id])
+      end
+    end
+
+    describe 'exact search' do
+      it 'finds expected records' do
+        res = TestProduct.not(name: 'Product 2')
+        expect(res.map(&:id)).to eq([@p1.id, @p3.id, @p4.id, @p5.id])
+      end
+    end
+
+    context 'basic regex' do
+      it 'finds expected records' do
+        res = TestProduct.not(tag_list: /two/)
+        expect(res.map(&:id)).to eq([@p3.id, @p5.id])
+      end
+
+      it 'is not case-sensitive' do
+        res = TestProduct.not(tag_list: /TWO/)
+        expect(res.map(&:id)).to eq([@p3.id, @p5.id])
+      end
+    end
+
+    describe 'starts with regex' do
+      it 'finds expected records' do
+        res = TestProduct.not(name: /^product/)
+        expect(res.map(&:id)).to eq([])
+
+        res = TestProduct.not(name: /^Product/)
+        expect(res.map(&:id)).to eq([])
+      end
+    end
+
+    describe 'ends with regex' do
+      it 'finds expected records' do
+        res = TestProduct.not(tag_list: /three$/)
+        expect(res.map(&:id)).to eq([@p3.id, @p4.id, @p5.id])
+
+        # res = TestProduct.where(name: /THREE$/)
+        # expect(res.map(&:id)).to eq([])
+        # expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p3.id])
+        # expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p3.id, @p4.id, @p5.id])
+      end
+    end
+
+    context 'regex with spaces' do
+      it 'finds expected records' do
+        res = TestProduct.not(tag_list: /number two/)
+        expect(res.map(&:id)).to eq([@p3.id, @p5.id])
+      end
+
+      xit 'handles escaped chars correctly' do
+        res = TestProduct.not(tag_list: /number\stwo/)
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p4.id])
+      end
+    end
+
+    context 'array value' do
+      it 'finds expected records' do
+        res = TestProduct.not(_id: [@p1.id, @p3.id, @p5.id])
+        expect(res.map(&:id)).to eq([@p2.id, @p4.id])
+      end
+    end
+  end
+
+  describe '#limit' do
+  end
+
+  describe '#offset' do
+  end
+
+  describe '#in_batches' do
+  end
+
+  describe '#paginate' do
+  end
+
+  describe '#sort_by' do
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'bundler'
+Bundler.require(:default, :test)
+
+require 'rspec/core'
+require './lib/groovy'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    # Groonga::Context.default = nil
+  end
+  config.after(:suite) do
+    FileUtils.rm_rf('tmp')
+  end
+end
+
+class TestProduct 
+  include Groovy::Model
+end
+
+def load_schema!(context_name)
+  TestProduct.load_schema context: context_name do |t|
+    t.boolean :visible
+    t.string  :name
+    t.integer :price
+    t.string  :tag_list
+  end
+end
+
+# load_schema!

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: groovy
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-03 00:00:00.000000000 Z
+date: 2019-05-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rroonga
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -25,19 +39,39 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.0.0
 - !ruby/object:Gem::Dependency
-  name: rroonga
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.1'
-  type: :runtime
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.2
 description: Allows using Groonga in your models a-la ActiveRecord.
 email:
 - tomas@forkhq.com
@@ -63,6 +97,9 @@ files:
 - lib/groovy/vector.rb
 - lib/groovy/version.rb
 - spec/groovy_spec.rb
+- spec/model_spec.rb
+- spec/query_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/tomas/groovy
 licenses: []
 metadata: {}