groovy 0.6.1 → 0.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf0e3aa6e2c0d1e3d9e0245062e1b778e4da15e9130cc672d07eb1e474e25d0f
-  data.tar.gz: add6fe670e018efb4f5706b02d05154bdf525d5f2bb3f8ce378e60bb92471f59
+  metadata.gz: dc2a1c85a6d482813b6ec9de3616e2c369206a419008b55600194f930bc56416
+  data.tar.gz: 968d357fb616dcfa9761f1ba93843678263d69ff38af2ec342ee9430bbf7ccc6
 SHA512:
-  metadata.gz: '0228c03673a0d86e3072c3f7a952a152c3799125f3c3a2998a219d6015a0c6ccea54bd10972996f17dab52b47298fdc3424fe9bff5de3343a3803748d22bbef1'
-  data.tar.gz: 8302d8af1e7940a878643f123760e5ae482b786c6c6857cf69306f8b2bb0e79a7364f05035659611102966a7b199aae7ce1eab869cdc9f2ab8055551cb5cdc42
+  metadata.gz: 7df3be7e3c43b5d48be0b563bb156da21a8992c97be9392b91b939a1943920f0587ee01ff4521c983b8524beb27b0ecd0eede630aff7c16e42e80e004ec42a46
+  data.tar.gz: e9a7fd6abc2dda7d902cd07d091f1fafbfe053e229a730754f0170dc04aa3326fbbef4a9646f3d6788cf896b7b72e9c0c10f0c010a4d17bd1e99aa97222fcda9

data/lib/groovy/model.rb

@@ -13,6 +13,10 @@ module Groovy
   class Error < StandardError; end
   class RecordNotPersisted < Error; end
 
+  def self.models
+    @models ||= {}
+  end
+
   module Model
 
     def self.initialize_from_record(obj)
@@ -33,9 +37,14 @@ module Groovy
       base.extend(ClassMethods)
       base.include(Forwardable)
       base.table_name = base.name.sub(/y$/, 'ie') + 's'
+
+      # 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)
     end
@@ -53,6 +62,10 @@ module Groovy
         db_context[table_name]
       end
 
+      def underscore_name
+        name.gsub(/([A-Z])/) { |x| "_#{x.downcase}" }.sub(/^_/, '')
+      end
+
       def attribute_names
         @attribute_names ||= schema.attribute_columns
       end
@@ -253,10 +266,14 @@ module Groovy
         @callbacks ||= {}
       end
 
-      [:before_create, :after_create].each do |event|
-        define_method(event) do |*method_names|
-          callbacks[:before_create] ||= []
-          callbacks[:before_create].push(*method_names)
+      [:before_create, :after_create, :before_update, :after_update].each do |event|
+        define_method(event) do |*args, &block|
+          callbacks[event] ||= []
+          if block
+            callbacks[event].push(block)
+          else
+            callbacks[event].push(*args)
+          end
         end
       end
 
@@ -306,6 +323,7 @@ module Groovy
 
     def initialize(attrs = nil, record = nil, key = nil)
       @attributes, @vectors, @_key = {}, {}, key # key is used on creation only
+      @foreign_refs_to_update = {}
 
       if set_record(record)
         # load_attributes_from_record(record)
@@ -344,6 +362,10 @@ module Groovy
       # _key.nil?
     end
 
+    def persisted?
+      !new_record?
+    end
+
     def [](key)
       k = key.to_sym
       @attributes[k] = get_record_attribute(k) unless @attributes.key?(k)
@@ -377,6 +399,18 @@ module Groovy
       obj.each { |k,v| public_send("#{k}=", v) }
     end
 
+    def set_reverse_reference(key, obj, removing = false)
+      if self.class.schema.singular_references.include?(key.to_sym)
+        # puts "setting #{obj} as #{key}"
+        set_ref(key, removing ? nil : obj, true)
+      elsif self.class.schema.plural_references.include?(key.to_sym)
+        # puts "adding #{obj} to #{key}"
+        public_send(key).set_ref(obj, removing)
+      else
+        raise "Invalid reference name: #{name}"
+      end
+    end
+
     def update_attributes(obj)
       set_attributes(obj)
       return false if respond_to?(:invalid?) and invalid?
