groovy 0.6.8 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc2f1ef55cf22504bc95fd3a143108b0d7097816274606cb557851c588c7ba02
-  data.tar.gz: 8881018c1036dab4257291bde59c8797317ba1568cafcb7d87ac12f8b7cf9499
+  metadata.gz: da506ad46a6a3aad6cd965b7fcc43079fd61903c1e1a9f0bee659342430dc9ad
+  data.tar.gz: 6eba099bd0552fcc3ce8aaa15a0d9fb46486a96e1c1eee8dcd427f86a7d44256
 SHA512:
-  metadata.gz: 63e936c9c4920be9e27d3567acc575cf75900fcd5be9786b55f171f068dec19ab4b618ce22367ae7856c30d602517574a61fbc2fef37e36dfc62a9f9d2b7bbf6
-  data.tar.gz: ee9f1292bb74220dd40acc1058151d4ca6f390e94b4f1b6e9c13561d6dfb1aa9a5df774d858a66695906478a70a8ba49c9ce368585496223287ad67a8276f563
+  metadata.gz: 4c26e85b1dc605632deff25150f39e3794079c75581c0098c4893d01fced0729a6f4cd99fea8cae1d840aa003b219dfc62a62acbc0fa0743514d2d4464bbf98a
+  data.tar.gz: 1efedf625a489694dc51442664438d8d3a1984dfa50398734f97ecccf8f8146ff4543c06f9a1a6b9a0b17c4007d4fd1baa636b5d2ade8a98b300142133e89240

data/lib/groovy/model.rb

@@ -17,6 +17,31 @@ module Groovy
     @models ||= {}
   end
 
+  module Utils
+    def self.singularize(str)
+      str.to_s.sub(/ies$/, 'y').sub(/s$/, '')
+    end
+
+    # category -> categories
+    # product -> products
+    def self.pluralize(str)
+      return str if str[-1] == 's' # already ends with s, assume already plural
+      str.to_s.sub(/y$/, 'ie') + 's'
+    end
+
+    def self.pluralize_and_classify(str)
+      classify(pluralize(str))
+    end
+
+    def self.underscore(str)
+      str.gsub(/([A-Z])/) { |x| "_#{x.downcase}" }.sub(/^_/, '')
+    end
+
+    def self.classify(str)
+      str.to_s.gsub(/([A-Z])/, '_\1').split('_').collect! { |w| w.capitalize }.join
+    end
+  end
+
   module Model
 
     def self.initialize_from_record(obj)
@@ -30,23 +55,21 @@ module Groovy
     # end
 
     def self.model_from_table(table_name)
-      get_class(table_name.to_s.sub(/ies$/, 'y').sub(/s$/, ''))
+      get_class(Utils.singularize(table_name))
     end
 
     def self.included(base)
       base.extend(ClassMethods)
       base.include(Forwardable)
-      base.table_name = base.name.sub(/y$/, 'ie') + 's'
+      base.table_name = Utils.pluralize(base.name)
 
       # add to global model list
       # Groovy.models[base.name] = base
       Groovy.models[base.table_name] = base
     end
 
-    def self.get_class(table_name)
-      # classify method
-      classified = table_name.gsub(/([A-Z])/, '_\1').split('_').collect! { |w| w.capitalize }.join
-      Kernel.const_get(classified)
+    def self.get_class(klass_name)
+      Kernel.const_get(Utils.classify(klass_name))
     end
 
     module ClassMethods
@@ -63,11 +86,15 @@ module Groovy
       end
 
       def underscore_name
-        name.gsub(/([A-Z])/) { |x| "_#{x.downcase}" }.sub(/^_/, '')
+        Utils.underscore(name)
       end
 
       def attribute_names
-        @attribute_names ||= schema.attribute_columns
+        schema.attribute_columns
+      end
+
+      def reference_names
+        schema.singular_references + schema.plural_references
       end
 
       # def singular_refs
@@ -87,11 +114,13 @@ module Groovy
           self.context_name = options[:context] || Groovy.first_context_name
           self.table_name = options[:table_name] if options[:table_name]
 
-          s = Schema.new(db_context, table_name, {})
+          s = Schema.new(db_context, table_name, options)
           yield s if block
           s.sync
 
-          extend(PatriciaTrieMethods) if table.is_a?(Groonga::PatriciaTrie)
+          include(HashTable) if table.is_a?(Groonga::Hash)
+          include(PatriciaTrieTable) if table.is_a?(Groonga::PatriciaTrie)
+
           s.column_names.each { |col| add_accessors_for(col, s) }
           s
         end
