stretchy-model 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7dff610329ad21128c58429c6f9d08b62138a7fad9adb0f610984bd744db1cf
-  data.tar.gz: 915256c1b413dd34d4777097b878f0c2c7886342b5d8dcfedc2159a405b3bdf2
+  metadata.gz: dd18b424c18bda352233d72af113e9bbc944277e03a02cfb950780f0fab9a405
+  data.tar.gz: 6eb86522e7bc91012cc4c743d0a9fccc54c7e75b14ff4d6f4fca5bdb9fa31626
 SHA512:
-  metadata.gz: 66f98b878a8e78d9d79b53f05edf89a8d4a61d4fd3a5b98d93ef349491c7c87f36d4cadb857b8be5e9e992308609c22d1abc45703eb39b95e78240d87c6ae081
-  data.tar.gz: 0eabc3b84d0aecb0f8051bf53238ec6da5d431c7ff5d0f7c3be20888a20252504e3324c7b558fe455d90c2cf0db827b1d0440e6d03d211569ed8ed7d60dade01
+  metadata.gz: 0fd2a0fb25439d79c799f43f43bb01df7c4dfe0ce9eb577d445b6d415eb9c38ecdc0f45c73d8255d2e079ff502e943f6491b874e3bb9c41fc9c853efed84d252
+  data.tar.gz: 8ea4cfa584ec825ac30aa4aa5dea88b04c709cbf7cc75089e28cd1e850318f150f1f68ead89bc571535739aa8ff8db777102d5dd05173087d4af499bac8d8bbb

data/.rspec

@@ -1 +1 @@
---require spec_helper
+--require spec_helper

data/README.md

@@ -1,6 +1,5 @@
 stretchy-model
 ===
-
 <p>
     <a href="https://stretchy.io/" target="_blank"><img src="./stretchy.logo.png" alt="Gum Image" width="450" /></a>
     <br><br>
@@ -9,104 +8,42 @@ stretchy-model
 
 </p>
 
-Stretchy provides Elasticsearch models in a Rails environment with an integrated ActiveRecord-like interface and features. 
 
 ## Features
 Stretchy simplifies the process of querying, aggregating, and managing Elasticsearch-backed models, allowing Rails developers to work with search indices as comfortably as they would with traditional Rails models.
 
