groovy 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ec75f430aa5b3ea423b52de62b4d578b4eb0b1e6722e9201c012cd444c616b
-  data.tar.gz: ec46772137b69e14dfe364d383fa9042ec8edd798bd22ed5c2dd4a47f895f1a4
+  metadata.gz: 4a5a7078b71e609451ea64d58ee47e7573f7570563118c1b1fdf62078617ce8d
+  data.tar.gz: 7444d38fc53884cb3540c0ab73efd91f296fcfa96828890cc29509831e6ae656
 SHA512:
-  metadata.gz: 044e5ba04d8097a354be1a6feb07c2ddd06c6e28355a07b41586936a4e572e028f1aefd35bb587dff46f2d1bbad513332d915e7aec01c00df26b09f6a3ffb357
-  data.tar.gz: 30ae3849bb6d769beb08db3ea8c676a0270a1037eb854c5ba7f4df2c3467906ad06055c7409ef8f2cf5284712f668c7153055b77470d0fa902e2d808591eedc4
+  metadata.gz: c20a741e4074aae0e28164ed307080229257d9c1fb6e00bd9fbe50f7b558b0189c1172cadc0ecd9b56484724b442a9bdd5bd59e67fbf748bdee9f4c39642fbd0
+  data.tar.gz: e6481be3ce2ae9fc87071bf1865e1672e7da9b3af0eee39a69dc718be6c4ef39b5dbb942cdd466fe26ccc2035fa5aba70037c12a2f373b44de42d88e3d7cc4b6

data/example/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    groovy (0.1.1)
+    groovy (0.1.2)
       rroonga (~> 7.1)
 
 GEM

data/example/basic.rb

@@ -16,7 +16,7 @@ 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)
+    Product.create!(name: "A product with index #{i}", price: 10000 + i % 10)
   end
 end
 

data/example/relations.rb

@@ -2,7 +2,7 @@ require 'bundler/setup'
 require 'groovy'
 
 Groovy.open('./db/2019', :current)
-Groovy.open('./db/2020', :next)
+# Groovy.open('./db/2020', :next)
 
 module Groovy::Model::ClassMethods
   def context_name
@@ -44,4 +44,13 @@ class Location
     t.string :coords
     t.timestamps
   end
-end
+end
+
+def insert_places(count = 1000)
+  puts "Inserting #{count} places!"
+  count.times do |i|
+    Place.create!(name: "Place #{i}", description: "A nice place")
+  end
+end
+
+insert_places if Place.count == 0

data/lib/groovy/model.rb

@@ -9,6 +9,10 @@ class Hash
 end unless {}.respond_to?(:symbolize_keys)
 
 module Groovy
+
+  class Error < StandardError; end
+  class RecordNotPersisted < Error; end
+
   module Model
 
     def self.initialize_from_record(obj)
@@ -61,7 +65,8 @@ module Groovy
 
       def scope(name, obj)
         define_singleton_method(name) do |*args|
-          obj.respond_to?(:call) ? obj.call(*args) : obj
+          res = obj.respond_to?(:call) ? obj.call(*args) : obj
+          self
         end
       end
 
@@ -87,7 +92,8 @@ module Groovy
       end
 
       def delete_all
-        schema.rebuild!
+        all.each { |child| child.delete }.count
+        # schema.rebuild!
       end
 
       # def column(name)
@@ -103,18 +109,34 @@ module Groovy
         # table.select("#{col}:#{q}", operator: Groonga::Operation::SIMILAR)
       end
 
+      def unique_values_for(column, limit: -1)
+        cols = [column]
+        opts = { drill_down: cols, drill_down_limit: limit, drilldown_sortby: '_key' }
+        resp = table.context.select(table_name, opts) # drill_down_output_columns: cols
+        arr  = resp.body[1] # or resp.drilldowns
+        arr.slice(2..-1) # .flatten
+      end
+
+      def clear_query
+        @query = nil
+      end
+
+      def query
+        @query ||= Query.new(self, table)
+      end
+
       def all