@@ -118,7 +147,7 @@ module Groovy
         elsif s.plural_references.include?(col)
           add_vector_accessors(col)
         else
-          puts "WARNING: Unknown column type: #{col}"
+          raise "Unknown column type: #{col}"
         end
       end
 
@@ -147,13 +176,13 @@ module Groovy
         end
       end
 
-      def create(attributes, key = nil)
-        obj = new(attributes, nil, key)
+      def create(attributes)
+        obj = new(attributes)
         obj.save ? obj : false
       end
 
-      def create!(attributes, key = nil)
-        create(attributes, key) or raise Error, "Invalid"
+      def create!(attributes)
+        create(attributes) or raise Error, "Invalid"
       end
 
       def update_all(attrs)
@@ -174,6 +203,12 @@ module Groovy
       #   Groonga["#{table_name}.#{name}"] # .search, .similar_search, etc
       # end
 
+      def search_table
+        schema.search_table
+      end
+
+      def_instance_delegators :search_table, :prefix_search, :each_with_prefix # just these two for now
+
       def index_search(column, query, options = {}, &block)
         results = table.select { |rec| rec[column].match(query) }
         render_results(results, &block)
@@ -230,6 +265,14 @@ module Groovy
         query.where(*args, &block)
       end
 
+      def each(&block)
+        query.each(&block)
+      end
+
+      def find_or_create_by(attributes)
+        find_by(**attributes) || create(**attributes)
+      end
+
       [:first, :last, :select, :find_by, :search, :not, :sort_by, :in_batches, :limit, :offset, :paginate].each do |scope_method|
         define_method scope_method do |**args, &block|
           query.public_send(scope_method, **args, &block)
@@ -308,21 +351,80 @@ module Groovy
       end
     end
 
-    module PatriciaTrieMethods
-      extend Forwardable
-      def_instance_delegators :table, :scan, :prefix_search, :open_prefix_cursor, :tag_keys
+    module PatriciaTrieTable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        extend Forwardable
+        def_instance_delegators :table, :scan, :prefix_search, :open_prefix_cursor, \
+                                :suffix_search, :open_near_cursor, :tag_keys
 
-      def each_with_prefix(prefix, options = {}, &block)
-        table.open_prefix_cursor(prefix, options) do |cursor|
-          cursor.each { |r| yield r }
+        def each_with_prefix(prefix, options = {}, &block)
+          table.open_prefix_cursor(prefix, options) do |cursor|
+            cursor.each { |r| yield r }
+          end
+        end
+
+        def each_near(str, options = {}, &block)
+          table.open_near_cursor(str, options) do |cursor|
+            cursor.each { |r| yield r }
+          end
         end
       end
     end
 
+    module HashTable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def find(key)
+          if record = table[key.to_s] and record.record_id
+            new_from_record(record)
+          end
+        end
+
+        def new_from_record(record)
+          # new(record.attributes, record)
+          new(record._key, nil, record)
+        end
+
+        def create(key, attributes)
+          obj = new(key, attributes)
+          obj.save ? obj : false
+        end
+
+        def create!(key, attributes)
+          create(key, attributes) or raise Error, "Invalid"
+        end
+      end
+
+      def initialize(key, attrs = nil, record = nil)
+        @key = key
+        super(attrs, record)
+      end
+
+      def load_record
+        self.class.table[key]
+      end
+
+      # def new_record?
+      #   key.nil?
+      # end
+
+      def key
+        @key || (record ? record._key : nil)
+      end
+
+    end
+
     attr_reader :id, :record, :changes
 
-    def initialize(attrs = nil, record = nil, key = nil)
-      @attributes, @vectors, @_key = {}, {}, key # key is used on creation only
+    def initialize(attrs = nil, record = nil)
+      @attributes, @vectors = {}, {}
       @foreign_refs_to_update = {}
 
       if set_record(record)
@@ -344,9 +446,9 @@ module Groovy
 
     # 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 load_record
+      self.class.table[id]
+    end
 
     def attributes
       load_attributes_from_record # populate missing
@@ -356,7 +458,7 @@ module Groovy
     alias_method :attrs, :attributes
 
     def inspect
-      "#<#{self.class.name} id:#{id.inspect} attributes:[#{self.class.attribute_names.join(', ')}]>"
+      "#<#{self.class.name} id:#{id.inspect} attributes:[#{self.class.attribute_names.join(', ')}] references:[#{self.class.reference_names.join(', ')}]>"
     end
 
     def dump
