jsonb_accessor 1.3.7-java

data/lib/jsonb_accessor/attribute_query_methods.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module JsonbAccessor
+  class AttributeQueryMethods
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def define(store_key_mapping_method_name, jsonb_attribute)
+      return if klass.superclass.respond_to? store_key_mapping_method_name
+
+      # <jsonb_attribute>_where scope
+      klass.define_singleton_method "#{jsonb_attribute}_where" do |attributes|
+        store_key_attributes = JsonbAccessor::Helpers.convert_keys_to_store_keys(attributes, all.model.public_send(store_key_mapping_method_name))
+        jsonb_where(jsonb_attribute, store_key_attributes)
+      end
+
+      # <jsonb_attribute>_where_not scope
+      klass.define_singleton_method "#{jsonb_attribute}_where_not" do |attributes|
+        store_key_attributes = JsonbAccessor::Helpers.convert_keys_to_store_keys(attributes, all.model.public_send(store_key_mapping_method_name))
+        jsonb_where_not(jsonb_attribute, store_key_attributes)
+      end
+
+      # <jsonb_attribute>_order scope
+      klass.define_singleton_method "#{jsonb_attribute}_order" do |*args|
+        ordering_options = args.extract_options!
+        order_by_defaults = args.each_with_object({}) { |attribute, config| config[attribute] = :asc }
+        store_key_mapping = all.model.public_send(store_key_mapping_method_name)
+
+        order_by_defaults.merge(ordering_options).reduce(all) do |query, (name, direction)|
+          key = store_key_mapping[name.to_s]
+          order_query = jsonb_order(jsonb_attribute, key, direction)
+          query.merge(order_query)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :klass
+  end
+end

data/lib/jsonb_accessor/helpers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module JsonbAccessor
+  module Helpers
+    module_function
+
+    def active_record_default_timezone
+      ActiveRecord.try(:default_timezone) || ActiveRecord::Base.default_timezone
+    end
+
+    # Replaces all keys in `attributes` that have a defined store_key with the store_key
+    def convert_keys_to_store_keys(attributes, store_key_mapping)
+      attributes.stringify_keys.transform_keys do |key|
+        store_key_mapping[key] || key
+      end
+    end
+
+    # Replaces all keys in `attributes` that have a defined store_key with the named key (alias)
+    def convert_store_keys_to_keys(attributes, store_key_mapping)
+      convert_keys_to_store_keys(attributes, store_key_mapping.invert)
+    end
+
+    def deserialize_value(value, attribute_type)
+      return value if value.blank?
+
+      if attribute_type == :datetime
+        value = if active_record_default_timezone == :utc
+                  Time.find_zone("UTC").parse(value).in_time_zone
+                else
+                  Time.zone.parse(value)
+                end
+      end
+
+      value
+    end
+  end
+end

