emanlib 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1325271b5892d5c0195b9169f09416790ea4887f680e194afb2445f33bb57b75
-  data.tar.gz: effa861c1070d969e2ab86287c101ba90bcd52ad9f82cceb87616d79f3b5a554
+  metadata.gz: 7c865695d10014ad5b2b967418ec8e4ea65165e9549590f7380c4f21e27b50b0
+  data.tar.gz: 00dda6a97a260530b29a932d883377b9f8877820d15b5605bce7582cd422ac72
 SHA512:
-  metadata.gz: 2a5248da79b6d73c42c62932c9a2473d10dee603aa9c40ba880cbe708f5ae450d1fa0861805c507051fa5dd3d777031dbfecd6a2120ac0fe688bc5743ee0eaf5
-  data.tar.gz: 77a89f7f87e7003134b581f272c4892f61c3cc861371cc7758b21a022463caa8468064b16adafd88b0d70f7b0bf1d431290b90bfe2dda22c16d6ff619d3d0389
+  metadata.gz: fc5e5219826053c84b0e007cf3e59dc5f72d6f483384ed5515f7938b5c3efb9fab39e77109adafe5b18a58fe17c65913d8951a4b4478b27445a93451a9f79851
+  data.tar.gz: bf1123ccc076eaa6c657c28fbc47aff2c4f0e23a749625b02ec33433e7605b5e9262fcd0ff3bdf43e67c56e026a5c75c01d881f938c7517923f22024efe4283e

data/lib/emanlib.rb

@@ -1,4 +1,5 @@
 require_relative "patch/define"
+require_relative "patch/enum"
 require_relative "patch/foobar"
 require_relative "patch/lambda"
 
@@ -6,10 +7,10 @@ module EmanLib
   # The identity Lambda object (`_`).
   # Store in a short variable, and use it as a building block for anonymous functions.
   #
-  #     _ = EmanLib.LAMBDA
+  #     _ = EmanLib._
   #     [1, 2, 3].map(&_.succ) => [2, 3, 4]
   #     [[1, 2], [3, 4]].map(&(_ + _).lift) => [3, 7]
-  LAMBDA = Lambda.new
+  _ = Lambda.new
 
   # Helper method to create definitions.
   # A convenient shorthand for `Object.new.define(...)`.
@@ -21,7 +22,11 @@ module EmanLib
   # @see [Object#define]
   #
   # @example
-  #   point = let(x: 10, y: 20)
+  #   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
@@ -31,22 +36,20 @@ module EmanLib
   #   end
   #   puts settings.theme # => "dark"
   #
-  #   complex_data = let([[:id, "item1"]], name: "Test Item") do
+  #   complex_data = let([[:id, 42]], name: "Xed") do
   #     details = { color: "red", size: "large" }
-  #     binding
+  #     binding # Required
   #   end
   #
-  #   puts complex_data.id            # => "item1"
-  #   puts complex_data.name          # => "Test Item"
+  #   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
 
-  module_function :let
-
   # Support for using a `_` as the second operand with operators.
-  # WARN: This method will MODIFY the standard library classes.
+  # 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
@@ -69,5 +72,5 @@ module EmanLib
     end
   end
 
-  module_function :support_lambda
+  module_function :let, :support_lambda
 end

data/lib/patch/enum.rb

@@ -0,0 +1,120 @@
+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., `Lvl.MID`).
+  # * 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
+      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 |name, value|
+          result = block.call(value, name)
+
+          # Make sure block result is Numeric
+          unless result.is_a?(Numeric)
+            raise ArgumentError, "Block must return a Numeric, got #{result.class}: #{result.inspect}"
+          end
+
+          # Check that result is unique
+          if values.include?(result)
+            raise ArgumentError, "Block must return unique values, duplicate: #{result}"
+          end
+
+          values.add(result)
+          pairs[name] = result
+        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 |name, value|
+        begin
+          klass.define_singleton_method(name) { value }
+        rescue => e
+          raise ArgumentError, "Invalid const name '#{name}': #{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(:to_h) do
+        @pairs.dup
+      end
+
+      klass.define_singleton_method(:consts) do
+        @pairs.keys
+      end
+
+      klass.define_singleton_method(:values) do
+        @pairs.values
+      end
+
+      klass.define_singleton_method(:each) do |&block|
+        return enum_for(:each) unless block
+
+        @pairs.each do |name, value|
+          block.call(value, name)
+        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.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: emanlib
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - emanrdesu
@@ -18,6 +18,7 @@ extra_rdoc_files: []
 files:
 - lib/emanlib.rb
 - lib/patch/define.rb
+- lib/patch/enum.rb
 - lib/patch/foobar.rb
 - lib/patch/lambda.rb
 homepage: https://github.com/emanrdesu/lib