groovy 0.2.8 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59f58f216c8fc9465c4eb8569145b401f55e71682e6c5361addb623eb3ad36aa
-  data.tar.gz: bdacfc59885d00a8f6457ebc707c653fd63a8251ed09ddcb133eed50f6a4d8df
+  metadata.gz: c2e735dd501cd86a3ee2ab21b111bf7aa4ab3d76d9d14acf8be86b97e34335b1
+  data.tar.gz: 97b3b88d1f297ab6d74b9818858272c8fa711a27a3c0d64964508988a3304b85
 SHA512:
-  metadata.gz: 7890d931e4ce3c20b6fb7c25772c7a3c078022640090fe18a2b2c5215a4e819951ee97ceb1485df5cdad5e148c7670f6de6e4f84e69f329db41a01f12b3e67ee
-  data.tar.gz: 823259a7565bad47388f1fedade8a0e2c0aa277f15d55fc1921f003c333d9be76fb01d98001dc002316941b3364ca9ca9bd92a199a95fd7221efaca8a28cfb8e
+  metadata.gz: deb85e6549f328555d795e542e282c6e3a50c574fdac769530648c69292f02ed469bc293304db863b7c9ac28a5bb653bd85eb79a7652f6390b3f5309fc492552
+  data.tar.gz: 7546011290684eca615cf4823df5886908fe823c9bee086a80504a01a7d3aa846a0fd34dc05efc023a061078ac3645d352618c64a03b614989cb51bc3ca4c5c9

data/example/basic.rb

@@ -9,6 +9,7 @@ class Product
   schema do |t|
     t.string :name
     t.integer :price
+    t.boolean :published
     t.timestamps
   end
 
@@ -19,11 +20,11 @@ end
 def populate
   5_000.times do |i|
     puts "Creating product #{i}" if i % 1000 == 0
-    Product.create!(name: "A product with index #{i}", price: 10000 + i % 10)
+    Product.create!(name: "A product with index #{i}", published: true, price: 10000 + i % 10)
   end
 end
 
-populate if Product.count == 0 
+populate if Product.count == 0
 
 # 50_000 products: 50M
 # 100_000 products: 50M

data/example/relations.rb

@@ -1,12 +1,12 @@
 require 'bundler/setup'
 require 'groovy'
 
-Groovy.open('./db/2019', :current)
-# Groovy.open('./db/2020', :next)
+Groovy.open('./db/2020', :current)
+# Groovy.open('./db/2021', :next)
 
 module Groovy::Model::ClassMethods
   def context_name
-    Time.now.year == 2019 ? :current : :next
+    Time.now.year == 2020 ? :current : :next
   end
 
   def table
@@ -34,6 +34,7 @@ class Place
     t.reference :categories, "Categories", type: :vector
     t.string :name
     t.string :description, index: true
+    t.boolean :visible
     t.timestamps
   end
 
@@ -50,6 +51,21 @@ class Location
   end
 end
 
+# from groonga tests
+#
+# schema.create_table("Users", :type => :hash, :key_type => "UInt32") { |table| }
+#
+# schema.create_table("Communities", :type => :hash, :key_type => "ShortText") do |table|
+#   table.reference("users", "Users", :type => :vector)
+# end
+#
+# groonga = @communities.add("groonga")
+# morita = @users.add(29)
+# groonga["users"] = [morita]
+#
+# assert_equal([29], @users.collect {|record| record.key})
+# assert_equal([29], groonga["users"].collect {|record| record.key})
+
 def insert_places(count = 1000)
   puts "Inserting #{count} places!"
   count.times do |i|
@@ -57,4 +73,4 @@ def insert_places(count = 1000)
   end
 end
 
-insert_places if Place.count == 0
+insert_places if Place.count == 0

data/lib/groovy.rb

@@ -1,6 +1,14 @@
 require 'groonga'
 require File.expand_path(File.dirname(__FILE__)) + '/groovy/model'
 
+# overwrite Groonga::Record#inspect because the #attributes part is
+# making debugging take ages
+class Groonga::Record
+  def inspect
+    super
+  end
+end
+
 module Groovy
 
   class Error < StandardError; end
@@ -16,18 +24,18 @@ module Groovy
     def [](name)
       contexts[name.to_sym]
     end
-    
+
     def first_context_name
       contexts.keys.first
     end
 
     def open(db_path, name = :default, opts = {})
       unless db_path.is_a?(String)
