json_schematize 0.6.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0b80648f60c06f94a7530ba812d49891e57d28549cd63f1ba42e7adfd74cb03
-  data.tar.gz: 0b97d3b638941ce37b2907640840759fc9462df4447d04f3828847bcb580aa8d
+  metadata.gz: ddc1b50176fdee42d41912116919c05fdd1c34e17c7932b4e588cb380abfd8f5
+  data.tar.gz: ee85dc09adc5d4505e75d04aa524d43f2aa6859ee82eddf474fbdd471613f885
 SHA512:
-  metadata.gz: cb8ac2f474f45303d6c9f17924ba1a92de71cb6cd645382ec12579e2d69274039ba8bc67c528c08f3fad0f2103265ac2792c8c88f12aec37b754b47a61f71691
-  data.tar.gz: 3f49f060c7fbcefd0705256e23853eb4220c5d63636c75be1e15f721b3fa2d0d631965424101e69cee1c4108d1976191a4717d1643ff15250a746b48d0794002
+  metadata.gz: 21a5a7c6d3e194c1ba1149b3b6e37dfe6da7724ee317f8e2d3856b1b917dbcaedad510a8cce42f3c6340b3a66d5b662dc0cac11ce598916b73ef1c59a6aed739
+  data.tar.gz: '09d5cb8dd10a426f98b8fbbc89ab14cb76800f3c3bdb7acb0bb7d640a9a135453732d533b75703a6b639e19b937b8b32ad77c502f804840fbf3ae49b6ec06f7a'

data/.circleci/config.yml

@@ -1,202 +1,29 @@
 version: 2.1
 
-# Declare the orbs that we'll use in our config.
-# read more about orbs: https://circleci.com/docs/2.0/using-orbs/
 orbs:
   ruby: circleci/ruby@1.0
+  node: circleci/node@2
+  cst: cst/framework@1
 