data/lib/jsonb_accessor/macro.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module JsonbAccessor
+  module Macro
+    module ClassMethods
+      def jsonb_accessor(jsonb_attribute, field_types)
+        names_and_store_keys = field_types.each_with_object({}) do |(name, type), mapping|
+          _type, options = Array(type)
+          mapping[name.to_s] = (options.try(:delete, :store_key) || name).to_s
+        end
+
+        # Defines virtual attributes for each jsonb field.
+        field_types.each do |name, type|
+          next attribute name, type unless type.is_a?(Array)
+          next attribute name, *type unless type.last.is_a?(Hash)
+
+          *args, keyword_args = type
+          attribute name, *args, **keyword_args
+        end
+
+        store_key_mapping_method_name = "jsonb_store_key_mapping_for_#{jsonb_attribute}"
+        # Defines methods on the model class
+        class_methods = Module.new do
+          # Allows us to get a mapping of field names to store keys scoped to the column
+          define_method(store_key_mapping_method_name) do
+            superclass_mapping = superclass.try(store_key_mapping_method_name) || {}
+            superclass_mapping.merge(names_and_store_keys)
+          end
+        end
+        # We extend with class methods here so we can use the results of methods it defines to define more useful methods later
+        extend class_methods
+
+        # Get field names to default values mapping
+        names_and_defaults = field_types.each_with_object({}) do |(name, type), mapping|
+          _type, options = Array(type)
+          field_default = options.try(:delete, :default)
+          mapping[name.to_s] = field_default unless field_default.nil?
+        end
+
+        # Get store keys to default values mapping
+        store_keys_and_defaults = JsonbAccessor::Helpers.convert_keys_to_store_keys(names_and_defaults, public_send(store_key_mapping_method_name))
+
+        # Define jsonb_defaults_mapping_for_<jsonb_attribute>
+        defaults_mapping_method_name = "jsonb_defaults_mapping_for_#{jsonb_attribute}"
+        class_methods.instance_eval do
+          define_method(defaults_mapping_method_name) do
+            superclass_mapping = superclass.try(defaults_mapping_method_name) || {}
+            superclass_mapping.merge(store_keys_and_defaults)
+          end
+        end
+
+        all_defaults_mapping = public_send(defaults_mapping_method_name)
+        # Fields may have procs as default value. This means `all_defaults_mapping` may contain procs as values. To make this work
+        # with the attributes API, we need to wrap `all_defaults_mapping` with a proc itself, making sure it returns a plain hash
+        # each time it is evaluated.
+        all_defaults_mapping_proc =
+          if all_defaults_mapping.present?
+            -> { all_defaults_mapping.transform_values { |value| value.respond_to?(:call) ? value.call : value }.to_h.compact }
+          end
+        attribute jsonb_attribute, :jsonb, default: all_defaults_mapping_proc if all_defaults_mapping_proc.present?
+
+        # Setters are in a module to allow users to override them and still be able to use `super`.
+        setters = Module.new do
+          # Overrides the setter created by `attribute` above to make sure the jsonb attribute is kept in sync.
+          names_and_store_keys.each do |name, store_key|
+            define_method("#{name}=") do |value|
+              super(value)
+
+              attribute_value = public_send(name)
+              # Rails always saves time based on `default_timezone`. Since #as_json considers timezone, manual conversion is needed
+              if attribute_value.acts_like?(:time)
+                attribute_value = (JsonbAccessor::Helpers.active_record_default_timezone == :utc ? attribute_value.utc : attribute_value.in_time_zone).strftime("%F %R:%S.%L")
+              end
+
+              new_values = (public_send(jsonb_attribute) || {}).merge(store_key => attribute_value)
+              write_attribute(jsonb_attribute, new_values)
+            end
+          end
+
+          # Overrides the jsonb attribute setter to make sure the jsonb fields are kept in sync.
+          define_method("#{jsonb_attribute}=") do |value|
+            value ||= {}
+            names_to_store_keys = self.class.public_send(store_key_mapping_method_name)
+
+            # this is the raw hash we want to save in the jsonb_attribute
+            value_with_store_keys = JsonbAccessor::Helpers.convert_keys_to_store_keys(value, names_to_store_keys)
+            write_attribute(jsonb_attribute, value_with_store_keys)
+
+            # this maps attributes to values
+            value_with_named_keys = JsonbAccessor::Helpers.convert_store_keys_to_keys(value, names_to_store_keys)
+
+            empty_named_attributes = names_to_store_keys.transform_values { nil }
+            empty_named_attributes.merge(value_with_named_keys).each do |name, attribute_value|
+              # Only proceed if this attribute has been defined using `jsonb_accessor`.
+              next unless names_to_store_keys.key?(name)
+
+              write_attribute(name, attribute_value)
+            end
+          end
+        end
+        include setters
+
+        # Makes sure new objects have the appropriate values in their jsonb fields.
+        after_initialize do
+          next unless has_attribute? jsonb_attribute
+
+          jsonb_values = public_send(jsonb_attribute) || {}
+          jsonb_values.each do |store_key, value|
+            name = names_and_store_keys.key(store_key)
+            next unless name
+
+            write_attribute(
+              name,
+              JsonbAccessor::Helpers.deserialize_value(value, self.class.type_for_attribute(name).type)
+            )
+            clear_attribute_change(name) if persisted?
+          end
+        end
+
+        JsonbAccessor::AttributeQueryMethods.new(self).define(store_key_mapping_method_name, jsonb_attribute)
+      end
+    end
+  end
+end