-        raise ArgumentError, "Invalid db_path: #{db_path}" 
+        raise ArgumentError, "Invalid db_path: #{db_path}"
       end
 
       if contexts[name.to_sym]
-        raise ArgumentError, "Context already defined: #{name}" 
+        raise ArgumentError, "Context already defined: #{name}"
       end
 
       contexts[name.to_sym] = if name == :default
@@ -40,7 +48,7 @@ module Groovy
     def close(name = :default)
       ctx = contexts[name.to_sym] or raise ContextNotFound.new(name)
       contexts.delete(name.to_sym)
-      ctx.close 
+      ctx.close
     rescue Groonga::Closed => e
       raise ContextAlreadyClosed
     end

data/lib/groovy/model.rb

@@ -20,11 +20,16 @@ module Groovy
       model.new_from_record(obj)
     end
 
+    # def self.initialize_from_hash(key, obj)
+    #   model = model_from_table(key)
+    #   model.find(obj['_id'])
+    # end
+
     def self.model_from_table(table_name)
-      Kernel.const_get(table_name.sub(/ies$/, 'y').sub(/s$/, ''))
+      Kernel.const_get(table_name.sub(/ies$/, 'y').sub(/s$/, '').capitalize)
     end
 
-    def self.included(base)  
+    def self.included(base)
       base.extend(ClassMethods)
       base.include(Forwardable)
       base.table_name = base.name.sub(/y$/, 'ie') + 's'
@@ -44,9 +49,17 @@ module Groovy
       end
 
       def attribute_names
-        schema.attribute_columns
+        @attribute_names ||= schema.attribute_columns
       end
 
+      # def singular_refs
+      #   schema.singular_references
+      # end
+
+      # def plural_refs
+      #   schema.plural_references
+      # end
+
       def schema(options = {}, &block)
         @schema ||= load_schema(options, &block)
       end
@@ -61,63 +74,104 @@ module Groovy
           s.sync
 
           extend(PatriciaTrieMethods) if table.is_a?(Groonga::PatriciaTrie)
-          s.attribute_columns.each { |col| add_attr_accessors(col) }
-          s.singular_references.each { |col| add_ref_accessors(col) }
-          s.plural_references.each { |col| add_vector_accessors(col) }
+          s.column_names.each { |col| add_accessors_for(col, s) }
           s
         end
       end
 
-      # called from Query, so needs to be public
-      def new_from_record(record)
-        new(record.attributes, record)
+      def add_column(name, type, options = {})
+        @attribute_names = nil # ensure cache is cleared
+        schema.column(name, type, options)
+        schema.sync
+        add_accessors_for(name)
       end
 
-      def find_and_init_record(id)
-        if found = table[id]
-          new_from_record(found)
+      def add_accessors_for(col, s = schema)
+        if s.attribute_columns.include?(col)
+          add_attr_accessors(col)
+        elsif s.singular_references.include?(col)
+          add_ref_accessors(col)
+        elsif s.plural_references.include?(col)
+          add_vector_accessors(col)
+        else
+          puts "WARNING: Unknown column type: #{col}"
         end
       end
 
-      def find_records(&block)
-        records = table.select(&block)
-        records.map do|r| 
-          find_and_init_record(r.attributes['_key']['_id'])
-        end
+      # called from Query, so needs to be public
+      def new_from_record(record)
+        # new(record.attributes, record)
+        new(nil, record)
       end
 
+      # def find_and_init_record(id)
+      #   if found = table[id.to_i]
+      #     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
+        if record = table[id.to_i] and record.record_id
           new_from_record(record)
         end
       end
 
-      def create(key, attributes = nil)
-        if record = insert(key, attributes)
-          new_from_record(record)
-        end
+      def create(attributes, key = nil)
+        obj = new(attributes, nil, key)
+        obj.save ? obj : false
+      end
+
+      def create!(attributes, key = nil)
+        create(attributes, key) or raise Error, "Invalid"
       end
 
-      def create!(key, attributes = nil)
-        create(key, attributes) or raise "Invalid!"
+      def update_all(attrs)
+        find_each { |child| child.update_attributes(attrs) }
       end
 
       def delete_all
-        all.each { |child| child.delete }.count
-        # schema.rebuild!
+        # find_each { |child| child.delete }
+        table.delete { |record| record._id > -1 }
       end
 
