like_query 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84fed18b7e4d5122c2d760bdf76c27bcc7094d7e44a140e0b42d8dff1d574827
-  data.tar.gz: adb485617d123592abd58140a086073da2745eef15d25a4c84a40635ae1e92f7
+  metadata.gz: 310d79668485fd3063a1e6c938d0c1bb925bf988e08cd93a7430c256c1f5cc50
+  data.tar.gz: 5b6c403c42b64078d728171d9c977ae267d482954e666b0afbf9068cbba8795c
 SHA512:
-  metadata.gz: 5e7b363e0409f55048163956d485b2b93668eddb3f1de4b49daca8aaffafd2f9866c4a3dfc6abf6b12fecbfdae5e190fe69e8265c162fac97b7e3aff0bfb858d
-  data.tar.gz: 4b5a6c0aff2b9a4c1f7c7fa2f08da962e6e4937146a351f8a2c57d8946f2880051a4b1d209a997fbdf4f0eac0e208dcf379603530bc0413b298e8ee8ec6f39e8
+  metadata.gz: 43a1cc9aab0e0df7fc3f8bf9fca7d2e4c0e44a72857294d779a8af8c633ff56ad54bb6921c10675661ae9ea533d1ad2f82ac2bd56cadd75e061612b6b4302132
+  data.tar.gz: ecf6ce1eaff200351093c36073e6e320ddf9645d2ba926f2098c2fbef815d4bc0a921cd2d4f53b09827d1cccdb82073f432a3c6c21695628c58522cd18e2e483

data/README.md

@@ -2,10 +2,14 @@
 
 For my customers apps, newly built with turbo, search queries are mostly for two purposes:
 
-Index view callable by a url like `/customers?find=müller screw` or a javascript dropdown on the front, in our case built with svelte, which receives a json and renders a table in a dropdown. 
+- Index view callable by a url like `/customers?find=müller screw` 
+- javascript component / dropdown on the front, in our case
+built with svelte, which receives a json and renders a table in a dropdown.
 
 This query generator is built for this two purposes.
 
+modules like a above mentioned svelte component having a total response time (from pressing a key until the result is rendered) from aproximately 60 msec while by turbo the same time is mostly around 140-160 msec. The gem itselve, from querying the database until producing a hash has a time from around 3 msec. Theese results are for small data sets (if found 30 records, by example)
+
 ## Installation
 
 add
@@ -14,18 +18,18 @@ add
 
 to Gemfile
 
-this adds the methods `#like` and `#like_result` to all models.
+this adds the methods `#like` and `#generate_hash` to all models.
 
 ## Usage
 
-**.like**
+**#like**
 
 ```ruby
 customer = Customer.create(name: 'Ambühl')
 art1 = Article.create(name: 'first', number: '01', customer: customer)
 
 Article.like('fir', :name, :number)
-# => would find art1
+# => <Article:0x00000001067107a8 id: ...>
 # => searches by: "where name like '%fir%' or number like '%fir%'"
 # => queries are built with Article.arel_table[:name].matches('%fir%')
 
@@ -35,75 +39,154 @@ Article.like(['fir', 'ambühl'], :name, :number, customer: :name)
 # => would also find art1
 ```
 
-**.like_result**
+**#generate_hash**
 
+can only be chained behind `#like`.
 returns a hash that can easily be transformed by `#to_json` for a javascript-frontend, by example
 
-can only be chained behind `#like`. 
-
 ```ruby
 customer = Customer.create(name: 'Ambühl')
 art1 = Article.create(name: 'first', number: '01', customer: customer)
 
-Article.like('fir', :name).like_result(limit: 10)
+Article.like('fir', :name).generate_hash(limit: 10)
 # returns: 
-{ 
-  :data=>[
+{
+  :data => [
     {
-      :attributes=>[[:name, "first"]], 
-      :id=>1}], 
-  :length=>1, 
-  :overflow=>false, 
-  :columns_count=>1, 
-  :sub_records_columns_count=>0
+      :attributes => [[:name, "first"]],
+      :id => 1 }],
+  :length => 1,
+  :overflow => false,
+  :columns_count => 1,
+  :sub_records_columns_count => 0
 }
 
-Article.like('fir', :name).like_result( :number, limit: 10)
+Article.like('fir', :name).generate_hash(:number, limit: 10)
 # would query like the above example: Search scope is only :name
 # but would return article-number instead of article-name inside the data block
 ```
 
-`#like_result` uses `LikeQuery::Collect`, functionality is the same.
+`#generate_hash` uses `LikeQuery::Collect`, functionality is the same.
 
-**Class LikeQuery::Collect** 
+**Class LikeQuery::Collect**
 
 ```ruby
 cust = Customer.create(name: 'Müller')
-20.times {Article.create(name: 'any-article', customer: cust)}
+20.times { Article.create(name: 'any-article', customer: cust) }
 
 c = LikeQuery::Collect.new(4)
 # => 4 is the limit
 
-c.receive { Article.like('any-art', :name) }
+c.collect { Article.like('any-art', :name) }
 # => would add 4 articles to the result hash because of limit
 
-c.receive { Customer.like('any-art', :name, image: :image_column, articles: :name) }
+c.collect { Customer.like('any-art', :name, image: :image_column, articles: :name) }
 # => limit is already exhausted: does nothing
 # => otherwise it would add Customers to the result hash
 
 c.result
 # => would return anything like (this output is from different code!!):
 {
-  :data=>[
-    {:attributes=>[[:name, "Ambühl"]], :id=>1, :image=>"src:customer-image", 
-     :associations=>{
-       :articles=>[
-         {:attributes=>[[:number, "01"]], :id=>1, :image=>"src:article-image"}, 
-         {:attributes=>[[:number, "01"]], :id=>2, :image=>"src:article-image"}
-       ]
-     }
+  :data => [
+    { :attributes => [[:name, "Ambühl"]], :id => 1, :image => "src:customer-image",
+      :associations => {
+        :articles => [
+          { :attributes => [[:number, "01"]], :id => 1, :image => "src:article-image" },
+          { :attributes => [[:number, "01"]], :id => 2, :image => "src:article-image" }
+        ]
+      }
     }
-  ], 
-  :length=>3, 
-  :overflow=>false, 
-  :columns_count=>1, 
-  :sub_records_columns_count=>1
+  ],
+  :length => 3,
+  :overflow => false,
+  :columns_count => 1,
+  :sub_records_columns_count => 1
+}
+```
+
+**query schema and result_schema**
+
+The resulting hash for one record looks like:
+
+```ruby
+{
+  :values => ["abc", "123"],
+  :id => 456,
+  :model => "article",
+  :image => "src:img..."
+}
+```
+
+The resulting hash or json is built from the schema, which can look like:
+
+```ruby
+:number
+```
+
+or
+
+```ruby
+[:number, :name]
+```
+
+or
+
+```ruby
+{
+  values: [:number, :name],
+  image: :name_of_a_column_or_method
 }
 ```
 
+There is a query schema and a output schema.
+If no output schema is defined, query schema is used for both
+
+```ruby
+Article.like('first', :name).generate_hash
+# => :values => ["first"]
+```
+
+If output schema is given, result can be different to the search scope:
+
+```ruby
+Article.like('first', :name).generate_hash(:number, :name)
+# => :values => ["012", "first"]
+```
+
+The collect class reminds the schema for a model:
+
+```ruby
+c = LikeQuery::Collect.new
+c.collect([:name]) { Article.like('x') }
+c.collect { Article.like('x') } #=> schema [:name] is used
+c.collect { Article.like('x', :number) } # => schema [:number] is used
+```
+
+**#set_schema**
+
+If a child delivers its parent, the schema for parent has to be given.
+Otherwise `#generate_hash` would not know which values it should return
+
+```ruby
+    c = LikeQuery::Collect.new
+    c.set_schema(Customer, :name)
+    # => now the customer will be returned with { values: [<name>] }
+    c.collect(parent: :customer) { Article.like('screw', :name) }
+    # => this will add the customer (unless it exists in the list) and add the Article as a child to the customer
+    r = c.generate_hash
+```
+
+**Performance**
+
+Values defined by schema are processed by `#send` method, but recursive.
+This, by example means, that for a `Article` with given key `customer.name` in schema would return the name of the associated customer.
+
+ATTENTION: This can trigger lots of database queries, depending on your structure or if or which method is behind the called names.
+
 ## Tests
 
