Removed dependency on Hashie

Author: ankane

CHANGELOG.md

@@ -6,6 +6,7 @@
 - Changed async reindex to use ranges for numeric primary keys with Active Record
 - Removed default quantization for `knn` option for Elasticsearch 8.14+
 - Removed `execute` option and method (no longer needed)
+- Removed dependency on Hashie
 - Deprecated `conversions` option in favor of `conversions_v2`
 - Dropped support for Elasticsearch 7 and OpenSearch 1
 - Dropped support for Active Record < 7.2

lib/searchkick.rb

@@ -6,7 +6,6 @@
 require "active_support/deprecation"
 require "active_support/log_subscriber"
 require "active_support/notifications"
-require "hashie"
 
 # stdlib
 require "forwardable"

lib/searchkick/hash_wrapper.rb

@@ -1,12 +1,33 @@
 module Searchkick
-  # Subclass of `Hashie::Mash` to wrap Hash-like structures
-  # (responses from Elasticsearch)
-  #
-  # The primary goal of the subclass is to disable the
-  # warning being printed by Hashie for re-defined
-  # methods, such as `sort`.
-  #
-  class HashWrapper < ::Hashie::Mash
-    disable_warnings if respond_to?(:disable_warnings)
+  class HashWrapper
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def [](name)
+      @attributes[name.to_s]
+    end
+
+    def to_h
+      @attributes
+    end
+
+    def method_missing(name, ...)
+      if @attributes.key?(name.to_s)
+        self[name]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, ...)
+      @attributes.key?(name.to_s) || super
+    end
+
+    def inspect
+      attributes = @attributes.reject { |k, v| k[0] == "_" }.map { |k, v| "#{k}: #{v.inspect}" }
+      attributes.unshift(attributes.pop) # move id to start
+      "#<#{self.class.name} #{attributes.join(", ")}>"
+    end
   end
 end

searchkick.gemspec

@@ -16,5 +16,4 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 3.2"
 
   spec.add_dependency "activemodel", ">= 7.2"
-  spec.add_dependency "hashie"
 end

test/load_test.rb

@@ -3,12 +3,26 @@
 class LoadTest < Minitest::Test
   def test_default
     store_names ["Product A"]
-    assert_kind_of Product, Product.search("product").first
+    product = Product.search("product").first
+    assert_kind_of Product, product
+    assert_match "#<Product id: ", product.inspect
+    assert_equal "Product A", product.name
+    assert_equal "Product A", product[:name]
+    assert_equal "Product A", product["name"]
+    refute product.respond_to?(:missing)
+    assert_nil product[:missing]
   end
 
   def test_false
     store_names ["Product A"]
-    assert_kind_of Searchkick::HashWrapper, Product.search("product", load: false).first
+    product = Product.search("product", load: false).first
+    assert_kind_of Searchkick::HashWrapper, product
+    assert_match "#<Searchkick::HashWrapper id: ", product.inspect
+    assert_equal "Product A", product.name
+    assert_equal "Product A", product[:name]
+    assert_equal "Product A", product["name"]
+    refute product.respond_to?(:missing)
+    assert_nil product[:missing]
   end
 
   def test_false_methods

test/select_test.rb

@@ -4,15 +4,15 @@ class SelectTest < Minitest::Test
   def test_basic
     store [{name: "Product A", store_id: 1}]
     result = Product.search("product", load: false, select: [:name, :store_id]).first
-    assert_equal %w(id name store_id), result.keys.reject { |k| k.start_with?("_") }.sort
+    assert_equal %w(id name store_id), result.to_h.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
     assert_equal 1, result.store_id
   end
 
   def test_relation
     store [{name: "Product A", store_id: 1}]
     result = Product.search("product", load: false).select(:name, :store_id).first
-    assert_equal %w(id name store_id), result.keys.reject { |k| k.start_with?("_") }.sort
+    assert_equal %w(id name store_id), result.to_h.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
     assert_equal 1, result.store_id
   end
@@ -32,15 +32,15 @@ def test_block_arguments
   def test_multiple
     store [{name: "Product A", store_id: 1}]
     result = Product.search("product", load: false).select(:name).select(:store_id).first
-    assert_equal %w(id name store_id), result.keys.reject { |k| k.start_with?("_") }.sort
+    assert_equal %w(id name store_id), result.to_h.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
     assert_equal 1, result.store_id
   end
 
   def test_reselect
     store [{name: "Product A", store_id: 1}]
     result = Product.search("product", load: false).select(:name).reselect(:store_id).first
-    assert_equal %w(id store_id), result.keys.reject { |k| k.start_with?("_") }.sort
+    assert_equal %w(id store_id), result.to_h.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal 1, result.store_id
   end
 
@@ -53,9 +53,9 @@ def test_array
   def test_single_field
     store [{name: "Product A", store_id: 1}]
     result = Product.search("product", load: false, select: :name).first
-    assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
+    assert_equal %w(id name), result.to_h.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
-    assert_nil result.store_id
+    refute result.respond_to?(:store_id)
   end
 
   def test_all
@@ -76,15 +76,15 @@ def test_none
   def test_includes
     store [{name: "Product A", user_ids: [1, 2]}]
     result = Product.search("product", load: false, select: {includes: [:name]}).first
-    assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
+    assert_equal %w(id name), result.to_h.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
-    assert_nil result.store_id
+    refute result.respond_to?(:store_id)
   end
 
   def test_excludes
     store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
     result = Product.search("product", load: false, select: {excludes: [:name]}).first
-    assert_nil result.name
+    refute result.respond_to?(:name)
     assert_equal [1, 2], result.user_ids
     assert_equal 1, result.store_id
   end
@@ -94,7 +94,7 @@ def test_include_and_excludes
     store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
     result = Product.search("product", load: false, select: {includes: [:store_id], excludes: [:name]}).first
     assert_equal 1, result.store_id
-    assert_nil result.name
-    assert_nil result.user_ids
+    refute result.respond_to?(:name)
+    refute result.respond_to?(:user_ids)
   end
 end