+      # def dump_table!
+      #   Groonga::TableDumper.new(table).dump
+      #   # schema.rebuild!
+      # end
+
       # def column(name)
       #   Groonga["#{table_name}.#{name}"] # .search, .similar_search, etc
       # end
 
-      def similar_search(col, q)
-        unless schema.index_columns.include?(col.to_sym)
-          raise "Column '#{col}' doesn't have an index set!"
+
+      def index_search(column, query, options = {}, &block)
+        results = table.select { |rec| rec[column].match(query) }
+        render_results(results, &block)
+      end
+
+      def similar_search(column, query, options = {}, &block)
+        unless schema.index_columns.include?(column.to_sym)
+          raise Error, "Column '#{column}' doesn't have an index set!"
         end
 
-        table.select { |r| r[col].similar_search(q) }
-        # table.select("#{col}:#{q}", operator: Groonga::Operation::SIMILAR)
+        # results = table.select("#{col}:#{q}", operator: Groonga::Operation::SIMILAR)
+        results = table.select { |rec| rec[column].similar_search(query) }
+        render_results(results, &block)
+      end
+
+      def render_results(results, &block)
+        if block_given?
+          results.each { |rec| yield new_from_record(rec) }
+        else
+          results.map { |rec| new_from_record(rec) }
+        end
       end
 
       def unique_values_for(column, limit: -1, cache: false)
@@ -144,7 +198,7 @@ module Groovy
       end
 
       def query
-		query_class.new(self, table)
+        query_class.new(self, table)
       end
 
       def scope(name, obj)
@@ -154,28 +208,25 @@ module Groovy
         end
       end
 
-      [:find_by, :search, :where, :not, :sort_by, :limit, :offset, :paginate, :in_batches].each do |scope_method|
+      [:select, :find_each, :find_by, :search, :where, :not, :sort_by, :limit, :offset, :paginate, :in_batches].each do |scope_method|
         define_method scope_method do |*args, &block|
           query.public_send(scope_method, *args, &block)
         end
       end
-      
-      # this seems to be the same as: `table[id]`
-      # def search(key, options = nil)
-      #   raise "Not supported!" unless table.respond_to?(:search)
-      #   table.search(key, options)
-      # end
 
       def_instance_delegators :table, :count, :size
 
       # called from instance too, so must by public
-      def insert(key, attributes = nil)
+      def insert(attributes, key = nil)
+        set_timestamp(attributes, :created_at)
+        set_timestamp(attributes, :updated_at)
+
         if table.support_key?
+          raise "Key required" if key.nil?
           table.add(key, attributes)
-        else # key is attributes
-          set_timestamp(key, :created_at)
-          set_timestamp(key, :updated_at)
-          table.add(key)
+        else
+          raise "Key present, but unsupported" if key
+          table.add(attributes)
         end
       end
 
@@ -183,6 +234,17 @@ module Groovy
         obj[key_name] = Time.now if attribute_names.include?(key_name.to_sym)
       end
 
+      def callbacks
+        @callbacks ||= {}
+      end
+
+      [:before_create, :after_create].each do |event|
+        define_method(event) do |*method_names|
+          callbacks[:before_create] ||= []
+          callbacks[:before_create].push(*method_names)
+        end
+      end
+
       private
 
       def query_class
@@ -194,7 +256,8 @@ module Groovy
       end
 
       def db_context
-        Groovy.contexts[context_name.to_sym] or raise "Context not defined: #{context_name}"
+        Groovy.contexts[context_name.to_sym] \
+          or raise "Context not defined: #{context_name} Please call Groovy.open('./db/path') first."
       end
 
       def add_attr_accessors(col)
@@ -224,30 +287,38 @@ module Groovy
       end
     end
 
-    attr_reader :id, :attributes, :refs, :record, :changes
+    attr_reader :id, :attributes, :record, :changes
 
-    def initialize(attrs = nil, record = nil)
-      @attributes, @refs, @vectors = {}, {}, {}
+    def initialize(attrs = nil, record = nil, key = nil)
+      @attributes, @vectors, @_key = {}, {}, key # key is used on creation only
 
       if set_record(record)
-        # TODO: lazy load this
-        # self.class.schema.singular_references.each do |col| 
-        #   set_ref(col, record.public_send(col))
-        # end
-      end
+        set_attributes_from_record(record)
+      else
+        attrs ||= {}
+        unless attrs.is_a?(Hash)
+          raise ArgumentError.new("Attributes should be a Hash")
+        end
 
