groovy 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a25e5062d4c0acc9b6df07b5684ee43a2c0db55e2d2cf4fc2778c9034a60223f
-  data.tar.gz: 2aebe2f7c50b0d44594e8f1f2933e2af5060e882186162268aadc70fbb2c4d80
+  metadata.gz: 1019bd31fda4785bec67322dfb8aeddfab4d0fa12143b23a8dd75f4a3c84515e
+  data.tar.gz: 44ab6a5fd87d136bc3b6915ab323fac95b6a8012f5cdc4ea2fb6498d5236cb3a
 SHA512:
-  metadata.gz: 54f57cd2730644aae24f09073446d137a6da6fffc2affa4d96ff24dea075d0fbf6660841e6508d27a0e3133b0b85e360e27e61612baaac37c86a70012955bd3f
-  data.tar.gz: 1534c7da96deb58c5845d4c7c22b5d61d0f41637e996b4ef97ffc835e7ef5f6f94d97a4f24407d3677f2cafb745b6764497dd7f51403ee5979a371372fbe35a1
+  metadata.gz: 2ae8f4bcfb8d6166fa4ad8814521c498a44f3e512de23c4cb986d7ce7cd4ef98722a889c3a8e69e1f55bdfc9651f19a9b03e9d31bcb2f87552c73c194fc8f099
+  data.tar.gz: 4a29d7007af10d67f4265ef9e431fa347ebc979745c87037fbf8957e2441fc012904cf5385d8aad8d1da6708e91ffae6b407acecf6e3c8e19f2f0bc787d90639

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
@@ -50,6 +50,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 +72,4 @@ def insert_places(count = 1000)
   end
 end
 
-insert_places if Place.count == 0
+insert_places if Place.count == 0

data/lib/groovy.rb

@@ -16,18 +16,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 +40,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,8 +20,13 @@ 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)
@@ -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,64 +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.find_each { |child| child.delete }
-        # table.delete { |record| record.id > -1 }
-        # 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)
@@ -155,28 +208,25 @@ module Groovy
         end
       end
 
-      [:find_by, :search, :where, :not, :sort_by, :limit, :offset, :paginate, :in_batches].each do |scope_method|
+      [: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
 
@@ -184,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
@@ -195,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)
@@ -225,30 +287,32 @@ 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
 
+    def inspect
+      "#<#{self.class.name} id:#{id.inspect} attributes:[#{self.class.attribute_names.join(', ')}]>"
+    end
+
     def new_record?
       id.nil?
       # _key.nil?
@@ -259,7 +323,9 @@ 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}"
@@ -300,59 +366,86 @@ 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)
+      if val = record[key]
+        if self.class.schema.time_column?(key)
+          fix_time_value(val)
+        else
+          val
+        end
+      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)
@@ -361,10 +454,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,19 +25,28 @@ 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 find(id)
       find_by(_id: id)
     end
@@ -46,9 +55,9 @@ module Groovy
       where(conditions).limit(1).first
     end
 
-    def find_each(&block)
+    def find_each(opts = {}, &block)
       count = 0
-      in_batches(of: 10) do |group|
+      in_batches({ of: 10 }.merge(opts)) do |group|
         group.each { |item| count += 1; yield(item) }
       end
       count
@@ -76,7 +85,7 @@ module Groovy
               add_param(AND + str)
 
             else
-              str = val.nil? || val == false || 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
@@ -110,7 +119,7 @@ module Groovy
               add_param(AND + str)
 
             else
-              str = val.nil? || val == false || 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
@@ -140,10 +149,10 @@ module Groovy
 
     # 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|
@@ -183,13 +192,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)
@@ -207,9 +224,7 @@ 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
 
@@ -228,25 +243,26 @@ module Groovy
     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?
         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
@@ -266,6 +282,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|
@@ -274,6 +294,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.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

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
@@ -71,6 +71,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
@@ -213,6 +218,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.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-25 00:00:00.000000000 Z
+date: 2020-09-09 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: []