fmrest-spyke 0.24.0 → 0.26.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5e06c891b093db66e7dc2c47d78dd946c2f0d11777595261df7f4292925dad1
-  data.tar.gz: 2661cfb08f3960786368aad7b7f5b4192dc127741be54a9391c5f870d30eee4f
+  metadata.gz: 9e1fed1df9ac96ceef8872d171e85bf8b2d07278ae01ed9208bee2d92e71c8d5
+  data.tar.gz: 7eee364c2aaa75edc7af92b6faeea94995ae8985a0571f5e01f1c7621073d86b
 SHA512:
-  metadata.gz: 37fed4c2e1598c3b7defddcdacf2d0fbae933e85d4ccb553a220e8660554f2a21a772c8e366309fe05ab28d28439812e7aff80ff077331f84a223689454daabb
-  data.tar.gz: ae11bbc7230e79ef021a15543a4a67ef6d0e8164d1aa92615e6a9d2e95cc0e467e2fae963a346edd88089850d1d6e747f4e30bc2626f4179275f7986c9b47ac5
+  metadata.gz: fb7aebd7dc09384f4b5053119cc008e12fa40d61b27702dc25676dc6dcbbc90508ad4f0855552928136aeb29ccef7fde41f388e72f1fcef1bd291a66976d4fa7
+  data.tar.gz: bdd921d574d31967548726033228886ecbc724dfd33a92611801364a2f4bed598f30bea9c3541e95d8d1315f6d9fa8dcf0f8afcce642f0b771ffb910388c505b

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## Changelog
 
+### 0.26.0
+
+* Add support for ActiveSupport 7.1
+* Drop support for ActiveSupport < 5.2
+
+### 0.25.0-rc1
+
+* Add `.and` query method
+* Fix crash when `.match` query method was given non-string values
+
 ### 0.24.0
 
 * Add `FmRest::Layout.ignore_mod_id` flag

data/README.md

@@ -584,10 +584,11 @@ FM Data API reference: https://help.claris.com/en/data-api-guide/
 
 \* You can manually supply the URL and JSON to a `FmRest` connection.
 
-## Supported Ruby versions
+## Supported Ruby and Rails versions
 
