bipolar_cache 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 00fb9f8f43d45504192121714c562545f1d9815f39801461c3bcda66cb7e26e6
+  data.tar.gz: e5e4e33e2ec9cc2566229fc301c2e7e94935a7c58035131fa5a0a8101f59494c
+SHA512:
+  metadata.gz: d6f667231620b0f8f7b3ff02be2ebf196dfa8c82ae8308f1fb25ee4bcc8ec1fdd51b827ba05245eb1877f15942d6931f2b316189f9b91a7b84b58beec5c81db6
+  data.tar.gz: 293f9bd8cfb8259351657b5ff038f157df257bab913a7b0e5526835032dd5a807545dbe395a6f62ecbd44597495a608be63ab92ffe82508b79afa68dc54a9bf7

data/.rubocop.yml

@@ -0,0 +1,19 @@
+AllCops:
+  TargetRubyVersion: 3.0
+  SuggestExtensions: false
+  NewCops: disable
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/README.md

@@ -0,0 +1,27 @@
+# BipolarCache
+
+Probabalistic caching toolkit useful for caching of database counters, and other operations.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add bipolar_cache
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install bipolar_cache
+
+## Usage
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rubakas/bipolar_cache.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/bipolar_cache/sequel/plugin_alpha.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module BipolarCache
+  module Sequel
+    module PluginAlpha
+      module ClassMethods
+        def instance_dataset_bipolar_count_cache(name, **opts)
+          opts = opts.merge({ name: name })
+          method_name = opts[:method] || "#{name}_count"
+
+          define_method method_name do
+            bcsp_cache(**fetch_or_build_procs(**opts))
+          end
+
+          define_method "#{method_name}_refresh!" do
+            procs = fetch_or_build_procs(**opts)
+            actual_value = procs[:actual].call
+            procs[:update].call(actual_value) if actual_value != procs[:cached].call
+            actual_value
+          end
+
+          define_method "#{method_name}_increment!" do |by: 1|
+            procs = fetch_or_build_procs(**opts)
+
+            procs[:update].call(by + procs[:cached].call)
+          end
+
+          define_method "#{method_name}_decrement!" do |by: 1|
+            procs = fetch_or_build_procs(**opts)
+
+            procs[:update].call((-by) + procs[:cached].call)
+          end
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def bcsp_cache(**procs)
+        BipolarCache.read!(**procs)
+      end
+
+      def fetch_or_build_procs(**opts)
+        # create cached store for instance procs, if none
+        instance_variable_set(:@bcsp_proc_store, {}) unless instance_variable_defined?(:@bcsp_proc_store)
+
+        if instance_variable_get(:@bcsp_proc_store)[opts[:name]].nil?
+          instance_variable_get(:@bcsp_proc_store)[opts[:name]] =
+            {
+              actual: bcsp_proc_actual_from(**opts),
+              cached: bcsp_proc_cached_from(**opts),
+              update: bcsp_proc_update_from(**opts),
+              chance: bcsp_proc_chance_from(**opts),
+              rescue: bcsp_proc_rescue_from(**opts),
+              if: bcsp_proc_if_from(**opts)
+            }
+        end
+
+        # stored procs
+        instance_variable_get(:@bcsp_proc_store)[opts[:name]]
+      end
+
+      def bcsp_proc_actual_from(**opts)
+        case opts[:actual]
+        when Proc
+          opts[:actual]
+        when String, Symbol
+          -> { send(opts[:actual]) }
+        else
+          -> { send("#{opts[:name]}_dataset").count }
+        end
+      end
+
+      def bcsp_proc_cached_from(**opts)
+        case opts[:cached]
+        when Proc
+          opts[:cached]
+        when String, Symbol
+          -> { send(opts[:cached]) }
+        else
+          -> { send("#{opts[:name]}_count_cache") }
+        end
+      end
+
+      def bcsp_proc_update_from(**opts)
+        cache_name = if opts[:cached].is_a?(String) || opts[:cached].is_a?(Symbol)
+                       opts[:cached]
+                     else
+                       "#{opts[:name]}_count_cache"
+                     end
+
+        case opts[:update]
+        when Proc
+          opts[:update]
+        when String, Symbol
+          -> { send(opts[:update]) }
+        else
+          ->(value) { update({ cache_name => value }) }
+        end
+      end
+
+      def bcsp_proc_chance_from(**opts)
+        case opts[:chance]
+        when Proc
+          opts[:chance]
+        when Integer, Float
+          normalised_chance = if opts[:chance] > 1
+                                opts[:chance] / 100
+                              else
+                                opts[:chance]
+                              end
+          ->(_value) { normalised_chance }
+        else # default
+          ->(value) { value < 10 ? 0.1 : 0.9 }
+        end
+      end
+
+      def bcsp_proc_rescue_from(**opts)
+        if opts[:rescue].is_a? Proc
+          opts[:rescue]
+        else # default
+          lambda { |e|
+            e.inspect
+            0
+          }
+        end
+      end
+
+      def bcsp_proc_if_from(**opts)
+        case opts[:if]
+        when Proc
+          opts[:if]
+        when TrueClass, FalseClass
+          value = opts[:if]
+          -> { value }
+        else # default
+          -> { true }
+        end
+      end
+    end
+  end
+end

data/lib/bipolar_cache/version.rb

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

data/lib/bipolar_cache.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "bipolar_cache/version"
+
+module BipolarCache
+  class Error < StandardError; end
+
+  ##
+  # It may read actual value,
+  # it may read cached value,
+  # or it may write actual value into cache!
+  # It depends on chance.
+  # Call it at your peril.
+  #
+  # @param actual [Proc] callable to perform an operation (cacheable)
+  # @param cached [Proc] callable to read cached value
+  # @param chance [Proc(Object)] callable to compute chance of cache hit
+  # @param if     [Proc] callable to enable/disable caching
+  # @param rescue [Proc(StandardError)] callable to be invoked on exception
+  # @param update [Proc(Object)] callable to update cached value
+  # @return [Object]
+  def self.read!(**procs)
+    return procs[:actual].call unless procs[:if].call
+
+    cached_value = procs[:cached].call
+
+    if procs[:chance].call(cached_value) > rand
+      cached_value
+    else
+      actual_value = procs[:actual].call
+      procs[:update].call(actual_value) if cached_value != actual_value
+
+      actual_value
+    end
+  rescue StandardError => e
+    procs[:rescue].call(e) if procs[:rescue].is_a?(Proc)
+  end
+end

data/sig/bipolar_cache.rbs

@@ -0,0 +1,4 @@
+module BipolarCache
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: bipolar_cache
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andriy Tyurnikov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-04-11 00:00:00.000000000 Z
+dependencies: []
+description: Probabalistic caching toolkit useful for caching of database counters,
+  and other operations.
+email:
+- Andriy.Tyurnikov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- README.md
+- Rakefile
+- lib/bipolar_cache.rb
+- lib/bipolar_cache/sequel/plugin_alpha.rb
+- lib/bipolar_cache/version.rb
+- sig/bipolar_cache.rbs
+homepage: https://github.com/rubakas/bipolar_cache
+licenses: []
+metadata:
+  homepage_uri: https://github.com/rubakas/bipolar_cache
+  source_code_uri: https://github.com/rubakas/bipolar_cache
+  changelog_uri: https://github.com/rubakas/bipolar_cache
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.6
+signing_key:
+specification_version: 4
+summary: BipolarCache. Probabalistic caching toolkit.
+test_files: []