-common_envs: &common_envs
-  environment:
-    APP_BUNDLER_VERSION: "2.3.8"
-    REDIS_URL: "redis://127.0.0.1"
-
-executors:
-  gem:
-    parameters:
-      ruby-version:
-        default: "3.0.0"
-        type: string
-    docker:
-      - image: cimg/ruby:<< parameters.ruby-version >>
-      - image: circleci/redis:6.0
-
-    <<: *common_envs
-
-commands:
-  bundler-preamble:
-    description: "Install ruby and the Gemfile dependencies"
-    parameters:
-      ruby-version:
-        type: string
-        default: "3"
-        description: "Ruby Gem version"
-      key-name:
-        type: string
-        default: ""
-        description: Custom name to add to the cache key
-      cache-breaker:
-        type: string
-        default: "0"
-        description: "Cache breaker to force new cache instantiation"
-      keep-lock-file:
-        type: boolean
-        default: false
-        description: "Retain lock file when bit is set to true. Otherwise generate a new one specific for this build"
-    steps:
-      - checkout
-      - attach_workspace:
-          at: workspace
-      - unless:
-            condition:
-              equal: [ true, << parameters.keep-lock-file >> ]
-            steps:
-              - run:
-                  name: Remove Gemfile.lock
-                  command: rm Gemfile.lock
-      - restore_cache:
-          key: bundle-<< parameters.ruby-version >>-<< parameters.key-name >>-{{ checksum "Gemfile" }}-<< parameters.cache-breaker >>
-      - ruby/install-deps:
-          path: vendor/bundle
-          with-cache: false
-      - run:
-          name: "Update dependencies"
-          command: bundle update
-      - save_cache:
-          key: bundle-<< parameters.ruby-version >>-<< parameters.key-name >>-{{ checksum "Gemfile" }}-<< parameters.cache-breaker >>
-          paths:
-            - vendor/bundle
-
-jobs:
-  publish-rubygems:
-    executor: gem
-    steps:
-      - bundler-preamble:
-          keep-lock-file: true
-      - run:
-          name: Publish to Ruby Gems
-          command: |
-            if [ -z "$GEM_HOST_API_KEY" ]; then
-              echo 'Environment variable GEM_HOST_API_KEY is not present'
-              exit 1
-            fi
-            gem_output=$(gem build json_schematize.gemspec)
-            VERSION=$(printf "$gem_output" | awk '/Version: / {print $2}')
-            FILE=$(printf "$gem_output" | awk '/File: / {print $2}')
-
-            gem push ${FILE}
-
-  publish-github:
-    executor: gem
-    steps:
-      - bundler-preamble:
-          keep-lock-file: true
-      - run:
-          name: 'Get Go'
-          command: |
-            sudo apt-get update -qq
-            sudo apt-get -y --no-install-recommends install golang-go
-      - run:
-          name: 'Set Git stats'
-          command: |
-            git config user.name $GITHUB_USER
-            git config user.email $GITHUB_EMAIL
-      - run:
-          name: Publish Git Release
-          command: |
-            curl -sSL https://github.com/tcnksm/ghr/releases/download/v0.13.0/ghr_v0.13.0_linux_amd64.tar.gz | tar xz -f - -C . ghr_v0.13.0_linux_amd64/ghr
-            mv ghr_v0.13.0_linux_amd64/ghr .
-            rm -rf ghr_v0.13.0_linux_amd64
-            chmod 0755 ghr
-
-            if [ -z "$GITHUB_TOKEN" ]; then
-              echo 'Environment variable GITHUB_TOKEN is not present'
-              exit 1
-            fi
-
-            if [ -z "$GITHUB_USER" ]; then
-              echo 'Environment variable GITHUB_USER is not present'
-              exit 1
-            fi
-
-            if [ $(git tag -l "$VERSION") ]; then
-              echo "Pre existing version $VERSION, not tagging."
-              exit 0
-            fi
-
-            gem_output=$(gem build json_schematize.gemspec)
-            VERSION=$(printf "$gem_output" | awk '/Version: / {print $2}')
-            FILE=$GEM_PATH$(printf "$gem_output" | awk '/File: / {print $2}')
-
-            git tag -a $VERSION -m "$VERSION"
-
-            SHA=$(git rev-parse HEAD)
-            ./ghr -soft -t ${GITHUB_TOKEN} -u ${GITHUB_USER} -r json_schematize -c ${SHA} ${VERSION} ${FILE}
-
-  test:
-    parameters:
-      ruby-version:
-        default: "3.0.0"
-        type: string
-        description: "Ruby version to test against"
-    executor:
-      name: gem
-      ruby-version: << parameters.ruby-version >>
-    steps:
-      - bundler-preamble:
-          ruby-version: "<< parameters.ruby-version >>"
-      - run:
-          name: Setup Climate Control test-reporter
-          command: |
-            curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-            chmod +x ./cc-test-reporter
-      - run:
-          name: Waiting for Redis to be ready
-          command: |
-            for i in `seq 1 10`;
-            do
-              nc -z localhost 6379 && echo Success && exit 0
-              echo -n .
-              sleep 1
-            done
-            echo Failed waiting for Redis to be available && exit 1
-      - run:
-          name: Run and Report tests
-          command: |
-            ./cc-test-reporter before-build
-            SIMPLE_COV_RUN=true bundle exec rspec --format RspecJunitFormatter --out test-results/rspec/rspec.xml --format progress --color
-      - when:
-          condition:
-            equal:
-              [
-                required-test-ruby2.7.5,
-                required-test-ruby<< parameters.ruby-version >>,
-              ]
-          steps:
-            - run:
-                name: Report CodeClimate Coverage
-                command: ./cc-test-reporter after-build --coverage-input-type simplecov
 workflows:
   version: 2
   yeet-le-jobs:
     jobs:
-      - test:
+      - cst/enforce-gem-version-bump
+      - cst/rspec-ruby:
+          rspec-system-args: "SIMPLE_COV_RUN=true"
+          cc-report-collect-ruby: "2.7.5"
           matrix:
             parameters:
               ruby-version: ["2.7.5" , "3.0.0", "3.0.3"]
             alias: required-matrix-tests
-          name: required-test-ruby<< matrix.ruby-version >>
-      - publish-github:
-          requires:
-            - required-matrix-tests
-          filters:
-            branches:
-              only:
-                - main
-      - publish-rubygems:
+          name: test-ruby<< matrix.ruby-version >>
+      - cst/publish-gem:
+          publish-git: true
+          publish-default-gem: true
           requires:
             - required-matrix-tests
           filters:
             branches:
               only:
                 - main
-

data/Gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gemspec
 
-gem 'redis'
+gem 'activesupport'
 gem 'faker'
 gem 'pry'
 gem 'rspec', '~> 3.0'

