like_query 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 16e59dc644a7dc678761df657971741c56ac76b3a0dcd773cb51b9e7ed241ecf
+  data.tar.gz: 7abd672371cb6ec62799ed15d882f41ed2d88a66f5828f25541eaa96cf1d49ce
+SHA512:
+  metadata.gz: adb0afaf4ef8a6bc4a5c1c5571958702c751405a55a9f50954f71c63e2ac6283e3f1b62488778ba0ecf3d144dd98dbad62c1585e7ed86e8c6c65ea40b6a11a6d
+  data.tar.gz: 3fb0bd08e5e6c3853f1ab63ae306080a17354d277c7ac0ede1310404c9e2f68777edf6df0770161bc13bc4247efffd5d5c9b7229d1442ffbe4df9f7897d53eaf

data/README.md

@@ -0,0 +1,130 @@
+# like_query
+
+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. 
+
+This query generator is built for this two purposes.
+
+## Installation
+
+add
+
+`gem "like_query"`
+
+to Gemfile
+
+this adds the methods `#like` and `#like_result` to all models.
+
+## Usage
+
+**.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
+# => searches by: "where name like '%fir%' or number like '%fir%'"
+# => queries are built with Article.arel_table[:name].matches('%fir%')
+
+Article.like(['fir', 'ambühl'], :name, :number, customer: :name)
+# => :customer is the name of the association
+# => search-tag as array adds a ".and(where( ... like '%ambühl%'))" for all scoped columns
+# => would also find art1
+```
+
+**.like_result**
+
+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)
+# returns: 
+# { 
+#   :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
+```
+
+**Class LikeQuery::Collect** 
+
+```ruby
+cust = Customer.create(name: 'Müller')
+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) }
+# => would add 4 articles to the result hash because of limit
+
+c.receive { Customer.like('any-art', :name, articles: :name) }
+# => limit is already exhausted: does nothing
+# => otherwise it would add Customers to the result hash
+
+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, 
+  :sub_records_columns_count=>1
+}
+```
+
+## 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) 
+
+- [ ] [Set up project integrations](https://gitlab.com/sedl/like_query/-/settings/integrations)
+
+## Collaborate with your team
+
+- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
+- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
+- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
+- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
+- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
+
+## Test and Deploy
+
+Use the built-in continuous integration in GitLab.
+
+- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
+- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
+- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
+- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
+- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
+
+***
+
+## Hope this helps
+
+I created this only for one of my customers. If it may help others, i am happy.
+
+## License
+
+[MIT](https://mit-license.org/)

data/lib/like_query/collect.rb

@@ -0,0 +1,95 @@
+module LikeQuery
+  class Collect
+    def initialize(limit = 50)
+      @limit = limit
+      @length = 0
+      @data = []
+      @overflow = false
+      @columns_count = 0
+      @sub_records_columns_count = 0
+    end
+
+    def receive(*result_pattern, image: nil, &block)
+
+      return false if @length >= @limit
+
+      recs = yield
+
+      pattern = (result_pattern.present? ? result_pattern : recs.like_query_pattern)
+
+      associations = []
+      pattern.each do |p|
+        if p.is_a?(Hash)
+          associations += p.keys
+        end
+      end
+
+      recs.includes(associations).each do |r|
+        rec_attr = {}
+        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
+
+              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[:id] = r.id
+
+          end
+        end
+        if @length >= @limit
+          @overflow = true
+          break
+        elsif @length < @limit
+          c = (image ? 1 : 0) + rec_attr[:attributes].length
+          @columns_count = c if c > @columns_count
+          @data.push(rec_attr)
+          @length += 1
+        end
+      end
+
+      true
+    end
+
+    def result
+      {
+        data: @data,
+        length: @length,
+        overflow: @overflow,
+        columns_count: @columns_count,
+        sub_records_columns_count: @sub_records_columns_count
+      }
+    end
+
+  end
+end

data/lib/like_query/model_extensions.rb

@@ -0,0 +1,70 @@
+module LikeQuery
+  module ModelExtensions
+
+    def like(search_string, *pattern)
+
+      raise 'like can only be called from a model' if self == ApplicationRecord
+
+      queries = nil
+      associations = []
+      @like_query_pattern = pattern
+
+      (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"
+        end
+        (pattern.first.is_a?(Array) ? pattern.first : pattern).each do |p|
+          if p.is_a?(Symbol) || p.is_a?(String)
+            _q = arel_table[p].matches(str)
+            q = (q ? q.or(_q) : _q)
+          elsif p.is_a?(Hash)
+            p.each do |k, v|
+              assoc = reflect_on_association(k)
+              raise "Unknown association: :#{k}" unless assoc.present?
+              associations.push(k.to_sym) unless associations.include?(k.to_sym)
+              if v.is_a?(Symbol) || v.is_a?(String)
+                _q = assoc.klass.arel_table[v].matches(str)
+                q = (q ? q.or(_q) : _q)
+              elsif v.is_a?(Array)
+                v.each do |_v|
+                  _q = assoc.klass.arel_table[_v].matches(str)
+                  q = (q ? q.or(_q) : _q)
+                end
+              else
+                raise "unknown element: #{p}"
+              end
+            end
+          end
+
+        end
+        queries = (queries ? queries.and(q) : q)
+      end
+
+      @query = 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)
+      c = LikeQuery::Collect.new(limit)
+      c.receive(*pattern){@query}
+      c.result
+    end
+
+    def like_query_pattern
+      @like_query_pattern
+    end
+
+  end
+end

data/lib/like_query/railtie.rb

@@ -0,0 +1,7 @@
+module LikeQuery
+  class Railtie < Rails::Railtie
+    config.after_initialize do
+      ApplicationRecord.send(:extend, LikeQuery::ModelExtensions)
+    end
+  end
+end

data/lib/like_query/version.rb

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

data/lib/like_query.rb

@@ -0,0 +1,5 @@
+require 'like_query/version'
+require 'like_query/model_extensions'
+require 'like_query/railtie'
+require 'like_query/collect'
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: like_query
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- christian
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.3
+description: helper for building active record calls.
+email:
+- christian@sedlmair.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/like_query.rb
+- lib/like_query/collect.rb
+- lib/like_query/model_extensions.rb
+- lib/like_query/railtie.rb
+- lib/like_query/version.rb
+homepage: https://gitlab.com/sedl/like_query
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://gitlab.com/sedl/like_query
+  source_code_uri: https://gitlab.com/sedl/like_query
+  changelog_uri: https://gitlab.com/sedl/like_query
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: helper for building active record calls.
+test_files: []