-      attrs ||= {}
-      unless attrs.is_a?(Hash)
-        raise ArgumentError.new("Attributes should be a hash") 
+        # don't call set_attributes since we don't want to call
+        # setters, that might be overriden with custom logic.
+        # attrs.each { |k,v| self[k] = v }
+        set_attributes(attrs)
       end
 
-      # don't call set_attributes since we don't want to call 
-      # setters, that might be overriden with custom logic.
-      # attrs.each { |k,v| self[k] = v }
-      set_attributes(attrs)
       @changes = {}
     end
 
+    # get reference to the actual record in the Groonga table,
+    # not the temporary one we get as part of a search result.
+    def load_record
+      self.class.table[id]
+    end
+
+    def inspect
+      "#<#{self.class.name} id:#{id.inspect} attributes:[#{self.class.attribute_names.join(', ')}]>"
+    end
+
     def new_record?
       id.nil?
       # _key.nil?
@@ -258,10 +329,12 @@ module Groovy
     end
 
     def []=(key, val)
-      return set_ref(key, val) if val.respond_to?(:record) || val.is_a?(Groonga::Record)
+      if self.class.schema.singular_references.include?(key.to_sym) # val.respond_to?(:record) || val.is_a?(Groonga::Record)
+        return set_ref(key, val)
+      end
 
       unless self.class.attribute_names.include?(key.to_sym)
-        raise "Invalid attribute: #{key}" 
+        raise "Invalid attribute: #{key}"
       end
 
       set_attribute(key, val)
@@ -299,58 +372,85 @@ module Groovy
 
     def save!(options = {})
       raise "Invalid!" unless save
+      self
     end
 
     def delete
-      record.delete # doesn't work if record.id doesn't match _key
-      # self.class.table.delete(_key)
+      # record.delete # doesn't work if record.id doesn't match _key
+      self.class.table.delete(record._id) # record.record_id
       set_record(nil)
       self
     rescue Groonga::InvalidArgument => e
-      puts "Error: #{e.inspect}"
-      raise RecordNotPersisted
+      # puts "Error: #{e.inspect}"
+      raise RecordNotPersisted, e.message
     end
 
     def reload
+      raise RecordNotPersisted if id.nil?
       ensure_persisted!
-      record = self.class.table[id] # _key
-      # TODO: fix duplication
-      set_attributes(record.attributes)
+      rec = self.class.table[id] # _key
+      # set_record(rec)
+      set_attributes_from_record(rec)
       @changes = {}
       self
     end
 
     def as_json(options = {})
-      attributes
+      options[:only] ? attributes.slice(*options[:only]) : attributes
     end
 
     def ==(other)
       self.id == other.id
     end
 
+    def <=>(other)
+      self.id <=> other.id
+    end
+
     private
 
+    def get_record_attribute(key)
+      val = record[key]
+      if self.class.schema.time_column?(key)
+        fix_time_value(val)
+      else
+        val
+      end
+    end
+
+    def fix_time_value(val)
+      return val.to_i == 0 ? nil : val
+    end
+
     # def _key
     #   return unless record
     #   record.respond_to?(:_key) ? record._key : id
     # end
 
+    def set_attributes_from_record(rec)
+      self.class.attribute_names.each do |col|
+        public_send("#{col}=", get_record_attribute(col))
+      end
+    end
+
     def set_attribute(key, val)
       changes[key.to_sym] = [self[key], val] if changes # nil when initializing
       attributes[key.to_sym] = val
     end
 
     def get_ref(name)
-      @refs[name]
+      if record and obj = record[name]
+        Model.initialize_from_record(obj)
+      end
     end
 
     def set_ref(name, obj)
-      unless obj.nil? || obj.respond_to?(:record) 
-        obj = Model.initialize_from_record(obj)
+      if record.nil?
+        set_attribute(name, obj.id) # obj should be a groovy model or groonga record
+      else
+        obj = obj.record if obj.respond_to?(:record)
+        record[name] = obj
       end
-
-      @refs[name] = obj
-      set_attribute(name, obj.nil? ? nil : obj.key)
     end
 
     def set_record(obj)
@@ -359,10 +459,18 @@ module Groovy
     end
 
     def create