data/Gemfile.lock

@@ -1,14 +1,19 @@
 PATH
   remote: .
   specs:
-    json_schematize (0.6.1)
+    json_schematize (0.7.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.0.2.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
     byebug (11.1.3)
     coderay (1.1.3)
-    concurrent-ruby (1.1.10)
+    concurrent-ruby (1.1.9)
     diff-lcs (1.5.0)
     docile (1.4.0)
     faker (2.20.0)
@@ -16,6 +21,7 @@ GEM
     i18n (1.10.0)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
+    minitest (5.15.0)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
@@ -23,7 +29,6 @@ GEM
       byebug (~> 11.0)
       pry (~> 0.13.0)
     rake (12.3.3)
-    redis (4.6.0)
     rspec (3.11.0)
       rspec-core (~> 3.11.0)
       rspec-expectations (~> 3.11.0)
@@ -33,7 +38,7 @@ GEM
     rspec-expectations (3.11.0)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.1)
+    rspec-mocks (3.11.0)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-support (3.11.0)
@@ -45,17 +50,19 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
 
 PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
+  activesupport
   faker
   json_schematize!
   pry
   pry-byebug
   rake (~> 12.0)
-  redis
   rspec (~> 3.0)
   rspec_junit_formatter
   simplecov

data/docker-compose.yml

@@ -10,13 +10,6 @@ services:
       - .:/gem
       - ..:/local
       - bundle-cache:/usr/local/bundle:delegated
-    environment:
-      REDIS_URL: redis://redis
-    links:
-      - redis
-  redis:
-    image: redis
-    expose:
-      - 6379
+
 volumes:
   bundle-cache:

data/json_schematize.gemspec

@@ -29,6 +29,8 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "class_composer", "~> 1.0"
+
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec", "~> 3.0"

data/lib/json_schematize/cache/class_methods/client.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module JsonSchematize::Cache::ClassMethods
+  module Client
+
+    def __deserialize_keys__(key_hash_bytes)
+      return [{}, 0] if key_hash_bytes.nil?
+
+      min_expire = Time.now.to_i
+      key_hash =  Marshal.load(key_hash_bytes)
+      keys_removed = 0
+      key_hash.each do |key, expire|
+        next if expire.to_i > min_expire
+
+        key_hash.delete(key)
+        keys_removed += 1
+      end
+
+      [key_hash, keys_removed]
+    rescue StandardError => e
+      ::Kernel.warn("Yikes!! Failed to parse. Returning empty. #{e.message}")
+      [{}, 0]
+    end
+
+    def __update_record_keeper__!(expire:, cache_key:, delete_key: false)
+      record_of_truth = cached_keys(with_expire: true)
+      if delete_key
+        record_of_truth.delete(cache_key)
+      else
+        record_of_truth[cache_key] = expire
+      end
+      serialized_string = Marshal.dump(record_of_truth)
+
+      cache_client.write(cache_namespace, serialized_string)
+    end
+
+    def __delete_record__!(key)
+      __update_record_keeper__!(expire: nil, cache_key: key, delete_key: true)
+    end
+
+    def cached_keys(with_expire: false, count_removed: false)
+      raw_string = cache_client.read(cache_namespace)
+      key_hash, keys_removed = __deserialize_keys__(raw_string)
+      return key_hash if with_expire
+      return keys_removed if count_removed
+
+      key_hash.keys
+    end
+
+    def cached_items(key_includes: nil)
+      clear_unscored_items! if rand > cache_configuration[:stochastic_cache_bust]
+
+      cached_keys.map do |key|
+        if key_includes
+          next unless key.include?(key_includes)
+        end
+
+        serialized_string = cache_client.read(key)
+        Marshal.load(serialized_string)
+      end.compact
+    end
+
+    def clear_cache!
+      cache_client.delete_multi(([cache_namespace] + cached_keys))
+    end
+
+    def clear_unscored_items!
+      cached_keys(count_removed: true)
+    end
+  end
+end