@@ -392,7 +426,7 @@ module Groovy
       if new_record?
         create && true
       else
-        update
+        update && true
       end
     end
 
@@ -422,6 +456,7 @@ module Groovy
 
       @attributes = {}
       @changes = {}
+      @foreign_refs_to_update = {}
       self
     end
 
@@ -439,6 +474,7 @@ module Groovy
 
     private
 
+
     def get_record_attribute(key)
       return if record.nil?
       val = record[key]
@@ -475,12 +511,26 @@ module Groovy
       end
     end
 
-    def set_ref(name, obj)
-      if record.nil?
+
+    def set_ref(name, obj, from_foreign = false)
+      # puts "Setting ref #{name} -> #{obj} (#{obj.class})"
+
+      if !from_foreign && obj.is_a?(Model) && !obj.new_record?
+        if foreign_ref = self.class.schema.reverse_reference_of(name.to_sym)
+          # puts "Found circular ref (#{name} -> #{foreign_ref})"
+          if current = get_ref(name)
+            current.set_reverse_reference(foreign_ref, self, true)
+          end
+
+          @foreign_refs_to_update[name] = [foreign_ref, obj]
+        end
+      end
+
+      if record.nil? # not persisted yet
         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
+        val = obj.respond_to?(:record) ? obj.record : obj
+        record[name] = val
       end
     end
 
@@ -492,17 +542,28 @@ module Groovy
     def create
       fire_callbacks(:before_create)
       set_record(self.class.insert(@attributes, @_key))
+      update_foreign_refs
       fire_callbacks(:after_create)
       self
     end
 
     def fire_callbacks(name)
+      # puts "Firing #{name} callbacks"
       if arr = self.class.callbacks[name] and arr.any?
-        arr.each { |fn| send(fn) }
+        arr.each { |fn| fire_callback(fn) }
+      end
+    end
+
+    def fire_callback(fn)
+      if fn.is_a?(Proc)
+        fn.call(self)
+      else
+        send(fn)
       end
     end
 
     def update
+      fire_callbacks(:before_update)
       ensure_persisted!
       changes.each do |key, values|
         # puts "Updating #{key} from #{values[0]} to #{values[1]}"
@@ -510,9 +571,22 @@ module Groovy
       end
       self.class.set_timestamp(record, :updated_at)
       changes = {}
+      update_foreign_refs
+      fire_callbacks(:after_update)
       self
     end
 
+    def update_foreign_refs
+      return if @foreign_refs_to_update.empty?
+
+      @foreign_refs_to_update.each do |attr, (ref, obj)|
+        # puts "setting #{obj.class}##{ref} to #{self}"
+        obj.set_reverse_reference(ref, self)
+      end
+
+      @foreign_refs_to_update = {}
+    end
+
     def ensure_persisted!
       raise "Not persisted" if new_record?
     end

data/lib/groovy/query.rb

@@ -238,7 +238,6 @@ module Groovy
     end
 
     def in_batches(of: 1000, from: nil, &block)
-      puts "of: #{of}"
       sorting[:limit] = of
       sorting[:offset] = from || 0
 

data/lib/groovy/schema.rb

@@ -33,6 +33,11 @@ module Groovy
       @table ||= context[table_name]
     end
 
+    # def [](key)
+    #   # @spec[key.to_sym]
+    #   table.columns.select { |c| c.column? && c.name.to_s == "#{table_name}.#{key.to_s}" }
+    # end
+
     def search_table
       @cache[:search_table] ||= context[SEARCH_TABLE_NAME]
     end
@@ -69,6 +74,22 @@ module Groovy
       get_names(table.columns.select { |c| c.column? && c.range.name == type })
     end
 
+    def refs_by_table
+      @refs_by_table ||= {}
+    end
+
+    def refs_by_name
+      @refs_by_name ||= {}
+    end
+
+    def reverse_reference_of(ref_name)
+      if ref_table = refs_by_name[ref_name.to_sym]
+        if foreign_model = Groovy.models[ref_table]
+          foreign_model.schema.refs_by_table[@table_name]
+        end
+      end
+    end
+
     def reload
       @cache = {}
     end
@@ -95,9 +116,25 @@ module Groovy
 
     def reference(name, table_name = nil, options = {})
       table_name = "#{name}s" if table_name.nil?
+
+      unless context[table_name]
+        log "Table #{table_name} doesn't exist yet! Creating now..."
+        create_table!(table_name)
+      end
+
+      refs_by_table[table_name] = name.to_sym
+      refs_by_name[name.to_sym] = table_name
       @spec[name.to_sym] = { type: :reference, args: [table_name, options] }
     end
 
+    def one(name, table_name = nil, options = {})
+      reference(name, table_name, options)
+    end
+
+    def many(name, table_name = nil, options = {})
+      reference(name, table_name, options.merge(type: :vector))
+    end
+
     def timestamps(opts = {})
       column(:created_at, 'time')
       column(:updated_at, 'time')
@@ -188,15 +225,15 @@ module Groovy
       end
     end
 
-    def create_table!
-      log "Creating table #{table_name}!"
-      Groonga::Schema.create_table(table_name, context: context)
+    def create_table!(name = table_name)
+      log "Creating table #{name}!"
+      Groonga::Schema.create_table(name, context: context)
     end
 
-    def remove_table!
-      log "Removing table #{table_name}!"
-      Groonga::Schema.remove_table(table_name, context: context)
-      @table = nil
+    def remove_table!(name = table_name)
+      log "Removing table #{name}!"
+      Groonga::Schema.remove_table(name, context: context)
+      @table = nil if name == table_name
     end
 
     def get_names(columns)
@@ -204,7 +241,7 @@ module Groovy
     end
 
     def log(str)
-      puts "[#{table_name}] #{str}" # if ENV['DEBUG']
+      puts "[#{table_name}] #{str}" if ENV['DEBUG']
     end
   end
 end

data/lib/groovy/vector.rb

@@ -26,20 +26,6 @@ module Groovy
 
     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
@@ -50,7 +36,9 @@ module Groovy
 
     def set(new_items)
       check_parent!
-      obj.record[key] = new_items
+      obj.record[key] = new_items.map do |obj|
+        obj.is_a?(Model) ? obj.record : obj
+      end
     end
 
     def has?(item)
@@ -61,25 +49,62 @@ module Groovy
     def push(item)
       raise "Invalid item type: #{item.class}" unless item.is_a?(Model)
       check_parent!
-      raise "Already in list!" if has?(item)
+      if has?(item)
+        # puts "Item already present #{item.inspect}"
+        return false
+      end
       item.save unless item.record
       push_record(item.record)
+      # size
+    end
+
+    def push!(item)
+      push or raise "Already in list!"
     end
 
     def remove(item)
       check_parent!
-      raise "Item not saved: #{record}" unless item.record
+      raise "Item not saved: #{item.inspect}" unless item.record
       remove_record(item.record)
     end
 
+    def set_ref(item, removing = false)
+      check_parent!
+      raise "Item not saved: #{item.inspect}" unless item.record
+
+      if removing
+        remove_record(item.record)
+      elsif !has?(item)
+        push_record(item.record)
+      end
+    end
+
     alias_method :<<, :push
 