data/lib/jsonb_accessor/query_builder.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module JsonbAccessor
+  module QueryBuilder
+    extend ActiveSupport::Concern
+
+    included do
+      scope(:jsonb_contains, lambda do |column_name, attributes|
+        JsonbAccessor::QueryHelper.validate_column_name!(all, column_name)
+        where("#{table_name}.#{column_name} @> (?)::jsonb", attributes.to_json)
+      end)
+
+      scope(:jsonb_excludes, lambda do |column_name, attributes|
+        JsonbAccessor::QueryHelper.validate_column_name!(all, column_name)
+        where.not("#{table_name}.#{column_name} @> (?)::jsonb", attributes.to_json)
+      end)
+
+      scope(:jsonb_number_where, lambda do |column_name, field_name, given_operator, value|
+        JsonbAccessor::QueryHelper.validate_column_name!(all, column_name)
+        operator = JsonbAccessor::QueryHelper::NUMBER_OPERATORS_MAP.fetch(given_operator.to_s)
+        where("(#{table_name}.#{column_name} ->> ?)::float #{operator} ?", field_name, value)
+      end)
+
+      scope(:jsonb_number_where_not, lambda do |column_name, field_name, given_operator, value|
+        JsonbAccessor::QueryHelper.validate_column_name!(all, column_name)
+        operator = JsonbAccessor::QueryHelper::NUMBER_OPERATORS_MAP.fetch(given_operator.to_s)
+        where.not("(#{table_name}.#{column_name} ->> ?)::float #{operator} ?", field_name, value)
+      end)
+
+      scope(:jsonb_time_where, lambda do |column_name, field_name, given_operator, value|
+        JsonbAccessor::QueryHelper.validate_column_name!(all, column_name)
+        operator = JsonbAccessor::QueryHelper::TIME_OPERATORS_MAP.fetch(given_operator.to_s)
+        where("(#{table_name}.#{column_name} ->> ?)::timestamp #{operator} ?", field_name, value)
+      end)
+
+      scope(:jsonb_time_where_not, lambda do |column_name, field_name, given_operator, value|
+        JsonbAccessor::QueryHelper.validate_column_name!(all, column_name)
+        operator = JsonbAccessor::QueryHelper::TIME_OPERATORS_MAP.fetch(given_operator.to_s)
+        where.not("(#{table_name}.#{column_name} ->> ?)::timestamp #{operator} ?", field_name, value)
+      end)
+
+      scope(:jsonb_where, lambda do |column_name, attributes|
+        query = all
+        contains_attributes = {}
+
+        JsonbAccessor::QueryHelper.convert_ranges(attributes).each do |name, value|
+          if JsonbAccessor::QueryHelper.number_query_arguments?(value)
+            value.each { |operator, query_value| query = query.jsonb_number_where(column_name, name, operator, query_value) }
+          elsif JsonbAccessor::QueryHelper.time_query_arguments?(value)
+            value.each { |operator, query_value| query = query.jsonb_time_where(column_name, name, operator, query_value) }
+          else
+            contains_attributes[name] = value
+          end
+        end
+
+        query.jsonb_contains(column_name, contains_attributes)
+      end)
+
+      scope(:jsonb_where_not, lambda do |column_name, attributes|
+        query = all
+        excludes_attributes = {}
+
+        attributes.each do |name, value|
+          raise JsonbAccessor::QueryHelper::NotSupported, "`jsonb_where_not` scope does not accept ranges as arguments. Given `#{value}` for `#{name}` field" if value.is_a?(Range)
+
+          if JsonbAccessor::QueryHelper.number_query_arguments?(value)
+            value.each { |operator, query_value| query = query.jsonb_number_where_not(column_name, name, operator, query_value) }
+          elsif JsonbAccessor::QueryHelper.time_query_arguments?(value)
+            value.each { |operator, query_value| query = query.jsonb_time_where_not(column_name, name, operator, query_value) }
+          else
+            excludes_attributes[name] = value
+          end
+        end
+
+        excludes_attributes.empty? ? query : query.jsonb_excludes(column_name, excludes_attributes)
+      end)
+
+      scope(:jsonb_order, lambda do |column_name, field_name, direction|
+        JsonbAccessor::QueryHelper.validate_column_name!(all, column_name)
+        JsonbAccessor::QueryHelper.validate_field_name!(all, column_name, field_name)
+        JsonbAccessor::QueryHelper.validate_direction!(direction)
+        order(Arel.sql("(#{table_name}.#{column_name} -> '#{field_name}') #{direction}"))
+      end)
+    end
+  end
+end