@@ -365,7 +467,6 @@ module Groovy
 
     def new_record?
       id.nil?
-      # _key.nil?
     end
 
     def persisted?
@@ -427,6 +528,9 @@ module Groovy
       update_attributes(obj) or raise "Invalid!"
     end
 
+    alias_method :update, :update_attributes
+    alias_method :update!, :update_attributes!
+
     def save(options = {})
       return false if respond_to?(:invalid?) and invalid?
       if new_record?
@@ -455,7 +559,7 @@ module Groovy
       unless new_record?
         # raise RecordNotPersisted if id.nil?
         # ensure_persisted!
-        rec = self.class.table[id] # _key
+        rec = load_record
         set_record(rec)
         # load_attributes_from_record
       end
@@ -494,11 +598,6 @@ module Groovy
       return val.to_i == 0 ? nil : val
     end
 
-    # def _key
-    #   return unless record
-    #   record.respond_to?(:_key) ? record._key : id
-    # end
-
     def load_attributes_from_record
       self.class.attribute_names.each do |col|
         public_send("#{col}=", get_record_attribute(col)) unless @attributes.key?(col)
@@ -533,7 +632,14 @@ module Groovy
       if record.nil? # not persisted yet
         set_attribute(name, obj.id) # obj should be a groovy model or groonga record
       else
-        val = obj.respond_to?(:record) ? obj.record : obj
+        val = if obj.is_a?(Groovy::Model)
+          obj.id
+        elsif obj.respond_to?(:record)
+          # obj.record.record_id
+          obj.record
+        else
+          obj
+        end
         record[name] = val
       end
     end
@@ -545,7 +651,7 @@ module Groovy
 
     def create
       fire_callbacks(:before_create)
-      set_record(self.class.insert(@attributes, @_key))
+      set_record(self.class.insert(@attributes, @key))
       update_foreign_refs
       fire_callbacks(:after_create)
       self

data/lib/groovy/query.rb

@@ -80,20 +80,26 @@ module Groovy
           add_param(AND + "(#{map_operator(handle_timestamps(conditions))})")
         when Hash # { foo: 'bar' } or { views: 1..100 }
           conditions.each do |key, val|
-            if val.is_a?(Range)
+            case val
+            when Model
+              raise "Object not persisted yet!" unless val.persisted?
+              str = "#{key}:#{val.id}"
+              add_param(AND + str)
+
+            when Range
               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)
+            when Regexp
               str = val.source.gsub('/', '_slash_').gsub('(', '_openp_').gsub(')', '_closep_').gsub(REMOVE_INVALID_CHARS_REGEX, '')
               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] }
+            when Array # { foo: [1,2,3] }
               str = "#{key}:#{val.join(" OR #{key}:")}"
               add_param(AND + str)
 
-            elsif val.is_a?(Time)
+            when Time
                # The second, specify the timestamp as string in following format:
                # “(YEAR)/(MONTH)/(DAY) (HOUR):(MINUTE):(SECOND)”
 

data/lib/groovy/schema.rb

@@ -4,6 +4,14 @@ module Groovy
   class Schema
 
     SEARCH_TABLE_NAME = 'Terms'.freeze
+
+    SEARCH_TABLE_OPTIONS = {
+      type: :patricia_trie,
+      normalizer: :NormalizerAuto,
+      key_type: "ShortText",
+      default_tokenizer: "TokenBigram"
+    }.freeze
+
     COLUMN_DEFAULTS = {
       compress: :zstandard
     }.freeze
@@ -33,6 +41,10 @@ module Groovy
       @table ||= context[table_name]
     end
 
+    def table_type
+      (@opts[:type] || :array).to_sym
+    end
+
     # def [](key)
     #   # @spec[key.to_sym]
     #   table.columns.select { |c| c.column? && c.name.to_s == "#{table_name}.#{key.to_s}" }
@@ -115,11 +127,11 @@ module Groovy
     end
 
     def reference(name, table_name = nil, options = {})
-      table_name = "#{name}s" if table_name.nil?
+      table_name = Utils.pluralize_and_classify(name) if table_name.nil?
 
       unless context[table_name]
         log "Table #{table_name} doesn't exist yet! Creating now..."
-        create_table!(table_name)
+        create_table!(table_name, nil)
       end
 
       refs_by_table[table_name] = name.to_sym
@@ -174,19 +186,17 @@ module Groovy
       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(name_col, name: name_col, with_position: true, with_section: true)
