like_query 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16e59dc644a7dc678761df657971741c56ac76b3a0dcd773cb51b9e7ed241ecf
-  data.tar.gz: 7abd672371cb6ec62799ed15d882f41ed2d88a66f5828f25541eaa96cf1d49ce
+  metadata.gz: 12f503e7aa188d223e922496909dabff55b2ff5c843e18ed23ae5525a5190dfa
+  data.tar.gz: fa7edce57c33d96b1c040767f5e41a95d32573b78cbc259ade1411178748a941
 SHA512:
-  metadata.gz: adb0afaf4ef8a6bc4a5c1c5571958702c751405a55a9f50954f71c63e2ac6283e3f1b62488778ba0ecf3d144dd98dbad62c1585e7ed86e8c6c65ea40b6a11a6d
-  data.tar.gz: 3fb0bd08e5e6c3853f1ab63ae306080a17354d277c7ac0ede1310404c9e2f68777edf6df0770161bc13bc4247efffd5d5c9b7229d1442ffbe4df9f7897d53eaf
+  metadata.gz: 50b1ff03fd06283c506b70a20867261236cae2e2d12f00732efb3a42da474761d817163c77fa8a6eda205b0a96812bb3d7347b86b4adf4184287f53ee1b7dabb
+  data.tar.gz: 3dd63ff9264451c79616e112885329ddff287ac34abb0dc5df438cba2de4402c8756b30aa65b7ae085c55f0f20e4d1919d02b847032a2b959eee3a55ee38737e

data/README.md

@@ -75,7 +75,7 @@ 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
 
@@ -83,14 +83,18 @@ c.result
 # => would return anything like:
 {
   :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

@@ -9,18 +9,25 @@ module LikeQuery
       @sub_records_columns_count = 0
     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 +36,84 @@ 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
-                end
+              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)
+
+              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
+
+
+                #_cols = (cols.is_a?(Enumerable) ? cols : [cols])
+                (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 }
+                    sub_hash[:image] = get_column_value(sub_record, image_column) if image_column
+                    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) }
+            # 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)])
+            # if image
+            #   img = nil
+            #   image.to_s.split('.').each { |i| img = (img ? img : r).send(i) }
+            #   rec_attr[:image] = img
+            # end
             rec_attr[:id] = r.id
 
           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
 
@@ -91,5 +130,13 @@ module LikeQuery
       }
     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.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: like_query
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - christian