emanlib 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1325271b5892d5c0195b9169f09416790ea4887f680e194afb2445f33bb57b75
-  data.tar.gz: effa861c1070d969e2ab86287c101ba90bcd52ad9f82cceb87616d79f3b5a554
+  metadata.gz: fd662dbc1918087da06994da20c822e4e3697a07db7f5681602c26c46839ed07
+  data.tar.gz: d1e82edbb74f7d2f60dbe906f5715cddc94a28639266107d713744517de52007
 SHA512:
-  metadata.gz: 2a5248da79b6d73c42c62932c9a2473d10dee603aa9c40ba880cbe708f5ae450d1fa0861805c507051fa5dd3d777031dbfecd6a2120ac0fe688bc5743ee0eaf5
-  data.tar.gz: 77a89f7f87e7003134b581f272c4892f61c3cc861371cc7758b21a022463caa8468064b16adafd88b0d70f7b0bf1d431290b90bfe2dda22c16d6ff619d3d0389
+  metadata.gz: 3b5a86384a130d687ef886a075b55d1d3ea892ccf656356df78cfee9c9949dbcdaa36691b92733506956b687c5af66baba8fcf6455e3176af3eaac7bdb80c181
+  data.tar.gz: 67b7d61d4cf0ad053c3c8e9121c734fe5c03b8a899c17f2b5b08d5c181142f70a494008820fe365f772dbcebb468ea99d14d3d2e2e3d9ea7198ad9b8c9f59482

data/lib/emanlib.rb

@@ -1,73 +1,8 @@
-require_relative "patch/define"
+require_relative "patch/enum"
 require_relative "patch/foobar"
 require_relative "patch/lambda"
+require_relative "patch/let"
 
 module EmanLib
-  # The identity Lambda object (`_`).
-  # Store in a short variable, and use it as a building block for anonymous functions.
-  #
-  #     _ = EmanLib.LAMBDA
-  #     [1, 2, 3].map(&_.succ) => [2, 3, 4]
-  #     [[1, 2], [3, 4]].map(&(_ + _).lift) => [3, 7]
-  LAMBDA = Lambda.new
-
-  # Helper method to create definitions.
-  # A convenient shorthand for `Object.new.define(...)`.
-  #
-  # @param args [Array<Hash, Array>] A list of Hashes or "hashy" Arrays.
-  # @param block [Proc] If provided, its local variables are used to define methods.
-  # @return [Object] A new object with dynamically defined methods.
-  #
-  # @see [Object#define]
-  #
-  # @example
-  #   point = let(x: 10, y: 20)
-  #   puts point.x # => 10
-  #
-  #   settings = let do
-  #     theme = "dark"
-  #     font_size = 12
-  #     binding
-  #   end
-  #   puts settings.theme # => "dark"
-  #
-  #   complex_data = let([[:id, "item1"]], name: "Test Item") do
-  #     details = { color: "red", size: "large" }
-  #     binding
-  #   end
-  #
-  #   puts complex_data.id            # => "item1"
-  #   puts complex_data.name          # => "Test Item"
-  #   puts complex_data.details.color # => "red"
-  def let(*args, &block)
-    Object.new.define(*args, &block)
-  end
-
-  module_function :let
-
-  # Support for using a `_` as the second operand with operators.
-  # WARN: This method will MODIFY the standard library classes.
-  # In particular, the operators: `- * / % ** & | ^ << >> <=> == === != > < >= <=`
-  # in the classes: `Integer, Float, Rational, Complex, Array, String, Hash, Range, Set`
-  def support_lambda
-    [[Integer, Float, Rational, Complex, Array, String, Hash, Range, Set],
-     %i[- * / % ** & | ^ << >> <=> == === != > < >= <=]].op(:product)
-      .each do |klass, op|
-      next unless klass.instance_methods(false).include?(op)
-
-      original = klass.instance_method(op)
-      klass.define_method(op) do |other|
-        if other.is_a?(Lambda)
-          repr = [self]
-          repr.concat(other.repr)
-          repr << Lambda::Function.new(op)
-          Lambda.new(repr)
-        else
-          original.bind(self).call(other)
-        end
-      end
-    end
-  end
-
-  module_function :support_lambda
+  VERSION = "0.1.2"
 end

data/lib/patch/enum.rb

@@ -0,0 +1,115 @@
+module EmanLib
+  # The Enum module provides a factory method `[]` to dynamically create
+  # simple, lightweight enum-like classes. These classes allow defining a set of
+  # named constants with associated numeric values.
+  #
+  # Enums are defined by passing symbols, strings, or hashes to the `[]` method.
+  #
+  # Usage examples:
+  #   OS = Enum[:Arch, :BSD] # OS.Arch => 0, OS.BSD => 1
+  #   Bool = Enum[nil: 1, :t 10] # Bool.nil => 1, Bool.t => 10
+  #   Way = Enum["↑", { ↓: 50 }, :→ ] # Way.↑ => 0, Way.↓ => 50, Way.→ => 51
+  #   Pet = Enum[:Dog, :Cat] { |v| 0.5 * v } # Pet.Dog => 0.0, Pet.Cat => 0.5
+  #
+  # The generated enum class provides:
+  # * Class methods to access each constant's value (e.g., `Way.↑`).
+  # * A `size` method to get the number of defined constants.
+  # * An `each` class method to iterate over value-name pairs.
+  # * A `to_h` class method to get a hash of name-value pairs.
+  module Enum
+    def self.[](*args, &block)
+      # At least one argument should be provided
+      raise ArgumentError, "Enums must have at least one constant" if args.empty?
+
+      # Initialize tracking variables
+      pairs = {}
+      current = 0
+
+      args.flatten!(1)
+
+      # Process all arguments to extract name-value pairs
+      args.each do |arg|
+        current = case arg
+          when Symbol, String
+            # Single enum value - assign current value and increment
+            pairs[arg.to_sym] = current
+            current + 1
+          when Hash
+            # Hash with explicit key-value mapping
+            arg.each do |key, value|
+              unless key.is_a?(Symbol) || key.is_a?(String)
+                raise ArgumentError, "Enum names must be Symbol|String: #{key.inspect}"
+              end
+              raise ArgumentError, "Enum values must be Numeric: #{value.inspect}" unless value.is_a?(Numeric)
+              pairs[key.to_sym] = value
+              current = value + 1
+            end
+
+            current
+          else
+            raise ArgumentError, "Invalid enum argument: #{arg.inspect}"
+          end
+      end
+
+      # Apply block transformation if provided
+      if block_given?
+        values = Set.new
+        pairs.each do |prop, value|
+          hash = block.call(value, prop)
+
+          # Make sure block result is Numeric
+          unless hash.is_a?(Numeric)
+            raise ArgumentError, "Block must return a Numeric, got #{hash.class}: #{hash.inspect}"
+          end
+
+          # Check that result is unique
+          if values.include?(hash)
+            raise ArgumentError, "Block must return unique values, duplicate: #{hash}"
+          end
+
+          values.add(hash)
+          pairs[prop] = hash
+        end
+      end
+
+      # Create enum class and include this module
+      klass = Class.new
+      klass.include(Enum)
+
+      # Store enums data for instance methods
+      klass.instance_variable_set(:@pairs, pairs.freeze)
+
+      # Define getter methods for each constant
+      pairs.each do |prop, value|
+        begin
+          klass.define_singleton_method(prop) { value }
+        rescue => e
+          raise ArgumentError, "Invalid const name '#{prop}': #{e.message}"
+        end
+      end
+
+      klass.define_method(:initialize) do
+        raise RuntimeError, "Enums are not meant to be instantiated"
+      end
+
+      # Define utility methods directly on the class
+      klass.define_singleton_method(:size) do
+        @pairs.size
+      end
+
+      klass.define_singleton_method(:to_h) do
+        @pairs.dup
+      end
+
+      klass.define_singleton_method(:each) do |&block|
+        return enum_for(:each) unless block
+
+        @pairs.each do |prop, value|
+          block.call(value, prop)
+        end
+      end
+
+      klass
+    end
+  end
+end

data/lib/patch/foobar.rb

@@ -121,22 +121,24 @@ class Object
   end
 
   # Asserts a condition about `self`.
-  # If a block is given, it asserts that the block, when called with `self`, returns a truthy value.
+  # If a block is given, it asserts that the block returns a truthy value.
+  # The block is passed `self` as an argument.
   # If no block is given, it asserts that `n === self` is true.
   # If the assertion fails, it performs a non-local exit by `raise`.
   #
-  # @param `n` ([Object]) The object to compare with `self` if no block is given. Defaults to `self`.
+  # @param `n` ([Object]) The object to compare with `self` if no block is given.
   # @param `error` ([Class]) The class of error to raise if the assertion fails.
-  #   Defaults to `StandardError`.
+  # @param `message` (String?) An optional message to include in the raised error.
   # @yield [self] Optional block whose truthiness is asserted.
   # @return [self] The original object if assertion passes.
   # @throw `error` (or a related symbol) if the assertion fails.
   #
   # @example
   #   5.assert(Integer) # Passes
-  #   "string".assert(error: ArgumentError) { |s| s.length > 5 } # Passes
-  def assert(n = self, error: StandardError)
-    tap { (block_given? ? yield(self) : (n === self)) || raise(error) }
+  #   "string".assert(error: ArgumentError) { |s| s.size > 5 } # Passes
+  #   "".assert(message: "String too short") {|s| s.size > 5 } # Raises error with message
+  def assert(n = self, error: StandardError, message: nil)
+    tap { (block_given? ? yield(self) : (n === self)) || (message ? raise(error, message) : raise(error)) }
   end
 
   # Prints the `inspect` representation of `self` to standard output.
@@ -281,8 +283,8 @@ class Array
   #   ["a","b"].third  # => nil
   %i[second third fourth fifth sixth seventh eighth ninth tenth]
     .zip(1..) # 1-based index for human-readable Nth
-    .each do |method_name, index|
-    define_method(method_name) do |n = 1|
+    .each do |method, index|
+    define_method(method) do |n = 1|
       # `index` is 1 for 'second', 2 for 'third', etc.
       # So, for 'second' (index 1), drop 1. For 'third' (index 2), drop 2.
       drop(index).take(n).simplify

data/lib/patch/lambda.rb

@@ -19,131 +19,168 @@ class Array
   end
 end
 
-# A Lambda object (`_`) is building block for anonymous functions.
-# For instance, (`_ + _`) represents f(x,y) = x + y
-# (`_ * 2`) represents f(x) = 2x.
-# You can use any method or operator on a `_`, and it will work:
-# -   `[1, 2].map(&_.succ ** 3)      => [8, 27]`
-# -   `[[1,2], [3,4]].map(&_.sum / 2)  => [1.5, 3.5]`
-#
-# The `lift` method allows a `_` to be used like so:
-# -   `[[1, 2], [3, 4]].map(&(_ + _).lift) => [3, 7]`
-#
-# i.e. it treats the first arg (that is an array) as the actual arguments to be used
-# WARN: "lift" state is contagious (e.g. `(_ + _.lift) <=> (_ + _).lift`).
-#
-# You can similarly use [unlift] to convert a lifted `_` back to a normal.
-# [support_lambda] will allow for a _ to be used as the second operand (e.g. `2 - _`)
-#
-class Lambda < BasicObject
-  class Arg; end
-
-  class Block
-    def initialize(block)
-      @proc = block
-    end
+module EmanLib
+
+  # A Lambda object (`_`) is building block for anonymous functions.
+  # For instance, (`_ + _`) represents f(x,y) = x + y
+  # (`_ * 2`) represents f(x) = 2x.
+  # You can use any method or operator on a `_`, and it will work:
+  # -   `[1, 2].map(&_.succ ** 3)      => [8, 27]`
+  # -   `[[1,2], [3,4]].map(&_.sum / 2)  => [1.5, 3.5]`
+  #
+  # The `lift` method allows a `_` to be used like so:
+  # -   `[[1, 2], [3, 4]].map(&(_ + _).lift) => [3, 7]`
+  #
+  # i.e. it treats the first arg (that is an array) as the actual arguments to be used
+  # WARN: "lift" state is contagious (e.g. `(_ + _.lift) <=> (_ + _).lift`).
+  #
+  # You can similarly use [unlift] to convert a lifted `_` back to a normal.
+  # [support_lambda] will allow for a _ to be used as the second operand (e.g. `2 - _`)
+  #
+  class Lambda < BasicObject
+    class Arg; end
 
-    def to_proc
-      @proc
-    end
-  end
+    class Block
+      def initialize(block)
+        @proc = block
+      end
 
-  class Function
-    def initialize(method)
-      @method = method
+      def to_proc
+        @proc
+      end
     end
 
-    def to_proc
-      @method.to_proc
+    class Function
+      def initialize(method)
+        @method = method
+      end
+
+      def to_proc
+        @method.to_proc
+      end
     end
-  end
 
-  def __repr__; @__repr__ end
-  def __tuply__; @__tuply__ end
+    def __repr__; @__repr__ end
+    def __tuply__; @__tuply__ end
 
-  def initialize(repr = [Arg.new], *args)
-    @__tuply__ = args.include?(:lift)
-    @__repr__ = repr
+    def initialize(repr = [Arg.new], *args)
+      @__tuply__ = args.include?(:lift)
+      @__repr__ = repr
 
-    return if repr != :lift
+      return if repr != :lift
 
-    @__repr__ = [Arg.new]
-    @__tuply__ = true
-  end
+      @__repr__ = [Arg.new]
+      @__tuply__ = true
+    end
 
-  def to_proc
-    ::Proc.new do |*args|
-      args = args.first if @__tuply__ && args.first.is_a?(::Array)
-      stack = []
-      index = 0
-
-      @__repr__.each do |element|
-        case element
-        when Arg
-          stack << args[index]
-          index += 1
-        when Function
-          f = element.to_proc
-          operands, block = stack.partition { |e| !e.is_a?(Block) }
-          empty = ::Object.new
-          xy = [operands.qoq(empty), operands.qoq(empty)]
-            .reject { |x| x.equal?(empty) }.reverse
-          stack = operands
-
-          if block.empty?
-            stack << f.call(*xy)
+    def to_proc
+      ::Proc.new do |*args|
+        args = args.first if @__tuply__ && args.first.is_a?(::Array)
+        stack = []
+        index = 0
+
+        @__repr__.each do |element|
+          case element
+          when Arg
+            stack << args[index]
+            index += 1
+          when Function
+            f = element.to_proc
+            operands, block = stack.partition { |e| !e.is_a?(Block) }
+            empty = ::Object.new
+            xy = [operands.qoq(empty), operands.qoq(empty)]
+              .reject { |x| x.equal?(empty) }.reverse
+            stack = operands
+
+            if block.empty?
+              stack << f.call(*xy)
+            else
+              stack << f.call(*xy, &block[0].to_proc)
+            end
           else
-            stack << f.call(*xy, &block[0].to_proc)
+            stack << element
           end
-        else
-          stack << element
         end
-      end
 
-      stack.first
+        stack.first
+      end
     end
-  end
 
-  # Temporary wrapper for @__repr__
-  class Repr
-    attr_reader :repr
+    # Temporary wrapper for @__repr__
+    class Repr
+      attr_reader :repr
 
-    def initialize(repr)
-      @repr = repr
+      def initialize(repr)
+        @repr = repr
+      end
     end
-  end
 
-  def method_missing(method, *args, &block)
-    extra = [Function.new(method)]
-    extra.unshift Block.new(block) if block
-    tuply = @__tuply__
+    def method_missing(method, *args, &block)
+      extra = [Function.new(method)]
+      extra.unshift Block.new(block) if block
+      tuply = @__tuply__
 
-    args.map do |arg|
-      if arg.is_a?(::Lambda)
-        tuply ||= arg.__tuply__
-        Repr.new(arg.__repr__)
-      else
-        arg
+      args.map do |arg|
+        if arg.is_a?(::Lambda)
+          tuply ||= arg.__tuply__
+          Repr.new(arg.__repr__)
+        else
+          arg
+        end
+      end.each_with_index do |arg, i|
+        if arg.is_a? Repr
+          args.insert(i, *arg.repr)
+          args.delete_at(i + arg.repr.size)
+        end
       end
-    end.each_with_index do |arg, i|
-      if arg.is_a? Repr
-        args.insert(i, *arg.repr)
-        args.delete_at(i + arg.repr.size)
+
+      if tuply
+        ::Lambda.new(@__repr__ + args + extra, :lift)
+      else
+        ::Lambda.new(@__repr__ + args + extra)
       end
     end
 
-    if tuply
-      ::Lambda.new(@__repr__ + args + extra, :lift)
-    else
-      ::Lambda.new(@__repr__ + args + extra)
+    def lift
+      ::Lambda.new(@__repr__, :lift)
     end
-  end
 
-  def lift
-    ::Lambda.new(@__repr__, :lift)
+    def unlift
+      @__tuply__ ? ::Lambda.new(@__repr__) : self
+    end
   end
 
-  def unlift
-    @__tuply__ ? ::Lambda.new(@__repr__) : self
+  # The identity Lambda object (`_`).
+  # Store in a short variable, and use it as a building block for anonymous functions.
+  #
+  #     _ = EmanLib._
+  #     [1, 2, 3].map(&_.succ) => [2, 3, 4]
+  #     [[1, 2], [3, 4]].map(&(_ + _).lift) => [3, 7]
+  _ = Lambda.new
+
+  # Support for using a `_` as the second operand with operators.
+  # WARN: This method WILL MODIFY the standard library classes.
+  # In particular, the operators: `- * / % ** & | ^ << >> <=> == === != > < >= <=`
+  # in the classes: `Integer, Float, Rational, Complex, Array, String, Hash, Range, Set`
+  def support_lambda
+    [[Integer, Float, Rational, Complex, Array, String, Hash, Range, Set],
+     %i[- * / % ** & | ^ << >> <=> == === != > < >= <=]].op(:product)
+      .each do |klass, op|
+      next unless klass.instance_methods(false).include?(op)
+
+      original = klass.instance_method(op)
+      klass.define_method(op) do |other|
+        if other.is_a?(Lambda)
+          repr = [self]
+          repr.concat(other.repr)
+          repr << Lambda::Function.new(op)
+          Lambda.new(repr)
+        else
+          original.bind(self).call(other)
+        end
+      end
+    end
   end
+
+  module_function :support_lambda
 end

data/lib/patch/let.rb

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+
+# Enhances the Binding class to easily extract local variables into a Hash.
+class Binding
+  # Converts the local variables accessible from this binding into a Hash.
+  # The keys of the hash are the variable names (as Symbols), and the values
+  # are the corresponding variable values.
+  #
+  # @return (Symbol to Object) {} - A hash mapping local variable names to their values
+  #
+  # @example
+  #   def my_method
+  #     a = 10
+  #     b = "hello"
+  #     binding.variables # => {:a=>10, :b=>"hello"}
+  #   end
+  def variables
+    Hash[
+      local_variables.map do |var|
+        [var, local_variable_get(var)]
+      end
+    ]
+  end
+end
+
+# Enhances the Array class with a utility method to check its structure.
+class Array
+  # Checks if the array is "hashy", meaning it consists entirely of
+  # two-element arrays. This structure is suitable for conversion to a Hash
+  # using `to_h`.
+  #
+  # @return [Boolean] `true` if the array is "hashy", `false` otherwise.
+  #
+  # @example
+  #   [[:a, 1], [:b, 2]].hashy?  # => true
+  #   [["key1", "value1"]].hashy? # => true
+  #   [[1, 2, 3], [:b, 2]].hashy? # => false (first item has 3 elements)
+  #   [1, 2, 3].hashy?            # => false (items are not arrays)
+  #   [[], [:a, 1]].hashy?       # => false (first item is empty)
+  def hashy?
+    all? { |item| item.is_a?(Array) && item.size == 2 }
+  end
+end
+
+# Enhances the String class with validation for method and variable names.
+class String
+  # Checks if the string is a valid Ruby method or variable name.
+  #
+  # Valid method names can include letters, numbers, underscores, and may
+  # end with `!`, `=`, or `?`.
+  # Valid variable names can include letters, numbers, and underscores but
+  # cannot end with `!`, `=`, or `?`.
+  #
+  # @param target [[:method, :variable, :var]] Whether to validate as a method
+  #   name or a variable name. Defaults to `:method`.
+  # @return [Boolean] `true` if the string is a valid name for the specified target,
+  #   `false` otherwise.
+  #
+  # @example
+  #   "my_method".valid_name?                # => true
+  #   "my_method?".valid_name?               # => true
+  #   "setter=".valid_name?                 # => true
+  #   "_private_method!".valid_name?         # => true
+  #   "ConstantLike".valid_name?             # => true
+  #   "1invalid".valid_name?                 # => false (starts with a number)
+  #   "invalid-name".valid_name?             # => false (contains hyphen)
+  #
+  #   "my_variable".valid_name?(:variable) # => true
+  #   "_var".valid_name?(:variable)        # => true
+  #   "my_variable?".valid_name?(:variable)# => false (ends with ?)
+  #   "A_CONSTANT".valid_name?(:variable)  # => true
+  def valid_name?(target = :method)
+    case target
+    when :method
+      self =~ /\A[a-zA-Z_]\w*[!?=]?\z/
+    when :var, :variable
+      self =~ /\A[a-zA-Z_]\w*\z/
+    else
+      false
+    end
+  end
+end
+
+module EmanLib
+  # A convenient shorthand for `Maplet.new.define!(...)`.
+  #
+  # @param args [Array<Hash, Array>] A list of Hashes or "hashy" Arrays.
+  # @param block [Proc] If provided, its local variables are used to define methods.
+  # @return [Object] A new object with dynamically defined methods.
+  #
+  # @see [Maplet#define!]
+  #
+  # @example
+  #   person = let(name: "Rio", age: 37)
+  #   puts person.name # => "Rio"
+  #   puts person.age  # => 37
+  #
+  #   point = let **{x: 10, y: 20}
+  #   puts point.x # => 10
+  #
+  #   settings = let do
+  #     theme = "dark"
+  #     font_size = 12
+  #     binding
+  #   end
+  #   puts settings.theme # => "dark"
+  #
+  #   complex_data = let([[:id, 42]], name: "Xed") do
+  #     details = { color: "red", size: "large" }
+  #     binding # Required
+  #   end
+  #
+  #   puts complex_data.id            # => 42
+  #   puts complex_data.name          # => "Xed"
+  #   puts complex_data.details.color # => "red"
+  def let(*args, &block)
+    Maplet.new.define!(*args, &block)
+  end
+
+  module_function :let
+
+  # Class that allows for dynamic definition of properties
+  class Maplet
+    include Enumerable
+
+    def initialize
+      @props = []
+    end
+
+    # Dynamically defines properties based on the provided arguments and/or block.
+    #
+    # Arguments can be Hashes or "hashy" Arrays (arrays of `[key, value]` pairs).
+    # If a block is given, its local variables are also used to define methods.
+    # Keys are converted to symbols and validated as method names.
+    #
+    # If a value is a Hash or a "hashy" Array, it's recursively
+    # used to define nested properties.
+    #
+    # @param `args` [Array<Hash, Array>] A list of Hashes or "hashy" Arrays.
+    #   Each key-value pair will result in a getter and setter method.
+    # @param `block` [Proc] If provided, `block.call` is expected to return a `Binding`
+    #   (i.e. last expression in the block must be `binding`).
+    #   Local variables from this binding will be used to define methods.
+    #
+    # @return [self] The object itself, now with the newly defined methods.
+    #
+    # @raise [ArgumentError] If an argument is not a Hash or a "hashy" Array.
+    # @raise [ArgumentError] If a key is not a valid method name.
+    #
+    # @example Defining with a Hash
+    #   # let(...) === Maplet.new.define!(...)
+    #
+    #   person = let(name: "Alice", age: 30)
+    #   person.name # => "Alice"
+    #   person.age = 31
+    #   person.age # => 31
+    #
+    # @example Defining with a "hashy" Array
+    #   config = let([[:host, "localhost"], [:port, 8080]])
+    #   config.host # => "localhost"
+    #
+    # @example Defining with a block
+    #   user = let do
+    #     username = "bob"
+    #     active = true
+    #     binding # Important: makes local variables available
+    #   end
+    #
+    #   user.username # => "bob"
+    #   user.active?  # This won't define active? automatically, but user.active
+    #
+    # @example Nested definitions
+    #   settings = let(
+    #     database: { adapter: "sqlite3", pool: 5 },
+    #     logging: [[:level, "info"], [:file, "/var/log/app.log"]]
+    #   )
+    #   settings.database.adapter # => "sqlite3"
+    #   settings.logging.level    # => "info"
+    #
+    # @example Combining arguments
+    #   complex = let({id: 1}, [[:type, "example"]]) do
+    #     description = "A complex object"
+    #     status = :new
+    #     binding
+    #   end
+    #
+    #   complex.id          # => 1
+    #   complex.type        # => "example"
+    #   complex.description # => "A complex object"
+    def define!(*args, &block)
+      # Stores all key-value pairs to be defined
+      variable = {}
+
+      # Process Hashes and "hashy" Arrays first
+      args.each do |arg|
+        case arg
+        when Hash
+          variable.merge!(arg)
+        when Array
+          raise ArgumentError, "Array should be Hash like." unless arg.hashy?
+          variable.merge!(arg.to_h)
+        else
+          raise ArgumentError, "Invalid argument type: #{arg.class}"
+        end
+      end
+
+      # Process local variables from the block
+      if block_given?
+        binding = block.call # The block is expected to return its binding.
+        raise ArgumentError, "Block must return a Binding object." unless binding.is_a?(Binding)
+
+        variable.merge!(binding.variables)
+      end
+
+      # Define getters and setters and store values
+      variable.each do |prop, value|
+        prop = prop.to_s.to_sym
+        raise ArgumentError, "Invalid name: #{prop}" unless prop.to_s.valid_name?
+
+        # Recursively define for nested Hashes or "hashy" Arrays
+        if value.is_a? Hash
+          value = Maplet.new.define!(value)
+        elsif value.is_a?(Array) && value.hashy?
+          value = Maplet.new.define!(value.to_h)
+        end
+
+        # Store the original value in an instance variable
+        instance_variable_set("@#{prop}", value)
+
+        define_singleton_method(prop) do
+          instance_variable_get("@#{prop}")
+        end
+
+        define_singleton_method("#{prop}=") do |value|
+          instance_variable_set("@#{prop}", value)
+        end
+      end
+
+      @props += variable.keys.map(&:to_sym)
+      self
+    end
+
+    # Accesses a prop's value, allowing for nested access.
+    #
+    # @param prop [Array<Symbol, String>] A sequence of prop names to access.
+    # @return [Object] The value of the specified property.
+    #
+    # @raise [ArgumentError] If no prop is given or does not exist.
+    #
+    # @example Accessing top-level and nested properties
+    #   settings = let(
+    #     host: "localhost",
+    #     database: { adapter: "sqlite3", pool: 5 }
+    #   )
+    #
+    #   settings[:host]                # => "localhost"
+    #   settings[:database]            # => <EmanLib::Maplet ...>
+    #   settings[:database, :adapter]  # => "sqlite3"
+    #   settings[:database, :pool]     # => 5
+    def [](*prop)
+      raise ArgumentError, "No property specified." if prop.empty?
+      value = instance_variable_get("@#{prop.first}")
+
+      if prop.size == 1
+        value
+      else
+        value[*prop[1..]]
+      end
+    rescue NameError
+      error = "Property '#{prop.join ?.}' is not defined in this Maplet."
+      error += " Available properties: [#{@props.join(", ")}]"
+      raise ArgumentError, error
+    end
+
+    # Converts the Maplet and any nested Maplets back into a Hash.
+    # Recursively transforms inner maplets into nested Hashes.
+    #
+    # @return [Hash{Symbol => Object}] A hash representation of the Maplet.
+    #
+    # @example
+    #   settings = let(host: 'localhost', db: { name: 'dev', pool: 5 })
+    #   settings.to_h # => { host: "localhost", db: { name: "dev", pool: 5 } }
+    def to_h
+      @props.each_with_object({}) do |prop, hash|
+        value = self[prop]
+
+        if value.is_a?(Maplet)
+          hash[prop] = value.to_h
+        else
+          hash[prop] = value
+        end
+      end
+    end
+
+    # Iterates over each leaf property of the Maplet.
+    #
+    # @yield [value, path] Gives the value and its full access path.
+    # @yieldparam value [Object] The value of the leaf property.
+    # @yieldparam path [String] The dotted path to the prop (e.g., `"dir.home"`).
+    #
+    # @return [self, Enumerator] Self if a block is given, otherwise an Enumerator.
+    #
+    # @example
+    #   user = let(name: 'Ian', meta: { role: 'Admin', active: true })
+    #   user.each { |value, path| puts "#{path}: #{value}" }
+    #   # Prints:
+    #   # name: Ian
+    #   # meta.role: Admin
+    #   # meta.active: true
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      tap do
+        @props.each do |prop|
+          value = self[prop]
+          if value.is_a?(Maplet)
+            value.each do |inner, nested|
+              yield inner, "#{prop}.#{nested}"
+            end
+          else
+            yield value, prop.to_s
+          end
+        end
+      end
+    end
+
+    # Creates a new Maplet by applying a block to each property's value.
+    # You can transform all properties or just a select few.
+    #
+    # @param only [Array<Symbol, String>] Optional. A list of top-level property
+    #   names to transform. If provided, other properties are copied as-is.
+    # @yield [value, prop] The block to apply to each selected property.
+    # @yieldparam value [Object] The value of the property.
+    # @yieldparam prop [String] The name of the property.
+    #
+    # @return [Maplet] A new Maplet with the transformed values.
+    #
+    # @example Transforming all numeric values
+    #   config = let(port: 80, timeout: 3000, host: "localhost")
+    #   doubled = config.map do |value, _|
+    #     value.is_a?(Numeric) ? value * 2 : value
+    #   end
+    #   doubled.to_h # => { port: 160, timeout: 6000, host: "localhost" }
+    #
+    # @example Transforming only a specific property
+    #   config = let(port: 80, host: "localhost")
+    #   upcased = config.map(:host) { |val, _| val.upcase }
+    #   upcased.to_h # => { port: 80, host: "LOCALHOST" }
+    def map(*only, &block)
+      return enum_for(:map) unless block_given?
+      hash = {}
+
+      @props.each do |prop|
+        value = self[prop]
+        if value.is_a?(Maplet)
+          hash[prop] = value.map(*only, &block)
+        elsif only.empty?
+          hash[prop] = yield(value, prop)
+        elsif only.any? { |p| p.to_sym == prop }
+          hash[prop] = yield(value, prop)
+        else
+          hash[prop] = value
+        end
+      end
+
+      Maplet.new.define!(hash)
+    end
+
+    # Returns a new Maplet that excludes the specified top-level properties.
+    # Note: This only works on top-level properties.
+    #
+    # @param props [Array<Symbol, String>] A list of property names to exclude.
+    # @return [Maplet] A new Maplet instance without the specified properties.
+    #
+    # @example
+    #   user = let(id: 1, name: 'Tico', email: 'tico@example.com')
+    #
+    #   user_public_data = user.without(:id)
+    #   user_public_data.to_h # => { name: "Tico", email: "tico@example.com" }
+    def without(*props)
+      return self if props.empty?
+
+      remaining = to_h
+      props.each { |p| remaining.delete(p.to_sym) }
+
+      Maplet.new.define!(remaining)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: emanlib
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - emanrdesu
@@ -17,9 +17,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/emanlib.rb
-- lib/patch/define.rb
+- lib/patch/enum.rb
 - lib/patch/foobar.rb
 - lib/patch/lambda.rb
+- lib/patch/let.rb
 homepage: https://github.com/emanrdesu/lib
 licenses:
 - GPL-3.0-only

data/lib/patch/define.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-# Enhances the Binding class to easily extract local variables into a Hash.
-class Binding
-  # Converts the local variables accessible from this binding into a Hash.
-  # The keys of the hash are the variable names (as Symbols), and the values
-  # are the corresponding variable values.
-  #
-  # @return [Hash<Symbol, Object>] A hash mapping local variable names to their values.
-  #
-  # @example
-  #   def my_method
-  #     a = 10
-  #     b = "hello"
-  #     binding.variables # => {:a=>10, :b=>"hello"}
-  #   end
-  def variables
-    Hash[
-      local_variables.map do |var|
-        [var, local_variable_get(var)]
-      end
-    ]
-  end
-end
-
-# Enhances the Array class with a utility method to check its structure.
-class Array
-  # Checks if the array is "hashy", meaning it consists entirely of
-  # two-element arrays. This structure is suitable for conversion to a Hash
-  # using `to_h`.
-  #
-  # @return [Boolean] `true` if the array is "hashy", `false` otherwise.
-  #
-  # @example
-  #   [[:a, 1], [:b, 2]].hashy?  # => true
-  #   [["key1", "value1"]].hashy? # => true
-  #   [[1, 2, 3], [:b, 2]].hashy? # => false (first item has 3 elements)
-  #   [1, 2, 3].hashy?            # => false (items are not arrays)
-  #   [[], [:a, 1]].hashy?       # => false (first item is not a 2-element array)
-  def hashy?
-    all? { |item| item.is_a?(Array) && item.size == 2 }
-  end
-end
-
-# Enhances the String class with validation for method and variable names.
-class String
-  # Checks if the string is a valid Ruby method or variable name.
-  #
-  # Valid method names can include letters, numbers, underscores, and may
-  # end with `!`, `=`, or `?`.
-  # Valid variable names can include letters, numbers, and underscores but
-  # cannot end with `!`, `=`, or `?`.
-  #
-  # @param target [:method, :variable] Specifies whether to validate as a method
-  #   name or a variable name. Defaults to `:method`.
-  # @return [Boolean] `true` if the string is a valid name for the specified target,
-  #   `false` otherwise.
-  #
-  # @example
-  #   "my_method".valid_name?                # => true
-  #   "my_method?".valid_name?               # => true
-  #   "setter=".valid_name?                 # => true
-  #   "_private_method!".valid_name?         # => true
-  #   "ConstantLike".valid_name?             # => true
-  #   "1invalid".valid_name?                 # => false (starts with a number)
-  #   "invalid-name".valid_name?             # => false (contains hyphen)
-  #
-  #   "my_variable".valid_name?(target: :variable) # => true
-  #   "_var".valid_name?(target: :variable)        # => true
-  #   "my_variable?".valid_name?(target: :variable)# => false (ends with ?)
-  #   "A_CONSTANT".valid_name?(target: :variable)  # => true
-  def valid_name?(target: :method)
-    case target
-    when :method
-      self =~ /\A[a-zA-Z_]\w*[!?=]?\z/
-    when :variable
-      self =~ /\A[a-zA-Z_]\w*\z/
-    else
-      false
-    end
-  end
-end
-
-# Enhances the base Object class to allow dynamic definition of properties
-class Object
-  # Dynamically defines properties on `self`,
-  # based on the provided arguments and/or block.
-  #
-  # Arguments can be Hashes or "hashy" Arrays (arrays of `[key, value]` pairs).
-  # If a block is given, its local variables are also used to define methods.
-  # Keys are converted to symbols and validated as method names.
-  #
-  # If a value is a Hash or a "hashy" Array, it's recursively
-  # used to define nested properties.
-  #
-  # @param `args` [Array<Hash, Array>] A list of Hashes or "hashy" Arrays.
-  #   Each key-value pair will result in a getter and setter method.
-  # @param `block` [Proc] If provided, `block.call` is expected to return a `Binding`
-  #   (i.e. last expression in the block must be `binding`).
-  #   Local variables from this binding will be used to define methods.
-  #
-  # @return [self] The object itself, now with the newly defined methods.
-  #
-  # @raise [ArgumentError] If an argument is not a Hash or a "hashy" Array.
-  # @raise [ArgumentError] If a key is not a valid method name.
-  #
-  # @example Defining with a Hash
-  #   # let(...) === Object.new.define(...)
-  #
-  #   person = let(name: "Alice", age: 30)
-  #   person.name # => "Alice"
-  #   person.age = 31
-  #   person.age # => 31
-  #
-  # @example Defining with a "hashy" Array
-  #   config = let([[:host, "localhost"], [:port, 8080]])
-  #   config.host # => "localhost"
-  #
-  # @example Defining with a block
-  #   user = let do
-  #     username = "bob"
-  #     active = true
-  #     binding # Important: makes local variables available
-  #   end
-  #
-  #   user.username # => "bob"
-  #   user.active?  # This won't define active? automatically, but user.active
-  #
-  # @example Nested definitions
-  #   settings = let(
-  #     database: { adapter: "sqlite3", pool: 5 },
-  #     logging: [[:level, "info"], [:file, "/var/log/app.log"]]
-  #   )
-  #   settings.database.adapter # => "sqlite3"
-  #   settings.logging.level    # => "info"
-  #
-  # @example Combining arguments
-  #   complex = let({id: 1}, [[:type, "example"]]) do
-  #     description = "A complex object"
-  #     status = :new
-  #     binding
-  #   end
-  #
-  #   complex.id          # => 1
-  #   complex.type        # => "example"
-  #   complex.description # => "A complex object"
-  def define(*args, &block)
-    # Stores all key-value pairs to be defined
-    variable = {}
-
-    # Process Hashes and "hashy" Arrays first
-    args.each do |arg|
-      case arg
-      when Hash
-        variable.merge!(arg)
-      when Array
-        raise ArgumentError, "Array should be Hash like." unless arg.hashy?
-        variable.merge!(arg.to_h)
-      else
-        raise ArgumentError, "Invalid argument type: #{arg.class}"
-      end
-    end
-
-    # Process local variables from the block
-    if block_given? # If provided
-      binding = block.call # The block is expected to return its binding.
-      raise ArgumentError, "Block must return a Binding object." unless binding.is_a?(Binding)
-
-      variable.merge!(binding.variables)
-    end
-
-    # Define getters and setters and store values
-    variable.each do |name, value|
-      name = name.to_s.to_sym
-      raise ArgumentError, "Invalid name: #{name}" unless name.to_s.valid_name?(target: :method)
-
-      # Recursively define for nested Hashes or "hashy" Arrays
-      if value.is_a? Hash
-        value = Object.new.define(value)
-      elsif value.is_a?(Array) && value.hashy?
-        value = Object.new.define(value.to_h)
-      end
-
-      # Store the original value in an instance variable
-      instance_variable_set("@#{name}", value)
-
-      define_singleton_method(name) do
-        instance_variable_get("@#{name}")
-      end
-
-      define_singleton_method("#{name}=") do |value|
-        instance_variable_set("@#{name}", value)
-      end
-    end
-
-    self
-  end
-end