latticerb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5250f7a9782b3db18aa0002eda4b3194f1092d0a832e4b764ce1c49cbb8f202
-  data.tar.gz: 7f2a83e342e5498728f3fac15d20e6706859a10a7b2697b666ccb0e67e72bccf
+  metadata.gz: 60031e0fe6baf8ed371a9e2705e905118008bd25c53f588754405399d7727429
+  data.tar.gz: 893b27940cca00121e203cf8ed0e685cdddfc8d7ee97758d0b1864d7eef1cb6b
 SHA512:
-  metadata.gz: 51b3c0f8c486a628f9e4274d2a6f66b2f79a7eb75c519e892c760cd3c65cdebedb005cd845189505f29bcac63ac716c6f3d0d249f38fb4c3a5a8a96d4543a381
-  data.tar.gz: 781caca48f95fc5ef3d8562c717ebe4dd2b987630a6ca2d5a886f51a8db0c06abdfeb4f19713531133c3e27a9149861821ff093385ad8b2f649d9ef5b118aa74
+  metadata.gz: 7d13bb576b7255cb8cfb255de5cf725d5a344ae8264861fcb0207803999b246fdf5ebf5ba4f07ba511846fbc8301df26256ccda8f48a7c785d66022570ac5a7d
+  data.tar.gz: fb8d83f8f505e560cdb1277e419a53dea19d2a9350c9090b04c2b5a380b9e6dbbaccd040b3d617d6d77bb1fa1fb1987b499d94cb5cf3803d8d27c54b9c5cbf34

data/README.md

@@ -54,7 +54,7 @@ run = Lattice.generate(
 
 run.scenarios        # array of { name => value } hashes
 run.coverage_curve   # cumulative coverage per scenario
-run.to_table         # human-readable table (also: to_json_output, to_csv, to_summary)
+run.to_table         # human-readable table (also: to_json_output, to_yaml_output, to_csv, to_summary)
 
 Lattice.scenarios(file: "...")  # shortcut straight to the hashes
 Lattice.validate!(schema)       # raises Lattice::ValidationError / Lattice::ConstraintError
@@ -70,6 +70,7 @@ The gem installs a `lattice` executable mirroring the Python CLI:
 cat schema.yaml | lattice validate
 cat schema.yaml | lattice generate                 # JSON by default
 lattice generate schema.yaml --format table
+lattice generate schema.yaml --format yaml         # same content as JSON, for hand-edited files
 lattice generate schema.yaml --strength 3 --seed 7
 lattice agent instructions                          # coding-agent integration guidance
 ```

data/lib/lattice/cli.rb

@@ -65,7 +65,7 @@ module Lattice
       }
       parser = OptionParser.new do |opts|
         opts.on("--strength STRENGTH", Integer)
-        opts.on("--format FORMAT", %w[table json csv summary])
+        opts.on("--format FORMAT", %w[table json csv summary yaml])
         opts.on("--seed SEED", Integer)
         opts.on("--pool-size SIZE", Integer) { |value| options[:pool_size] = value }
         opts.on("--max-rows ROWS", Integer) { |value| options[:max_rows] = value }

data/lib/lattice/formatters.rb

@@ -7,8 +7,9 @@ require_relative "ipog"
 require_relative "model"
 
 module Lattice
-  # Output rendering. Table, JSON, CSV, and summary formats are byte-identical
-  # to the Python implementation's output for the same model and result.
+  # Output rendering. Table, JSON, CSV, summary, and YAML formats are
+  # byte-identical to the Python implementation's output for the same model
+  # and result.
   module Formatters
     extend self
 
@@ -18,6 +19,7 @@ module Lattice
       when "json" then format_json(model, result, seed:)
       when "csv" then format_csv(model, result)
       when "summary" then format_summary(model, result)
+      when "yaml" then format_yaml(model, result, seed:)
       else
         raise ArgumentError, "Unknown format `#{output_format}`."
       end
@@ -77,16 +79,81 @@ module Lattice
           }
         end
       }
-      JSON.pretty_generate(payload, ascii_only: true)
+      # Python's json.dumps also escapes DEL, which Ruby's ascii_only leaves raw.
+      JSON.pretty_generate(payload, ascii_only: true).gsub("\u007f", "\\u007f")
     end
 
-    def format_csv(model, result)
-      CSV.generate(row_sep: "\r\n") do |csv|
-        csv << model.parameter_names
-        named_rows(model, result).each do |row|
-          csv << model.parameter_names.map { |name| row[name] }
+    # Same content as format_json, written by hand in one fixed style so Ruby
+    # and Python emit identical bytes (Psych and PyYAML each quote and wrap
+    # differently). Every string is double-quoted, so no value can be read
+    # back as a boolean, null, number or date.
+    def format_yaml(model, result, seed:)
+      last_point = result.coverage_curve.last
+      lines = [
+        "meta:",
+        "  model_name: #{yaml_string(model.model_name)}",
+        "  strength: #{model.strength}",
+        "  test_count: #{result.rows.length}",
+        "  exhaustive_count: #{model.exhaustive_count}",
+        "  reduction: #{yaml_string(reduction_label(model.exhaustive_count, result.rows.length))}",
+        "  coverage: #{yaml_string(last_point ? format('%.1f%%', last_point.cumulative_pct) : '0.0%')}",
+        "  seed: #{seed.nil? ? 'null' : seed}"
+      ]
+
+      if result.coverage_curve.empty?
+        lines << "coverage_curve: []"
+      else
+        lines << "coverage_curve:"
+        result.coverage_curve.each do |point|
+          lines << "  - scenario: #{point.scenario}"
+          lines << "    cumulative_pct: #{JSON.generate(point.cumulative_pct)}"
+        end
+      end
+
+      rows = named_rows(model, result)
+      if rows.empty?
+        lines << "scenarios: []"
+      else
+        lines << "scenarios:"
+        rows.each_with_index do |row, index|
+          lines << "  - id: #{index + 1}"
+          lines << "    values:"
+          model.parameter_names.each do |name|
+            lines << "      #{yaml_string(name)}: #{yaml_string(row[name])}"
+          end
         end
-      end.strip
+      end
+      lines.join("\n")
+    end
+
+    YAML_ESCAPES = {
+      "\"" => "\\\"", "\\" => "\\\\", "\b" => "\\b", "\t" => "\\t", "\n" => "\\n", "\f" => "\\f", "\r" => "\\r"
+    }.freeze
+
+    # Characters escaped inside a double-quoted YAML string: the quote and
+    # backslash, C0 controls, DEL, C1 controls (U+0085 would otherwise fold to
+    # a space), the Unicode line and paragraph separators, the byte-order mark,
+    # and the two noncharacters YAML cannot hold. Everything else is written as
+    # UTF-8, so accented letters and emoji stay readable.
+    YAML_ESCAPED_CHARS = /["\\\u0000-\u001f\u007f-\u009f\u2028\u2029\ufeff\ufffe\uffff]/
+
+    def yaml_string(value)
+      escaped = value.gsub(YAML_ESCAPED_CHARS) do |char|
+        YAML_ESCAPES.fetch(char) { format("\\u%04x", char.ord) }
+      end
+      "\"#{escaped}\""
+    end
+
+    # Matches Python's csv.writer: empty fields are written bare, except a row
+    # made of a single empty field, which is written as "" so it isn't a blank
+    # line.
+    def format_csv(model, result)
+      records = [model.parameter_names] + named_rows(model, result).map do |row|
+        model.parameter_names.map { |name| row[name] }
+      end
+      records.map do |record|
+        record == [""] ? "\"\"\r\n" : CSV.generate_line(record, row_sep: "\r\n", quote_empty: false)
+      end.join.strip
     end
 
     def headline(model, result)

data/lib/lattice/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lattice
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/lattice.rb

@@ -32,6 +32,7 @@ module Lattice
     def to_json_output = Formatters.render_output(model, result, output_format: "json", seed:)
     def to_csv = Formatters.render_output(model, result, output_format: "csv", seed:)
     def to_summary = Formatters.render_output(model, result, output_format: "summary", seed:)
+    def to_yaml_output = Formatters.render_output(model, result, output_format: "yaml", seed:)
   end
 
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: latticerb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tyler Klose