-        table.index(name_col, name: name_col.sub('.', '_'))
+        if opts[:search] # search column requires with_position: true
+          table.index(name_col, name: name_col, with_position: true, with_section: true)
+        else
+          table.index(name_col, name: name_col.sub('.', '_'))
+        end
       end
     end
 
     def ensure_search_table!
       return if search_table
-      opts = (@opts[:search_table] || {}).merge({
-        type: :patricia_trie,
-        normalizer: :NormalizerAuto,
-        key_type: "ShortText",
-        default_tokenizer: "TokenBigram"
-      })
+      opts = (@opts[:search_table] || {}).merge(SEARCH_TABLE_OPTIONS)
       log("Creating search table with options: #{opts.inspect}")
       Groonga::Schema.create_table(SEARCH_TABLE_NAME, opts.merge(context: context))
     end
@@ -225,9 +235,9 @@ module Groovy
       end
     end
 
-    def create_table!(name = table_name)
-      log "Creating table #{name}!"
-      Groonga::Schema.create_table(name, context: context)
+    def create_table!(name = table_name, type = table_type)
+      log "Creating table #{name} with type #{type.inspect}!"
+      Groonga::Schema.create_table(name, context: context, type: type)
     end
 
     def remove_table!(name = table_name)

data/lib/groovy/version.rb

@@ -1,3 +1,3 @@
 module Groovy
-  VERSION = '0.6.8'.freeze
+  VERSION = '0.7.1'.freeze
 end

data/spec/callbacks_spec.rb

@@ -4,14 +4,14 @@ describe Groovy::Model do
 
   before :all do
     Groovy.open('tmp/callbacks', 'callbacks_spec')
-    load_callbacks_schema!
+    load_test_schema!
   end
 
   after :all do
     Groovy.close('callbacks_spec')
   end
 
-  def load_callbacks_schema!
+  def load_test_schema!
     klass = Class.new
     Object.const_set("User", klass)
     User.class_eval do
@@ -35,8 +35,6 @@ describe Groovy::Model do
         # puts "updated"
       end
     end
-
-    User.add_reference :comments, "Comments", type: :vector
   end
 
   it 'fires created callbacks' do

data/spec/model_spec.rb

@@ -15,7 +15,6 @@ describe Groovy::Model do
   end
 
   describe '.scope' do
-
     before :all do
       TestProduct.class_eval do
         scope :with_name, -> (name) { where(name: name) if name }
@@ -120,6 +119,21 @@ describe Groovy::Model do
   end
 
   describe '#update_attributes' do
+
+    it 'allows setting references out of searches' do
+      cat = TestCategory.create!(name: 'A category')
+      cat2 = TestCategory.create!(name: 'Another category')
+
+      prod = TestProduct.create!(name: 'A product', price: 100)
+      prod.update_attributes(test_category: cat)
+
+      last = TestCategory.last
+      expect(last).to eq(cat2)
+      puts "last: #{last.inspect}"
+      prod.update_attributes(test_category: last)
+      expect(prod.reload.test_category).to eq(cat2)
+    end
+
   end
 
   describe '#save' do
@@ -147,15 +161,12 @@ describe Groovy::Model do
   end
 
   describe 'attributes accessors' do
-
   end
 
   describe 'singular refs' do
-
   end
 
   describe 'plural refs' do
-
   end
 
 end

data/spec/query_spec.rb

@@ -16,6 +16,13 @@ describe Groovy::Query do
     Groovy.close('query_spec')
   end
 
+  # describe '#first' do
+  #   it 'returns a valid object' do
+  #     res = TestProduct.first
+  #     expect(res.record.table.name).to eq(TestProduct.table.name)
+  #   end
+  # end
+
   describe '#where' do
     describe 'boolean value' do
       it 'finds expected records' do

data/spec/schema_spec.rb