data/lib/json_schematize/cache/class_methods/configuration.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module JsonSchematize::Cache::ClassMethods
+  module Configuration
+    def cache_options(key: nil, cache_client: nil, cache_namespace: nil, ttl: nil, update_on_change: nil, stochastic_cache_bust: nil)
+      cache_configuration[:key] = key if key
+      cache_configuration[:ttl] = ttl if ttl
+      cache_configuration[:stochastic_cache_bust] = stochastic_cache_bust if stochastic_cache_bust
+      cache_configuration[:update_on_change] = update_on_change if update_on_change
+      cache_namespace = cache_configuration[:cache_namespace] = cache_namespace if cache_namespace
+
+      self.cache_client = cache_configuration[:cache_client] = cache_client if cache_client
+    end
+
+    def cache_namespace
+       cache_configuration[:cache_namespace] ||= "jss:#{self.name.downcase}"
+    end
+
+    def cache_namespace=(namespace)
+      cache_configuration[:cache_namespace] = namespace
+    end
+
+    def cache_configuration
+      @cache_configuration ||= begin
+        {
+          cache_client: JsonSchematize.configuration.cache_client,
+          cache_namespace: JsonSchematize.configuration.cache_namespace,
+          key: JsonSchematize.configuration.cache_key,
+          stochastic_cache_bust: JsonSchematize.configuration.cache_stochastic_bust,
+          ttl: JsonSchematize.configuration.cache_ttl,
+          update_on_change: JsonSchematize.configuration.cache_update_on_change,
+        }
+      end
+    end
+
+    def cache_client=(client)
+      cache_configuration[:cache_client] = client
+    end
+
+    def cache_client
+      cache_configuration[:cache_client].is_a?(Proc) ? cache_configuration[:cache_client].call : cache_configuration[:cache_client]
+    end
+  end
+end

data/lib/json_schematize/cache/instance_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JsonSchematize
   module Cache
     module InstanceMethods
@@ -12,16 +14,17 @@ module JsonSchematize
 
       def __update_cache_item__(with_delete: true)
         __clear_entry__! if with_delete # needs to get done first in the event the cache_key changes
-        client = self.class.redis_client
+        client = self.class.cache_client
         ttl = self.class.cache_configuration[:ttl].to_i
         score = Time.now.to_i + ttl
-        client.zadd(__cache_namespace__, score, __cache_key__)
-        client.set(__cache_key__, Marshal.dump(self), ex: ttl)
+        self.class.__update_record_keeper__!(expire: score, cache_key: __cache_key__)
+
+        client.write(__cache_key__, Marshal.dump(self), expires_in: ttl)
       end
 
       def __clear_entry__!
-        self.class.redis_client.zrem(__cache_namespace__, __cache_key__)
-        self.class.redis_client.unlink(__cache_key__)
+        self.class.cache_client.delete(__cache_key__)
+        self.class.__delete_record__!(__cache_key__)
       end
 
       def __cache_key__

data/lib/json_schematize/cache.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
 require "json_schematize/cache/instance_methods"
-require "json_schematize/cache/class_methods"
+require "json_schematize/cache/class_methods/client"
+require "json_schematize/cache/class_methods/configuration"
 
 module JsonSchematize
   module Cache
-    def self.included(base)
-      raise StandardError, "Yikes! JsonSchematize::Cache Needs Redis to work. Include it as a gem" unless defined?(Redis)
+    module ClassMethods; end
 
+    def self.included(base)
       base.include(JsonSchematize::Cache::InstanceMethods)
-      base.extend(JsonSchematize::Cache::ClassMethods)
+      base.extend(JsonSchematize::Cache::ClassMethods::Client)
+      base.extend(JsonSchematize::Cache::ClassMethods::Configuration)
     end
   end
 end