-        Query.new(self, table)
+        query
       end
 
-      def first(count = 1)
-        arr = limit(count)
-        count == 1 && arr.first || arr
+      def first(num = 1)
+        arr = limit(num)
+        num == 1 ? arr.first : arr
       end
 
-      def last(count = 1)
-        arr = limit(count).to_a.reverse
-        count == 1 && arr.first || arr
+      def last(num = 1)
+        arr = all.sort_by(_id: :desc).limit(num)
+        num == 1 ? arr.first : arr
       end
 
       def find_by(params)
@@ -127,9 +149,7 @@ module Groovy
 
       [:search, :where, :not, :sort_by, :limit, :offset].each do |scope_method|
         define_method scope_method do |*args|
-          Query.new(self, table).tap do |q|
-            q.public_send(scope_method, *args)
-          end
+          query.public_send(scope_method, *args)
         end
       end
       
@@ -191,28 +211,31 @@ module Groovy
 
     attr_reader :id, :attributes, :refs, :record, :changes
 
-    def initialize(attributes = nil, record = nil)
+    def initialize(attrs = nil, record = nil)
       @attributes, @refs, @vectors = {}, {}, {}
-      
-      if @record = record 
-        @id = attributes.delete('_id')
+
+      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(attributes)     
+      attrs ||= {}
+      unless attrs.is_a?(Hash)
+        raise ArgumentError.new("Attributes should be a hash") 
+      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 new_record?
       id.nil?
-    end
-
-    def key
-      return unless record
-      record.respond_to?(:_key) ? record._key : record.id
+      # _key.nil?
     end
 
     def [](key)
@@ -239,6 +262,7 @@ module Groovy
     end
 
     def set_attributes(obj = {})
+      obj.delete('_id') # just in case
       # we call the method instead of []= to allow overriding setters
       obj.each { |k,v| public_send("#{k}=", v) }
     end
@@ -250,7 +274,7 @@ module Groovy
 
     def save(options = {})
       return false if respond_to?(:invalid) and invalid?
-      @record ? update : create
+      new_record? ? create : update
     end
 
     def save!(options = {})
@@ -258,15 +282,21 @@ module Groovy
     end
 
     def delete
-      record.delete
+      record.delete # doesn't work if record.id doesn't match _key
+      # self.class.table.delete(_key)
+      set_record(nil)
       self
+    rescue Groonga::InvalidArgument => e
+      puts "Error: #{e.inspect}"
+      raise RecordNotPersisted
     end
 
     def reload
-      raise "Not persisted" if key.nil?
-      record = self.class.table[key]
-      attributes = record.attributes.symbolize_keys
-      changes = {}
+      ensure_persisted!
+      record = self.class.table[id] # _key
+      # TODO: fix duplication
+      set_attributes(record.attributes)
+      @changes = {}
       self
     end
 
@@ -276,6 +306,11 @@ module Groovy
 
     private
 
+    # def _key
+    #   return unless record
+    #   record.respond_to?(:_key) ? record._key : id
+    # end
+
     def set_attribute(key, val)
       changes[key.to_sym] = [self[key], val] if changes # nil when initializing
       attributes[key.to_sym] = val
@@ -294,13 +329,18 @@ module Groovy
       set_attribute(name, obj.nil? ? nil : obj.key)
     end
 
+    def set_record(obj)
+      @id = obj ? obj._id : nil
+      @record = obj # return value
+    end
+
     def create
-      @record = self.class.insert(attributes)
+      set_record(self.class.insert(attributes))
       self
     end
 
     def update
-      raise "Not persisted" unless key
+      ensure_persisted!
       changes.each do |key, values|
         # puts "Updating #{key} from #{values[0]} to #{values[1]}"
         record[key] = values.last
@@ -310,5 +350,9 @@ module Groovy
       self
     end
 
+    def ensure_persisted!
+      raise "Not persisted" if new_record?
+    end
+
   end
 end

data/lib/groovy/query.rb

@@ -1,6 +1,7 @@
 module Groovy
 
   class Query
