hecks 0.3.0 → 1.0.0

data/lib/hecks/fuzzing/value_generator.rb

@@ -41,8 +41,31 @@ module Hecks
         "", "x", "with \"quotes\"", "with, a comma", "with a \\backslash",
         "unicode héllo wörld 🎉", "x" * 200, "  leading and trailing  "
       ].freeze
-      INTEGER_EDGE_CASES = [0, -1, 2_147_483_647, -2_147_483_648].freeze
-      FLOAT_EDGE_CASES   = [0.0, -0.5, -100.25].freeze
+      # PRD 05 (numeric-boundary-coverage) — Bignum (`2**100`, past i64's
+      # own ceiling, which Ruby's own `Integer` has no such ceiling for —
+      # `rust/src/kernel/json.rs`'s own `integral_i64` doc comment names
+      # exactly this: a Rust kernel value CANNOT represent it, so this
+      # exercises a real cross-runtime capability gap, not a Ruby-only
+      # edge) and its negative twin. Both round-trip through Ruby's own
+      # arithmetic/JSON cleanly (confirmed directly: `(2**100).clamp(...)`
+      # and `JSON.generate(2**100)` both just work — Integer has no
+      # ceiling here), so nothing in THIS runtime needed a fix for these;
+      # they're included so a real generated sequence occasionally
+      # produces the value at all, since nothing had, repo-wide, before.
+      INTEGER_EDGE_CASES = [0, -1, 2_147_483_647, -2_147_483_648, 2**100, -(2**100)].freeze
+      # NaN and +/-Infinity — the real find (see `spec/runtime/
+      # numeric_boundary_spec.rb`): `Value::Coercion#check_numeric_fields`
+      # used to let all three sail through untyped-checked (each really
+      # is a Float), reaching either `CommandRules::Arithmetic#clamp`
+      # (raw `ArgumentError`, not a domain refusal) or `JSON.generate`
+      # (`JSON::GeneratorError`, also not a domain refusal) — both fixed
+      # at the source now, so these are safe to generate. -0.0 is
+      # deliberately included too even though it was ALREADY safe
+      # (finite, round-trips through JSON as `-0.0` cleanly) — a signed
+      # zero is exactly the kind of boundary a hand-written corpus never
+      # happens to type, and the fuzzer existing to cover it is the
+      # point.
+      FLOAT_EDGE_CASES = [0.0, -0.0, -0.5, -100.25, Float::NAN, Float::INFINITY, -Float::INFINITY].freeze
       WORDS = %w[alpha bravo charlie delta echo foxtrot golf hotel india juliet].freeze
       CURRENCY_CODES = %w[USD EUR GBP JPY].freeze
 

data/lib/hecks/grammar/evolve.rb

@@ -17,6 +17,39 @@ module Hecks
 
       module_function
 
+      # bin/evolve's own `--name value` flag reader. Only consumes the
+      # NEXT argv element as the value when that element doesn't itself
+      # look like a flag — otherwise `--foo --bar` would swallow `--bar`
+      # as `--foo`'s value (and `--bar` would then never be seen at
+      # all), and a value-less `--foo` at the end of argv would bypass
+      # whatever default `foo` promised instead of falling back to it.
+      def option(argv, name, default = nil)
+        index = argv.index("--#{name}")
+        return default unless index
+
+        value = argv[index + 1]
+        value.nil? || value.start_with?("-") ? default : value
+      end
+
+      # The snapshot/restore ceremony bin/evolve wraps every mutating
+      # command in: read every `paths` file, run the block, and put
+      # every file back exactly as it was if the block raises partway
+      # through — `rename`'s keyword-row write followed by its
+      # argument cascade across several files (`cascade_argument_rename`
+      # above) included, not only a declared gate failing after the
+      # block has already returned cleanly (bin/evolve's own `guarded`
+      # still handles that half on its own, since it depends on running
+      # the gate specs, not on anything this method knows about). A
+      # clean return leaves the snapshots unused; the caller decides
+      # from there whether the tree stands.
+      def restore_on_raise(paths)
+        snapshots = paths.to_h { |path| [path, File.read(path)] }
+        yield
+      rescue StandardError
+        snapshots.each { |path, content| File.write(path, content) }
+        raise
+      end
+
       def syntax_paths
         Dir.glob(File.expand_path("../language/**/*.bluebook", __dir__)).select do |path|
           source = File.read(path)

data/lib/hecks/grammar/expression.bluebook

