like_query 0.0.7 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 310d79668485fd3063a1e6c938d0c1bb925bf988e08cd93a7430c256c1f5cc50
-  data.tar.gz: 5b6c403c42b64078d728171d9c977ae267d482954e666b0afbf9068cbba8795c
+  metadata.gz: '09331b69e73a5710ea602d9f20c26a11453589480b8be7130bb678a430c13f17'
+  data.tar.gz: 82eb9cb8c04f0c3d0d6fa7bccd22fde4cf9468a3aec31f533f2ce8d2fb9d0765
 SHA512:
-  metadata.gz: 43a1cc9aab0e0df7fc3f8bf9fca7d2e4c0e44a72857294d779a8af8c633ff56ad54bb6921c10675661ae9ea533d1ad2f82ac2bd56cadd75e061612b6b4302132
-  data.tar.gz: ecf6ce1eaff200351093c36073e6e320ddf9645d2ba926f2098c2fbef815d4bc0a921cd2d4f53b09827d1cccdb82073f432a3c6c21695628c58522cd18e2e483
+  metadata.gz: '090626d9d0b0afe7879c6a7053e9ab3e87fd7e3faa797015ab47bbc258c41ee19bc2666fda4bb0bfacb8c563e871e9f75c2e959275836d0233955f3cd7fdbdad'
+  data.tar.gz: c1835c63c13d9b09d084b34b6b7ae24db6cf890317166e130e13daf56f8f8baabe6d4ae49bc9f36b94798276caa07853fbca6eee0f58978bca143dfecd7a76d1

data/README.md

@@ -1,14 +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` 
-- javascript component / dropdown on the front, in our case
-built with svelte, which receives a json and renders a table in a dropdown.
+- 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 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)
+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
 
@@ -20,13 +19,23 @@ to Gemfile
 
 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**
 
 ```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)
 # => <Article:0x00000001067107a8 id: ...>
@@ -41,8 +50,7 @@ Article.like(['fir', 'ambühl'], :name, :number, customer: :name)
 
 **#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
+returns a hash that can easily be transformed by `#to_json` for a javascript frontend, for example
 
 ```ruby
 customer = Customer.create(name: 'Ambühl')
@@ -51,14 +59,22 @@ art1 = Article.create(name: 'first', number: '01', customer: customer)
 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).generate_hash(:number, limit: 10)
@@ -71,42 +87,56 @@ Article.like('fir', :name).generate_hash(:number, limit: 10)
 **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.collect { Article.like('any-art', :name) }
-# => would add 4 articles to the result hash because of limit
-
-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.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 one record looks like:
+The resulting hash for a record looks like this:
 
 ```ruby
 {
@@ -117,7 +147,7 @@ The resulting hash for one record looks like:
 }
 ```
 
-The resulting hash or json is built from the schema, which can look like:
+The resulting hash or json is built from the schema, which can look like this:
 
 ```ruby
 :number
@@ -138,22 +168,22 @@ or
 }
 ```
 
-There is a query schema and a output schema.
-If no output schema is defined, query schema is used for both
+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 output schema is given, result can be different to the search scope:
+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 reminds the schema for a model:
+The collect class remembers the schema for a model:
 
 ```ruby
 c = LikeQuery::Collect.new
@@ -164,8 +194,8 @@ 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
+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
@@ -178,15 +208,14 @@ Otherwise `#generate_hash` would not know which values it should return
 
 **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.
+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 lots of database queries, depending on your structure or if or which method is behind the called names.
+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,7 +1,13 @@
 module LikeQuery
   class Collect
-    def initialize(limit = 20)
-      @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 = {}
       @overflow = false
@@ -18,9 +24,7 @@ module LikeQuery
       @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')
+    def collect(output_schema = nil, limit: nil, parent: nil, image: nil, url: nil, &block)
 
       _limit = (limit ? (@limit && @limit < limit ? @limit : limit) : @limit)
       return false if @length >= _limit
@@ -45,15 +49,6 @@ module LikeQuery
         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.each do |rec|
@@ -62,19 +57,17 @@ module LikeQuery
           @overflow = true
           break
         else
-          r = record_to_hash(rec, schema, image)
-          c = (@image ? 1 : 0) + r[:values].to_a.length
-          @columns_count = c if c > @columns_count
+
           if parent
             parent_record = rec.send(parent)
-            parent_class_name = parent_record.class
+            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]
-              pk = parent_record.class.to_s
-              parent_schema = @schemes[pk]
+              parent_schema = @schemes[parent_class_name]
               unless parent_schema
-                Rails.logger.debug("WARNING: NO SCHEMA GIVEN FOR «#{pk}»")
+                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])
@@ -83,8 +76,11 @@ module LikeQuery
             @data[parent_key][:children] ||= []
             @data[parent_key][:children].push(r)
           else
+            r = record_to_hash(rec, schema, image, url: url)
             @data["#{rec.class}#{rec.id}"] = r
           end
+          c = (@image ? 1 : 0) + r[:values].to_a.length
+          @columns_count = c if c > @columns_count
           @length += 1
           length += 1
         end
@@ -107,17 +103,30 @@ module LikeQuery
       }
     end
 
+    def generate_json
+      generate_hash.to_json
+    end
+
     private
 
-    def record_to_hash(record, schema, image)
+    def record_to_hash(record, schema, image, parent = nil, url: nil)
       r = {}
-      schema[:values].each do |v|
+      schema[:values].each do |k|
+        v = get_column_value(record, k)
         r[:values] ||= []
-        r[:values].push(get_column_value(record, v))
+        r[:values].push(v)
+        r[:attributes] ||= {}
+        r[:attributes][k] = v
       end
       r[:id] = record.id
-      r[:model] = record.class.to_s.underscore
+      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[:url]  = url.yield(record) if url
       r
     end
 

data/lib/like_query/model_extensions.rb

@@ -53,12 +53,18 @@ module LikeQuery
       end
     end
 
-    def generate_hash(output_schema = nil, limit: 50, image: nil)
+    def generate_hash(output_schema = nil, limit: 50, image: nil, url: nil)
       c = LikeQuery::Collect.new(limit)
-      c.collect(output_schema, limit: limit, image: image) { all }
+      c.collect(output_schema, limit: limit, image: image, url: url) { all }
       c.generate_hash
     end
 
+    def generate_json(output_schema = nil, limit: 50, image: nil, url: nil)
+      c = LikeQuery::Collect.new(limit)
+      c.collect(output_schema, limit: limit, image: image, url: url) { all }
+      c.generate_json
+    end
+
     def like_query_schema
       @like_query_schema
     end

data/lib/like_query/version.rb

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

metadata

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