-    [:first, :last, :find_by, :search, :where, :not, :sort_by, :limit, :offset, :paginate, :in_batches].each do |scope_method|
+    [:new, :create, :create!].each do |relation_method|
+      define_method relation_method do |attrs|
+        vector_model.public_send(relation_method, attrs.merge(object_name => obj))
+      end
+    end
+
+    [: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
 
+    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 ==(arr)
       to_a == arr
     end
@@ -87,21 +112,26 @@ module Groovy
     private
     attr_reader :obj, :key
 
-    def query
-      model = Model.model_from_table(key.capitalize)
-      obj_name = obj.class.name.downcase
-      model.query.where(obj_name => obj.id)
-    end
-
     def method_missing(name, *args, &block)
-      model = Model.model_from_table(key.capitalize)
-      if model.scopes.include?(name)
+      if vector_model.scopes.include?(name)
         query.send(name)
       else
         super
       end
     end
 
+    def query
+      vector_model.query.where({ object_name => obj.id })
+    end
+
+    def object_name
+      obj.class.underscore_name # eg "product_brand"
+    end
+
+    def vector_model
+      @vector_model ||= Model.model_from_table(key.capitalize)
+    end
+
     def remove_record(rec)
       recs = obj.record[key].delete_if { |r| r == rec }
       obj.record[key] = recs

data/lib/groovy/version.rb

@@ -1,3 +1,3 @@
 module Groovy
-  VERSION = '0.6.1'.freeze
+  VERSION = '0.6.6'.freeze
 end

data/spec/callbacks_spec.rb

@@ -0,0 +1,58 @@
+require_relative './spec_helper'
+
+describe Groovy::Model do
+
+  before :all do
+    Groovy.open('tmp/callbacks', 'callbacks_spec')
+    load_callbacks_schema!
+  end
+
+  after :all do
+    Groovy.close('callbacks_spec')
+  end
+
+  def load_callbacks_schema!
+    klass = Class.new
+    Object.const_set("User", klass)
+    User.class_eval do
+      include Groovy::Model
+
+      after_create :created!
+      after_update do |record|
+        record.updated!
+      end
+
+      schema(context: 'callbacks_spec') do |t|
+        t.string :name
+        t.timestamps
+      end
+
+      def created!
+        # puts "created"
+      end
+
+      def updated!
+        # puts "updated"
+      end
+    end
+
+    User.add_reference :comments, "Comments", type: :vector
+  end
+
+  it 'fires created callbacks' do
+    user = User.new(name: 'John')
+    expect(user).to receive(:created!)
+    expect(user).not_to receive(:updated!)
+    expect(user.save).to eq(true)
+  end
+
+  it 'fires updated callbacks' do
+    user = User.new(name: 'John')
+    user.save
+    user.name = 'Josh'
+    expect(user).not_to receive(:created!)
+    expect(user).to receive(:updated!)
+    expect(user.save).to eq(true)
+  end
+
+end

data/spec/vector_spec.rb

@@ -22,7 +22,7 @@ describe Groovy::Model do
       end
     end
 
-    klass = Class.new;
+    klass = Class.new
     Object.const_set("User", klass)
     User.class_eval do
       include Groovy::Model
@@ -42,13 +42,25 @@ describe Groovy::Model do
       load_vector_schema!
     end
 
-    it 'loads records and keeps relations' do
+    it 'loads records and adds reverse relations automatically' do
       user = User.new(name: 'John')
       expect(user.save).to eq(true)
       comment = Comment.new(author: user, content: 'Hello there!')
       expect(comment.save).to eq(true)
-      user.comments << comment
+      # user.comments << comment
       expect(user.reload.comments).to eq([comment])
+
+      user2 = User.new(name: 'Paul')
+      expect(user2.save).to eq(true)
+
+      comment.author = user2
+      comment.save
+
+      expect(user.reload.comments).to eq([])
+      expect(user2.reload.comments).to eq([comment])
+
+      comment.delete
+      expect(user2.reload.comments).to eq([])
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: groovy
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.6
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-29 00:00:00.000000000 Z
+date: 2023-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rroonga
@@ -97,6 +97,7 @@ files:
 - lib/groovy/types.rb
 - lib/groovy/vector.rb
 - lib/groovy/version.rb
+- spec/callbacks_spec.rb
 - spec/groovy_spec.rb
 - spec/model_spec.rb
 - spec/query_spec.rb