-fmrest-ruby is [tested against](https://github.com/beezwax/fmrest-ruby/actions?query=workflow%3ACI)
-Ruby 2.6 through 3.1.
+The latest fmrest-ruby is
+[tested against](https://github.com/beezwax/fmrest-ruby/actions?query=workflow%3ACI)
+Ruby 3.0 through 3.3.0-rc1, and Rails (ActiveSupport) 6.1 through 7.1.
 
 ## Gem development
 

data/lib/fmrest/spyke/model/associations.rb

@@ -16,12 +16,8 @@ module FmRest
           # to parse the portalData JSON in SpykeFormatter
           #
           # TODO: Replace this with options in PortalBuilder
-          class_attribute :portal_options, instance_accessor: false, instance_predicate: false
-
-          # class_attribute supports a :default option since ActiveSupport 5.2,
-          # but we want to support previous versions too so we set the default
-          # manually instead
-          self.portal_options = {}.freeze
+          class_attribute :portal_options, instance_accessor: false, instance_predicate: false,
+            default: {}.freeze
 
           class << self; private :portal_options=; end
 

data/lib/fmrest/spyke/model/attributes.rb

@@ -22,16 +22,18 @@ module FmRest
           # when calling ActiveModels' define_attribute_method, otherwise it
           # will define an `attribute` method which overrides the one provided
           # by Spyke
-          self.attribute_method_matchers.shift
+          if respond_to? :attribute_method_patterns
+            # ActiveModel >= 7.1
+            attribute_method_patterns.shift
+          else
+            # ActiveModel < 7.1
+            attribute_method_matchers.shift
+          end
 
           # Keep track of attribute mappings so we can get the FM field names
           # for changed attributes
-          class_attribute :mapped_attributes, instance_writer: false, instance_predicate: false
-
-          # class_attribute supports a :default option since ActiveSupport 5.2,
-          # but we want to support previous versions too so we set the default
-          # manually instead
-          self.mapped_attributes = ::ActiveSupport::HashWithIndifferentAccess.new.freeze
+          class_attribute :mapped_attributes, instance_writer: false, instance_predicate: false,
+            default: ::ActiveSupport::HashWithIndifferentAccess.new.freeze
 
           class << self; private :mapped_attributes=; end
 

data/lib/fmrest/spyke/model/orm.rb

@@ -25,7 +25,7 @@ module FmRest
           delegate :limit, :offset, :sort, :order, :query, :match, :omit,
             :portal, :portals, :includes, :with_all_portals, :without_portals,
             :script, :find_one, :first, :any, :find_some, :find_in_batches,
-            :find_each, to: :all
+            :find_each, :and, :or, to: :all
 
           # Spyke override -- Use FmRest's Relation instead of Spyke's vanilla
           # one
@@ -34,9 +34,9 @@ module FmRest
             current_scope || Relation.new(self, uri: uri)
           end
 
-          # Spyke override -- allows properly setting limit, offset and other
-          # options, as well as using the appropriate HTTP method/URL depending
-          # on whether there's a query present in the current scope.
+          # Spyke override -- properly sets limit, offset and other options, as
+          # well as using the appropriate HTTP method/URL depending on whether
+          # there's a query present in the current scope.
           #
           # @option options [Boolean] :raise_on_no_matching_records whether to
           #   raise `APIError::NoMatchingRecordsError` when no records match (FM

data/lib/fmrest/spyke/relation.rb

@@ -5,6 +5,18 @@ module FmRest
     class Relation < ::Spyke::Relation
       SORT_PARAM_MATCHER = /(.*?)(!|__desc(?:end)?)?\Z/.freeze
 
+      # This needs to use four-digit numbers in order to work with Date fields
+      # also, otherwise FileMaker will complain about date formatting
+      ZERO_RESULTS_QUERY = '1001..1000'
+
+      UNSATISFIABLE_QUERY_VALUE =
+        Object.new.tap do |u|
+          def u.inspect; 'Unsatisfiable'; end
+          def u.to_s; ZERO_RESULTS_QUERY; end
+        end.freeze
+
+      NORMALIZED_OMIT_KEY = 'omit'
+
       class UnknownQueryKey < ArgumentError; end
 
       # NOTE: We need to keep limit, offset, sort, query and portal accessors
@@ -14,7 +26,8 @@ module FmRest
 
 
       attr_accessor :limit_value, :offset_value, :sort_params, :query_params,
-                    :or_flag, :included_portals, :portal_params, :script_params
+                    :chain_flag, :included_portals, :portal_params,
+                    :script_params
 
       def initialize(*_args)
         super
@@ -204,9 +217,12 @@ module FmRest
         with_clone do |r|
           params = params.flatten.map { |p| normalize_query_params(p) }
 
-          if r.or_flag || r.query_params.empty?
+          if r.chain_flag == :or || r.query_params.empty?
             r.query_params += params
-            r.or_flag = nil
+            r.chain_flag = nil
+          elsif r.chain_flag == :and
+            r.cartesian_product_query_params(params)
+            r.chain_flag = nil
           elsif params.length > r.query_params.length
             params[0, r.query_params.length].each_with_index do |p, i|
               r.query_params[i].merge!(p)
@@ -229,22 +245,22 @@ module FmRest
       # @return [FmRest::Spyke::Relation] a new relation with the exact match
       #   conditions applied
       def match(*params)
-        query(transform_query_values(params) { |v| "==#{FmRest::V1.escape_find_operators(v)}" })
+        query(transform_query_values(params) { |v| "==#{FmRest::V1.escape_find_operators(v.to_s)}" })
       end
 
-      # Negated version of `.query`, sets conditions to omit in a find request.
+      # Adds a new set of conditions to omit in a find request.
       #
-      # This is the same as passing `omit: true` to `.query`.
+      # This is the same as passing `omit: true` to `.or`.
       #
       # @return [FmRest::Spyke::Relation] a new relation with the given find
       #   conditions applied negated
       def omit(params)
-        query(params.merge(omit: true))
+        self.or(params.merge(omit: true))
       end
 
       # Signals that the next query conditions to be set (through `.query`,
       # `.match`, etc.) should be added as a logical OR relative to previously
-      # set conditions (rather than the default AND).
+      # set conditions.
       #
       # In practice this means the JSON query request will have a new
       # conditions object appended, e.g.:
@@ -256,15 +272,91 @@ module FmRest
       # You can call this method with or without parameters. If parameters are
       # given they will be passed down to `.query` (and those conditions
       # immediately set), otherwise it just prepares the next
-      # conditions-setting method to use OR.
+      # conditions-setting method (e.g. `match`) to use OR.
       #
       # @example
-      #   # Add conditions directly in .or call:
+      #   # Add conditions directly on .or call:
       #   Person.query(name: "=Alice").or(name: "=Bob")
       #   # Add exact match conditions through method chaining
       #   Person.match(email: "alice@example.com").or.match(email: "bob@example.com")
       def or(*params)
-        clone = with_clone { |r| r.or_flag = true }
+        clone = with_clone { |r| r.chain_flag = :or }
+        params.empty? ? clone : clone.query(*params)
+      end
+
+      # Signals that the next query conditions to be set (through `.query`,
+      # `.match`, etc.) should be added as a logical AND relative to previously
+      # set conditions.
+      #
+      # In practice this means the given conditions will be applied through
+      # cartesian product onto the previously defined conditions objects in the
+      # JSON query request.
+      #
+      # For example, if you had these conditions:
+      #
+      # ```
+      # [{name: "Alice"}, {name: "Bob"}]
+      # ```
+      #
+      # After calling `.and(age: 20)`, the conditions would look like:
+      #
+      # ```
+      # [{name: "Alice", age: 20}, {name: "Bob", age: 20}]
+      # ```
+      #
+      # Or in pseudocode logical representation:
+      #
+      # ```
+      # (name = "Alice" OR name = "Bob") AND age = 20
+      # ```
+      #
+      # You can also pass multiple condition hashes to `.and`, in which case
+      # it will treat them as OR-separated, e.g.:
+      #
+      # ```
+      # .query({ name: "Alice" }, { name: "Bob" }).and({ age: 20 }, { age: 30 })
+      # ```
+      #
+      # Would result in the following conditions:
+      #
+      # ```
+      # [
+      #   {name: "Alice", age: 20 },
+      #   {name: "Alice", age: 30 },
+      #   {name: "Bob", age: 20 },
+      #   {name: "Bob", age: 30 }
+      # ]
+      # ```
+      #
+      # In pseudocode:
+      #
+      # ```
+      # (name = "Alice" OR name = "Bob") AND (age = 20 OR age = 30)
+      # ```
+      #
+      # You can call this method with or without parameters. If parameters are
+      # given they will be passed down to `.query` (and those conditions
+      # immediately set), otherwise it just prepares the next
+      # conditions-setting method (e.g. `match`) to use AND.
+      #
+      # Note that if you use this method on fields that already had conditions
+      # set you may end up with an unsatisfiable condition (e.g. name matches
+      # 'Bob' AND 'Alice' simultaneously). In that case fmrest-ruby will
+      # replace your given values with an expression that's guaranteed to
+      # return zero results, as that is the logically expected result.
+      #
+      # @example
+      #   # Add conditions directly on .and call:
+      #   Person.query(name: "=Alice").and(city: "=Wonderland")
+      #   # Add exact match conditions through method chaining:
+      #   Person.match(name: "Alice").and.match(city: "Wonderland")
+      #   # With multiple condition hashes:
+      #   Person.query(name: "=Alice").and({ city: "=Wonderland" }, { city: "=London" })
+      #   # With conflicting criteria:
+      #   Person.match(name: "Alice").and.match(name: "Bob")
+      #   # => JSON: { "name": "1001..1000" } -> forced empty result set
+      def and(*params)
+        clone = with_clone { |r| r.chain_flag = :and }
         params.empty? ? clone : clone.query(*params)
       end
 
@@ -397,8 +489,33 @@ module FmRest
         end
       end
 
+      def cartesian_product_query_params(params)
+        if (query_params + params).any? { |p| p.key?(NORMALIZED_OMIT_KEY) }
+          raise ArgumentError, "Cannot use `and' with queries containing `omit'"
+        end
+
+        self.query_params =
+          query_params
+            .product(params)
+            .map { |a, b| a.merge(b) { |k, v1, v2| v1 == v2 ? v1 : unsatisfiable(k, v1, v2) } }
+      end
+
       private
 
+      def unsatisfiable(field, a, b)
+        unless a == UNSATISFIABLE_QUERY_VALUE || b == UNSATISFIABLE_QUERY_VALUE
+          # TODO: Add a setting to make this an exception instead of a warning?
+          warn(
+            "An FmRest query using `and' required that `#{field}' match " \
+            "'#{a}' and '#{b}' at the same time which can't be satisified. " \
+            "This will appear in the find request as '#{UNSATISFIABLE_QUERY_VALUE}' " \
+            "and may result in an empty resultset."
+          )
+        end
+
+        UNSATISFIABLE_QUERY_VALUE
+      end
+
       def normalize_sort_param(param)
         if param.kind_of?(Symbol) || param.kind_of?(String)
           _, attr, descend = param.to_s.match(SORT_PARAM_MATCHER).to_a
@@ -432,10 +549,10 @@ module FmRest
 
       def normalize_query_params(params)
         params.each_with_object({}) do |(k, v), normalized|
-          if k == :omit || k == "omit"
+          if k == :omit || k == NORMALIZED_OMIT_KEY
             # FM Data API wants omit values as strings, e.g. "true" or "false"
             # rather than true/false
-            normalized["omit"] = v.to_s
+            normalized[NORMALIZED_OMIT_KEY] = v.to_s
             next
           end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fmrest-spyke
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.26.0.rc1
 platform: ruby
 authors:
 - Pedro Carbajal
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-14 00:00:00.000000000 Z
+date: 2023-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fmrest-core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: 0.26.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: 0.26.0.rc1
 - !ruby/object:Gem::Dependency
   name: spyke
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
 description: fmrest-spyke is an ActiveRecord-like ORM client library for the FileMaker
   Data API built on top of fmrest-core and Spyke (https://github.com/balvig/spyke).
 email:
@@ -88,11 +102,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: FileMaker Data API ORM client library