+
     include Enumerable
     AND = '+'.freeze
     NOT = '-'.freeze
@@ -31,6 +32,11 @@ module Groovy
       end
     end
 
+    def inspect
+      clear_query
+      super
+    end
+
     # http://groonga.org/docs/reference/grn_expr/query_syntax.html
     # TODO: support match_columns (search value in two or more columns)
     def where(conditions = nil)
@@ -46,6 +52,9 @@ module Groovy
               str = val.source.gsub(/[^a-z]/, '')
               param = val.source[0] == '^' ? ':^' : ':~' # starts with or regexp
               parameters.push(AND + [key, str].join(param))
+            elsif val.is_a?(Array) # { foo: [1,2,3] }
+              str = "#{key}:#{val.join(" OR #{key}:")}"
+              parameters.push(AND + str)
             else
               parameters.push(AND + [key, val.to_s].join(':'))
             end
@@ -67,8 +76,11 @@ module Groovy
         when Hash # { foo: 'bar' }
           conditions.each do |key, val|
             if val.is_a?(Range)
-              parameters.push(AND + [key, val.min].join(':<=')) if val.min # gte
-              parameters.push(AND + [key, val.max].join(':>=')) if val.max # lte
+              parameters.push(AND + [key, val.min].join(':<=')) if val.min > 0 # gte
+              parameters.push(AND + [key, val.max].join(':>=')) if val.max # lte, nil if range.max is -1
+            elsif val.is_a?(Array) # { foo: [1,2,3] }
+              str = "#{key}:!#{val.join(" OR #{key}:!")}"
+              parameters.push(AND + str)
             else
               parameters.push(AND + [key, val.to_s].join(':!')) # not
             end
@@ -91,10 +103,10 @@ module Groovy
       self
     end
 
-    def paginate(page)
+    def paginate(page = 1)
       page = 1 if page.to_i < 1
       offset = ((page.to_i)-1) * PER_PAGE
-      offset(offset).limit(PER_PAGE)
+      offset(offset).limit(PER_PAGE) # returns self
     end
 
     # sort_by(title: :asc)
@@ -105,10 +117,17 @@ module Groovy
       self
     end
 
+    def group_by(column)
+      sorting[:group_by] = column
+      self
+    end
+
+    def query
+      self
+    end
+
     def all
-      @all ||= results.map do |r| 
-        model.new(r.attributes['_value']['_key'], r)
-      end
+      @records || query
     end
 
     def size
@@ -118,19 +137,24 @@ module Groovy
     alias_method :count, :size
 
     def to_a
-      all
+      records
     end
 
     def [](index)
-      all[index]
+      records[index]
     end
 
     def each(&block)
-      all.each { |r| block.call(r) }
+      records.each { |r| block.call(r) }
+    end
+    
+    def total_entries
+      results # ensure query has been run
+      @total_entries
     end
 
     def last
-      all[size-1]
+      records[size-1]
     end
 
     def in_batches(of: 1000, from: nil)
@@ -139,36 +163,56 @@ module Groovy
 
       while results.any?
         yield all
+        break if results.size < of
 
         @sorting[:offset] += of
         @all = @results = nil # reset
       end
     end
 
+    def records
+      @records ||= results.map do |r| 
+        # FIXME: figure out the right way to do this.
+        # model.new(r.value.attributes['_key'], r)
+        id = r.attributes['_value']['_key']['_id']
+        model.new_from_record(table[id])
+      end
+    end
+
     private
     attr_reader :model, :table, :options
 
+    def clear_query
+      model.clear_query # sets @query to nil
+    end
+
     def results
       @results ||= execute
     rescue Groonga::TooLargeOffset
       # puts "Offset is higher than table size!"
       []
+    ensure
+      clear_query
     end
 
     def execute
       set = if parameters.any?
-        query = parameters.join(" ").gsub(/\s(\w)/, '\ \1')
+        query = prepare_query
         puts query if ENV['DEBUG']
         table.select(query, options)
       else
         table.select(options)
       end
 
+      @total_entries = set.size
+
       puts "Sorting with #{sort_key_and_order}, #{sorting.inspect}" if ENV['DEBUG']
-      set.sort(sort_key_and_order, { 
+      set = set.sort(sort_key_and_order, { 
         limit: sorting[:limit], 
         offset: sorting[:offset] 
       })
+
+      sorting[:group_by] ? set.group(group_by) : set
     end
 
     def map_operator(str)
@@ -185,10 +229,16 @@ module Groovy
       sorting[:by] or [{ key: @default_sort_key, order: :asc }]
     end
 
+    def prepare_query
+      query = parameters.join(" ").split(/ or /i).map do |part|
+        part.gsub(/\s(\w)/, '\ \1')
+      end.join(' OR ')
+    end
+
     def method_missing(name, *args)
       if model.respond_to?(name)
         other = model.public_send(name, *args)
-        merge_with!(other)
+        merge_with!(other.query)
       else
         super
       end

data/lib/groovy/types.rb

@@ -25,8 +25,8 @@ module Groovy
     # UNIGRAM
 
     MAPPINGS = {
-      'String' => 'short_text',
-      'Text' => 'text',
+      'String' => 'short_text', # max 4095 bytes
+      'Text' => 'text',         # max 65,535 bytes
       'Float' => 'float',
       'Bool' => 'boolean',
       'Boolean' => 'boolean',

data/lib/groovy/vector.rb

@@ -2,14 +2,23 @@ module Groovy
   class Vector
     include Enumerable
 
+    REMOVE_MISSING = true.freeze
+
     def initialize(obj, key)
       @obj, @key = obj, key
     end
 
-    def count
-      records.count
+    def size
+      # records.count
+      items.count # so we filter out removed ones
+    end
+
+    def inspect
+      items.to_s
     end
 
+    alias_method :count, :size
+
     def each(&block)
       items.each { |r| block.call(r) }
     end
@@ -18,20 +27,28 @@ module Groovy
       set([])
     end
 
-    def set(items)
-      raise "Please save parent record first" unless obj.record
-      obj.record[key] = items
+    def set(new_items)
+      check_parent!
+      obj.record[key] = new_items
+    end
+
+    def has?(item)
+      return false unless item.record
+      obj.record[key].find { |r| r == item.record }
     end
 
     def push(item)
-      raise "Please save parent record first" unless obj.record
-      obj.record[key] = obj.record[key].concat([item.record])
+      raise "Invalid item type: #{item.class}" unless item.is_a?(Model)
+      check_parent!
+      raise "Already in list!" if has?(item)
+      item.save unless item.record
+      push_record(item.record)
     end
 
     def remove(item)
-      raise "Please save parent record first" unless obj.record
-      recs = obj.record[key].delete_if { |r| r == item.record }
-      obj.record[key] = recs
+      check_parent!
+      raise "Item not saved: #{record}" unless item.record
+      remove_record(item.record)
     end
 
     alias_method :<<, :push
@@ -39,9 +56,33 @@ module Groovy
     private
     attr_reader :obj, :key
 
+    def remove_record(rec)
+      recs = obj.record[key].delete_if { |r| r == rec }
+      obj.record[key] = recs
+    end
+
+    def push_record(rec)
+      obj.record[key] = obj.record[key].concat([rec])
+    end
+
+    def check_parent!
+      raise "Please save parent record first" unless obj.record
+    end
+
     def items
       return [] unless obj.record
-      records.map { |r| Model.initialize_from_record(r) }
+      records.map do |r| 
+        if !exists?(r) 
+          remove_record(r) if REMOVE_MISSING
+          nil
+        else
+          Model.initialize_from_record(r)
+        end
+      end.compact
+    end
+
+    def exists?(rec)
+      rec.table.exist?(rec._id)
     end
 
     def records

data/lib/groovy/version.rb

@@ -1,3 +1,3 @@
 module Groovy
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.1.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: groovy
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-02 00:00:00.000000000 Z
+date: 2019-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler