json_schematize 0.5.2 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 848f3c00ddb189bb1e82dc00336d599962a0f3b883318de678a14b88a3b09eb0
-  data.tar.gz: 647b9efcb2b29a9392103397f6902b2d4bd24320392f1fadff4f5856469ddb14
+  metadata.gz: 51e2681baf728aedcec1f36235ec2c80ba340228da15d8445b64d1f520c0226d
+  data.tar.gz: b0423051b51cce86508bc2e554365d7df66f88824124ad0157087e9b11577733
 SHA512:
-  metadata.gz: b44776ceb76244451c8121c1c3a306789b4d917f71176e813a0bc477c35424dd0d6414a006ff3d17ca15efb42af412028a336303ee9dc08519c1570447118960
-  data.tar.gz: 82db9b87e549ef31f658dce84e589372811269ab8249abe9e3913a8b6c73834c2c39fe6da1674b397e76225ea9c7283be837d15e75f24aa729ba2e0e9640e79e
+  metadata.gz: b84409952c29690b3e9f731dcd4bdf15cf5b63ca494875b319d383640ebd4197f4ec3b59b0d96721d9b6ae26d4784f40a1afbb4ade69911944530f3032a7451e
+  data.tar.gz: 786329f8de424b9a83a4eb7ac12884fa1f352f8eef62f4c65fb23b11e5561b10a2a3c204ccaf7cd4adda1988b9ca9bb2576a83df44bbbd8e88acc74a2ed6f710

data/.circleci/config.yml

@@ -1,189 +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"
-
-executors:
-  gem:
-    parameters:
-      ruby-version:
-        default: "3.0.0"
-        type: string
-    docker:
-      - image: cimg/ruby:<< parameters.ruby-version >>
-    <<: *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: 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:
+          name: test-ruby<< matrix.ruby-version >>
+      - cst/publish-gem:
+          publish-git: true
+          publish-default-gem: true
           requires:
             - required-matrix-tests
           filters:
             branches:
               only:
                 - main
-      - publish-rubygems:
-          requires:
-            - required-matrix-tests
-          filters:
-            branches:
-              only:
-                - main
-

data/CHANGELOG.md

@@ -7,10 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.1.0] - YYYY-MM-DD
+## [0.6.0] - 2021-04-01
 
 ### Added
-- New feature 1
+- Caching Layer
 - New feature 2
 
 ### Changed
@@ -24,3 +24,5 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 - Bug fix 1
 - Bug fix 2
+
+[//]: # (Added, Changed, Removed, Fixed are the possible headers for each changlog version)

data/Gemfile

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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    json_schematize (0.5.2)
+    json_schematize (0.6.0)
 
 GEM
   remote: https://rubygems.org/
@@ -23,6 +23,7 @@ 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)
@@ -54,6 +55,7 @@ DEPENDENCIES
   pry
   pry-byebug
   rake (~> 12.0)
+  redis
   rspec (~> 3.0)
   rspec_junit_formatter
   simplecov

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Matt Taylor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -110,6 +110,87 @@ class CustomClasses < JsonSchematize::Generator
 end
 ```
 
+### Caching Adapter
+
+JsonSchematize is built to be schema for API results. But what happens when you dont expect the result to change? Introducing the caching layer. This layer lets you cache a `JsonSchematize` object that can be queried from later
+
+**Note: This requires redis**
+
+```ruby
+class CachedClass < JsonSchematize::Generator
+  include JsonSchematize::Cache
+  cache_options key: ->(instance_of_cached_class, cache_key_from_initialization) { "#{instance_of_cached_class.id}:#{cache_key_from_initialization}" }
+  cache_options ttl: 7.days.to_i
+
+  schema_default option: :dig_type, value: :string
+
+  add_field name: :id, type: Integer
+end
+
+params = { id: 1 }
+CachedClass.new(cache_key: User.first.id, **params)
+###
+params = { "id" => 1 }
+CachedClass.new(params, cache_key: User.first.id)
+```
+
+#### Instance methods for Cache
+```ruby
+# optional cache_key added on initialization: Can be used to customize the cache entry for the instance
+item = CachedClass.new(cache_key: User.first.id, **params)
+
+# Update the cached item -- Note: This will overwrite the previous cached item IFF the `__cache_key__` remains the same. This is not gaurenteed
+# Optional Param: with_delete, Default true -- Will attempt to delete the original object
+item.__update_cache_item__
+
+# Manually delete the cached entry
+item.__clear_entry__!
+
+# Cache key for the item
+item.__cache_key__
+```
+
+#### Class methods for Cache
+```ruby
+# Retrieve all cached items for the class. Returns an array of CachedClass objects. Only objects that have not expired via TTL
+# Optional: key_includes: "string_expected_in_cache", default is nil and return everthing
+CachedClass.cached_items
+
+# Retrieves all valid object keys from the cache
+CachedClass.cached_keys
+
+# Clears all cached items for the given class
+CachedClass.clear_cache!
+
+# manually clear objects that have expired
+CachedClass.clear_unscored_items!
+```
+### Cache options
+```ruby
+# [Required] false; [Expect] Proc; [Return] String to be used as instance key; [Default] key will be the hash of the object
+cache_options key: ->(instance_of_class, custom_key) { }
+
+# [Required] false; [Expect] String; [Default] ENV["CACHE_LAYER_REDIS_URL"] || ENV["REDIS_URL"]
+cache_options redis_url: _redis_url_value
+
+# [Required] false; [Expect] Redis Object or Proc that returns value of Redis Client; [Default] Redis.new(url: redis_url)
+cache_options redis_client: redis_client
+
+# [Required] false; [Expect] Object that plays with to_s and has no spaces; [Default] Full class name downcased
+cache_options cache_namespace: cache_namespace
+
+# [Required] false; [Expect] Integer in seconds; [Default] 1 day
+cache_options ttl: (60 * 60)
+
+# [Required] false; [Expect] Boolean; [Default] true
+# Update the cache when a value has been changed manually
+cache_options update_on_change: true
+
+# [Required] false; [Expect] Float; [Default] 0.8
+# Expected value to be between 0 and 1. The sample rate that the class will clear oldcache values on retreival
+cache_options stochastic_cache_bust: 0.8
+```
+
 ## Development
 
 This gem can be developed against local machine or while using docker. Simpleified Docker commands can be found in the `Makefile` or execute `make help`

data/docker-compose.yml

@@ -10,6 +10,13 @@ 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/lib/json_schematize/base.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-class JsonSchematize::Base
-  def self.acceptable_types
-    raise NoMethodError, "Expected acceptable_values to be defined in parent class"
+module JsonSchematize
+  class Base
+    def self.acceptable_types
+      raise NoMethodError, "Expected acceptable_values to be defined in parent class"
+    end
   end
 end

data/lib/json_schematize/boolean.rb

@@ -2,18 +2,20 @@
 
 require "json_schematize/base"
 
-class JsonSchematize::Boolean < JsonSchematize::Base
-  FALSE_VALUES = ["false", "f", "0", false]
-  TRUE_VALUES = ["true", "t", "1", true]
+module JsonSchematize
+  class Boolean < JsonSchematize::Base
+    FALSE_VALUES = ["false", "f", "0", false]
+    TRUE_VALUES = ["true", "t", "1", true]
 
-  def self.new(val)
-    return false if FALSE_VALUES.include?(val)
-    return true if TRUE_VALUES.include?(val)
+    def self.new(val)
+      return false if FALSE_VALUES.include?(val)
+      return true if TRUE_VALUES.include?(val)
 
-    raise JsonSchematize::UndefinedBoolean, "#{val} is not a valid #{self.class}"
-  end
+      raise JsonSchematize::UndefinedBoolean, "#{val} is not a valid #{self.class}"
+    end
 
-  def self.acceptable_types
-    [TrueClass, FalseClass]
+    def self.acceptable_types
+      [TrueClass, FalseClass]
+    end
   end
 end

data/lib/json_schematize/cache/class_methods.rb

@@ -0,0 +1,81 @@
+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.compact
+      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

data/lib/json_schematize/cache/instance_methods.rb

@@ -0,0 +1,36 @@
+module JsonSchematize
+  module Cache
+    module InstanceMethods
+      def initialize(stringified_params = nil, cache_key: nil, skip_cache_update: false, raise_on_error: true, **params)
+        super(stringified_params, raise_on_error: raise_on_error, **params)
+
+        @__incoming_cache_key__ = cache_key
+        if @values_assigned
+          __update_cache_item__(with_delete: false) unless skip_cache_update
+        end
+      end
+
+      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
+        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)
+      end
+
+      def __clear_entry__!
+        self.class.redis_client.zrem(__cache_namespace__, __cache_key__)
+        self.class.redis_client.unlink(__cache_key__)
+      end
+
+      def __cache_key__
+        "#{__cache_namespace__}:#{self.class.cache_configuration[:key].call(self, @__incoming_cache_key__)}"
+      end
+
+      def __cache_namespace__
+        self.class.cache_namespace
+      end
+    end
+  end
+end

data/lib/json_schematize/cache.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "json_schematize/cache/instance_methods"
+require "json_schematize/cache/class_methods"
+
+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)
+
+      base.include(JsonSchematize::Cache::InstanceMethods)
+      base.extend(JsonSchematize::Cache::ClassMethods)
+    end
+  end
+end

data/lib/json_schematize/generator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json_schematize/cache"
 require "json_schematize/field"
 require "json_schematize/introspect"
 
@@ -58,6 +59,12 @@ class JsonSchematize::Generator
     @optional_fields ||= []
   end
 
+  # def self.update_block(&block)
+  #   @skip_individual_updates = true
+  #   yield(cloned)
+  #   @skip_individual_updates = false
+  # end
+
   def self.convenience_methods(field:)
     unless self.instance_methods.include?(:"#{field.name}=")
       define_method(:"#{field.name}=") do |value|
@@ -70,6 +77,7 @@ class JsonSchematize::Generator
         return false unless validate_value(**validate_params)
 
         instance_variable_set(:"@#{field.name}", value)
+        __update_cache__!
         return true
       end
     end
@@ -99,6 +107,13 @@ class JsonSchematize::Generator
 
   private
 
+  def __update_cache__!
+    return unless self.class.include?(JsonSchematize::Cache)
+    return unless self.class.cache_configuration[:update_on_change]
+
+    __update_cache_item__
+  end
+
   def assign_values!
     self.class.fields.each do |field|
       value = field.value_from_field(@__params)[:transformed_value]

data/lib/json_schematize/version.rb

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

data/lib/json_schematize.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json_schematize/version"
+
 require "json_schematize/base"
 require "json_schematize/boolean"
 require "json_schematize/generator"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schematize
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.2
 platform: ruby
 authors:
 - Matt Taylor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-14 00:00:00.000000000 Z
+date: 2022-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry-byebug
@@ -82,6 +82,7 @@ files:
 - Dockerfile
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - Makefile
 - README.md
 - bin/console
@@ -90,6 +91,9 @@ files:
 - lib/json_schematize.rb
 - 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/instance_methods.rb
 - lib/json_schematize/empty_value.rb
 - lib/json_schematize/field.rb
 - lib/json_schematize/field_transformations.rb
@@ -118,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.32
 signing_key: 
 specification_version: 4
 summary: This gem gives you the ability to turn API results into a standardized schema's