groovy 0.4.2 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2e735dd501cd86a3ee2ab21b111bf7aa4ab3d76d9d14acf8be86b97e34335b1
-  data.tar.gz: 97b3b88d1f297ab6d74b9818858272c8fa711a27a3c0d64964508988a3304b85
+  metadata.gz: 43812d3bd8ef9579ceed22b3d19e78378ceb3a924bfc8d6c0983e49199c26c88
+  data.tar.gz: 5960ca73a253d62f31301995c8f643bcaa084a99140b5f59eee0161c816d20e2
 SHA512:
-  metadata.gz: deb85e6549f328555d795e542e282c6e3a50c574fdac769530648c69292f02ed469bc293304db863b7c9ac28a5bb653bd85eb79a7652f6390b3f5309fc492552
-  data.tar.gz: 7546011290684eca615cf4823df5886908fe823c9bee086a80504a01a7d3aa846a0fd34dc05efc023a061078ac3645d352618c64a03b614989cb51bc3ca4c5c9
+  metadata.gz: 22cc09a73d9804f5d5e1cb432d3948ff24ef9a28dbd84b5a403b3709477d013089617ebf19b23f4d3450c3c7dc8e15c01ab527698c5efa5821c9d351056777ad
+  data.tar.gz: 809b9fa8e3158df7afeb6e80967d7156772094b21b69f6fe7d9f5e6db03626fe8a9b2ee123f89c7bf791ef6e195415524b1e967291d836becdc6173fbd0bfbfc

data/example/basic.rb

@@ -28,4 +28,18 @@ populate if Product.count == 0
 
 # 50_000 products: 50M
 # 100_000 products: 50M
-# 500_000 products: 62M
+# 500_000 products: 62M
+
+module MemInfo
+  KERNEL_PAGE_SIZE = `getconf PAGESIZE`.chomp.to_i rescue 4096
+  STATM_PATH       = "/proc/#{Process.pid}/statm"
+  STATM_FOUND      = File.exist?(STATM_PATH)
+  def self.rss
+    STATM_FOUND ? (File.read(STATM_PATH).split(' ')[1].to_i * KERNEL_PAGE_SIZE) / 1024 : 0
+  end
+end
+
+puts MemInfo.rss
+prices = Product.all.map { |x| x.price }
+puts prices.inspect
+puts MemInfo.rss

data/lib/groovy/model.rb

@@ -150,7 +150,6 @@ module Groovy
       #   Groonga["#{table_name}.#{name}"] # .search, .similar_search, etc
       # end
 
-
       def index_search(column, query, options = {}, &block)
         results = table.select { |rec| rec[column].match(query) }
         render_results(results, &block)
@@ -187,16 +186,6 @@ module Groovy
         query
       end
 
-      def first(num = 1)
-        arr = limit(num)
-        num == 1 ? arr.first : arr
-      end
-
-      def last(num = 1)
-        arr = all.sort_by(_id: :desc).limit(num)
-        num == 1 ? arr.first : arr
-      end
-
       def query
         query_class.new(self, table)
       end
@@ -208,7 +197,7 @@ module Groovy
         end
       end
 
-      [:select, :find_each, :find_by, :search, :where, :not, :sort_by, :limit, :offset, :paginate, :in_batches].each do |scope_method|
+      [:first, :last, :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
@@ -221,6 +210,12 @@ module Groovy
         set_timestamp(attributes, :created_at)
         set_timestamp(attributes, :updated_at)
 
+        # remove nil attributes for integer columns, otherwise
+        # we get a TypeError (no implicit conversion from nil to integer)
+        attributes.each do |k, v|
+          attributes.delete(k) if v.nil? # && schema.integer_columns.include?(k)
+        end
+
         if table.support_key?
           raise "Key required" if key.nil?
           table.add(key, attributes)
@@ -287,17 +282,17 @@ module Groovy
       end
     end
 
-    attr_reader :id, :attributes, :record, :changes
+    attr_reader :id, :record, :changes
 
     def initialize(attrs = nil, record = nil, key = nil)
       @attributes, @vectors, @_key = {}, {}, key # key is used on creation only
 
       if set_record(record)
-        set_attributes_from_record(record)
+        # load_attributes_from_record(record)
       else
         attrs ||= {}
         unless attrs.is_a?(Hash)
-          raise ArgumentError.new("Attributes should be a Hash")
+          raise ArgumentError.new("Attributes should be a Hash, not a #{attrs.class}")
         end
 
         # don't call set_attributes since we don't want to call
@@ -311,8 +306,13 @@ 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]
+    # def load_record
+    #   self.class.table[id]
+    # end
+
+    def attributes
+      load_attributes_from_record # populate missing
+      @attributes
     end
 
     def inspect
@@ -325,7 +325,9 @@ module Groovy
     end
 
     def [](key)
-      attributes[key.to_sym]
+      k = key.to_sym
+      @attributes[k] = get_record_attribute(k) unless @attributes.key?(k)
+      @attributes[k]
     end
 
     def []=(key, val)
@@ -386,11 +388,15 @@ module Groovy
     end
 
     def reload
-      raise RecordNotPersisted if id.nil?
-      ensure_persisted!
-      rec = self.class.table[id] # _key
-      # set_record(rec)
-      set_attributes_from_record(rec)
+      unless new_record?
+        # raise RecordNotPersisted if id.nil?
+        # ensure_persisted!
+        rec = self.class.table[id] # _key
+        set_record(rec)
+        # load_attributes_from_record
+      end
+
+      @attributes = {}
       @changes = {}
       self
     end
@@ -400,18 +406,19 @@ module Groovy
     end
 
     def ==(other)
-      self.id == other.id
+      self.class == other.class && self.id == other.id
     end
 
     def <=>(other)
-      self.id <=> other.id
+      self.class == other.class && self.id <=> other.id
     end
 
     private
 
     def get_record_attribute(key)
+      return if record.nil?
       val = record[key]
-      if self.class.schema.time_column?(key)
+      if self.class.schema.time_columns.include?(key)
         fix_time_value(val)
       else
         val
@@ -427,15 +434,15 @@ module Groovy
     #   record.respond_to?(:_key) ? record._key : id
     # end
 
-    def set_attributes_from_record(rec)
+    def load_attributes_from_record
       self.class.attribute_names.each do |col|