-      set_record(self.class.insert(attributes))
+      fire_callbacks(:before_create)
+      set_record(self.class.insert(attributes, @_key))
+      fire_callbacks(:after_create)
       self
     end
 
+    def fire_callbacks(name)
+      if arr = self.class.callbacks[name] and arr.any?
+        arr.each { |fn| send(fn) }
+      end
+    end
+
     def update
       ensure_persisted!
       changes.each do |key, values|

data/lib/groovy/query.rb

@@ -25,18 +25,32 @@ module Groovy
       @default_sort_key = table.is_a?(Groonga::Hash) ? '_key' : '_id'
     end
 
+    # def inspect
+    #   "<#{self.class.name} #{parameters}>"
+    # end
+
+    def as_json(options = {})
+      Array.new.tap do |arr|
+        each { |record| arr.push(record.as_json(options)) }
+      end
+    end
+
     def search(obj)
       obj.each do |col, q|
-        unless model.index_columns.include?(col)
-          raise "Not an index column, so cannot do fulltext search: #{col}"
-        end
-        parameters.push(AND + "(#{col}:@#{q})")
+        # unless model.schema.index_columns.include?(col)
+        #   raise "Not an index column, so cannot do fulltext search: #{col}"
+        # end
+        q.split(' ').each do |word|
+          parameters.push(AND + "(#{col}:@#{word})")
+        end if q.is_a?(String) && q.strip != ''
       end
+      self
     end
 
-    # def inspect
-    #   "<#{self.class.name} #{parameters}>"
-    # end
+    def select(&block)
+      @select_block = block
+      self
+    end
 
     def find(id)
       find_by(_id: id)
@@ -46,10 +60,12 @@ module Groovy
       where(conditions).limit(1).first
     end
 
-    def find_each(&block)
-      in_batches(of: 10) do |group|
-        group.each { |item| yield(item) }
+    def find_each(opts = {}, &block)
+      count = 0
+      in_batches({ of: 10 }.merge(opts)) do |group|
+        group.each { |item| count += 1; yield(item) }
       end
+      count
     end
 
     # http://groonga.org/docs/reference/grn_expr/query_syntax.html
@@ -74,7 +90,7 @@ module Groovy
               add_param(AND + str)
 
             else
-              str = val.nil? || val.to_s.strip == '' ? '\\' : val.to_s
+              str = val.nil? || val === false || val.to_s.strip == '' ? "\"\"" : escape_val(val)
               add_param(AND + [key, str].join(':'))
             end
           end
@@ -108,7 +124,7 @@ module Groovy
               add_param(AND + str)
 
             else
-              str = val.nil? || val.to_s.strip == '' ? '\\' : val.to_s
+              str = val.nil? || val === false || val.to_s.strip == '' ? "\"\"" : escape_val(val)
               add_param(AND + [key, str].join(':!')) # not
             end
           end
@@ -130,18 +146,18 @@ module Groovy
       self
     end
 
-    def paginate(page = 1)
+    def paginate(page = 1, per_page: PER_PAGE)
       page = 1 if page.to_i < 1
-      offset = ((page.to_i)-1) * PER_PAGE
-      offset(offset).limit(PER_PAGE) # returns self
+      offset = ((page.to_i)-1) * per_page
+      offset(offset).limit(per_page) # returns self
     end
 
     # sort_by(title: :asc)
     def sort_by(hash)
-      if hash.is_a?(String) # e.g. title.desc
-        param, dir = hash.split('.')
+      if hash.is_a?(String) || hash.is_a?(Symbol) # e.g. 'title.desc' or :title (asc by default)
+        param, dir = hash.to_s.split('.')
         hash = {}
-        hash[param] = dir
+        hash[param] = dir || 'asc'
       end
 
       sorting[:by] = hash.keys.map do |key|
@@ -181,13 +197,21 @@ module Groovy
       records.each { |r| block.call(r) }
     end
 
+    def update_all(attrs)
+      each { |r| r.update_attributes(attrs) }
+    end
+
     def total_entries
       results # ensure query has been run
       @total_entries
     end
 
-    def last
-      records[size-1]
+    def last(count = 1)
+      if count > 1
+        records[(size-count)..-1]
+      else
+        records[size-1]
+      end
     end
 
     def in_batches(of: 1000, from: nil, &block)
@@ -205,46 +229,45 @@ module Groovy
 
     def records
       @records ||= results.map do |r|
