like_query 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84fed18b7e4d5122c2d760bdf76c27bcc7094d7e44a140e0b42d8dff1d574827
-  data.tar.gz: adb485617d123592abd58140a086073da2745eef15d25a4c84a40635ae1e92f7
+  metadata.gz: c46b541528f87a7bd078c47eaa7bc264503ff6b1c333af0caf18aacb2beea24c
+  data.tar.gz: 8d5d867c0707f5cfe827a4d55082434d5e02bec45528f04737a8927746388fcd
 SHA512:
-  metadata.gz: 5e7b363e0409f55048163956d485b2b93668eddb3f1de4b49daca8aaffafd2f9866c4a3dfc6abf6b12fecbfdae5e190fe69e8265c162fac97b7e3aff0bfb858d
-  data.tar.gz: 4b5a6c0aff2b9a4c1f7c7fa2f08da962e6e4937146a351f8a2c57d8946f2880051a4b1d209a997fbdf4f0eac0e208dcf379603530bc0413b298e8ee8ec6f39e8
+  metadata.gz: aaf145febd6f66ee1549dd8d2d5b5285d1c191f6e5759519ec5053eb88a6055c087411ab3d4962afb282d3c208f439f9a7fad5f852797a3466e93c22238f6aba
+  data.tar.gz: 7097e44705ad35add8233002e3db0e0b20330525197a3dcc4d15070e43d38f03221c3f2e9902e8677ee6e273e68e6eaf4490d6bc825ce82fdce2722d0301dd2d

data/README.md

@@ -1,10 +1,13 @@
 # like_query
 
-For my customers apps, newly built with turbo, search queries are mostly for two purposes:
+For my clients' newly built applications with Turbo, search queries mostly serve 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.
+This query generator is built for these two purposes
+
+Modules like one of the svelte components mentioned above have a total response time (from pressing a key until the result is rendered) of about 60 msec, while with turbo the same time is mostly around 140-160 msec. The gem itself, from querying the database to producing a hash, has a time of about 3 msec. These results are for small data sets (e.g. 30 records found).
 
 ## Installation
 
@@ -14,18 +17,28 @@ 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.
+
+**Config**
+
+You can set a default limit by
+
+```ruby
+  config.x.like_query.limit = 20
+```
+
+This can be overriden by calling the methods
 
 ## Usage
 
-**.like**
+**#like**
 
 ```ruby
 customer = Customer.create(name: 'Ambühl')
-art1 = Article.create(name: 'first', number: '01', customer: customer)
+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 +48,174 @@ Article.like(['fir', 'ambühl'], :name, :number, customer: :name)
 # => would also find art1
 ```
 
-**.like_result**
-
-returns a hash that can easily be transformed by `#to_json` for a javascript-frontend, by example
+**#generate_hash**
 
