phronomy 0.18.0 → 0.20.0

data/lib/phronomy/state_store/base.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module StateStore
-    # Abstract base class for workflow state persistence backends.
-    #
-    # Subclasses must implement {#load}, {#save}, and {#delete}.
-    # A snapshot is a plain +Hash+ with two keys:
-    #   +:fields+ — output of +context.to_h+
-    #   +:phase+  — +context.phase.to_s+
-    #
-    # @example Implementing a custom backend
-    #   class MyStore < Phronomy::StateStore::Base
-    #     def load(thread_id) = MyRecord.find_by(thread_id:)&.to_h
-    #     def save(thread_id, snapshot) = MyRecord.upsert(thread_id:, data: snapshot)
-    #     def delete(thread_id) = MyRecord.where(thread_id:).delete_all
-    #   end
-    class Base
-      # Load the stored snapshot for +thread_id+.
-      #
-      # @param thread_id [String]
-      # @return [Hash, nil] stored snapshot hash, or +nil+ if absent
-      # @api public
-      def load(thread_id)
-        raise NotImplementedError, "#{self.class}#load is not implemented"
-      end
-
-      # Persist +snapshot+ for +thread_id+. Overwrites any existing snapshot.
-      #
-      # @param thread_id [String]
-      # @param snapshot [Hash] serialisable hash of workflow state
-      # @return [void]
-      # @api public
-      def save(thread_id, snapshot)
-        raise NotImplementedError, "#{self.class}#save is not implemented"
-      end
-
-      # Delete the stored snapshot for +thread_id+. No-op if absent.
-      #
-      # @param thread_id [String]
-      # @return [void]
-      # @api public
-      def delete(thread_id)
-        raise NotImplementedError, "#{self.class}#delete is not implemented"
-      end
-    end
-  end
-end

data/lib/phronomy/state_store/in_memory.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module StateStore
-    # Thread-safe in-process state store backed by a plain Ruby Hash.
-    #
-    # Used as the recommended default for single-process applications and tests.
-    # State does not survive process restart.
-    #
-    # @example
-    #   store = Phronomy::StateStore::InMemory.new
-    #   store.save("t1", { fields: { count: 1 }, phase: "__end__" })
-    #   store.load("t1")   # => { fields: { count: 1 }, phase: "__end__" }
-    #   store.delete("t1")
-    #   store.load("t1")   # => nil
-    class InMemory < Base
-      def initialize
-        @data = {}
-        @mutex = Mutex.new
-      end
-
-      # @param thread_id [String]
-      # @return [Hash, nil]
-      # @api public
-      def load(thread_id)
-        @mutex.synchronize do
-          snap = @data[thread_id]
-          snap ? deep_dup(snap) : nil
-        end
-      end
-
-      # @param thread_id [String]
-      # @param snapshot [Hash]
-      # @return [void]
-      # @api public
-      def save(thread_id, snapshot)
-        @mutex.synchronize { @data[thread_id] = deep_dup(snapshot) }
-        nil
-      end
-
-      # @param thread_id [String]
-      # @return [void]
-      # @api public
-      def delete(thread_id)
-        @mutex.synchronize { @data.delete(thread_id) }
-        nil
-      end
-
-      private
-
-      # Recursively deep-duplicates a plain-data value (Hash, Array, or scalar).
-      # Sufficient for snapshot data which consists of JSON-compatible types.
-      def deep_dup(val)
-        case val
-        when Hash then val.each_with_object({}) { |(k, v), h| h[k] = deep_dup(v) }
-        when Array then val.map { |v| deep_dup(v) }
-        else val.frozen? ? val : (val.dup rescue val) # rubocop:disable Style/RescueModifier
-        end
-      end
-    end
-  end
-end

data/scripts/check_private_enforcement.rb

@@ -1,93 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# check_private_enforcement.rb
-#
-# Verifies that every instance method annotated @api private in lib/ is
-# actually non-public at the Ruby level (i.e., NOT in Module#public_instance_methods).
-#
-# Class methods (def self.xxx) are excluded from this check because their
-# visibility is managed separately on the singleton class and rarely causes
-# accidental public exposure to consumers.
-#
-# Usage (run from the phronomy/ repository root):
-#   bundle exec ruby scripts/check_private_enforcement.rb
-#
-# Exit codes:
-#   0 — all @api private instance methods are non-public (or have no Ruby def)
-#   1 — one or more @api private instance methods are exposed as public
-
-require "bundler/setup"
-require_relative "../lib/phronomy"
-
-lib_dir = File.expand_path("../lib", __dir__)
-
-unless File.directory?(lib_dir)
-  warn "ERROR: lib directory not found at #{lib_dir}"
-  exit 1
-end
-
-# Step 1: Collect instance methods annotated @api private via static analysis.
-api_private_entries = []
-
-Dir.glob(File.join(lib_dir, "**", "*.rb")).sort.each do |file|
-  lines = File.readlines(file)
-
-  lines.each_with_index do |line, i|
-    next unless line.match?(/^\s*#\s*@api\s+private\s*$/)
-
-    # Advance past any further comment or blank lines to reach the def.
-    j = i + 1
-    j += 1 while j < lines.size && lines[j].match?(/^\s*(#|$)/)
-    next unless j < lines.size
-
-    # Skip class-level methods — they live on the singleton class, not as
-    # public instance methods accessible to consumers.
-    next if lines[j].match?(/def\s+self\./)
-
-    # Match both plain def and "private def".
-    m = lines[j].match(/^\s*(?:private\s+)?def\s+(\w+[!?=]?)/)
-    next unless m
-
-    rel_path = file.sub("#{lib_dir}/../", "")
-    api_private_entries << {name: m[1].to_sym, file: rel_path, line: j + 1}
-  end
-end
-
-if api_private_entries.empty?
-  puts "No @api private instance methods found."
-  exit 0
-end
-
-# Step 2: Build a map of publicly exposed instance methods across all
-# Phronomy-namespaced modules/classes (own methods only, no inheritance).
-all_phronomy_modules = ObjectSpace.each_object(Module).select do |mod|
-  mod.name&.start_with?("Phronomy")
-end
-
-public_exposure_map = {}
-all_phronomy_modules.each do |mod|
-  mod.public_instance_methods(false).each do |meth|
-    (public_exposure_map[meth] ||= []) << mod.name
-  end
-end
-
-# Step 3: Report violations — @api private methods that are still public.
-errors = []
-
-api_private_entries.each do |entry|
-  exposing_modules = public_exposure_map[entry[:name]]
-  next unless exposing_modules
-
-  errors << "#{entry[:file]}:#{entry[:line]}  def #{entry[:name]}" \
-            "  (annotated @api private but public in: #{exposing_modules.join(", ")})"
-end
-
-if errors.empty?
-  puts "OK: all #{api_private_entries.size} @api private instance methods are non-public."
-  exit 0
-else
-  warn "ERROR: #{errors.size} @api private instance method(s) are exposed as public:"
-  errors.each { |e| warn "  #{e}" }
-  exit 1
-end