@@ -0,0 +1,74 @@
+require_relative './spec_helper'
+
+describe Groovy::Model do
+
+  CONTEXT_NAME = 'schema_spec'
+
+  before :all do
+    Groovy.open('tmp/' + CONTEXT_NAME, CONTEXT_NAME)
+    load_test_schema!
+  end
+
+  after :all do
+    Groovy.close(CONTEXT_NAME)
+  end
+
+  def load_test_schema!
+    klass = Class.new
+    Object.const_set("Product", klass)
+    Product.class_eval do
+      include Groovy::Model
+
+      schema(type: 'hash', context: CONTEXT_NAME) do |t|
+        t.string :name
+        t.many :categories
+        t.timestamps
+      end
+    end
+
+    klass = Class.new
+    Object.const_set("Category", klass)
+    Category.class_eval do
+      include Groovy::Model
+
+      schema(context: CONTEXT_NAME) do |t|
+        t.many :products, "Products"
+        t.string :name
+        t.timestamps
+      end
+    end
+  end
+
+  describe 'hash table' do
+
+    it 'creates, updates and finds records as expected' do
+      product = Product.new('ipod-mini', name: 'iPod Mini')
+      expect(product.new_record?).to eq(true)
+
+      expect(product.name).to eq('iPod Mini')
+      expect(product.save).to eq(true)
+      expect(product.persisted?).to eq(true)
+      expect(product.key).to eq('ipod-mini')
+
+      expect(product.update_attributes(name: 'iPod Mini 2nd Generation'))
+      expect(product.name).to eq('iPod Mini 2nd Generation')
+
+      expect(Product.find('ipod-mini')).to eq(product)
+    end
+
+    it 'works with references too' do
+      product = Product.new('ipod-mini', name: 'iPod Mini')
+      expect(product.save).to eq(true)
+
+      category = Category.new(name: 'iPods')
+      expect(category.save).to eq(true)
+
+      category.products << product
+      product.categories << category
+
+      expect(product.reload.categories).to eq([category])
+    end
+
+  end
+
+end

data/spec/search_spec.rb

@@ -6,7 +6,7 @@ describe Groovy::Model, 'searching' do
     Groovy.open('tmp/search', 'search_spec')
     load_schema! 'search_spec'
 
-    TestProduct.add_column :description, :string, index: true
+    TestProduct.add_column :description, :string, index: true #, search: true
 
     TestProduct.create!(name: 'First product', description: 'Lorem ipsum dolor sit amet')
     TestProduct.create!(name: 'Second product', description: 'Lorea el ipsum poh loco')
@@ -51,4 +51,25 @@ describe Groovy::Model, 'searching' do
       expect(res.first.name).to eq('Second product')
     end
   end
+
+  describe 'prefix search' do
+    it 'returns results' do
+      res = TestProduct.prefix_search('Lore')
+      expect(res.count).to eq(0)
+
+      res = TestProduct.prefix_search('lore')
+      expect(res.count).to eq(2)
+      expect(res.first).to be_a(Groonga::Record)
+      parts = res.map { |rec| rec['._key'] }
+      expect(parts).to eq(['lorem', 'lorea'])
+    end
+
+    # it 'works with each_with_prefix too' do
+    #   parts = []
+    #   res = TestProduct.each_with_prefix('lore') do |rec|
+    #     parts.push(rec['._key'])
+    #   end
+    #   expect(parts).to eq(['lorem', 'lorea'])
+    # end
+  end
 end

data/spec/spec_helper.rb

@@ -16,12 +16,21 @@ RSpec.configure do |config|
   end
 end
 
+class TestCategory
+  include Groovy::Model
+end
+
 class TestProduct
   include Groovy::Model
 end
 
 def load_schema!(context_name)
+  TestCategory.load_schema context: context_name do |t|
+    t.string :name
+  end
+
   TestProduct.load_schema context: context_name do |t|
+    t.one :test_category
     t.boolean :visible
     t.string  :name
     t.integer :price

data/spec/vector_spec.rb

@@ -63,6 +63,13 @@ describe Groovy::Model do
       expect(user2.reload.comments).to eq([])
     end
 
+    it 'finds records using relations too' do
+      user = User.create(name: 'John')
+      comment = Comment.create(author: user, content: 'Hello there!')
+
+      expect(Comment.find_by(author: user)).to eq(comment)
+    end
+
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: groovy
 version: !ruby/object:Gem::Version
-  version: 0.6.8
+  version: 0.7.1
 platform: ruby
 authors:
 - Tomás Pollak
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-06 00:00:00.000000000 Z
+date: 2024-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rroonga
@@ -101,13 +101,14 @@ files:
 - spec/groovy_spec.rb
 - spec/model_spec.rb
 - spec/query_spec.rb
+- spec/schema_spec.rb
 - spec/search_spec.rb
 - spec/spec_helper.rb
 - spec/vector_spec.rb
 homepage: https://github.com/tomas/groovy
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -122,8 +123,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.4.6
+signing_key:
 specification_version: 4
 summary: A wrapper around Groonga/Rroonga
 test_files: []