-        # FIXME: figure out the right way to do this.
-        id = r.attributes['_value']['_key']['_id']
-        model.find_and_init_record(id)
+        model.new_from_record(r)
       end
     end
 
     private
-    attr_reader :model, :table, :options
+    attr_reader :model, :table, :options, :select_block
 
     def add_param(param)
-      if parameters.include?(param)
-        raise "Duplicate param: #{param}"
-      end
-
-      # if param matches blank/nil, put at the end of the stack
-      param[/:\!?\\/] ? parameters.push(param) : parameters.unshift(param)
+      raise "Select block already given!" if select_block
+      raise "Duplicate param: #{param}" if parameters.include?(param)
+      parameters.push(param)
     end
 
     def results
       @results ||= execute
     rescue Groonga::TooLargeOffset
-      # puts "Offset is higher than table size!"
+      puts "Offset is higher than table size!"
       []
     end
 
     def execute
-      set = if parameters.any?
+      set = if select_block
+        debug "Finding records with select block"
+        table.select { |record| select_block.call(record) }
+      elsif parameters.any?
         query = prepare_query
-        puts "Finding records with query: #{query}" if ENV['DEBUG']
+        debug "Finding records with query: #{query}"
         table.select(query, options)
       else
+        debug "Finding records with options: #{options.inspect}"
         table.select(options)
       end
 
       @total_entries = set.size
 
-      puts "Sorting with #{sort_key_and_order}, #{sorting.inspect}" if ENV['DEBUG']
+      debug "Sorting with #{sort_key_and_order}, #{sorting.inspect}"
       set = set.sort(sort_key_and_order, {
         limit: sorting[:limit],
-        offset: sorting[:offset]
+        offset: sorting[:offset], # [sorting[:offset], @total_entries].min
       })
 
       sorting[:group_by] ? set.group(group_by) : set
@@ -264,6 +287,10 @@ module Groovy
       sorting[:by] or [{ key: @default_sort_key, order: :asc }]
     end
 
+    def escape_val(val)
+      val.to_s.gsub(':', '\:')
+    end
+
     def prepare_query
       space_regex = Regexp.new('\s([' + VALID_QUERY_CHARS + '])')
       query = parameters.join(' ').split(/ or /i).map do |part|
@@ -272,6 +299,11 @@ module Groovy
             .gsub(/(\d\d):(\d\d):(\d\d)/, '\1\:\2\:\3') # escape hh:mm:ss in timestamps
       end.join(' OR ').sub(/^-/, '_id:>0 -') #.gsub(' OR -', ' -')
     end
+
+    def debug(str)
+      puts str if ENV['DEBUG']
+    end
+
   end
 
 end

data/lib/groovy/schema.rb

@@ -16,7 +16,9 @@ module Groovy
       'boolean' => 'boolean',
       'integer' => 'int32',
       'big_integer' => 'int64',
-      'time' => 'time'
+      'date' => 'date',
+      'time' => 'time',
+      'datetime' => 'time'
     }.freeze
 
     attr_reader :index_columns
@@ -39,15 +41,27 @@ module Groovy
     end
 
     def singular_references
-      get_names table.columns.select(&:reference_column?).reject(&:vector?)
+      # @singular_references ||=
+      get_names(table.columns.select(&:reference_column?).reject(&:vector?))
     end
 
     def plural_references
-      get_names table.columns.select(&:vector?)
+      # @plural_references ||=
+      get_names(table.columns.select(&:vector?))
     end
 
     def attribute_columns
-      get_names table.columns.select(&:column?)
+      # @attribute_columns ||=
+      get_names(table.columns.select { |c| c.column? && !c.reference_column? && !c.vector? })
+    end
+
+    def time_columns
+      # @time_columns ||=
+      get_names(table.columns.select { |c| c.column? && c.range.name == 'Time' })
+    end
+
+    def time_column?(name)
+      time_columns.include?(name)
     end
 
     def rebuild!
@@ -91,6 +105,7 @@ module Groovy
       @index_columns.each do |col|
         add_index_on(col)
       end
+      self
     end
 
     private
@@ -102,13 +117,15 @@ module Groovy
       @table = @search_table = nil # clear cached vars
     end
 
-    def add_index_on(col)
+    def add_index_on(col, opts = {})
       ensure_search_table!
       return false if search_table.have_column?([table_name, col].join('_'))
 
-      log "Adding index on #{col}"
+      name_col = [table_name, col].join('.')
+      log "Adding index on #{name_col}"
       Groonga::Schema.change_table(SEARCH_TABLE_NAME, context: context) do |table|
-        table.index([table_name, col].join('.'))
+        # table.index(name_col, name: name_col, with_position: true, with_section: true)
+        table.index(name_col, name: name_col.sub('.', '_'))
       end
     end
 
@@ -117,6 +134,7 @@ module Groovy
       opts = (@opts[:search_table] || {}).merge({
         type: :patricia_trie,
         normalizer: :NormalizerAuto,
+        key_type: "ShortText",
         default_tokenizer: "TokenBigram"
       })
       log("Creating search table with options: #{opts.inspect}")

data/lib/groovy/vector.rb

@@ -9,16 +9,37 @@ module Groovy
     end
 
     def size
-      # records.count
-      items.count # so we filter out removed ones
+      return 0 unless obj.record
+      records.count
+      # items.count # so we filter out removed ones
     end
 
     def inspect
-      items.to_s
+      "#<#{obj.class}->#{key.capitalize} size:#{size}>"
+    end
+
+    def as_json(options = {})
+      Array.new.tap do |arr|
+        each { |record| arr.push(record.as_json(options)) }
+      end
     end
 
     alias_method :count, :size
 
+    # we redefine first and last to avoid having to perform a full query
+
+    def first
+      if obj = records.first
+        Model.initialize_from_record(obj)
+      end
+    end
+
+    def last
+      if obj = records.last
+        Model.initialize_from_record(obj)
+      end
+    end
+
     def each(&block)
       items.each { |r| block.call(r) }
     end
@@ -71,8 +92,8 @@ module Groovy
 
     def items
       return [] unless obj.record
-      records.map do |r| 
-        if !exists?(r) 
+      records.map do |r|
+        if !exists?(r)
           remove_record(r) if REMOVE_MISSING
           nil
         else

data/lib/groovy/version.rb

@@ -1,3 +1,3 @@
 module Groovy
-  VERSION = '0.2.8'.freeze
+  VERSION = '0.4.2'.freeze
 end

data/spec/model_spec.rb

@@ -58,6 +58,23 @@ describe Groovy::Model do
   end
 
   describe '.delete_all' do
+
+    before do
+      @first  = TestProduct.create!(name: 'A product', price: 100)
+      @second = TestProduct.create!(name: 'Another product', price: 200)
+      expect(TestProduct.count).to eq(2)
+    end
+
+    it 'deletes all' do
+      TestProduct.delete_all
+      expect(TestProduct.count).to eq(0)
+
+      # expect { @first.reload }.to raise_error
+      # expect { @second.reload }.to raise_error
+      # expect { TestProduct.find(@first.id) }.to raise_error
+      # expect { TestProduct.find(@second.id) }.to raise_error
+    end
+
   end
 
   describe '#[]' do

data/spec/query_spec.rb

@@ -7,7 +7,7 @@ describe Groovy::Query do
     load_schema! 'query_spec'
     @p1 = TestProduct.create!(name: "Product 1", visible: true, price: 10, tag_list: 'one, number two & 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)
+    @p3 = TestProduct.create!(name: "Product 3: The Best", 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
@@ -17,11 +17,36 @@ describe Groovy::Query do
   end
 
   describe '#where' do
+    describe 'boolean value' do
+      it 'finds expected records' do
+        res = TestProduct.where(visible: true)
+        expect(res.map(&:id)).to eq([@p1.id, @p3.id, @p5.id])
+
+        res = TestProduct.where(visible: false)
+        expect(res.map(&:id)).to eq([@p2.id, @p4.id])
+      end
+
+      it 'works with other args too' do
+        res = TestProduct.where(visible: true).where(name: 'Product 5')
+        expect(res.map(&:id)).to eq([@p5.id])
+
+        res = TestProduct.where(visible: false).where(name: 'Product 2')
+        expect(res.map(&:id)).to eq([@p2.id])
+      end
+    end
+
     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 nil values too' do
+        res = TestProduct.where(visible: nil).where(tag_list: nil)
+        expect(res.map(&:id)).to eq([])
+
+        res = TestProduct.where(tag_list: nil).where(name: nil)
+        expect(res.map(&:id)).to eq([])
+      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])
@@ -53,6 +78,11 @@ describe Groovy::Query do
         res = TestProduct.where(tag_list: 'one, number two & three')
         expect(res.map(&:id)).to eq([@p1.id])
       end
+
+      it 'escapes required chars' do
+        res = TestProduct.where(name: 'Product 3: The Best')
+        expect(res.map(&:id)).to eq([@p3.id])
+      end
     end
 
     describe 'lower/greater than search (timestamps)' do
@@ -141,11 +171,36 @@ describe Groovy::Query do
   end
 
   describe '#not' do
+    describe 'boolean value' do
+      it 'finds expected records' do
+        res = TestProduct.where.not(visible: true)
+        expect(res.map(&:id)).to eq([@p2.id, @p4.id])
+
+        res = TestProduct.where.not(visible: false)
+        expect(res.map(&:id)).to eq([@p1.id, @p3.id, @p5.id])
+      end
+
+      it 'works with other args too' do
+        res = TestProduct.where.not(visible: true).where(name: 'Product 2')
+        expect(res.map(&:id)).to eq([@p2.id])
+
+        res = TestProduct.where.not(visible: false).where(name: 'Product 5')
+        expect(res.map(&:id)).to eq([@p5.id])
+      end
+    end
+
     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 nil values too' do
+        res = TestProduct.where.not(visible: nil).where(tag_list: nil)
+        expect(res.map(&:id)).to eq([@p3.id, @p5.id])
+
+        res = TestProduct.where.not(tag_list: nil).where(name: nil)
+        expect(res.map(&:id)).to eq([])
+      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])
@@ -177,6 +232,10 @@ describe Groovy::Query do
         res = TestProduct.not(tag_list: 'one, number two & three')
         expect(res.map(&:id)).to eq([@p2.id, @p3.id, @p4.id, @p5.id])
       end
+      it 'escapes required chars' do
+        res = TestProduct.not(name: 'Product 3: The Best')
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p4.id, @p5.id])
+      end
     end
 
     context 'basic regex' do

data/spec/search_spec.rb

@@ -0,0 +1,54 @@
+require_relative './spec_helper'
+
+describe Groovy::Model, 'searching' do
+
+  before :all do
+    Groovy.open('tmp/search', 'search_spec')
+    load_schema! 'search_spec'
+
+    TestProduct.add_column :description, :string, index: true
+
+    TestProduct.create!(name: 'First product', description: 'Lorem ipsum dolor sit amet')
+    TestProduct.create!(name: 'Second product', description: 'Lorea el ipsum poh loco')
+  end
+
+  after :all do
+    Groovy.close('search_spec')
+  end
+
+  describe 'single word, exact match' do
+    it 'returns results' do
+      # res = TestProduct.search(description: 'sit')
+      res = TestProduct.search(description: 'sit')
+      expect(res.first.name).to eq('First product')
+
+      # res = TestProduct.search(description: 'loco')
+      res = TestProduct.search(description: 'loco')
+      expect(res.first.name).to eq('Second product')
+    end
+  end
+
+  describe 'two consecutive words, exact match' do
+    it 'returns results' do
+      # res = TestProduct.search(description: 'sit amet')
+      res = TestProduct.search(description: 'sit amet')
+      expect(res.first.name).to eq('First product')
+
+      # res = TestProduct.search(description: 'lorea el')
+      res = TestProduct.search(description: 'lorea el')
+      expect(res.first.name).to eq('Second product')
+    end
+  end
+
+  describe 'two random words, both match' do
+    it 'returns results' do
+      # res = TestProduct.search(description: 'amet ipsum')
+      res = TestProduct.search(description: 'amet ipsum')
+      expect(res.first.name).to eq('First product')
+
+      # res = TestProduct.search(description: 'poh el')
+      res = TestProduct.search(description: 'poh el')
+      expect(res.first.name).to eq('Second product')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,6 +4,9 @@ Bundler.require(:default, :test)
 require 'rspec/core'
 require './lib/groovy'
 
+# Groonga::Logger.path = "/tmp/groonga.log"
+# Groonga::Logger.max_level = :debug
+
 RSpec.configure do |config|
   config.before(:each) do
     # Groonga::Context.default = nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: groovy
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.4.2
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-16 00:00:00.000000000 Z
+date: 2020-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rroonga
@@ -100,6 +100,7 @@ files:
 - spec/groovy_spec.rb
 - spec/model_spec.rb
 - spec/query_spec.rb
+- spec/search_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/tomas/groovy
 licenses: []