data/lib/jsonb_accessor/query_helper.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module JsonbAccessor
+  module QueryHelper
+    # Errors
+    InvalidColumnName = Class.new(StandardError)
+    InvalidFieldName = Class.new(StandardError)
+    InvalidDirection = Class.new(StandardError)
+    NotSupported = Class.new(StandardError)
+
+    # Constants
+    GREATER_THAN = ">"
+    GREATER_THAN_OR_EQUAL_TO = ">="
+    LESS_THAN = "<"
+    LESS_THAN_OR_EQUAL_TO = "<="
+
+    NUMBER_OPERATORS_MAP = {
+      GREATER_THAN => GREATER_THAN,
+      "greater_than" => GREATER_THAN,
+      "gt" => GREATER_THAN,
+      GREATER_THAN_OR_EQUAL_TO => GREATER_THAN_OR_EQUAL_TO,
+      "greater_than_or_equal_to" => GREATER_THAN_OR_EQUAL_TO,
+      "gte" => GREATER_THAN_OR_EQUAL_TO,
+      LESS_THAN => LESS_THAN,
+      "less_than" => LESS_THAN,
+      "lt" => LESS_THAN,
+      LESS_THAN_OR_EQUAL_TO => LESS_THAN_OR_EQUAL_TO,
+      "less_than_or_equal_to" => LESS_THAN_OR_EQUAL_TO,
+      "lte" => LESS_THAN_OR_EQUAL_TO
+    }.freeze
+
+    NUMBER_OPERATORS = NUMBER_OPERATORS_MAP.keys.freeze
+
+    TIME_OPERATORS_MAP = {
+      "after" => GREATER_THAN,
+      "before" => LESS_THAN
+    }.freeze
+
+    TIME_OPERATORS = TIME_OPERATORS_MAP.keys.freeze
+
+    ORDER_DIRECTIONS = [:asc, :desc, "asc", "desc"].freeze
+
+    class << self
+      def validate_column_name!(query, column_name)
+        raise InvalidColumnName, "a column named `#{column_name}` does not exist on the `#{query.model.table_name}` table" if query.model.columns.none? { |column| column.name == column_name.to_s }
+      end
+
+      def validate_field_name!(query, column_name, field_name)
+        store_keys = query.model.public_send("jsonb_store_key_mapping_for_#{column_name}").values
+        if store_keys.exclude?(field_name.to_s)
+          valid_field_names = store_keys.map { |key| "`#{key}`" }.join(", ")
+          raise InvalidFieldName, "`#{field_name}` is not a valid field name, valid field names include: #{valid_field_names}"
+        end
+      end
+
+      def validate_direction!(option)
+        raise InvalidDirection, "`#{option}` is not a valid direction for ordering, only `asc` and `desc` are accepted" if ORDER_DIRECTIONS.exclude?(option)
+      end
+
+      def number_query_arguments?(arg)
+        arg.is_a?(Hash) && arg.keys.map(&:to_s).all? { |key| NUMBER_OPERATORS.include?(key) }
+      end
+
+      def time_query_arguments?(arg)
+        arg.is_a?(Hash) && arg.keys.map(&:to_s).all? { |key| TIME_OPERATORS.include?(key) }
+      end
+
+      def convert_number_ranges(attributes)
+        attributes.each_with_object({}) do |(name, value), new_attributes|
+          is_range = value.is_a?(Range)
+
+          new_attributes[name] = if is_range && value.first.is_a?(Numeric) && value.exclude_end?
+                                   { greater_than_or_equal_to: value.first, less_than: value.end }
+                                 elsif is_range && value.first.is_a?(Numeric)
+                                   { greater_than_or_equal_to: value.first, less_than_or_equal_to: value.end }
+                                 else
+                                   value
+                                 end
+        end
+      end
+
+      def convert_time_ranges(attributes)
+        attributes.each_with_object({}) do |(name, value), new_attributes|
+          is_range = value.is_a?(Range)
+
+          if is_range && (value.first.is_a?(Time) || value.first.is_a?(Date))
+            start_time = value.first
+            end_time = value.end
+            new_attributes[name] = { before: end_time, after: start_time }
+          else
+            new_attributes[name] = value
+          end
+        end
+      end
+
+      def convert_ranges(attributes)
+        %i[convert_number_ranges convert_time_ranges].reduce(attributes) do |new_attributes, converter_method|
+          public_send(converter_method, new_attributes)
+        end
+      end
+    end
+  end
+end