data/lib/json_schematize/configuration.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "class_composer"
+require "json_schematize/errors"
+
+module JsonSchematize
+  class Configuration
+    include ClassComposer::Generator
+
+    DEFAULT_ONE_MIN = 60 * 60
+    DEFAULT_ONE_HOUR = DEFAULT_ONE_MIN * 60
+    DEFAULT_ONE_DAY = DEFAULT_ONE_HOUR * 24
+    DEFAULT_CACHE_OPTIONS = {
+      cache_client: nil,
+      cache_key: ->(val, _custom_key) { val.hash },
+      cache_namespace: nil,
+      cache_stochastic_bust: 0.8,
+      cache_ttl: DEFAULT_ONE_DAY,
+      cache_update_on_change: true,
+    }
+
+    add_composer :cache_key, allowed: Proc, default: DEFAULT_CACHE_OPTIONS[:cache_key], validation_error_klass: ::JsonSchematize::ConfigError, invalid_message: -> (val) { _assign_msg_("cache_key", "->(val, cusom_key) { val.hash }", "Default proc to assign cache key") }
+    add_composer :cache_namespace, allowed: [String, Symbol]
+    add_composer :cache_stochastic_bust, allowed: [Float, Integer], default: DEFAULT_CACHE_OPTIONS[:cache_stochastic_bust]
+    add_composer :cache_ttl, allowed: [Float, Integer], default: DEFAULT_CACHE_OPTIONS[:cache_ttl]
+    add_composer :cache_update_on_change, allowed: [TrueClass, FalseClass], default: DEFAULT_CACHE_OPTIONS[:cache_update_on_change]
+
+    def cache_hash
+      DEFAULT_CACHE_OPTIONS.map do |key, value|
+        val = public_send(key)
+        [key, val]
+      end.to_h
+    end
+
+    def cache_key=(value)
+      if value.is_a? Proc
+        @key = value
+        return @key
+      end
+
+      assign = _assign_msg_("cache_key", "->(val, cusom_key) { val.hash }", "Default proc to assign cache key")
+      msg = "cache_key must be a proc. \n#{assign}"
+      raise JsonSchematize::ConfigError, msg
+    end
+
+    def cache_client=(client)
+      min_required = [:read, :write, :delete_multi, :read_multi]
+      min_required.each do |meth|
+        next if client.methods.include?(meth)
+
+        assign = _assign_msg_("cache_client", "_initialized_client_", "Preferably an ActiveSupport::Cache::Store supported client")
+        msg = "Passed in client does not accept minimum values. #{min_required} are required methods \n#{assign}"
+        raise JsonSchematize::ConfigError, msg
+      end
+
+
+      @cache_client = client
+    end
+
+    def cache_client
+      return @cache_client unless @cache_client.nil?
+
+      begin
+        Kernel.require 'active_support'
+      rescue LoadError
+        assign = _assign_msg_("cache_client", "ActiveSupport::Cache::MemoryStore.new", "A ActiveSupport::Cache::Store supported client")
+        msg = "Default client missing. Attempted to use 'active_support/cache' but not loaded. \n#{assign}"
+        raise JsonSchematize::ConfigError, msg
+      end
+
+      @cache_client = ActiveSupport::Cache::MemoryStore.new
+      @cache_client
+    end
+
+    private
+
+    def _assign_msg_(key, assignment, comment)
+      config = "  config.#{key} = #{assignment} # #{comment}"
+      "\n\n# Initializer for json_schematize\n" \
+      "JsonSchematize.configure do |config|\n" \
+      "#{config}\n" \
+      "end\n\n"
+    end
+  end
+end

data/lib/json_schematize/errors.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JsonSchematize
+  class Error < StandardError; end
+  class ConfigError < Error; end
+  class FieldError < Error; end
+
+  class InvalidField < Error; end
+  class InvalidFieldByValidator < InvalidField; end
+  class InvalidFieldByType < InvalidField; end
+  class InvalidFieldByArrayOfTypes < InvalidField; end
+
+  ## Customized class errors
+  class UndefinedBoolean < Error; end
+end

data/lib/json_schematize/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JsonSchematize
-  VERSION = "0.6.1"
+  VERSION = "0.8.0"
 end

data/lib/json_schematize.rb

@@ -1,21 +1,29 @@
 # frozen_string_literal: true
 
-require "json_schematize/version"
-
 require "json_schematize/base"
 require "json_schematize/boolean"
-require "json_schematize/generator"
+require "json_schematize/configuration"
 require "json_schematize/empty_value"
+require "json_schematize/errors"
+require "json_schematize/generator"
 require "json_schematize/version"
 
 module JsonSchematize
-  class Error < StandardError; end
-  class FieldError < Error; end
-  class InvalidField < Error; end
-  class InvalidFieldByValidator < InvalidField; end
-  class InvalidFieldByType < InvalidField; end
-  class InvalidFieldByArrayOfTypes < InvalidField; end
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  def self.configuration
+    @configuration ||= JsonSchematize::Configuration.new
+  end
+
+  def self.configuration=(object)
+    raise ConfigError, "Expected configuration to be a JsonSchematize::Configuration" unless object.is_a?(JsonSchematize::Configuration)
+
+    @configuration = object
+  end
 