@@ -10,11 +10,14 @@ Hecks.bluebook "Expression" do
     # has two rules that are not operators: parenthesization (a structural
     # strip-and-recurse, no symbol of its own) and the bare-leaf fallback
     # (whatever matches nothing else falls through to the inner grammar).
-    # Its inner grammar has three more: integer/float/string/bool/nil
-    # literals and the dotted-lookup fallback are TERMINAL productions —
-    # they recognize text, they do not combine operands, and they have
-    # nothing meaningful to render per target (a literal's spelling does
-    # not differ between targets the way an operation's might).
+    # Its inner grammar has three more: integer/float/string/bool/nil/
+    # array literals and the dotted-lookup fallback are TERMINAL
+    # productions — they recognize text, they do not combine operands,
+    # and they have nothing meaningful to render per target (a literal's
+    # spelling does not differ between targets the way an operation's
+    # might — `rust/src/kernel/expr.rs`'s own `Expr::Array` is a LEAF
+    # there too, for the identical reason, not routed through
+    # `OperatorCategory`).
     # Forcing them into this shape would stretch `renderings` and the
     # Arity invariant past what they mean. They stay declared only in
     # prose — named here rather than silently left out.

data/lib/hecks/grammar/expression_operators.json

@@ -1,6 +1,6 @@
 {
   "name": "expression-operators",
-  "note": "The admission ledger \u2014 every operator and normalisation rule the expression machinery runs, driven through the grammar chapter's own lifecycle. Propose, then a rendering per target, then Admit, so the 'reads in every target' guard gates each admission for real. spec/operator_conformance_spec.rb replays this and holds the evaluator's tables equal to what survives \u2014 an operator absent here is not a slow operator, it is not an operator.",
+  "note": "The admission ledger — every operator and normalisation rule the expression machinery runs, driven through the grammar chapter's own lifecycle. Propose, then a rendering per target, then Admit, so the 'reads in every target' guard gates each admission for real. spec/operator_conformance_spec.rb replays this and holds the evaluator's tables equal to what survives — an operator absent here is not a slow operator, it is not an operator.",
   "steps": [
     {
       "verb": "Expression::Operator.Propose",
@@ -1058,6 +1058,502 @@
         }
       }
     },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".match?"
+        },
+        "category": {
+          "value": "pattern_match"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 2
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "call_pattern_match"
+        },
+        "position": {
+          "value": 13
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".match?"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "receiver.match?(/pattern/)"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".match?"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "receiver.match?(/pattern/) -> regex crate, Ruby-Regexp-compatible subset"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".match?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".present?"
+        },
+        "category": {
+          "value": "presence"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 1
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "suffix_match"
+        },
+        "position": {
+          "value": 14
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".present?"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "a.present?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".present?"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "a.present? -> !blank(a)"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".present?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".blank?"
+        },
+        "category": {
+          "value": "presence"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 1
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "suffix_match"
+        },
+        "position": {
+          "value": 15
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".blank?"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "a.blank?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".blank?"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "a.blank? -> blank(a)"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".blank?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".split"
+        },
+        "category": {
+          "value": "text"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 2
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "call_pattern_match"
+        },
+        "position": {
+          "value": 16
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".split"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "a.split(\"SEP\")"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".split"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "a.split(\"SEP\") -> Value::Array of Value::Str"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".split"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".start_with?"
+        },
+        "category": {
+          "value": "text"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 2
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "call_pattern_match"
+        },
+        "position": {
+          "value": 17
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".start_with?"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "a.start_with?(\"prefix\")"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".start_with?"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "a.start_with?(\"prefix\")"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".start_with?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".end_with?"
+        },
+        "category": {
+          "value": "text"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 2
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "call_pattern_match"
+        },
+        "position": {
+          "value": 18
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".end_with?"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "a.end_with?(\"suffix\")"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".end_with?"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "a.end_with?(\"suffix\")"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".end_with?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".first"
+        },
+        "category": {
+          "value": "positional"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 1
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "suffix_match"
+        },
+        "position": {
+          "value": 19
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".first"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "a.first"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".first"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "a.first -> first element or Nil"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".first"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".last"
+        },
+        "category": {
+          "value": "positional"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 1
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "suffix_match"
+        },
+        "position": {
+          "value": 20
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".last"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "a.last"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".last"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "a.last -> last element or Nil"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".last"
+        }
+      }
+    },
     {
       "verb": "Expression::Normalisation.Propose",
       "args": {