data/lib/jsonb_accessor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JsonbAccessor
+  VERSION = "1.3.7"
+end

data/lib/jsonb_accessor.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+require "active_record/connection_adapters/postgresql_adapter"
+
+require "jsonb_accessor/version"
+require "jsonb_accessor/helpers"
+require "jsonb_accessor/macro"
+require "jsonb_accessor/query_helper"
+require "jsonb_accessor/query_builder"
+require "jsonb_accessor/attribute_query_methods"
+
+module JsonbAccessor
+  extend ActiveSupport::Concern
+  include Macro
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.include JsonbAccessor
+  ActiveRecord::Base.include JsonbAccessor::QueryBuilder
+end

metadata

@@ -0,0 +1,263 @@
+--- !ruby/object:Gem::Specification
+name: jsonb_accessor
+version: !ruby/object:Gem::Version
+  version: 1.3.7
+platform: java
+authors:
+- Michael Crismali
+- Joe Hirn
+- Jason Haruska
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  name: activerecord
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  name: activesupport
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '50.0'
+  name: activerecord-jdbcpostgresql-adapter
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '50.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  name: appraisal
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: awesome_print
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  name: database_cleaner
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: pry
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: pry-doc
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: pry-nav
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  name: psych
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  name: rubocop
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Adds typed jsonb backed fields to your ActiveRecord models.
+email:
+- michael@crismali.com
+- joe@devmynd.com
+- jason@haruska.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- Appraisals
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Dockerfile
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- UPGRADE_GUIDE.md
+- bin/console
+- bin/setup
+- db/config.yml
+- db/migrate/20150407031737_set_up_testing_db.rb
+- db/schema.rb
+- docker-compose.yml
+- gemfiles/activerecord_5.0.0.gemfile
+- gemfiles/activerecord_5.1.0.gemfile
+- gemfiles/activerecord_5.2.0.gemfile
+- gemfiles/activerecord_6.0.0.gemfile
+- gemfiles/activerecord_6.1.0.gemfile
+- gemfiles/activerecord_7.0.1.gemfile
+- jsonb_accessor.gemspec
+- lib/jsonb_accessor.rb
+- lib/jsonb_accessor/attribute_query_methods.rb
+- lib/jsonb_accessor/helpers.rb
+- lib/jsonb_accessor/macro.rb
+- lib/jsonb_accessor/query_builder.rb
+- lib/jsonb_accessor/query_helper.rb
+- lib/jsonb_accessor/version.rb
+homepage: https://github.com/devmynd/jsonb_accessor
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Adds typed jsonb backed fields to your ActiveRecord models.
+test_files: []