-Tests for this gem, by rspec, are included not inside this gem, they can be found in a [test project](https://gitlab.com/sedl/like_query_project) 
+Tests for this gem, by rspec, are included not inside this gem, they can be found in
+a [test project](https://gitlab.com/sedl/like_query_project)
 
 - [ ] [Set up project integrations](https://gitlab.com/sedl/like_query/-/settings/integrations)
 

data/lib/like_query/collect.rb

@@ -1,116 +1,90 @@
 module LikeQuery
   class Collect
-    def initialize(limit = 50)
+    def initialize(limit = 20)
       @limit = limit
       @length = 0
-      @data = []
+      @data = {}
       @overflow = false
       @columns_count = 0
       @sub_records_columns_count = 0
       @image = false
-      @sub_records_image = false
+      #@sub_records_image = false
+      @start_time = Time.now
+      @schemes = {}
+      @images = {}
     end
 
-    def receive(*result_pattern, limit: nil, image: nil, &block)
+    def set_schema(model, schema)
+      @schemes[model.to_s] = schema_to_hash(schema)
+    end
+
+    def collect(output_schema = nil, limit: nil, parent: nil, image: nil, &block)
+
+      Rails.logger.debug(' x x x x x x x x x         START COLLECT            x x x x x x x x x x x x x x x x x x')
 
-      return false if @length >= @limit
+      _limit = (limit ? (@limit && @limit < limit ? @limit : limit) : @limit)
+      return false if @length >= _limit
       length = 0
-      @image = image.present?
 
-      recs = yield
+      recs = yield.includes(parent).limit(_limit)
 
-      _pattern = (result_pattern.present? ? result_pattern : recs.like_query_pattern)
-      if _pattern.first.is_a?(Array)
-        raise 'pattern can only be a array of hashes or symbols' if _pattern.length >= 2
-        pattern = _pattern.first
-      else
-        pattern = _pattern
+      scm = (output_schema.present? ? output_schema : recs.like_query_schema)
+      if scm.present?
+        @schemes[recs.klass.to_s] = schema_to_hash(scm)
+      end
+      model_name = recs.klass.to_s
+      schema = @schemes[model_name] || schema_to_hash(nil)
+      _img = image || schema[:image]
+      if _img.present?
+        @images[model_name] = _img
+        @image = true
       end
 
-      associations = []
-      pattern.each do |p|
-        if p.is_a?(Hash)
-          associations += p.keys.map { |k| (k.to_sym >= :image ? nil : k.to_sym) }.compact
+      if parent
+        parent_assoc = recs.klass.reflect_on_association(parent)
+        if !parent_assoc
+          raise "parent «#{parent}» is not a valid association"
         end
+        # parent_polymorphic = parent_assoc.options[:polymorphic]
+        # unless parent_polymorphic
+        #   parent_class_name = parent_assoc.klass.to_s
+        #   parent_schema = @schemes[parent_class_name]
+        #   unless parent_schema
+        #     Rails.logger.debug("WARNING: NO SCHEMA GIVEN FOR «#{parent_class_name}»")
+        #     parent_schema = schema_to_hash(nil)
+        #   end
+        # end
       end
 
-      recs.includes(associations).each do |r|
-        rec_attr = {}
-        pattern.each do |p|
-          if p.is_a?(Hash)
-
-            p.each do |assoc, cols|
+      recs.each do |rec|
 
-              if assoc.to_sym == :image
-
-                # raise 'Missing input: image column for given key :image' unless cols.present?
-                #
-                # # IMAGE COLUMN
-                #
-                # rec_attr[:image] = get_column_value(r, cols)
-                # @image = true
-
-              else
-
-                # ASSOCIATIONS
-
-                sub_records = r.send(assoc)
-                image_column = nil
-
-                _cols = if cols.is_a?(Hash)
-                          image_column = cols[:image]
-                          cols[:values]
-                        elsif cols.is_a?(Enumerable)
-                          cols
-                        else
-                          [cols]
-                        end
-
-                (sub_records.is_a?(Enumerable) ? sub_records : [sub_records]).each do |sub_record|
-                  sub_attr = []
-                  _cols.each do |c|
-                    sub_attr.push(get_column_value(sub_record, c))
-                  end
-
-                  if @length >= @limit || (limit && length >= limit)
-                    @overflow = true
-                    break
-                  else
-                    c = sub_attr.length
-                    @sub_records_columns_count = c if c > @sub_records_columns_count
-                    rec_attr[:associations] ||= {}
-                    rec_attr[:associations][assoc] ||= []
-                    sub_hash = { values: sub_attr, id: sub_record.id, model: sub_record.class.to_s.underscore }
-                    if image_column
-                      sub_hash[:image] = get_column_value(sub_record, image_column)
-                      @sub_records_image = true
-                    end
-                    rec_attr[:associations][assoc].push(sub_hash)
-                    @length += 1
-                    length += 1
-                  end
-                end
-              end
-            end
-          elsif p.is_a?(Symbol) || p.is_a?(String)
-
-            # MAIN RECORD
-
-            rec_attr[:values] ||= []
-            rec_attr[:values].push(get_column_value(r, p))
-            rec_attr[:id] = r.id
-            rec_attr[:model] = r.class.to_s.underscore
-            rec_attr[:image] = r.send(image) if @image
-
-          end
-        end
-        if @length >= @limit || (limit && length >= limit)
+        if @length >= _limit
           @overflow = true
           break
         else
-          c = (image ? 1 : 0) + rec_attr[:values].length
+          r = record_to_hash(rec, schema, image)
+          c = (@image ? 1 : 0) + r[:values].to_a.length
           @columns_count = c if c > @columns_count
-          @data.push(rec_attr)
+          if parent
+            parent_record = rec.send(parent)
+            parent_class_name = parent_record.class
+            parent_key = "#{parent_class_name}#{parent_record.id}"
+
+            unless @data[parent_key]
+              pk = parent_record.class.to_s
+              parent_schema = @schemes[pk]
+              unless parent_schema
+                Rails.logger.debug("WARNING: NO SCHEMA GIVEN FOR «#{pk}»")
+                parent_schema = schema_to_hash(nil)
+              end
+              @data[parent_key] = record_to_hash(parent_record, parent_schema, @images[parent_class_name])
+              @length += 1
+            end
+            @data[parent_key][:children] ||= []
+            @data[parent_key][:children].push(r)
+          else
+            @data["#{rec.class}#{rec.id}"] = r
+          end
           @length += 1
           length += 1
         end
@@ -119,23 +93,94 @@ module LikeQuery
       true
     end
 
-    def result
+    def generate_hash
+      data = @data.map { |_, v| v }
       {
-        data: @data,
+        data: data,
         length: @length,
         overflow: @overflow,
         columns_count: @columns_count,
         sub_records_columns_count: @sub_records_columns_count,
         image: @image,
-        sub_records_image: @sub_records_image
+        # sub_records_image: @sub_records_image,
+        time: Time.now - @start_time
       }
     end
 
     private
 
+    def record_to_hash(record, schema, image)
+      r = {}
+      schema[:values].each do |v|
+        r[:values] ||= []
+        r[:values].push(get_column_value(record, v))
+      end
+      r[:id] = record.id
+      r[:model] = record.class.to_s.underscore
+      r[:image] = record.send(image) if image
+      r
+    end
+
+    def schema_to_hash(schema)
+
+      if schema.is_a?(Array) && schema.first.is_a?(Array)
+        _schema = schema.first
+        raise 'invalid schema format' if schema.length >= 2
+      else
+        _schema = schema
+      end
+
+      if _schema.is_a?(String) || _schema.is_a?(Symbol)
+        { values: [_schema.to_sym] }
+      elsif _schema.is_a?(Array)
+        r = {}
+        _schema.each do |s|
+          if s.is_a?(String) || s.is_a?(Symbol)
+            r[:values] ||= []
+            r[:values].push(s.to_sym)
+          elsif s.is_a?(Hash)
+            s.each do |k, v|
+              if k.to_sym == :image
+                r[:image] = v
+              end
+            end
+          else
+            raise "invalid schema format (#{s}) in schema => «#{schema}»"
+          end
+        end
+        r
+      elsif _schema.is_a?(Hash)
+        _schema
+      elsif !schema.present?
+        { values: [] }
+      else
+        raise "invalid schema format => «#{schema}»"
+      end
+    end
+
     def get_column_value(record, column)
       val = nil
-      column.to_s.split('.').each { |i| val = (val ? val : record).send(i) }
+      if column.is_a?(Hash)
+        r = []
+        column.each do |k, v|
+          if v.is_a?(Array)
+            v.each do |_v|
+              if _v.is_a?(String) || _v.is_a?(Symbol)
+                r.push(get_column_value(record, "#{k}.#{_v}"))
+              else
+                raise "Too deeply nested objects: #{v}"
+              end
+            end
+          elsif v.is_a?(String) || v.is_a?(Symbol)
+            r.push(get_column_value(record, "#{k}.#{v}"))
+          else
+            raise "query column value can only be done by string or symbol, but given: #{v}"
+          end
+        end
+        val = r.join(', ')
+      else
+        column.to_s.split('.').each { |i| val = (val ? val : record).send(i) }
+      end
       (val ? val : '')
     end
 

data/lib/like_query/model_extensions.rb

@@ -1,21 +1,21 @@
 module LikeQuery
   module ModelExtensions
 
-    def like(search_string, *pattern)
+    def like(search_string, *schema)
 
       raise 'like can only be called from a model' if self == ApplicationRecord
 
       queries = nil
       associations = []
-      @like_query_pattern = pattern
+      @like_query_schema = schema
 
       (search_string.is_a?(String) ? search_string.split(' ') : search_string).each do |s|
         str = "%#{s}%"
         q = nil
-        if pattern.first.is_a?(Array) && pattern.length >= 2
-          raise "only one array can be given: Either pattern as one array or as multiple args, not as array"
+        if schema.first.is_a?(Array) && schema.length >= 2
+          raise "only one array can be given: Either schema as one array or as multiple args, not as array"
         end
-        (pattern.first.is_a?(Array) ? pattern.first : pattern).each do |p|
+        (schema.first.is_a?(Array) ? schema.first : schema).each do |p|
           if p.is_a?(Symbol) || p.is_a?(String)
             _q = arel_table[p].matches(str)
             q = (q ? q.or(_q) : _q)
@@ -42,28 +42,25 @@ module LikeQuery
         queries = (queries ? queries.and(q) : q)
       end
 
-      @query = if associations.present?
-                  left_outer_joins(associations).where(
-                    queries
-                  )
-                else
-                  where(
-                    queries
-                  )
-                end
+      if associations.present?
+        left_outer_joins(associations).where(
+          queries
+        )
+      else
+        where(
+          queries
+        )
+      end
     end
 
-    def like_result(*pattern, limit: 50, image: nil)
-
-
-      raise 'has to be called behind #like' unless @like_query_pattern.is_a?(Array)
+    def generate_hash(output_schema = nil, limit: 50, image: nil)
       c = LikeQuery::Collect.new(limit)
-      c.receive(*pattern, limit: limit, image: image){@query}
-      c.result
+      c.collect(output_schema, limit: limit, image: image) { all }
+      c.generate_hash
     end
 
-    def like_query_pattern
-      @like_query_pattern
+    def like_query_schema
+      @like_query_schema
     end
 
   end

data/lib/like_query/version.rb

@@ -1,3 +1,3 @@
 module LikeQuery
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: like_query
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - christian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-28 00:00:00.000000000 Z
+date: 2023-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails