like_query 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16e59dc644a7dc678761df657971741c56ac76b3a0dcd773cb51b9e7ed241ecf
-  data.tar.gz: 7abd672371cb6ec62799ed15d882f41ed2d88a66f5828f25541eaa96cf1d49ce
+  metadata.gz: eb533ef11731913bdf3356f5177354cbdc85b4506ba2aae392f7149b7fe7e6d2
+  data.tar.gz: 4b256fb9aa9336559e6a9fc529e7376fae1f6fc09da1cd9b662eb18dd770c5dd
 SHA512:
-  metadata.gz: adb0afaf4ef8a6bc4a5c1c5571958702c751405a55a9f50954f71c63e2ac6283e3f1b62488778ba0ecf3d144dd98dbad62c1585e7ed86e8c6c65ea40b6a11a6d
-  data.tar.gz: 3fb0bd08e5e6c3853f1ab63ae306080a17354d277c7ac0ede1310404c9e2f68777edf6df0770161bc13bc4247efffd5d5c9b7229d1442ffbe4df9f7897d53eaf
+  metadata.gz: 6fdeaadc79ef10c0690dff7d0213d8241ea0f01679fdb1494d95bb4b9f975813ef5319ae2639a431bb291793ca74ceb1902ca11e9ba5ad9b7423f114c4b3ed0e
+  data.tar.gz: 7d53223f4fe56b448e28aebb46e3db3f400de45b7698a5a3526543612180f4a937951733ade9cff093e177e9d4340fd50b90cc132ea64be811cde32ab2440e7b

data/README.md

@@ -47,22 +47,24 @@ art1 = Article.create(name: 'first', number: '01', customer: customer)
 
 Article.like('fir', :name).like_result(limit: 10)
 # returns: 
-# { 
-#   :data=>[
-#     {
-#       :attributes=>[[:name, "first"]], 
-#       :id=>1}], 
-#   :length=>1, 
-#   :overflow=>false, 
-#   :columns_count=>1, 
-#   :sub_records_columns_count=>0
-# }
+{ 
+  :data=>[
+    {
+      :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)
 # 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.
+
 **Class LikeQuery::Collect** 
 
 ```ruby
@@ -75,22 +77,26 @@ c = LikeQuery::Collect.new(4)
 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, articles: :name) }
+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.result
-# => would return anything like:
+# => would return anything like (this output is from different code!!):
 {
   :data=>[
-    {:attributes=>[["customer.name", "Müller"]], :id=>1}, 
-    {:attributes=>[["customer.name", "Müller"]], :id=>2}, 
-    {
-      :attributes=>[[:name, "second"], [:number, "01"]], :id=>3, 
-      :associations=>{:customer=>[{:attributes=>[[:name, "Ambühl"]], :id=>2}]}}], 
-  :length=>4, 
-  :overflow=>true, 
-  :columns_count=>2, 
+    {: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
 }
 ```

data/lib/like_query/collect.rb

@@ -7,20 +7,29 @@ module LikeQuery
       @overflow = false
       @columns_count = 0
       @sub_records_columns_count = 0
+      @image = false
+      @sub_records_image = false
     end
 
-    def receive(*result_pattern, image: nil, &block)
+    def receive(*result_pattern, limit: nil, image: nil, &block)
 
       return false if @length >= @limit
+      length = 0
 
       recs = yield
 
-      pattern = (result_pattern.present? ? result_pattern : recs.like_query_pattern)
+      _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
+      end
 
       associations = []
       pattern.each do |p|
         if p.is_a?(Hash)
-          associations += p.keys
+          associations += p.keys.map { |k| (k.to_sym >= :image ? nil : k.to_sym) }.compact
         end
       end
 
@@ -29,52 +38,79 @@ module LikeQuery
         pattern.each do |p|
           if p.is_a?(Hash)
 
-            # ASSOCIATED RECORDS
-
             p.each do |assoc, cols|
-              rec_attr[:associations] ||= {}
-              rec_attr[:associations][assoc] ||= []
-              sub = r.send(assoc)
-              _cols = (cols.is_a?(Enumerable) ? cols : [cols])
-              (sub.is_a?(Enumerable) ? sub : [sub]).each do |_sub|
-                sub_attr = []
-                _cols.each do |c|
-                  sub_attr.push([c, _sub.send(c)])
-                end
 
-                if @length >= @limit
-                  @overflow = true
-                  break
-                elsif @length < @limit
-                  c = sub_attr.length
-                  @sub_records_columns_count = c if c > @sub_records_columns_count
-                  rec_attr[:associations][assoc] ||= []
-                  rec_attr[:associations][assoc].push({ attributes: sub_attr, id: _sub.id })
-                  @length += 1
+              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[:attributes]
+                        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([c, sub_record.send(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 = { attributes: 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
 
-            v = nil
-            p.to_s.split('.').each { |_p| v = (v ? v : r).send(_p) }
             rec_attr[:attributes] ||= []
-            rec_attr[:attributes].push([p, v])
+            rec_attr[:attributes].push([p, get_column_value(r, p)])
             rec_attr[:id] = r.id
+            rec_attr[:model] = r.class.to_s.underscore
 
           end
         end
-        if @length >= @limit
+        if @length >= @limit || (limit && length >= limit)
           @overflow = true
           break
-        elsif @length < @limit
+        else
           c = (image ? 1 : 0) + rec_attr[:attributes].length
           @columns_count = c if c > @columns_count
           @data.push(rec_attr)
           @length += 1
+          length += 1
         end
       end
 
@@ -87,9 +123,19 @@ module LikeQuery
         length: @length,
         overflow: @overflow,
         columns_count: @columns_count,
-        sub_records_columns_count: @sub_records_columns_count
+        sub_records_columns_count: @sub_records_columns_count,
+        image: @image,
+        sub_records_image: @sub_records_image
       }
     end
 
+    private
+
+    def get_column_value(record, column)
+      val = nil
+      column.to_s.split('.').each { |i| val = (val ? val : record).send(i) }
+      val
+    end
+
   end
 end

data/lib/like_query/model_extensions.rb

@@ -58,7 +58,7 @@ module LikeQuery
 
       raise 'has to be called behind #like' unless @like_query_pattern.is_a?(Array)
       c = LikeQuery::Collect.new(limit)
-      c.receive(*pattern){@query}
+      c.receive(*pattern, limit: limit, image: image){@query}
       c.result
     end
 

data/lib/like_query/version.rb

@@ -1,3 +1,3 @@
 module LikeQuery
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

metadata

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