-can only be chained behind `#like`. 
+returns a hash that can easily be transformed by `#to_json` for a javascript frontend, for example
 
 ```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=>[
-    {
-      :attributes=>[[:name, "first"]], 
-      :id=>1}], 
-  :length=>1, 
-  :overflow=>false, 
-  :columns_count=>1, 
-  :sub_records_columns_count=>0
+{
+  data: 
+    [
+      {
+        values: ["Müller"], 
+        attributes: {"customer.name": "Müller"}, 
+        id: 1, 
+        model: "Article"
+      }, 
+      ...
+    ], 
+  length: 4, 
+  overflow: true, 
+  columns_count: 2, 
+  sub_records_columns_count: 0, 
+  image: false, 
+  time: 18.282996
 }
 
-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)}
+cust = Customer.create(name: 'cust')
+Article.create(name: 'screw', customer: cust)
 
 c = LikeQuery::Collect.new(4)
 # => 4 is the limit
 
-c.receive { 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) }
-# => limit is already exhausted: does nothing
-# => otherwise it would add Customers to the result hash
-
+c.set_schema(Customer, :name)
+c.collect(parent: :customer) { Article.like('screw', :name) }
+c.generate_json
 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": [
+    {
+      "values": [
+        "cust"
+      ],
+      "attributes": {
+        "name": "cust"
+      },
+      "id": 1,
+      "model": "Customer",
+      "children": [
+        {
+          "values": [
+            "screw"
+          ],
+          "attributes": {
+            "name": "screw"
+          },
+          "id": 1,
+          "model": "Customer.Article",
+          "parent_id": 1,
+        }
+      ]
     }
-  ], 
-  :length=>3, 
-  :overflow=>false, 
-  :columns_count=>1, 
-  :sub_records_columns_count=>1
+  ],
+  "length": 2,
+  "overflow": false,
+  "columns_count": 1,
+  "sub_records_columns_count": 0,
+  "image": false,
+  "time": 0.0075
+}
+```
+
+**query schema and result_schema**
+
+The resulting hash for a record looks like this:
+
+```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 this:
+
+```ruby
+:number
+```
+
+or
+
+```ruby
+[:number, :name]
+```
+
+or
+
+```ruby
+{
+  values: [:number, :name],
+  image: :name_of_a_column_or_method
 }
 ```
 
+There is a query schema and an output schema.
+If no output schema is defined, the query schema is used for both.
+
+```ruby
+Article.like('first', :name).generate_hash
+# => :values => ["first"]
+```
+
+If an output schema is specified, the result may differ from the search scope:
+
+```ruby
+Article.like('first', :name).generate_hash(:number, :name)
+# => :values => ["012", "first"]
+```
+
+The collect class remembers 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**
+
+When a child returns its parent, the schema for the parent must be given.
+Otherwise `#generate_hash` would not know what values to 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 the schema are processed by the `#send` method, but recursively.
+This means, for example, that for an `article` with the given key `customer.employees.contact_details.email` in the schema would return the name of the associated customer.
+
+ATTENTION: This can trigger a lot 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 not included in this gem, they can be found in [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,86 @@
 module LikeQuery
   class Collect
-    def initialize(limit = 50)
-      @limit = limit
+    def initialize(limit = nil)
+      if limit
+        @limit = limit
+      elsif Rails.configuration.x.like_query.limit
+        @limit = Rails.configuration.x.like_query.limit
+      else
+        @limit = nil
+      end
       @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 set_schema(model, schema)
+      @schemes[model.to_s] = schema_to_hash(schema)
     end
 
-    def receive(*result_pattern, limit: nil, image: nil, &block)
+    def collect(output_schema = nil, limit: nil, parent: nil, image: nil, &block)
 
-      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
       end
 
-      recs.includes(associations).each do |r|
-        rec_attr = {}
-        pattern.each do |p|
-          if p.is_a?(Hash)
+      recs.each do |rec|
 
-            p.each do |assoc, cols|
-
-              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
+        if @length >= _limit
+          @overflow = true
+          break
+        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
+          if parent
+            parent_record = rec.send(parent)
+            r = record_to_hash(rec, schema, image, parent_record)
+            parent_class_name = parent_record.class.to_s
+            parent_key = "#{parent_class_name}#{parent_record.id}"
+
+            unless @data[parent_key]
+              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
+              @data[parent_key] = record_to_hash(parent_record, parent_schema, @images[parent_class_name])
+              @length += 1
             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
-
+            @data[parent_key][:children] ||= []
+            @data[parent_key][:children].push(r)
+          else
+            r = record_to_hash(rec, schema, image)
+            @data["#{rec.class}#{rec.id}"] = r
           end
-        end
-        if @length >= @limit || (limit && length >= limit)
-          @overflow = true
-          break
-        else
-          c = (image ? 1 : 0) + rec_attr[:values].length
+          c = (@image ? 1 : 0) + r[:values].to_a.length
           @columns_count = c if c > @columns_count
-          @data.push(rec_attr)
           @length += 1
           length += 1
         end
@@ -119,23 +89,106 @@ 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
 
+    def generate_json
+      generate_hash.to_json
+    end
+
     private
 
+    def record_to_hash(record, schema, image, parent = nil)
+      r = {}
+      schema[:values].each do |k|
+        v = get_column_value(record, k)
+        r[:values] ||= []
+        r[:values].push(v)
+        r[:attributes] ||= {}
+        r[:attributes][k] = v
+      end
+      r[:id] = record.id
+      if parent
+        r[:model] = "#{parent.class.to_s}.#{record.class}"
+        r[:parent_id] = parent.id
+      else
+        r[:model] = record.class.to_s
+      end
+      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,31 @@ 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)
-
+    def generate_hash(output_schema = nil, limit: 50, image: nil)
+      c = LikeQuery::Collect.new(limit)
+      c.collect(output_schema, limit: limit, image: image) { all }
+      c.generate_hash
+    end
 
-      raise 'has to be called behind #like' unless @like_query_pattern.is_a?(Array)
+    def generate_json(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_json
     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.8"
 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.8
 platform: ruby
 authors:
 - christian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-28 00:00:00.000000000 Z
+date: 2023-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails