stretchy-model 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a85f7bffcc11c54366d4cae7fec47b91341425e06b7f1c8a6269e0b23d4e649b
-  data.tar.gz: cd0b9314fa734aa7af7179f12ed00626a17bc869186f82088158bfca87c8d915
+  metadata.gz: d7dff610329ad21128c58429c6f9d08b62138a7fad9adb0f610984bd744db1cf
+  data.tar.gz: 915256c1b413dd34d4777097b878f0c2c7886342b5d8dcfedc2159a405b3bdf2
 SHA512:
-  metadata.gz: e193c837695100177eac9888841b14243596dfc9694515696ab1a9934174287c821cf52b2ca165e3f3eda04de9ba16c7c7330cb187641d71229d322c06674977
-  data.tar.gz: 21ace7b64f85d505a05b61b89b5b85d9d2af34941b57672da45f70e6c8736e8b9451c59891fef7d0795f8b54076cffd88bfc141fcd4da1c1f8ffaddcf8276697
+  metadata.gz: 66f98b878a8e78d9d79b53f05edf89a8d4a61d4fd3a5b98d93ef349491c7c87f36d4cadb857b8be5e9e992308609c22d1abc45703eb39b95e78240d87c6ae081
+  data.tar.gz: 0eabc3b84d0aecb0f8051bf53238ec6da5d431c7ff5d0f7c3be20888a20252504e3324c7b558fe455d90c2cf0db827b1d0440e6d03d211569ed8ed7d60dade01

data/README.md

@@ -98,16 +98,6 @@ Model.bulk_in_batches(records, size: 100) do |batch|
 end
 ```
 
-
-## Instrumentation
-```ruby
-Blanket.first
-```
-
-```sh
-Blanket (6.322ms) curl -X GET 'http://localhost:9200/blankets/_search?size=1' -d '{"sort":{"date":"desc"}}'
-```
-
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -131,6 +121,12 @@ rails credentials:edit
 ```yaml
 elasticsearch:
    url: localhost:9200
+
+# or opensearch
+# opensearch:
+#    host: https://localhost:9200
+#    user: admin
+#    password: admin
 ```
 
 #### Create an initializer 
@@ -154,6 +150,21 @@ After checking out the repo, run `bin/setup` to install dependencies. You can al
 > Full documentation on [Elasticsearch Query DSL and Aggregation options](https://github.com/elastic/elasticsearch-rails/tree/main/elasticsearch-persistence)
 
 ## Testing
+<details>
+<summary>Act</summary>
+
+Run github action workflow locally
+
+```sh
+brew install act --HEAD
+```
+
+```sh
+act -P ubuntu-latest=ghcr.io/catthehacker/ubuntu:runner-latest
+```
+
+</details>
+
 <details>
 <summary>Elasticsearch</summary>
 

data/Rakefile

@@ -2,3 +2,95 @@
 
 require "bundler/gem_tasks"
 task default: %i[]
+
+require 'octokit' 
+require 'versionomy'
+require 'rainbow'
+
+def determine_current_version
+  # Load current version
+  load 'lib/stretchy/version.rb'
+  current_version = Versionomy.parse(Stretchy::VERSION)
+end
+
+def determine_new_version(version)
+  # Load current version
+  current_version = determine_current_version
+
+  # Determine new version
+  case version.to_sym
+  when :major
+    current_version.bump(:major)
+  when :minor
+    current_version.bump(:minor)
+  when :patch
+    current_version.bump(:tiny)
+  else
+    version =~ /\Av?\d+\.\d+\.\d+\z/ ? Versionomy.parse(version).to_s.gsub(/v/,'') : current_version
+  end
+end
+
+def create_release_branch(new_version, base_branch)
+  system("git stash save 'Changes before creating release branch'")
+  system("git fetch origin #{base_branch}")
+  branch_name = "release/v#{new_version}"
+  system("git checkout -b #{branch_name} #{base_branch}")
+  branch_name
+end
+
+def update_version_file(new_version)
+  # Update lib/stretchy/version.rb
+  File.open('lib/stretchy/version.rb', 'w') do |file|
+    file.puts "module Stretchy\n  VERSION = '#{new_version}'\nend"
+  end
+end
+
+def commit_and_push_changes(new_version, branch_name)
+  system("git add lib/stretchy/version.rb")
+  system("git commit -m 'Bump version to v#{new_version}'")
+  system("git tag v#{new_version}")
+  system("git push origin #{branch_name} --tags -f")
+end
+
+def create_pull_request(new_version, base_branch, branch_name)
+  # Create a pull request
+  client = Octokit::Client.new(access_token: ENV['GH_TOKEN'])
+  client.create_pull_request('theablefew/stretchy', base_branch, branch_name, "Release v#{new_version}")
+end
+
+namespace :publish do
+  desc "Create a release"
+  task :release, [:version, :base_branch] do |t, args|
+    args.with_defaults(version: :patch, base_branch: 'main')
+    version = args[:version]
+    base_branch = args[:base_branch]
+  
+    old_version = determine_current_version
+    new_version = determine_new_version(version)
+    puts Rainbow("Bumping version from #{old_version} to #{new_version}").green
+    branch_name = create_release_branch(new_version, base_branch)
+    begin
+    update_version_file(new_version)
+    commit_and_push_changes(new_version, branch_name)
+    create_pull_request(new_version, base_branch, branch_name)
+    rescue => e
+      puts "Error: #{e.message}"
+      puts "Rolling back changes"
+      system("git tag -d v#{new_version}")
+      system("git checkout #{base_branch}")
+      system("git branch -D #{branch_name}")
+    end
+  end
+
+  task :major do
+    Rake::Task['publish:release'].invoke('major')
+  end
+
+  task :minor do
+    Rake::Task['publish:release'].invoke('minor')
+  end
+
+  task :patch do
+    Rake::Task['publish:release'].invoke('patch')
+  end
+end

data/lib/stretchy/attributes/transformers/keyword_transformer.rb

@@ -0,0 +1,85 @@
+module Stretchy
+  module Attributes
+    module Transformers
+      class KeywordTransformer
+
+          KEYWORD_AGGREGATION_KEYS = [:terms, :rare_terms, :significant_terms, :cardinality, :string_stats]
+
+          attr_reader :attribute_types
+
+          def initialize(attribute_types)
+            @attribute_types = attribute_types
+          end
+
+          def cast_value_keys
+            values.transform_values do |value|
+              case value
+              when Array
+                value.map { |item| transform_keys_for_item(item) }
+              when Hash
+                transform_keys_for_item(value)
+              else
+                value
+              end
+            end
+          end
+          
+          def keyword?(arg)
+            attr = @attribute_types[arg.to_s] 
+            return false unless attr
+            attr.is_a?(Stretchy::Attributes::Type::Keyword)
+          end
+
+          def protected?(arg)
+            return false if arg.nil?
+            Stretchy::Relations::AggregationMethods::AGGREGATION_METHODS.include?(arg.to_sym)
+          end
+          
+          def transform(item, *ignore) 
+            item.each_with_object({}) do |(k, v), new_item|
+              if ignore && ignore.include?(k)
+                new_item[k] = v
+                next
+              end
+              new_key = (!protected?(k) && keyword?(k)) ? "#{k}.keyword" : k
+
+              new_value = v
+          
+              if new_value.is_a?(Hash)
+                new_value = transform(new_value)
+              elsif new_value.is_a?(Array)
+                new_value = new_value.map { |i| i.is_a?(Hash) ? transform(i) : i }
+              elsif new_value.is_a?(String) || new_value.is_a?(Symbol) 
+                new_value = "#{new_value}.keyword" if keyword?(new_value)
+              end
+
+              new_item[new_key] = new_value
+            end
+          end
+
+          # If terms are used, we assume that the field is a keyword field
+          # and append .keyword to the field name
+          # {terms: {field: 'gender'}}
+          # or nested aggs
+          # {terms: {field: 'gender'}, aggs: {name: {terms: {field: 'position.name'}}}}
+          # should be converted to
+          # {terms: {field: 'gender.keyword'}, aggs: {name: {terms: {field: 'position.name.keyword'}}}}
+          # {date_histogram: {field: 'created_at', interval: 'day'}}
+          # TODO: There may be cases where we don't want to add .keyword to the field and there should be a way to override this
+          def assume_keyword_field(args={}, parent_match=false)
+            if args.is_a?(Hash)
+              args.each do |k, v|
+                if v.is_a?(Hash) 
+                  assume_keyword_field(v, KEYWORD_AGGREGATION_FIELDS.include?(k))
+                else
+                  next unless v.is_a?(String) || v.is_a?(Symbol)
+                  args[k] = ([:field, :fields].include?(k.to_sym) && v !~ /\.keyword$/ && parent_match) ? "#{v}.keyword" : v.to_s
+                end
+              end
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/stretchy/attributes/type/keyword.rb

@@ -0,0 +1,11 @@
+module Stretchy
+    module Attributes
+        module Type
+            class Keyword < ActiveModel::Type::String # :nodoc:
+                def type
+                    :keyword
+                end
+            end
+        end
+    end
+end

data/lib/stretchy/attributes.rb

@@ -0,0 +1,10 @@
+module Stretchy
+  module Attributes
+
+    def self.register!
+      ActiveModel::Type.register(:array, ActiveModel::Type::Array)
+      ActiveModel::Type.register(:hash, ActiveModel::Type::Hash)
+      ActiveModel::Type.register(:keyword, Stretchy::Attributes::Type::Keyword)
+    end
+  end
+end

data/lib/stretchy/querying.rb

@@ -1,11 +1,12 @@
 module Stretchy
   module Querying
     delegate :first, :first!, :last, :last!, :exists?, :has_field, :any?, :many?, to: :all
-    delegate :order, :limit, :size, :sort, :where, :rewhere, :eager_load, :includes,  :create_with, :none, :unscope, to: :all
-    delegate :or_filter, :filter, :fields, :source, :highlight, :aggregation, to: :all
-    delegate :skip_callbacks, :routing, to: :all
-    delegate :search_options, :routing, to: :all
-    delegate :must, :must_not, :should, :where_not, :query_string, to: :all
+    delegate :order, :limit, :size, :sort, :rewhere, :eager_load, :includes,  :create_with, :none, :unscope, to: :all
+    delegate :or_filter, :fields, :source, :highlight, to: :all
+    delegate *Stretchy::Relations::AggregationMethods::AGGREGATION_METHODS, to: :all
+
+    delegate :skip_callbacks, :routing, :search_options, to: :all
+    delegate :must, :must_not, :should, :where_not, :where, :filter_query, :query_string, to: :all
 
     def fetch_results(es)
       unless es.count?

data/lib/stretchy/relation.rb

@@ -4,7 +4,7 @@ module Stretchy
     class Relation
 
         # These methods can accept multiple values.
-        MULTI_VALUE_METHODS  = [:order, :where, :or_filter, :filter, :bind, :extending, :unscope, :skip_callbacks]
+        MULTI_VALUE_METHODS  = [:order, :where, :or_filter, :filter_query, :bind, :extending, :unscope, :skip_callbacks]
 
         # These methods can accept a single value.
         SINGLE_VALUE_METHODS = [:limit, :offset, :routing, :size]
@@ -16,7 +16,7 @@ module Stretchy
         VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
 
         # Include modules.
-        include Relations::FinderMethods, Relations::SpawnMethods, Relations::QueryMethods, Relations::SearchOptionMethods, Delegation
+        include Relations::FinderMethods, Relations::SpawnMethods, Relations::QueryMethods, Relations::AggregationMethods, Relations::SearchOptionMethods, Delegation
 
         # Getters.
         attr_reader :klass, :loaded
@@ -162,7 +162,7 @@ module Stretchy
         #
         # @return [QueryBuilder] The query builder for the relation.
         def query_builder
-          Relations::QueryBuilder.new(values)
+          Relations::QueryBuilder.new(values, klass.attribute_types)
         end
 
     end