-  ## Customized class errors
-  class UndefinedBoolean < Error; end
+  def self.cache_client
+    configuration.cache_client
+  end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: json_schematize
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Matt Taylor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-02 00:00:00.000000000 Z
+date: 2022-07-04 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: class_composer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -92,9 +106,12 @@ files:
 - lib/json_schematize/base.rb
 - lib/json_schematize/boolean.rb
 - lib/json_schematize/cache.rb
-- lib/json_schematize/cache/class_methods.rb
+- lib/json_schematize/cache/class_methods/client.rb
+- lib/json_schematize/cache/class_methods/configuration.rb
 - lib/json_schematize/cache/instance_methods.rb
+- lib/json_schematize/configuration.rb
 - lib/json_schematize/empty_value.rb
+- lib/json_schematize/errors.rb
 - lib/json_schematize/field.rb
 - lib/json_schematize/field_transformations.rb
 - lib/json_schematize/field_validators.rb
@@ -122,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.11
 signing_key: 
 specification_version: 4
 summary: This gem gives you the ability to turn API results into a standardized schema's

data/lib/json_schematize/cache/class_methods.rb

@@ -1,81 +0,0 @@
-module JsonSchematize
-  module Cache
-    module ClassMethods
-      DEFAULT_ONE_MIN = 60 * 60
-      DEFAULT_ONE_HOUR = DEFAULT_ONE_MIN * 60
-      DEFAULT_ONE_DAY = DEFAULT_ONE_HOUR * 24
-      DEFAULT_URL = ENV["CACHE_LAYER_REDIS_URL"] || ENV["REDIS_URL"]
-      DEFAULTS = {
-        redis_url: DEFAULT_URL,
-        ttl: DEFAULT_ONE_DAY,
-        key: ->(val, _custom_key) { val.hash },
-        update_on_change: true,
-        redis_client: ->() { ::Redis.new(url: DEFAULT_URL) },
-        stochastic_cache_bust: 0.8,
-      }
-
-      def cache_options(key: nil, redis_url: nil, redis_client: nil, cache_namespace: nil, ttl: nil, update_on_change: nil, stochastic_cache_bust: nil)
-        cache_configuration[:key] = key if key
-        cache_configuration[:ttl] = ttl if ttl
-        cache_configuration[:stochastic_cache_bust] = stochastic_cache_bust if stochastic_cache_bust
-        cache_configuration[:update_on_change] = update_on_change if update_on_change
-        cache_namespace = cache_configuration[:cache_namespace] = cache_namespace if cache_namespace
-
-        self.redis_client = cache_configuration[:redis_client] = redis_client if redis_client
-        self.redis_url = cache_configuration[:redis_url] = redis_url if redis_url
-      end
-
-      def cache_namespace
-         cache_configuration[:cache_namespace] ||= "jss:#{self.name.downcase}"
-      end
-
-      def cache_namespace=(namespace)
-        cache_configuration[:cache_namespace] = namespace
-      end
-
-      def cache_configuration
-        @cache_configuration ||= DEFAULTS.clone
-      end
-
-      def redis_client=(client)
-        cache_configuration[:redis_client] = client
-      end
-
-      def redis_url=(url)
-        cache_configuration[:redis_url] = url
-        cache_configuration[:redis_client] = ::Redis.new(url: url)
-      end
-
-      def redis_client
-        cache_configuration[:redis_client].is_a?(Proc) ? cache_configuration[:redis_client].call : cache_configuration[:redis_client]
-      end
-
-      def cached_keys
-        max_length = Time.now.to_i + cache_configuration[:ttl].to_i + 10
-        redis_client.zrangebyscore(cache_namespace, Time.now.to_i, "+inf")
-      end
-
-      def cached_items(key_includes: nil)
-        clear_unscored_items! if rand > cache_configuration[:stochastic_cache_bust]
-
-        cached_keys.map do |key|
-          if key_includes
-            next unless key.include?(key_includes)
-          end
-
-          serialized_string = redis_client.get(key)
-          Marshal.load(serialized_string)
-        end
-      end
-
-      def clear_cache!
-        redis_client.unlink(*cached_keys) if cached_keys.length > 0
-        redis_client.unlink(cache_namespace)
-      end
-
-      def clear_unscored_items!
-        redis_client.zremrangebyscore(cache_namespace, "-inf", Time.now.to_i)
-      end
-    end
-  end
-end