flexor 0.1.0

data/lib/flexor.rb

@@ -0,0 +1,187 @@
+require_relative "flexor/version"
+require_relative "flexor/hash_delegation"
+require_relative "flexor/serialization"
+require_relative "flexor/vivification"
+
+##
+# A Hash-like data store with autovivifying nested access, nil-safe
+# chaining, and seamless conversion between hashes and method-style
+# access.
+class Flexor
+  class Error < StandardError; end
+
+  include HashDelegation
+  include Serialization
+  include Vivification
+
+  def self.[](input = {})
+    case input
+    when String then from_json(input)
+    when Hash then new(input)
+    else raise ArgumentError, "expected a String or Hash, got #{input.class}"
+    end
+  end
+
+  def self.from_json(json)
+    require "json"
+    JSON.parse(json, symbolize_names: true)
+        .then { new it }
+  end
+
+  def self.===(other)
+    other.is_a?(self)
+  end
+
+  def initialize(hash = {}, root: true)
+    raise ArgumentError, "expected a Hash, got #{hash.class}" unless hash.is_a?(Hash)
+
+    @root  = root
+    @store = vivify(hash)
+  end
+
+  def initialize_copy(original)
+    super
+    @store = @store.dup
+  end
+
+  def [](key)
+    @store[key]
+  end
+
+  def []=(key, value)
+    @store[key] = vivify_value(value)
+  end
+
+  def set_raw(key, value)
+    @store[key] = value
+  end
+
+  def delete(key)
+    @store.delete(key)
+  end
+
+  def clear
+    @store.clear
+    self
+  end
+
+  def to_ary
+    nil
+  end
+
+  def freeze
+    @store.freeze
+    super
+  end
+
+  def to_h
+    @store.each_with_object({}) do |(key, value), hash|
+      result = recurse_to_h(value)
+      hash[key] = result unless value.is_a?(Flexor) && result.nil?
+    end
+  end
+
+  def to_json(...)
+    require "json"
+    to_h.to_json(...)
+  end
+
+  def to_s
+    return "" if nil?
+
+    @store.to_s
+  end
+
+  def inspect
+    return @store.inspect if @root
+    return nil.inspect if @store.empty?
+
+    @store.inspect
+  end
+
+  def deconstruct
+    @store.values
+  end
+
+  def deconstruct_keys(keys)
+    return @store if keys.nil?
+
+    @store.slice(*keys)
+  end
+
+  def nil?
+    @store.empty?
+  end
+
+  def merge!(other)
+    other = other.to_h if other.is_a?(Flexor)
+    other.each do |key, value|
+      if value.is_a?(Hash) && self[key].is_a?(Flexor) && !self[key].nil?
+        self[key].merge!(value)
+      else
+        self[key] = value
+      end
+    end
+    self
+  end
+
+  def merge(other)
+    dup.merge!(other)
+  end
+
+  def ==(other)
+    case other
+    in nil then nil?
+    in Flexor then to_h == other.to_h
+    in Hash then to_h == other
+    else super
+    end
+  end
+
+  def ===(other)
+    other.nil? ? nil? : super
+  end
+
+  def respond_to_missing?(_name, _include_private = false)
+    true
+  end
+
+  private
+
+  def method_missing(name, *args, &block)
+    return super if block
+
+    case [name, args]
+    in /^[^=]+=$/, [arg] then write_via_method(name, arg)
+    in _, [] then read_via_method(name)
+    else super
+    end
+  end
+
+  def write_via_method(name, arg)
+    key = name.to_s.chomp("=").to_sym
+    cache_setter(name, key)
+    self[key] = arg
+  end
+
+  def read_via_method(name)
+    cache_getter(name) if !frozen? && @store.key?(name)
+    self[name]
+  end
+
+  def cache_setter(name, key)
+    define_singleton_method(name) do |val = nil, &blk|
+      raise NoMethodError, "undefined method '#{name}' for #{inspect}" if blk
+
+      self[key] = val
+    end
+  end
+
+  def cache_getter(name)
+    define_singleton_method(name) do |*a, &blk|
+      raise NoMethodError, "undefined method '#{name}' for #{inspect}" if blk || !a.empty?
+
+      self[name]
+    end
+  end
+end

data/rakelib/benchmark.rake

@@ -0,0 +1,4 @@
+desc "Run performance benchmarks (optionally install hashie gem for comparison)"
+task :benchmark do
+  ruby "--yjit", "-rbundler/setup", "benchmark/compare.rb"
+end

data/rakelib/rdoc.rake

@@ -0,0 +1,8 @@
+require "rdoc/task"
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = "doc"
+  rdoc.title = "Flexor #{Flexor::VERSION}"
+  rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
+  rdoc.main = "README.md"
+end

data/rakelib/version.rake

@@ -0,0 +1,72 @@
+VERSION_PATTERN = /VERSION\s*=\s*"(\d+\.\d+\.\d+)"/
+
+# Encapsulates version file manipulation logic for rake tasks.
+module VersionBumper
+  module_function
+
+  def version_path
+    File.expand_path("../lib/flexor/version.rb", __dir__)
+  end
+
+  def print_current
+    require_relative "../lib/flexor/version"
+    puts "Current version: #{Flexor::VERSION}"
+  end
+
+  def bump
+    File.open(version_path, File::RDWR, 0o644) do |f|
+      f.flock(File::LOCK_EX)
+      old_version, new_version, new_source = compute_bump(f.read)
+      f.rewind
+      f.write(new_source)
+      f.truncate(f.pos)
+      puts "Version bumped from #{old_version} to #{new_version}"
+    end
+  end
+
+  def compute_bump(source)
+    match = source.match(VERSION_PATTERN)
+    abort "Could not find VERSION in #{version_path}" unless match
+
+    old_version = match[1]
+    parts = old_version.split(".").map(&:to_i)
+    parts[-1] += 1
+    new_version = parts.join(".")
+    new_source = source.sub(/VERSION\s*=\s*"#{Regexp.escape(old_version)}"/, "VERSION = \"#{new_version}\"")
+    [old_version, new_version, new_source]
+  end
+
+  def commit
+    require_relative "../lib/flexor/version"
+    system("git", "add", version_path) || abort("git add failed")
+    system("git", "commit", "-m", "Bump version to #{Flexor::VERSION}") || abort("git commit failed")
+    puts "Version change committed."
+  end
+
+  def revert
+    last_message = `git log -1 --pretty=%B`.strip
+    abort "Last commit does not appear to be a version bump." unless last_message.start_with?("Bump version to ")
+
+    system("git", "revert", "HEAD", "--no-edit") || abort("git revert failed")
+    puts "Version bump reverted."
+  end
+end
+
+namespace :version do
+  desc "Display the current version"
+  task(:current) { VersionBumper.print_current }
+
+  desc "Bump the patch version"
+  task(:bump) { VersionBumper.bump }
+
+  desc "Commit the version change"
+  task(:commit) { VersionBumper.commit }
+
+  desc "Revert the last version bump commit"
+  task(:revert) { VersionBumper.revert }
+end
+
+namespace :release do
+  desc "Bump version, commit, and release"
+  task full: ["version:bump", "version:commit", :release]
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: flexor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Gillis
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Flexor provides autovivifying nested access, nil-safe chaining, and seamless
+  conversion between hashes and method-style access. Built for flexible data containers,
+  middleware state, and prototyping.
+email:
+- david@flipmine.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/compare.rb
+- benchmark/results-with-caching.txt
+- docs/benchmark-results.md
+- docs/original_specification.yaml
+- docs/specification.yaml
+- lib/flexor.rb
+- lib/flexor/hash_delegation.rb
+- lib/flexor/serialization.rb
+- lib/flexor/version.rb
+- lib/flexor/vivification.rb
+- rakelib/benchmark.rake
+- rakelib/rdoc.rake
+- rakelib/version.rake
+homepage: https://github.com/gillisd/flexor
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/gillisd/flexor
+  source_code_uri: https://github.com/gillisd/flexor
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: A Hash-like data store that does what you tell it to do
+test_files: []