expressir 2.4.31-aarch64-linux → 2.4.36-aarch64-linux

data/lib/expressir/conformance/trend.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Expressir
+  module Conformance
+    # Trended property metrics over a corpus slice: parse rate and
+    # format idempotence rate are fractions; the diagnostic rate is the
+    # number of Checker notes per parsed file. Per-note-id counts make
+    # the report actionable. Published by the nightly conformance
+    # workflow as a JSON artifact so the numbers can be trended.
+    class Trend
+      def self.measure(files)
+        report = {
+          "files" => files.size,
+          "parsed" => 0,
+          "parse_failed" => 0,
+          "measurement_failed" => 0,
+          "idempotent" => 0,
+          "not_idempotent" => 0,
+          "notes" => 0,
+          "errors" => 0,
+          "warnings" => 0,
+          "note_ids" => {},
+        }
+        files.each do |path|
+          measure_file(path, report)
+        end
+        report.merge!(
+          "parse_rate" => rate(report["parsed"], report["files"]),
+          "idempotence_rate" => rate(report["idempotent"], report["parsed"]),
+          "diagnostic_rate" => rate(report["notes"], report["parsed"]),
+        )
+        report
+      end
+
+      def self.run(files, output:)
+        report = measure(files)
+        File.write(output, "#{JSON.pretty_generate(report)}\n")
+        report
+      end
+
+      def self.measure_file(path, report)
+        repository = parse_file(path)
+        unless repository
+          report["parse_failed"] += 1
+          return
+        end
+        report["parsed"] += 1
+        measure_properties(repository, report)
+      end
+      private_class_method :measure_file
+
+      def self.parse_file(path)
+        Expressir::Express::Parser.from_exp(File.read(path))
+      rescue StandardError
+        nil
+      end
+      private_class_method :parse_file
+
+      def self.measure_properties(repository, report)
+        schema = Array(repository.schemas).first
+        if schema && idempotent?(schema)
+          report["idempotent"] += 1
+        else
+          report["not_idempotent"] += 1
+        end
+        notes = Expressir::Express::Checker.new(
+          Expressir::Model::Repository.new(files: [repository]),
+        ).check.notes
+        report["notes"] += notes.size
+        notes.each do |note|
+          report[note.severity == :error ? "errors" : "warnings"] += 1
+          report["note_ids"][note.id.to_s] =
+            report["note_ids"].fetch(note.id.to_s, 0) + 1
+        end
+      rescue StandardError
+        report["measurement_failed"] += 1
+      end
+      private_class_method :measure_properties
+
+      def self.idempotent?(schema)
+        once = Expressir::Express::Formatter.format(schema)
+        reparsed = Expressir::Express::Parser.from_exp(once)
+        twice = Expressir::Express::Formatter.format(reparsed.schemas.first)
+        once == twice
+      rescue StandardError
+        false
+      end
+      private_class_method :idempotent?
+
+      def self.rate(numerator, denominator)
+        return 0.0 if denominator.zero?
+
+        (numerator.to_f / denominator).round(4)
+      end
+      private_class_method :rate
+    end
+  end
+end

data/lib/expressir/conformance.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Expressir
+  # Measurement tiers over the standards corpus (TODO.sota/07 part 2).
+  module Conformance
+    autoload :Trend, "#{__dir__}/conformance/trend"
+  end
+end

data/lib/expressir/eval/environment.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Eval
+    # Lexical scope chain: a name resolves to a value through the
+    # innermost scope that declares it. The schema provides type
+    # context; the population (step 3) provides instances for the
+    # instance-aware builtins.
+    class Environment
+      attr_reader :schema, :population
+
+      def initialize(schema:, population: nil, frames: [{}])
+        @schema = schema
+        @population = population
+        @frames = frames
+      end
+
+      def push(frame)
+        Environment.new(schema: @schema, population: @population,
+                        frames: @frames + [frame])
+      end
+
+      def define(name, value)
+        frame = @frames.last.dup
+        frame[name.safe_downcase] = value
+        Environment.new(schema: @schema, population: @population,
+                        frames: @frames[0..-2] + [frame])
+      end
+
+      def lookup(name)
+        key = name.safe_downcase
+        @frames.reverse_each do |frame|
+          return frame[key] if frame.key?(key)
+        end
+        nil
+      end
+
+      def bound?(name)
+        !lookup(name).nil? || @frames.any? { |f| f.key?(name.safe_downcase) }
+      end
+
+      def interpreter
+        @interpreter ||= Interpreter.new(schema: @schema,
+                                         population: @population)
+      end
+
+      # Part 21 attribute slots for an entity: inherited explicit
+      # attributes (supertype closure order) then the entity's own —
+      # the same order the P21 validator maps values by.
+      def slots_for(entity)
+        @slots ||= {}
+        @slots[entity] ||= begin
+          inherited = entity.supertype_closure.flat_map do |supertype|
+            explicit_attributes(supertype)
+          end
+          (inherited + explicit_attributes(entity)).each_with_index
+            .to_h do |attribute, index|
+            [attribute.id&.safe_downcase, index]
+          end
+        end
+      end
+
+      def explicit_attributes(entity)
+        Array(entity.attributes)
+          .select { |a| a.instance_of?(Model::Declarations::Attribute) }
+      end
+
+      def entity_for_keyword(keyword)
+        Array(@schema&.entities).find do |entity|
+          entity.id&.safe_downcase == keyword&.safe_downcase
+        end
+      end
+
+      def instance_for(reference)
+        return nil unless @population && reference.is_a?(String)
+        return nil unless reference.start_with?("#")
+
+        record = @population.instances[reference]
+        record && Values::Instance.new(id: reference[1..], record: record)
+      end
+    end
+  end
+end