-        public_send("#{col}=", get_record_attribute(col))
+        public_send("#{col}=", get_record_attribute(col)) unless @attributes.key?(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
+      changes[key.to_sym] = [self[key], val] if changes # nil before initializing
+      @attributes[key.to_sym] = val
     end
 
     def get_ref(name)
@@ -460,7 +467,7 @@ module Groovy
 
     def create
       fire_callbacks(:before_create)
-      set_record(self.class.insert(attributes, @_key))
+      set_record(self.class.insert(@attributes, @_key))
       fire_callbacks(:after_create)
       self
     end

data/lib/groovy/query.rb

@@ -3,9 +3,11 @@ module Groovy
   class Query
 
     include Enumerable
+
     AND = '+'.freeze
     NOT = '-'.freeze
     PER_PAGE = 50.freeze
+    # ESCAPE_CHARS_REGEX = /([\(\)\/\\])/.freeze
     VALID_QUERY_CHARS = 'a-zA-Z0-9_\.,&-'.freeze
     REMOVE_INVALID_CHARS_REGEX = Regexp.new('[^\s' + VALID_QUERY_CHARS + ']').freeze
 
@@ -81,7 +83,7 @@ module Groovy
               add_param(AND + [key, val.max].join(':<=')) if val.max # gte
 
             elsif val.is_a?(Regexp)
-              str = val.source.gsub(REMOVE_INVALID_CHARS_REGEX, '')
+              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
 
@@ -115,7 +117,7 @@ module Groovy
               add_param(AND + [key, val.max].join(':>=')) if val.max # lte, nil if range.max is -1
 
             elsif val.is_a?(Regexp)
-              str = val.source.gsub(REMOVE_INVALID_CHARS_REGEX, '')
+              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(NOT + [key, str.downcase].join(param)) # regex must be downcase
 
@@ -137,12 +139,12 @@ module Groovy
     end
 
     def limit(num)
-      @sorting[:limit] = num
+      sorting[:limit] = num
       self
     end
 
     def offset(num)
-      @sorting[:offset] = num
+      sorting[:offset] = num
       self
     end
 
@@ -154,8 +156,8 @@ module Groovy
 
     # sort_by(title: :asc)
     def sort_by(hash)
-      if hash.is_a?(String) || hash.is_a?(Symbol) # e.g. 'title.desc' or :title (asc by default)
-        param, dir = hash.to_s.split('.')
+      if hash.is_a?(String) || hash.is_a?(Symbol) # e.g. 'title.desc', 'title desc' or :title (asc by default)
+        param, dir = hash.to_s.split(/\s|\./)
         hash = {}
         hash[param] = dir || 'asc'
       end
@@ -190,11 +192,16 @@ module Groovy
     end
 
     def [](index)
-      records[index]
+      if r = results[index]
+        model.new_from_record(r)
+      end
     end
 
     def each(&block)
-      records.each { |r| block.call(r) }
+      # records.each { |r| block.call(r) }
+      results.each_with_index do |r, index|
+        yield model.new_from_record(r)
+      end
     end
 
     def update_all(attrs)
@@ -206,35 +213,50 @@ module Groovy
       @total_entries
     end
 
-    def last(count = 1)
-      if count > 1
-        records[(size-count)..-1]
-      else
-        records[size-1]
+    def first(num = 1)
+      limit(num)
+      num == 1 ? records.first : records
+    end
+
+    def last(num = 1)
+      if sorting[:by]
+        get_last(num)
+      else # no sorting, so
+        sort_by(_id: :desc).limit(num)
+        # if last(2) or more, then re-sort by ascending ID
+        num == 1 ? records.first : records.sort { |a,b| a.id <=> b.id }
       end
     end
 
     def in_batches(of: 1000, from: nil, &block)
-      @sorting[:limit] = of
-      @sorting[:offset] = from || 0
+      sorting[:limit] = of
+      sorting[:offset] = from || 0
 
       while results.any?
         yield to_a
         break if results.size < of
 
-        @sorting[:offset] += of
+        sorting[:offset] += of
         @records = @results = nil # reset
       end
     end
 
+    private
+    attr_reader :model, :table, :options, :select_block
+
     def records
       @records ||= results.map do |r|
         model.new_from_record(r)
       end
     end
 
-    private
-    attr_reader :model, :table, :options, :select_block
+    def get_last(count = 1)
+      if count > 1
+        records[(size-count)..-1]
+      else
+        records[size-1]
+      end
+    end
 
     def add_param(param)
       raise "Select block already given!" if select_block
@@ -264,7 +286,7 @@ module Groovy
 
       @total_entries = set.size
 
-      debug "Sorting with #{sort_key_and_order}, #{sorting.inspect}"
+      debug "Sorting with #{sort_key_and_order} (options: #{sorting.inspect})"
       set = set.sort(sort_key_and_order, {
         limit: sorting[:limit],
         offset: sorting[:offset], # [sorting[:offset], @total_entries].min
@@ -296,6 +318,7 @@ module Groovy
       query = parameters.join(' ').split(/ or /i).map do |part|
         part.gsub('  ', ' ') # replace double with single spaces
             .gsub(space_regex, '\ \1') # escape spaces before word letters
+            .gsub('_slash_', '\/').gsub('_openp_', '\(').gsub('_closep_', '\)')
             .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

data/lib/groovy/schema.rb

@@ -26,6 +26,7 @@ module Groovy
     def initialize(context, table_name, opts = {})
       @context, @table_name, @opts = context, table_name, opts || {}
       @spec, @index_columns = {}, []
+      @cache = {}
     end
 
     def table
@@ -33,35 +34,43 @@ module Groovy
     end
 
     def search_table
-      @search_table ||= context[SEARCH_TABLE_NAME]
+      @cache[:search_table] ||= context[SEARCH_TABLE_NAME]
     end
 
     def column_names
-      get_names table.columns
+      @cache[:column_names] ||= get_names(table.columns)
     end
 
     def singular_references
-      # @singular_references ||=
-      get_names(table.columns.select(&:reference_column?).reject(&:vector?))
+      @cache[:singular_references] ||= get_names(table.columns.select(&:reference_column?).reject(&:vector?))
     end
 
     def plural_references
-      # @plural_references ||=
-      get_names(table.columns.select(&:vector?))
+      @cache[:plural_references] ||= get_names(table.columns.select(&:vector?))
     end
 
     def attribute_columns
-      # @attribute_columns ||=
-      get_names(table.columns.select { |c| c.column? && !c.reference_column? && !c.vector? })
+      @cache[: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' })
+      @cache[:time_columns] ||= columns_by_type('Time')
     end
 
-    def time_column?(name)
-      time_columns.include?(name)
+    def integer_columns
+      @cache[:integer_columns] ||= columns_by_type('Int32')
+    end
+
+    def boolean_columns
+      @cache[:boolean_columns] ||= columns_by_type('Bool')
+    end
+
+    def columns_by_type(type)
+      get_names(table.columns.select { |c| c.column? && c.range.name == type })
+    end
+
+    def reload
+      @cache = {}
     end
 
     def rebuild!
@@ -105,6 +114,8 @@ module Groovy
       @index_columns.each do |col|
         add_index_on(col)
       end
+
+      reload
       self
     end
 

data/lib/groovy/version.rb

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

data/spec/model_spec.rb

@@ -17,7 +17,7 @@ describe Groovy::Model do
   describe '.scope' do
 
     before :all do
-      TestProduct.class_eval do 
+      TestProduct.class_eval do
         scope :with_name, -> (name) { where(name: name) if name }
         scope :by_price_asc, -> { sort_by(price: :asc) }
         scope :cheapest, -> { by_price_asc }
@@ -49,6 +49,13 @@ describe Groovy::Model do
   end
 
   describe '.create' do
+
+    it 'does not explode when inserting nil values for columns' do
+      expect do
+        TestProduct.create({ price: nil })
+      end.not_to raise_error
+    end
+
   end
 
   describe '.find' do
@@ -60,6 +67,7 @@ describe Groovy::Model do
   describe '.delete_all' do
 
     before do
+      TestProduct.delete_all
       @first  = TestProduct.create!(name: 'A product', price: 100)
       @second = TestProduct.create!(name: 'Another product', price: 200)
       expect(TestProduct.count).to eq(2)
@@ -78,6 +86,28 @@ describe Groovy::Model do
   end
 
   describe '#[]' do
+    it 'reads value from record' do
+      prod = TestProduct.create!(name: 'A product', price: 100)
+      expect(prod.name).to eq('A product')
+      expect(prod['name']).to eq('A product')
+      expect(prod[:name]).to eq('A product')
+
+      prod = TestProduct.find(prod.id)
+      expect(prod.name).to eq('A product')
+      expect(prod['name']).to eq('A product')
+      expect(prod[:name]).to eq('A product')
+
+      prod = TestProduct.new
+      expect(prod.name).to eq(nil)
+      prod.name = 'Another product'
+      expect(prod.name).to eq('Another product')
+      prod.reload
+      expect(prod.name).to eq(nil)
+      prod.name = 'Another product'
+      prod.save
+      prod.reload
+      expect(prod.name).to eq('Another product')
+    end
   end
 
   describe '#[]=' do

data/spec/query_spec.rb

@@ -8,7 +8,7 @@ describe Groovy::Query do
     @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: The Best", visible: true, price: 30, tag_list: nil)
-    @p4 = TestProduct.create!(name: "Product 4", visible: false, price: 40, tag_list: 'one, number two')
+    @p4 = TestProduct.create!(name: "Product 4", visible: false, price: 40, tag_list: 'one, number two / something')
     @p5 = TestProduct.create!(name: "Product 5", visible: true, price: 50, tag_list: '')
   end
 
@@ -124,6 +124,12 @@ describe Groovy::Query do
         res = TestProduct.where(tag_list: /two & three/)
         expect(res.map(&:id)).to eq([@p1.id])
       end
+
+      it 'works with slashes' do
+        str = 'two / something'
+        res = TestProduct.where(tag_list: /#{str}/)
+        expect(res.map(&:id)).to eq([@p4.id])
+      end
     end
 
     describe 'starts with regex' do
@@ -253,6 +259,12 @@ describe Groovy::Query do
         res = TestProduct.not(tag_list: /two & three/)
         expect(res.map(&:id)).to eq([@p2.id, @p3.id, @p4.id, @p5.id])
       end
+
+      it 'works with slashes' do
+        str = 'two / something'
+        res = TestProduct.not(tag_list: /#{str}/)
+        expect(res.map(&:id)).to eq([@p1.id, @p2.id, @p3.id, @p5.id])
+      end
     end
 
     describe 'starts with regex' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: groovy
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.7
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-13 00:00:00.000000000 Z
+date: 2020-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rroonga