-## Attributes
-
-```ruby
-class Post < Stretchy::Record
-
-    attribute :title,                   :string
-    attribute :body,                    :string
-    attribute :flagged,                 :boolean,  default: false  
-    attribute :author,                   :hash 
-    attribute :tags,                    :array, default: []
-
-end
-```
->[!NOTE]
->`created_at`, `:updated_at` and `:id` are automatically added to all `Stretchy::Records`
-
-
-## Query
-```ruby
-  Post.where('author.name': "Jadzia", flagged: true).first
-  #=> <Post id: aW02w3092, title: "Fun Cats", body: "...", flagged: true,
-  #         author: {name: "Jadzia", age: 20}, tags: ["cat", "amusing"]>
-```
-
-## Aggregations
-```ruby
-
-  result = Post.filter(:range, 'author.age': {gte: 18})
-    .aggregation(:post_frequency, date_histogram: {
-      field: :created_at,
-      calender_interval: :month
-    })
-
-  result.aggregations.post_frequency
-  #=> {buckets: [{key_as_string: "2024-01-01", doc_count: 20}, ...]}
-```
-
-## Scopes
-
-```ruby
-class Post < Stretchy::Record
-  # ...attributes
-
-  # Scopes
-  scope :flagged, -> { where(flagged: true) }
-  scope :top_links, lambda do |size=10, url=".com"| 
-    aggregation(:links, 
-      terms: {
-        field: :links, 
-        size: size, 
-        include: ".*#{url}.*"
-      })
-  end
-end
+* Model fully back by Elasticsearch/Opensearch
+* Chain queries, scopes and aggregations
+* Reduce Elasticsearch query complexity
+* Support for time-based indices and aliases
+* Associations to both ActiveRecord models and Stretchy::Record
+* Bulk Operations made easy
+* Validations, custom attributes, and more...
 
-# Returns flagged posts and includes the top 10 'youtube.com' 
-# links in results.aggregations.links
-result = Post.flagged.top_links(10, "youtube.com")
+Follow the guides to learn more about:
 
-```
+* [Models](https://theablefew.github.io/stretchy/#/guides/models?id=models)
+* [Querying](https://theablefew.github.io/stretchy/#/guides/querying?id=querying)
+* [Aggregations](https://theablefew.github.io/stretchy/#/guides/aggregations?id=aggregations)
+* [Scopes](https://theablefew.github.io/stretchy/#/guides/scopes?id=scopes)
 
-## Bulk Operations
 
+[Read the Documentation](https://theablefew.github.io/stretchy/#/) or walk through of a simple [Data Analysis](https://theablefew.github.io/stretchy/#/examples/data_analysis?id=data-analysis) example.
 
-```ruby
-Model.bulk(records_as_bulk_operations)
-```
 
-#### Bulk helper
-Generates structure for the bulk operation
-```ruby
-record.to_bulk # default to_bulk(:index)
-record.to_bulk(:delete)
-record.to_bulk(:update)
-```
-
-#### In batches
-Run bulk operations in batches specified by `size`
-```ruby
-Model.bulk_in_batches(records, size: 100) do |batch|
-    batch.map! { |record| Model.new(record).to_bulk }
-end
-```
 
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add stretchy-model
+```sh
+ bundle add stretchy-model
+```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install stretchy-model
+```sh
+  gem install stretchy-model
+```
 
 <details>
 <summary>Rails Configuration</summary>
@@ -145,8 +82,6 @@ end
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 >[!TIP]
->This library is built on top of the excellent [elasticsearch-persistence](https://github.com/elastic/elasticsearch-rails/tree/main/elasticsearch-persistence) gem. 
->
 > Full documentation on [Elasticsearch Query DSL and Aggregation options](https://github.com/elastic/elasticsearch-rails/tree/main/elasticsearch-persistence)
 
 ## Testing

data/lib/stretchy/associations.rb

@@ -3,7 +3,11 @@ module Stretchy
     extend ActiveSupport::Concern
 
     def save!
+      if valid?
         self.save
+      else
+        raise "Record is invalid"
+      end
     end
 
     # Required for Elasticsearch < 7
@@ -34,7 +38,7 @@ module Stretchy
     end
 
     def association_reflection(association)
-      ElasticRelation.new @@_associations[association], (dirty[association.to_sym] || [])
+      Stretchy::Relation.new @@_associations[association], (dirty[association.to_sym] || [])
     end
 
     def _destroy=(bool)
@@ -48,6 +52,7 @@ module Stretchy
     def save_associations
       @_after_save_objects.each_pair do |association, collection|
         collection.each do |instance|
+          # TODO: bulk update 
           instance.send("#{@@_association_options[association.to_sym][:foreign_key]}=", self.id)
           instance.save
         end
@@ -59,59 +64,194 @@ module Stretchy
       @@_associations ||= {}
       @@_association_options ||= {}
 
+      # The belongs_to method is used to set up a one-to-one connection with another model.
+      # This indicates that this model has exactly one instance of another model.
+      # For example, if your application includes authors and books, and each book can be assigned exactly one author,
+      # you'd declare the book model to belong to the author model.
+      #
+      # association:: [Symbol] the name of the association
+      # options:: [Hash] a hash to set up options for the association
+      #           :foreign_key - the foreign key used for the association. Defaults to "#{association}_id"
+      #           :primary_key - the primary key used for the association. Defaults to "id"
+      #           :class_name - the name of the associated object's class. Defaults to the name of the association
+      #
+      # Example:
+      #   belongs_to :author
+      #
+      # This creates a book.author method that returns the author of the book.
+      # It also creates an author= method that allows you to assign the author of the book.
+      #
       def belongs_to(association, options = {})
         @@_association_options[association] = {
           foreign_key: "#{association}_id", 
           primary_key: "id",
           class_name: association
-        }.reverse_merge(options)
+        }.merge(options)
 
         klass = @@_association_options[association][:class_name].to_s.singularize.classify.constantize
         @@_associations[association] = klass
 
         define_method(association.to_sym) do
-          klass.where(_id: self.send(@@_association_options[association][:foreign_key].to_sym)).first
+          instance_variable_get("@#{association}") || 
+            klass.where(_id: self.send(@@_association_options[association][:foreign_key].to_sym)).first
         end
 
         define_method("#{association}=".to_sym) do |val|
           options = @@_association_options[association] 
-          instance_variable_set("@#{options[:foreign_key]}", val.send(options[:primary_key]))
+          self.send("#{options[:foreign_key]}=", val.send(options[:primary_key]))
+          instance_variable_set("@#{association}", val)
+        end
+
+        define_method("build_#{association}") do |*args|
+          associated_object = klass.new(*args)
+          instance_variable_set("@#{association}", associated_object)
+          associated_object
+        end
+
+        before_save do
+          associated_object = instance_variable_get("@#{association}")
+          if associated_object && associated_object.new_record?
+            if associated_object.save!
+              self.send("#{@@_association_options[association][:foreign_key]}=", associated_object.id)
+            end
+          end
         end
       end
 
-      def has_one(association, class_name: nil, foreign_key: nil, dependent: :destroy)
 
-        klass = association.to_s.singularize.classify.constantize unless class_name.present?
-        foreign_key = "#{self.name.downcase}_id" unless foreign_key.present?
+
+
+
+
+
+
+
+
+      # The has_one method is used to set up a one-to-one connection with another model.
+      # This indicates that this model contains the foreign key.
+      #
+      # association:: [Symbol] The name of the association.
+      # options:: [Hash] A hash to set up options for the association.
+      #           :class_name - The name of the associated model. If not provided, it's derived from +association+.
+      #           :foreign_key - The name of the foreign key on the associated model. If not provided, it's derived from the name of this model.
+      #           :dependent - If set to +:destroy+, the associated object will be destroyed when this object is destroyed. This is the default behavior.
+      #           :primary_key - The name of the primary key on the associated model. If not provided, it's assumed to be +id+.
+      #           
+      #
+      # Example:
+      #   has_one :profile
+      #
+      # This creates a user.profile method that returns the profile of the user.
+      # It also creates a profile= method that allows you to assign the profile of the user.
+      #
+      def has_one(association, options = {})
+
+        @@_association_options[association] = {
+          foreign_key: "#{self.name.underscore}_id", 
+          primary_key: "id",
+          class_name: association
+        }.merge(options)
+
+        klass = @@_association_options[association][:class_name].to_s.singularize.classify.constantize
         @@_associations[association] = klass
 
+        foreign_key = @@_association_options[association][:foreign_key]
+
         define_method(association.to_sym) do
-          klass.where("#{foreign_key}": self.id).first
+          instance_variable_get("@#{association}") || 
+            klass.where("#{foreign_key}": self.id).first
+        end
+
+        define_method("#{association}=".to_sym) do |val|
+          instance_variable_set("@#{association}", val)
+          save!
+        end
+
+        before_save do
+          associated_object = instance_variable_get("@#{association}")
+          if associated_object
+            associated_object.send("#{foreign_key}=", self.id)
+            associated_object.save!
+          end
         end
       end
 
-      def has_many(association, klass, options = {})
-        @@_associations[association] = klass
 
-        opt_fk = options.delete(:foreign_key)
-        foreign_key = opt_fk ? opt_fk : "#{self.name.split("::").last.tableize.singularize}_id"
 
-        @@_association_options[association] = { foreign_key: foreign_key }
+
+
+
+
+
+
+      # The has_many method is used to set up a one-to-many connection with another model.
+      # This indicates that this model can be matched with zero or more instances of another model.
+      # For example, if your application includes authors and books, and each author can have many books,
+      # you'd declare the author model to have many books.
+      #
+      # association:: [Symbol] the name of the association
+      # options:: [Hash] a hash to set up options for the association
+      #           :foreign_key - the foreign key used for the association. Defaults to "#{self.name.downcase}_id"
+      #           :primary_key - the primary key used for the association. Defaults to "id"
+      #           :class_name - the name of the associated object's class. Defaults to the name of the association
+      #           :dependent - if set to :destroy, the associated object will be destroyed when this object is destroyed. This is the default behavior.
+      #           
+      #
+      # Example:
+      #   has_many :books
+      #
+      # This creates an author.books method that returns a collection of books for the author.
+      # It also creates a books= method that allows you to assign the books for the author.
+      #
+      def has_many(association, options = {})
+        @@_association_options[association] = {
+          foreign_key: "#{self.name.underscore}_id", 
+          primary_key: "id",
+          class_name: association.to_s.singularize.to_sym
+        }.merge(options)
+
+        klass = @@_association_options[association][:class_name].to_s.classify.constantize
+        foreign_key = @@_association_options[association][:foreign_key]
+        primary_key = @@_association_options[association][:primary_key]
+        @@_associations[association] = klass
 
         define_method(association.to_sym) do
           args = {}
-          args[foreign_key] = self.id
+          args["_#{primary_key}"] = self.send("#{association.to_s.singularize}_ids")
           self.new_record? ? association_reflection(association) : klass.where(args)
         end
 
+        define_method("#{association.to_s.singularize}_ids") do 
+          instance_variable_get("@#{association.to_s.singularize}_ids".to_sym)
+        end
+
+        define_method("#{association.to_s.singularize}_ids=") do |val|
+          instance_variable_set("@#{association.to_s.singularize}_ids".to_sym, val)
+        end
+
+        define_method("#{association}=".to_sym) do |val|
+          val.each { |v| after_save_objects(v.attributes, association)}
+          self.send("#{association.to_s.singularize}_ids=", val.map(&:id))
+          dirty
+        end
+
         define_method("build_#{association}".to_sym) do |*args|
           opts = {}
           opts[foreign_key] = self.id
           args.first.merge! opts
           klass.new *args
         end
+
+        after_save do
+          save_associations
+        end
       end
 
+
+
+
+
+
       def validates_associated(*attr_names)
         validates_with AssociatedValidator, _merge_attributes(attr_names)
       end
@@ -131,7 +271,7 @@ module Stretchy
       end
 
       def reflect_on_association(association)
-        ElasticRelation.new @@_associations[association]
+        Stretchy::Relation.new @@_associations[association]
       end
 
       def update_all(records, **attributes)

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

@@ -0,0 +1,15 @@
+module Stretchy
+    module Attributes
+        module Type
+
+            class Array < ActiveModel::Type::Value # :nodoc:
+
+                def type
+                    :array
+                end
+
+            end
+
+        end
+    end
+end

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

@@ -0,0 +1,17 @@
+module Stretchy
+    module Attributes
+        module Type
+            class Hash < ActiveModel::Type::Value # :nodoc:
+                def type
+                    :hash
+                end
+
+                private
+
+                def cast_value(value)
+                    Elasticsearch::Model::HashWrapper[value]
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,12 @@
+module Stretchy
+  module Attributes
+      module Type
+          # alias for ActiveModel::Type::String
+          class Text < ActiveModel::Type::String
+              def type
+                  :text
+              end
+          end
+      end
+  end
+end

data/lib/stretchy/attributes.rb

@@ -1,10 +1,30 @@
 module Stretchy
   module Attributes
+    extend ActiveSupport::Concern
+
+    def [](attribute)
+      self.send(attribute)
+    end
+
+    def []=(attribute, value)
+        self.send("#{attribute}=", value)
+    end
+
+    def inspect
+      "#<#{self.class.name} #{attributes.map { |k,v| "#{k}: #{v.blank? ? 'nil' : v}" }.join(', ')}>"
+    end
+
+    class_methods do
+      def inspect
+        "#<#{self.name} #{attribute_types.map { |k,v| "#{k}: #{v.type}" }.join(', ')}>"
+      end
+    end
 
     def self.register!
-      ActiveModel::Type.register(:array, ActiveModel::Type::Array)
-      ActiveModel::Type.register(:hash, ActiveModel::Type::Hash)
+      ActiveModel::Type.register(:array, Stretchy::Attributes::Type::Array)
+      ActiveModel::Type.register(:hash, Stretchy::Attributes::Type::Hash)
       ActiveModel::Type.register(:keyword, Stretchy::Attributes::Type::Keyword)
+      ActiveModel::Type.register(:text, Stretchy::Attributes::Type::Text)
     end
   end
 end

data/lib/stretchy/common.rb

@@ -2,11 +2,10 @@ module Stretchy
     module Common
         extend ActiveSupport::Concern
 
-        def inspect
-            "#<#{self.class.name} #{attributes.map { |k,v| "#{k}: #{v.blank? ? 'nil' : v}" }.join(', ')}>"
+        def highlights_for(attribute)
+            highlights[attribute.to_s]
         end
 
-
         class_methods do
 
             # Set the default sort key to be used in sort operations

data/lib/stretchy/delegation/gateway_delegation.rb

@@ -28,11 +28,17 @@ module Stretchy
           if @index_name.respond_to?(:call)
             @index_name.call
           else
-            @index_name || base_class.model_name.collection
+            @index_name || base_class.model_name.collection.parameterize.underscore
           end
       end
 
+      def reload_gateway_configuration!
+        @gateway = nil
+      end
+
       def gateway(&block)
+          reload_gateway_configuration! if @gateway && @gateway.client != Stretchy.configuration.client
+            
           @gateway ||= Stretchy::Repository.create(client: Stretchy.configuration.client, index_name: index_name, klass: base_class)
           block.arity < 1 ? @gateway.instance_eval(&block) : block.call(@gateway) if block_given?
           @gateway

data/lib/stretchy/model/serialization.rb

@@ -9,6 +9,7 @@ module Stretchy
 
             def deserialize(document)
                 attribs = ActiveSupport::HashWithIndifferentAccess.new(document['_source']).deep_symbolize_keys
+                attribs[:_highlights] = document["highlight"] if document["highlight"]
                 _id = __get_id_from_document(document)
                 attribs[:id] = _id if _id
                 klass.new attribs

data/lib/stretchy/querying.rb

@@ -6,7 +6,7 @@ module Stretchy
     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
+    delegate :must, :must_not, :should, :where_not, :where, :filter_query, :query_string, :regexp, to: :all
 
     def fetch_results(es)
       unless es.count?

data/lib/stretchy/record.rb

@@ -14,11 +14,6 @@ module Stretchy
                 include ActiveModel::Conversion
                 include ActiveModel::Serialization
                 include ActiveModel::Serializers::JSON
-                include ActiveModel::Validations
-                include ActiveModel::Validations::Callbacks
-                extend ActiveModel::Callbacks
-
-
 
                 include Stretchy::Model::Callbacks
                 include Stretchy::Indexing::Bulk
@@ -28,6 +23,8 @@ module Stretchy
                 include Stretchy::Common
                 include Stretchy::Scoping
                 include Stretchy::Utils
+                include Stretchy::SharedScopes
+                include Stretchy::Attributes
 
                 extend Stretchy::Delegation::DelegateCache
                 extend Stretchy::Querying
@@ -44,11 +41,13 @@ module Stretchy
                 # overriden by #size
                 default_size 10000
 
-            end
+                attr_accessor :highlights
+
+                def initialize(attributes = {})
+                    @highlights = attributes.delete(:_highlights) 
+                    super(attributes)
+                end
 
-            def initialize(attributes = {})
-                self.assign_attributes(attributes) if attributes
-                super()
             end
 
         end

data/lib/stretchy/relation.rb

@@ -3,20 +3,16 @@ module Stretchy
     # It provides methods for querying and manipulating the documents.
     class Relation
 
-        # These methods can accept multiple values.
-        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]
-
         # These methods cannot be used with the `delete_all` method.
         INVALID_METHODS_FOR_DELETE_ALL = [:limit, :offset]
 
-        # All value methods.
-        VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
-
         # Include modules.
-        include Relations::FinderMethods, Relations::SpawnMethods, Relations::QueryMethods, Relations::AggregationMethods, Relations::SearchOptionMethods, Delegation
+        include Relations::FinderMethods, 
+                Relations::SpawnMethods, 
+                Relations::QueryMethods, 
+                Relations::AggregationMethods, 
+                Relations::SearchOptionMethods, 
+                Delegation
 
         # Getters.
         attr_reader :klass, :loaded
@@ -49,14 +45,13 @@ module Stretchy
         #
         # @return [Array] The results of the relation.
         def to_a
-
           load
           @records
         end
         alias :results :to_a
 
         def response
-          to_a.response
+          results.response
         end
 
         # Returns the results of the relation as a JSON object.
@@ -64,7 +59,7 @@ module Stretchy
         # @param options [Hash] The options to pass to the `as_json` method.
         # @return [Hash] The results of the relation as a JSON object.
         def as_json(options = nil)
-          to_a.as_json(options)
+          results.as_json(options)
         end
 
         # Returns the Elasticsearch query for the relation.
@@ -98,7 +93,6 @@ module Stretchy
         # @return [Relation] The relation object.
         def load
           exec_queries unless loaded?
-
           self
         end
         alias :fetch :load
@@ -146,8 +140,8 @@ module Stretchy
           begin
             entries = to_a.results.take([size_value.to_i + 1, 11].compact.min).map!(&:inspect)
             message = {}
-            message = {total: to_a.total, max: to_a.total}
-            message.merge!(aggregations: results.response.aggregations.keys) unless results.response.aggregations.nil?
+            message = {total: results.total, max: results.total}
+            message.merge!(aggregations: response.aggregations.keys) unless response.aggregations.nil?
             message = message.each_pair.collect { |k,v|  "#{k}: #{v}" }
             message.unshift entries.join(', ') unless entries.size.zero?
             "#<#{self.class.name} #{message.join(', ')}>"

data/lib/stretchy/relations/merger.rb

@@ -7,8 +7,12 @@ module Stretchy
       class HashMerger # :nodoc:
         attr_reader :relation, :hash
 
+        VALUE_METHODS = Stretchy::Relations::QueryMethods::MULTI_VALUE_METHODS.concat( 
+                          Stretchy::Relations::QueryMethods::SINGLE_VALUE_METHODS
+                        )
+
         def initialize(relation, hash)
-          hash.assert_valid_keys(*Relation::VALUE_METHODS)
+          hash.assert_valid_keys(*VALUE_METHODS)
 
           @relation = relation
           @hash     = hash

data/lib/stretchy/relations/query_builder.rb

@@ -38,6 +38,10 @@ module Stretchy
         @shoulds ||= compact_where(values[:should])
       end
 
+      def regexes
+        @regexes ||= values[:regexp]
+      end
+
       def fields
         values[:field]
       end
@@ -88,7 +92,7 @@ module Stretchy
       private
 
       def missing_bool_query?
-        query.nil? && must_nots.nil? && shoulds.nil?
+        query.nil? && must_nots.nil? && shoulds.nil? && regexes.nil?
       end
 
       def missing_query_string?
@@ -102,7 +106,12 @@ module Stretchy
       def build_query
         return if missing_bool_query? && missing_query_string? && missing_query_filter?
         structure.query do
+          structure.regexp do
+            build_regexp unless regexes.nil?
+          end
+
           structure.bool do
+
                 structure.must query unless missing_bool_query?
                 structure.must_not must_nots unless must_nots.nil?
                 structure.set! :should, shoulds unless shoulds.nil?
@@ -120,6 +129,14 @@ module Stretchy
         end.with_indifferent_access
       end
 
+      def build_regexp
+        regexes.each do |args|
+            target_field = args.first.keys.first
+            value_field = args.first.values.first
+            structure.set! target_field, args.last.merge(value: value_field)
+        end
+      end
+
       def build_filtered_query
         structure.filter do
           structure.or do
@@ -157,7 +174,13 @@ module Stretchy
         structure.highlight do
           structure.fields do
             highlights.each do |highlight|
-              structure.set! highlight, extract_highlighter(highlight)
+              if highlight.is_a?(String) || highlight.is_a?(Symbol)
+                structure.set! highlight, {}
+              elsif highlight.is_a?(Hash)
+                highlight.each_pair do |k,v|
+                  structure.set! k, v
+                end
+              end
             end
           end
         end

data/lib/stretchy/relations/query_methods.rb

@@ -18,7 +18,8 @@ module Stretchy
         :filter_query, 
         :or_filter,
         :extending,
-        :skip_callbacks
+        :skip_callbacks,
+        :regexp
       ]
 
       SINGLE_VALUE_METHODS = [:size]
@@ -173,6 +174,16 @@ module Stretchy
       #          }
       #        }
       #
+      # .where acts as a convienence method for adding conditions to the query. It can also be used to add
+      # range , regex, terms, and id queries through shorthand parameters.
+      #
+      # @example
+      #   Model.where(price: {gte: 10, lte: 20})
+      #   Model.where(age: 19..33)
+      #   Model.where(color: /gr(a|e)y/)
+      #   Model.where(id: [10, 22, 18])
+      #   Model.where(names: ['John', 'Jane'])
+      #
       # @return [ActiveRecord::Relation, WhereChain] a new relation, which reflects the conditions, or a WhereChain if opts is :chain
       # @see #must
       def where(opts = :chain, *rest)
@@ -181,7 +192,28 @@ module Stretchy
         elsif opts.blank?
           self
         else
-          spawn.where!(opts, *rest)
+          opts.each do |key, value|
+            case value
+            when Range
+              between(value, key)
+            when Hash
+              filter_query(:range, key => value) if value.keys.any? { |k| [:gte, :lte, :gt, :lt].include?(k) }
+            when Regexp
+              regexp(Hash[key, value])
+            when Array
+              # handle ID queries
+              # if [:id, :_id].include?(key)
+
+              # else
+                spawn.where!(opts, *rest)
+              # end
+            else
+              spawn.where!(opts, *rest)
+            end
+          end
+
+          self
+
         end
       end
 
@@ -199,6 +231,38 @@ module Stretchy
       # @see #where
       alias :must :where
 
+      # Adds a regexp condition to the query.
+      # 
+      # @param field [Hash] the field to filter by and the Regexp to match
+      # @param opts [Hash] additional options for the regexp query
+      #     - :flags [String] the flags to use for the regexp query (e.g. 'ALL')
+      #     - :use_keyword [Boolean] whether to use the .keyword field for the regexp query. Default: true
+      #     - :case_insensitive [Boolean] whether to use case insensitive matching. If the regexp has ignore case flag `/regex/i`, this is automatically set to true
+      #     - :max_determinized_states [Integer] the maximum number of states that the regexp query can produce
+      #     - :rewrite [String] the rewrite method to use for the regexp query
+      #     
+      # 
+      # @example
+      #  Model.regexp(:name, /john|jane/)
+      #  Model.regexp(:name, /john|jane/i)
+      #  Model.regexp(:name, /john|jane/i, flags: 'ALL')
+      #  
+      # @return [Stretchy::Relation] a new relation, which reflects the regexp condition
+      # @see #where
+      def regexp(args)
+        spawn.regexp!(args)
+      end
+
+      def regexp!(args) # :nodoc:
+        args = args.to_a
+        target_field, regex = args.shift
+        opts = args.to_h
+        opts.reverse_merge!(use_keyword: true)
+        target_field = "#{target_field}.keyword" if opts.delete(:use_keyword)
+        opts.merge!(case_insensitive: true) if regex.casefold?
+        self.regexp_values += [[Hash[target_field, regex.source], opts]]
+        self
+      end
 
 
 

data/lib/stretchy/shared_scopes.rb

@@ -4,7 +4,7 @@ module Stretchy
 
         included do
 
-            scope :between, lambda { |range| filter(:range, "date" => {gte: range.begin, lte: range.end}) }
+            scope :between, ->(range, range_field = "created_at") { filter_query(:range, range_field => {gte: range.begin, lte: range.end}) }
             scope :using_time_based_indices, lambda { |range| search_options(index: time_based_indices(range)) }
 
         end

data/lib/stretchy/version.rb

@@ -1,3 +1,3 @@
 module Stretchy
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/stretchy.rb

@@ -7,8 +7,6 @@ require 'elasticsearch/model'
 require 'elasticsearch/persistence'
 require 'active_model'
 require 'active_support/all'
-require 'active_model/type/array'
-require 'active_model/type/hash'
 
 require_relative "stretchy/version"
 require_relative "rails/instrumentation/railtie" if defined?(Rails)

data/lib/stretchy_model.rb

@@ -0,0 +1,9 @@
+# This is a simple model that inherits from Stretchy::Record
+# for aesthetic purposes. 
+#
+# In Rails applications, you can use this model as a base class
+# for your models.
+# 
+class StretchyModel < Stretchy::Record
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stretchy-model
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Spencer Markowski
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-10 00:00:00.000000000 Z
+date: 2024-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -224,8 +224,6 @@ files:
 - containers/Dockerfile.elasticsearch
 - containers/Dockerfile.opensearch
 - docker-compose.yml
-- lib/active_model/type/array.rb
-- lib/active_model/type/hash.rb
 - lib/rails/instrumentation/publishers.rb
 - lib/rails/instrumentation/railtie.rb
 - lib/stretchy.rb
@@ -234,7 +232,10 @@ files:
 - lib/stretchy/associations/elastic_relation.rb
 - lib/stretchy/attributes.rb
 - lib/stretchy/attributes/transformers/keyword_transformer.rb
+- lib/stretchy/attributes/type/array.rb
+- lib/stretchy/attributes/type/hash.rb
 - lib/stretchy/attributes/type/keyword.rb
+- lib/stretchy/attributes/type/text.rb
 - lib/stretchy/common.rb
 - lib/stretchy/delegation/delegate_cache.rb
 - lib/stretchy/delegation/gateway_delegation.rb
@@ -263,6 +264,7 @@ files:
 - lib/stretchy/shared_scopes.rb
 - lib/stretchy/utils.rb
 - lib/stretchy/version.rb
+- lib/stretchy_model.rb
 - sig/stretchy.rbs
 - stretchy-model/lib/stretchy-model.rb
 - stretchy.logo.png

data/lib/active_model/type/array.rb

@@ -1,13 +0,0 @@
-module ActiveModel
-    module Type
-
-        class Array < Value # :nodoc:
-
-            def type
-                :array
-            end
-
-        end
-
-    end
-end

data/lib/active_model/type/hash.rb

@@ -1,15 +0,0 @@
-module ActiveModel
-    module Type
-        class Hash < Value # :nodoc:
-            def type
-                :hash
-            end
-
-            private
-
-            def cast_value(value)
-                Elasticsearch::Model::HashWrapper[value]
-            end
-        end
-    end
-end