# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "zeitwerk"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            Zeitwerk::Loader.new.then do |loader|
          
        
      
        

          

            
              1
            

            
              
            

              loader.tag = File.basename __FILE__, ".rb"
          
        
      
        

          

            
              1
            

            
              
            

              loader.push_dir __dir__
          
        
      
        

          

            
              1
            

            
              
            

              loader.setup
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # Main namespace.
          
        
      
        

          

            
              1
            

            
              
            

            module Lode
          
        
      
        

          

            
              1
            

            
              
            

              PRIMARY_KEY = :id
          
        
      
        

          

            
              1
            

            
              
            

              MODES = %i[default thread file max].freeze
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

              def self.loader registry = Zeitwerk::Registry
          
        
      
        

          

            
              6
            

            
              
            

                @loader ||= registry.loaders.each.find { |loader| loader.tag == File.basename(__FILE__, ".rb") }
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

              def self.new(...) = Client.new(...)
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "forwardable"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/pathname"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Lode
          
        
      
        

          

            

            
              
            

              # Provides an enhanced PStore-based client.
          
        
      
        

          

            
              1
            

            
              
            

              class Client
          
        
      
        

          

            
              1
            

            
              
            

                extend Forwardable
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                using Refinements::Pathname
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :path, :store
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                delegate %i[register registry] => :configuration
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize path, configuration: Configuration.new
          
        
      
        

          

            
              13
            

            
              
                
                  then: 1
                
              
                
                  else: 12
                
              
            

                  yield configuration if block_given?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              13
            

            
              
            

                  @path = Pathname(path).make_ancestors
          
        
      
        

          

            
              13
            

            
              
            

                  @configuration = configuration
          
        
      
        

          

            
              13
            

            
              
            

                  @store = configuration.store_for path
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def read(key, &) = transact(__method__, key, &)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def write(key, &) = transact(:commit, key, &)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :configuration
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def transact(mode, key, &)
          
        
      
        

          

            
              7
            

            
              
            

                  store.transaction mode == :read do
          
        
      
        

          

            
              7
            

            
              
            

                    configuration.table_for(store, key).instance_eval(&)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "pstore"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Lode
          
        
      
        

          

            

            
              
            

              # Models the default configuration.
          
        
      
        

          

            
              1
            

            
              
            

              Configuration = Struct.new :store, :mode, :table, :primary_key, :registry do
          
        
      
        

          

            
              1
            

            
              
            

                using Refines::PersistentStore
          
        
      
        

          

            
              1
            

            
              
            

                using Refinements::Array
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize store: PStore,
          
        
      
        

          

            

            
              
            

                               mode: :default,
          
        
      
        

          

            

            
              
            

                               table: Tables::Hash,
          
        
      
        

          

            

            
              
            

                               primary_key: PRIMARY_KEY,
          
        
      
        

          

            

            
              
            

                               registry: {}
          
        
      
        

          

            
              20
            

            
              
            

                  super
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def store_for(path) = store.with(path, mode:)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def table_for store, key, setting: Setting.new
          
        
      
        

          

            
              9
            

            
              
            

                  table.new store, key, setting: registry.fetch(key, setting)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def register key, model: Hash, primary_key: PRIMARY_KEY
          
        
      
        

          

            
              5
            

            
              
            

                  registry[key] = Setting[model:, primary_key:]
          
        
      
        

          

            
              5
            

            
              
            

                  self
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "pstore"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/array"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Lode
          
        
      
        

          

            
              1
            

            
              
            

              module Refines
          
        
      
        

          

            

            
              
            

                # Refines and enhances PStore functionality.
          
        
      
        

          

            
              1
            

            
              
            

                module PersistentStore
          
        
      
        

          

            
              1
            

            
              
            

                  using Refinements::Array
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  refine PStore.singleton_class do
          
        
      
        

          

            
              1
            

            
              
            

                    def with path, mode: :default
          
        
      
        

          

            
              22
            

            
              
                
                  when: 15
                
              
            

                      case mode
          
        
      
        

          

            
              15
            

            
              
                
                  when: 3
                
              
            

                        when :default then new path
          
        
      
        

          

            
              3
            

            
              
                
                  when: 2
                
              
            

                        when :thread then new path, true
          
        
      
        

          

            
              4
            

            
              
                
                  when: 1
                
              
            

                        when :file then new(path).tap { |instance| instance.ultra_safe = true }
          
        
      
        

          

            
              2
            

            
              
                
                  else: 1
                
              
            

                        when :max then new(path, true).tap { |instance| instance.ultra_safe = true }
          
        
      
        

          

            
              1
            

            
              
            

                        else fail PStore::Error, %(Invalid mode. Use: #{MODES.to_usage "or"}.)
          
        
      
        

          

            

            
              
            

                      end
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  refine PStore do
          
        
      
        

          

            
              1
            

            
              
            

                    def thread_safe? = @thread_safe
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    def file_safe? = @ultra_safe
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Lode
          
        
      
        

          

            

            
              
            

              # Defines a configuration setting.
          
        
      
        

          

            
              1
            

            
              
            

              Setting = Data.define :model, :primary_key do
          
        
      
        

          

            
              1
            

            
              
            

                def initialize model: Hash, primary_key: PRIMARY_KEY
          
        
      
        

          

            
              61
            

            
              
            

                  super
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "dry/monads"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/array"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Lode
          
        
      
        

          

            
              1
            

            
              
            

              module Tables
          
        
      
        

          

            

            
              
            

                # Provides an abstract table for subclassing.
          
        
      
        

          

            
              1
            

            
              
            

                class Abstract
          
        
      
        

          

            
              1
            

            
              
            

                  include Dry::Monads[:result]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  using Refinements::Array
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize store, key, setting: Setting.new
          
        
      
        

          

            
              51
            

            
              
            

                    @store = store
          
        
      
        

          

            
              51
            

            
              
            

                    @key = key
          
        
      
        

          

            
              51
            

            
              
            

                    @setting = setting
          
        
      
        

          

            
              51
            

            
              
            

                    @records = store.fetch key, []
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def primary_key = setting.primary_key
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def all = Success records.dup.freeze
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def find id, key: primary_key
          
        
      
        

          

            
              84
            

            
              
            

                    records.find { |record| primary_id(record, key:) == id }
          
        
      
        

          

            

            
              
            

                           .then do |record|
          
        
      
        

          

            
              63
            

            
              
                
                  then: 19
                
              
                
                  else: 44
                
              
            

                             return Success record if record
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              44
            

            
              
            

                             Failure "Unable to find #{key}: #{id.inspect}."
          
        
      
        

          

            

            
              
            

                           end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def create record, key: primary_key
          
        
      
        

          

            
              13
            

            
              
            

                    id = primary_id(record, key:)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              14
            

            
              
            

                    find(id, key:).bind { Failure "Record exists for #{key}: #{id}." }
          
        
      
        

          

            

            
              
            

                                  .or do |error|
          
        
      
        

          

            
              12
            

            
              
                
                  then: 10
                
              
                
                  else: 2
                
              
            

                                    return append record if error.include? "Unable to find"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                                    Failure error
          
        
      
        

          

            

            
              
            

                                  end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def update change, key: primary_key
          
        
      
        

          

            
              9
            

            
              
            

                    id = primary_id(change, key:)
          
        
      
        

          

            
              12
            

            
              
            

                    find(id, key:).bind { |existing| revise existing, change }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def upsert record, key: primary_key
          
        
      
        

          

            
              1
            

            
              
            

                    fail NoMethodError,
          
        
      
        

          

            

            
              
            

                         "`#{self.class}##{__method__} #{method(__method__).parameters}` must be implemented."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def delete id, key: primary_key
          
        
      
        

          

            
              10
            

            
              
            

                    find(id, key:).fmap do |record|
          
        
      
        

          

            
              5
            

            
              
            

                      records.delete record
          
        
      
        

          

            
              5
            

            
              
            

                      store[key] = records
          
        
      
        

          

            
              5
            

            
              
            

                      record
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  protected
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :store, :key, :setting, :records
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def primary_id record, key: primary_key
          
        
      
        

          

            
              2
            

            
              
            

                    fail NoMethodError,
          
        
      
        

          

            

            
              
            

                         "`#{self.class}##{__method__} #{method(__method__).parameters}` must be implemented."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def revise existing, change
          
        
      
        

          

            
              9
            

            
              
            

                    records.supplant existing, change
          
        
      
        

          

            
              9
            

            
              
            

                    store[key] = records
          
        
      
        

          

            
              9
            

            
              
            

                    Success change
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def append record
          
        
      
        

          

            
              32
            

            
              
            

                    records.append record
          
        
      
        

          

            
              32
            

            
              
            

                    store[key] = records
          
        
      
        

          

            
              31
            

            
              
            

                    Success record
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "dry/monads"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Lode
          
        
      
        

          

            
              1
            

            
              
            

              module Tables
          
        
      
        

          

            

            
              
            

                # Provides an array-based table for hash objects.
          
        
      
        

          

            
              1
            

            
              
            

                class Hash < Abstract
          
        
      
        

          

            
              1
            

            
              
            

                  include Dry::Monads[:result]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def upsert change, key: primary_key
          
        
      
        

          

            
              16
            

            
              
            

                    find(change[key], key:).either(
          
        
      
        

          

            
              3
            

            
              
            

                      -> existing { revise existing, change },
          
        
      
        

          

            
              13
            

            
              
            

                      proc { append change }
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  protected
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def primary_id(record, key: primary_key) = record[key]
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "dry/monads"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Lode
          
        
      
        

          

            
              1
            

            
              
            

              module Tables
          
        
      
        

          

            

            
              
            

                # Provides an array-based table for value objects.
          
        
      
        

          

            
              1
            

            
              
            

                class Value < Abstract
          
        
      
        

          

            
              1
            

            
              
            

                  include Dry::Monads[:result]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def upsert change, key: primary_key
          
        
      
        

          

            
              11
            

            
              
            

                    record = record_for change
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              11
            

            
              
            

                    find(primary_id(record, key:)).either(
          
        
      
        

          

            
              2
            

            
              
            

                      -> existing { revise existing, record },
          
        
      
        

          

            
              9
            

            
              
            

                      proc { append record }
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  protected
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def primary_id(record, key: primary_key) = record.public_send(key)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # :reek:FeatureEnvy
          
        
      
        

          

            
              1
            

            
              
            

                  def record_for change
          
        
      
        

          

            
              11
            

            
              
            

                    model = setting.model
          
        
      
        

          

            
              11
            

            
              
                
                  then: 10
                
              
                
                  else: 1
                
              
            

                    change.is_a?(model) ? change : model[**change.to_h]
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end