emanlib 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c865695d10014ad5b2b967418ec8e4ea65165e9549590f7380c4f21e27b50b0
-  data.tar.gz: 00dda6a97a260530b29a932d883377b9f8877820d15b5605bce7582cd422ac72
+  metadata.gz: fd662dbc1918087da06994da20c822e4e3697a07db7f5681602c26c46839ed07
+  data.tar.gz: d1e82edbb74f7d2f60dbe906f5715cddc94a28639266107d713744517de52007
 SHA512:
-  metadata.gz: fc5e5219826053c84b0e007cf3e59dc5f72d6f483384ed5515f7938b5c3efb9fab39e77109adafe5b18a58fe17c65913d8951a4b4478b27445a93451a9f79851
-  data.tar.gz: bf1123ccc076eaa6c657c28fbc47aff2c4f0e23a749625b02ec33433e7605b5e9262fcd0ff3bdf43e67c56e026a5c75c01d881f938c7517923f22024efe4283e
+  metadata.gz: 3b5a86384a130d687ef886a075b55d1d3ea892ccf656356df78cfee9c9949dbcdaa36691b92733506956b687c5af66baba8fcf6455e3176af3eaac7bdb80c181
+  data.tar.gz: 67b7d61d4cf0ad053c3c8e9121c734fe5c03b8a899c17f2b5b08d5c181142f70a494008820fe365f772dbcebb468ea99d14d3d2e2e3d9ea7198ad9b8c9f59482

data/lib/emanlib.rb

@@ -1,76 +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._
-  #     [1, 2, 3].map(&_.succ) => [2, 3, 4]
-  #     [[1, 2], [3, 4]].map(&(_ + _).lift) => [3, 7]
-  _ = 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
-  #   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)
-    Object.new.define(*args, &block)
-  end
-
-  # 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 :let, :support_lambda
+  VERSION = "0.1.2"
 end

data/lib/patch/enum.rb

@@ -12,11 +12,10 @@ module EmanLib
   #   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., `Lvl.MID`).
+  # * 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.
-  # * A `consts` class method to get an array of constant names (as symbols).
-  # * A `values` class method to get an array of constant values.
   module Enum
     def self.[](*args, &block)
       # At least one argument should be provided
@@ -55,21 +54,21 @@ module EmanLib
       # Apply block transformation if provided
       if block_given?
         values = Set.new
-        pairs.each do |name, value|
-          result = block.call(value, name)
+        pairs.each do |prop, value|
+          hash = block.call(value, prop)
 
           # Make sure block result is Numeric
-          unless result.is_a?(Numeric)
-            raise ArgumentError, "Block must return a Numeric, got #{result.class}: #{result.inspect}"
+          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?(result)
-            raise ArgumentError, "Block must return unique values, duplicate: #{result}"
+          if values.include?(hash)
+            raise ArgumentError, "Block must return unique values, duplicate: #{hash}"
           end
 
-          values.add(result)
-          pairs[name] = result
+          values.add(hash)
+          pairs[prop] = hash
         end
       end
 
@@ -81,11 +80,11 @@ module EmanLib
       klass.instance_variable_set(:@pairs, pairs.freeze)
 
       # Define getter methods for each constant
-      pairs.each do |name, value|
+      pairs.each do |prop, value|
         begin
-          klass.define_singleton_method(name) { value }
+          klass.define_singleton_method(prop) { value }
         rescue => e
-          raise ArgumentError, "Invalid const name '#{name}': #{e.message}"
+          raise ArgumentError, "Invalid const name '#{prop}': #{e.message}"
         end
       end
 
@@ -94,23 +93,19 @@ module EmanLib
       end
 
       # Define utility methods directly on the class
-      klass.define_singleton_method(:to_h) do
-        @pairs.dup
-      end
-
-      klass.define_singleton_method(:consts) do
-        @pairs.keys
+      klass.define_singleton_method(:size) do
+        @pairs.size
       end
 
-      klass.define_singleton_method(:values) do
-        @pairs.values
+      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 |name, value|
-          block.call(value, name)
+        @pairs.each do |prop, value|
+          block.call(value, prop)
         end
       end
 

data/lib/patch/foobar.rb

@@ -283,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.1
+  version: 0.1.2
 platform: ruby
 authors:
 - emanrdesu
@@ -17,10 +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