rail_verdict 1.0.0

data/lib/rail_verdict/reporters/console.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RailVerdict
+  module Reporters
+    module Console
+      module_function
+
+      def render(result)
+        lines = ["RailVerdict #{RailVerdict::VERSION}", "", "Analyzers"]
+        result.analyzer_results.each do |analyzer|
+          version = analyzer.tool_version ? " (#{analyzer.tool_version})" : ""
+          lines << format(
+            "  %s: %s%s, %d findings",
+            analyzer.analyzer,
+            analyzer.execution_status,
+            version,
+            analyzer.finding_ids.length
+          )
+        end
+        lines << "  none" if result.analyzer_results.empty?
+
+        lines << ""
+        lines << "Findings"
+        if result.findings.empty?
+          lines << "  none"
+        else
+          result.findings.each do |finding|
+            lines << format(
+              "  %s [%s] %s %s",
+              finding.fetch("severity"),
+              finding.fetch("state"),
+              finding.fetch("id"),
+              finding.fetch("blocking") ? "blocking" : "advisory"
+            )
+          end
+        end
+
+        unless result.operational_failures.empty?
+          lines << ""
+          lines << "Operational failures"
+          result.operational_failures.each do |failure|
+            analyzer = failure["analyzer"] ? "#{failure['analyzer']}: " : ""
+            lines << "  [#{failure.fetch('code')}] #{analyzer}#{sanitize(failure.fetch('message'))}"
+          end
+        end
+
+        if result.baseline
+          baseline = result.baseline
+          if baseline["loaded"]
+            lines << ""
+            lines << "Baseline: loaded #{baseline['path']} (v#{baseline['schema_version']}, fp v#{baseline['fingerprint_version']})"
+          else
+            lines << ""
+            lines << "Baseline: none (#{baseline['path']})"
+          end
+        end
+
+        if result.comparison
+          counts = result.comparison["counts"] || {}
+          lines << ""
+          lines << format("Comparison: Introduced: %d  Existing: %d  Resolved: %d  Changed: %d  Moved: %d  Waived: %d",
+            counts["introduced"] || 0, counts["existing"] || 0, counts["resolved"] || 0,
+            counts["changed"] || 0, counts["moved"] || 0, counts["waived"] || 0)
+        end
+
+        if result.git
+          git = result.git
+          if git["error"]
+            lines << ""
+            lines << "Git: error #{sanitize(git.fetch('error'))}: #{sanitize(git.fetch('error_message', ''))}"
+          else
+            changed_count = (git["changed_files"] || []).length
+            lines << ""
+            lines << format("Git: head %s base %s merge-base %s (%d changed files)",
+              sanitize(git["head"].to_s[0, 7]), sanitize(git["base"].to_s[0, 7]), sanitize(git["merge_base"].to_s[0, 7]), changed_count)
+            lines << "Scope: changed" if git["head"] && git["merge_base"]
+          end
+        end
+
+        if result.rails_context
+          rc = result.rails_context
+          entries = rc["entries"] || []
+          detected = rc["detected"] || {}
+          lines << ""
+          lines << format("Rails context: %d entries (%s, %s)",
+            entries.length,
+            sanitize(detected["rails_version"] || "no rails"),
+            sanitize(rc["scope"] || "unknown"))
+        end
+
+        lines << ""
+        lines << "Gate: #{result.gate}"
+        lines << "Policy: #{result.policy_status}"
+        lines << "Reasons"
+        result.decision_reasons.each do |reason|
+          lines << "  - #{reason.fetch('code')}: #{sanitize(reason.fetch('message'))}"
+        end
+        lines.join("\n") + "\n"
+      end
+
+      def sanitize(value)
+        value.to_s.gsub(/[[:cntrl:]]/) { |character| character == "\n" ? " " : "?" }
+      end
+      private_class_method :sanitize
+    end
+  end
+end

data/lib/rail_verdict/reporters/github_annotations.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RailVerdict
+  module Reporters
+    module GitHubAnnotations
+      module_function
+
+      def render(result, findings: nil)
+        findings_list = findings || result.findings
+        lines = []
+        findings_list.sort_by { |finding| [finding["path"] || finding["location"]&.dig("path") || "", finding["start_line"] || finding["location"]&.dig("start_line") || 0, finding["id"] || ""] }.each do |finding|
+          path = extract_path(finding)
+          line = extract_line(finding)
+          col = extract_column(finding)
+          message = finding["message"] || finding[:message] || finding["id"] || ""
+          rule_id = finding["rule_id"] || finding[:rule_id] || finding["id"] || "unknown"
+          analyzer = finding["analyzer"] || finding[:analyzer] || "unknown"
+          severity = finding["severity"] || finding[:severity] || "info"
+          blocking = finding["blocking"]
+          level = annotation_level(severity, blocking, result.gate)
+          file_part = "file=#{escape_property(path)}"
+          line_part = line ? ",line=#{line}" : ""
+          col_part = col ? ",col=#{col}" : ""
+          title = escape_data("#{analyzer}:#{rule_id}")
+          msg = escape_data("#{message} [#{finding['state'] || finding[:state] || 'observed'}]")
+          lines << "::#{level} #{file_part}#{line_part}#{col_part},title=#{title}::#{msg}"
+        end
+        lines.join("\n") + (lines.empty? ? "" : "\n")
+      end
+
+      def render_summary_markdown(result, findings: nil)
+        findings_list = findings || result.findings
+        header = "| File | Rule | Message | Severity | State | Blocking |\n| --- | --- | --- | --- | --- | --- |\n"
+        rows = findings_list.sort_by { |finding| [finding["path"] || finding["location"]&.dig("path") || "", finding["id"] || ""] }.map do |finding|
+          path = finding["path"] || finding["location"]&.dig("path") || finding[:path] || "unknown"
+          rule = finding["rule_id"] || finding[:rule_id] || finding["id"] || ""
+          msg = (finding["message"] || finding[:message] || "").to_s.gsub("|", "\\|").gsub("\n", " ")[0, 200]
+          severity = finding["severity"] || finding[:severity] || ""
+          state = finding["state"] || finding[:state] || ""
+          blocking = finding["blocking"] ? "yes" : "no"
+          "| #{path} | #{rule} | #{msg} | #{severity} | #{state} | #{blocking} |"
+        end
+        summary = "# RailVerdict #{result.gate} (#{result.policy_status})\n\n"
+        summary += findings_list.empty? ? "No findings.\n" : header + rows.join("\n") + "\n"
+        summary += "\nReasons:\n"
+        result.decision_reasons.each do |reason|
+          summary += "- #{reason.fetch('code')}: #{reason.fetch('message')}\n"
+        end
+        summary
+      end
+
+      def annotation_level(severity, blocking, gate)
+        return "error" if blocking == true
+        return "error" if gate == "FAIL"
+
+        case severity.to_s
+        when "critical", "high"
+          "error"
+        when "medium"
+          "warning"
+        when "low", "info"
+          "notice"
+        else
+          "notice"
+        end
+      end
+      private_class_method :annotation_level
+
+      def extract_path(finding)
+        loc = finding["location"] || finding[:location]
+        return finding["path"] || finding[:path] || "unknown" if !loc.is_a?(Hash)
+
+        loc["path"] || loc[:path] || finding["path"] || "unknown"
+      end
+      private_class_method :extract_path
+
+      def extract_line(finding)
+        loc = finding["location"] || finding[:location]
+        return finding["start_line"] || finding[:start_line] if !loc.is_a?(Hash) || loc.nil?
+
+        loc["start_line"] || loc[:start_line]
+      end
+      private_class_method :extract_line
+
+      def extract_column(finding)
+        loc = finding["location"] || finding[:location]
+        return finding["start_column"] || finding[:start_column] if !loc.is_a?(Hash) || loc.nil?
+
+        loc["start_column"] || loc[:start_column]
+      end
+      private_class_method :extract_column
+
+      def escape_property(value)
+        value.to_s.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A").gsub(":", "%3A").gsub(",", "%2C")
+      end
+      private_class_method :escape_property
+
+      def escape_data(value)
+        value.to_s.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A")
+      end
+      private_class_method :escape_data
+    end
+  end
+end

data/lib/rail_verdict/reporters/json_reporter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailVerdict
+  module Reporters
+    module JsonReporter
+      module_function
+
+      def render(result)
+        document = result.to_schema_h
+        errors = SchemaValidator.validate_result(document)
+        raise RailVerdict::Error, "result-v1 validation failed: #{errors.join('; ')}" unless errors.empty?
+
+        JSON.generate(document) + "\n"
+      end
+    end
+  end
+end

data/lib/rail_verdict/reporters/sarif.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailVerdict
+  module Reporters
+    module Sarif
+      SEVERITY_LEVEL = {
+        "critical" => "error",
+        "high" => "error",
+        "medium" => "warning",
+        "low" => "note",
+        "info" => "note"
+      }.freeze
+
+      module_function
+
+      def render(result, findings: nil)
+        all_findings = findings || result.findings
+        rules = dedup_rules(all_findings)
+        results = all_findings.map { |finding| finding_to_result(finding) }.sort_by { |entry| [entry["ruleId"].to_s, entry.dig("locations", 0, "physicalLocation", "artifactLocation", "uri").to_s, entry.dig("locations", 0, "physicalLocation", "region", "startLine").to_i] }
+
+        {
+          "version" => "2.1.0",
+          "$schema" => "https://json.schemastore.org/sarif-2.1.0.json",
+          "runs" => [
+            {
+              "tool" => {
+                "driver" => {
+                  "name" => "RailVerdict",
+                  "version" => RailVerdict::VERSION,
+                  "informationUri" => "https://railverdict.dev",
+                  "rules" => rules
+                }
+              },
+              "results" => results,
+              "invocations" => [
+                {
+                  "executionSuccessful" => result.completion_status == "complete",
+                  "toolExecutionNotifications" => result.decision_reasons.map { |reason| { "message" => { "text" => reason.fetch("message") }, "level" => "note", "descriptor" => { "id" => reason.fetch("code") } } }
+                }
+              ]
+            }
+          ]
+        }
+      end
+
+      def render_json(result, findings: nil)
+        JSON.generate(render(result, findings: findings)) + "\n"
+      end
+
+      def finding_to_result(finding)
+        severity = finding["severity"] || finding[:severity] || "info"
+        level = SEVERITY_LEVEL.fetch(severity.to_s, "note")
+        fingerprint = finding["fingerprint"] || finding[:fingerprint]
+        path = extract_path(finding)
+        start_line = extract_start_line(finding)
+        message = finding["message"] || finding[:message] || finding["id"] || finding[:id] || ""
+
+        location = {
+          "physicalLocation" => {
+            "artifactLocation" => { "uri" => uri_encode(path) }
+          }
+        }
+        if start_line
+          location["physicalLocation"]["region"] = { "startLine" => start_line.to_i }
+          col = extract_start_column(finding)
+          location["physicalLocation"]["region"]["startColumn"] = col.to_i if col
+        end
+
+        result = {
+          "ruleId" => finding["rule_id"] || finding[:rule_id] || finding["id"] || finding[:id] || "unknown",
+          "level" => level,
+          "message" => { "text" => message.to_s },
+          "locations" => [location]
+        }
+        if fingerprint
+          result["partialFingerprints"] = { "primaryLocationLineHash" => fingerprint.to_s }
+          result["fingerprints"] = { "primaryLocationLineHash" => fingerprint.to_s }
+        end
+        result["properties"] = { "severity" => severity.to_s, "state" => (finding["state"] || finding[:state] || "observed").to_s } if finding["state"] || finding[:state]
+        result
+      end
+      private_class_method :finding_to_result
+
+      def extract_path(finding)
+        loc = finding["location"] || finding[:location]
+        return finding["path"] || finding[:path] || "unknown" unless loc.is_a?(Hash)
+
+        loc["path"] || loc[:path] || finding["path"] || "unknown"
+      end
+      private_class_method :extract_path
+
+      def extract_start_line(finding)
+        loc = finding["location"] || finding[:location]
+        return nil unless loc.is_a?(Hash)
+
+        loc["start_line"] || loc[:start_line]
+      end
+      private_class_method :extract_start_line
+
+      def extract_start_column(finding)
+        loc = finding["location"] || finding[:location]
+        return nil unless loc.is_a?(Hash)
+
+        loc["start_column"] || loc[:start_column]
+      end
+      private_class_method :extract_start_column
+
+      def dedup_rules(findings)
+        seen = {}
+        findings.each do |finding|
+          rule_id = finding["rule_id"] || finding[:rule_id] || finding["id"] || "unknown"
+          analyzer = finding["analyzer"] || finding[:analyzer] || "unknown"
+          key = "#{analyzer}:#{rule_id}"
+          next if seen.key?(key)
+
+          seen[key] = {
+            "id" => rule_id.to_s,
+            "name" => rule_id.to_s,
+            "shortDescription" => { "text" => "#{analyzer}/#{rule_id}" },
+            "fullDescription" => { "text" => "Analyzer #{analyzer} rule #{rule_id}" },
+            "properties" => { "analyzer" => analyzer.to_s }
+          }
+        end
+        seen.values.sort_by { |rule| rule["id"].to_s }
+      end
+      private_class_method :dedup_rules
+
+      def uri_encode(path)
+        str = path.to_s.dup.force_encoding(Encoding::UTF_8).scrub("?")
+        str = str.gsub("\\", "/")
+        str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
+      end
+      private_class_method :uri_encode
+    end
+  end
+end

data/lib/rail_verdict/run_context.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RailVerdict
+  class RunContext
+    DETERMINISTIC_INPUTS = {
+      "locale" => "C.UTF-8",
+      "timezone" => "UTC",
+      "ordering" => "canonical-v1"
+    }.freeze
+
+    GEMFILE_LOCK_RAILS = /^\s+rails \((\d+\.\d+\.\d+(?:\.\d+)*)\)/
+    GEMFILE_LOCK_RUBY = /^\s+ruby (\d+\.\d+\.\d+)/
+
+    attr_reader :repository_root, :revision, :ruby_version, :target_ruby_version,
+                :rails_version, :analyzers, :analyzer_versions, :configuration_mode,
+                :configuration_digest, :deterministic_inputs, :git_context
+
+    def self.build(repository_root:, configuration:, analyzer_versions:, revision_resolver: nil, git_context: nil)
+      root =
+        begin
+          File.realpath(repository_root)
+        rescue Errno::ENOENT, Errno::EACCES
+          raise RailVerdict::Error, "repository root does not exist: #{repository_root}"
+        end
+      raise RailVerdict::Error, "repository root is not a directory: #{repository_root}" unless File.directory?(root)
+
+      revision = revision_resolver ? revision_resolver.call(root) : nil
+      lockfile_text = read_lockfile(root)
+
+      new(
+        repository_root: root,
+        revision: revision,
+        ruby_version: RUBY_VERSION,
+        target_ruby_version: lockfile_text && lockfile_text[GEMFILE_LOCK_RUBY, 1],
+        rails_version: lockfile_text && lockfile_text[GEMFILE_LOCK_RAILS, 1],
+        analyzers: configuration.analyzers,
+        analyzer_versions: analyzer_versions,
+        configuration_mode: configuration.mode,
+        configuration_digest: configuration.digest,
+        deterministic_inputs: DETERMINISTIC_INPUTS,
+        git_context: git_context
+      )
+    end
+
+    def self.read_lockfile(root)
+      path = File.join(root, "Gemfile.lock")
+      return nil unless File.file?(path)
+
+      text = File.binread(path).force_encoding(Encoding::UTF_8)
+      return nil unless text.valid_encoding?
+
+      text
+    end
+
+    private_class_method :read_lockfile
+
+    def initialize(repository_root:, revision:, ruby_version:, target_ruby_version:, rails_version:,
+                   analyzers:, analyzer_versions:, configuration_mode:, configuration_digest:,
+                   deterministic_inputs:, git_context: nil)
+      @repository_root = repository_root.dup.freeze
+      @revision = revision && revision.dup.freeze
+      @ruby_version = ruby_version.dup.freeze
+      @target_ruby_version = target_ruby_version && target_ruby_version.dup.freeze
+      @rails_version = rails_version && rails_version.dup.freeze
+      @analyzers = deep_freeze(analyzers)
+      @analyzer_versions = deep_freeze(analyzer_versions)
+      @configuration_mode = configuration_mode.dup.freeze
+      @configuration_digest = configuration_digest.dup.freeze
+      @deterministic_inputs = deep_freeze(deterministic_inputs.dup)
+      @git_context = git_context
+      freeze
+    end
+
+    def changed?
+      !@git_context.nil?
+    end
+
+    private
+
+    def deep_freeze(value)
+      case value
+      when Hash
+        value.each do |key, child|
+          key.freeze if key.is_a?(String)
+          deep_freeze(child)
+        end
+        value.freeze
+      when Array
+        value.each { |child| deep_freeze(child) }
+        value.freeze
+      when String
+        value.freeze
+      else
+        value
+      end
+      value
+    end
+  end
+end

data/lib/rail_verdict/schema_validator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "json"
+require "json_schemer"
+
+module RailVerdict
+  module SchemaValidator
+    CONFIGURATION_SCHEMA = "configuration-v1.schema.json"
+    CONFIGURATION_V11_SCHEMA = "configuration-v1.1.schema.json"
+    CONFIGURATION_V12_SCHEMA = "configuration-v1.2.schema.json"
+    CONFIGURATION_V13_SCHEMA = "configuration-v1.3.schema.json"
+    CONFIGURATION_V14_SCHEMA = "configuration-v1.4.schema.json"
+    AI_ANALYSIS_SCHEMA = "ai-analysis-v1.schema.json"
+    FINDING_SCHEMA = "finding-v1.schema.json"
+    RESULT_SCHEMA = "result-v1.schema.json"
+    BASELINE_SCHEMA = "baseline-v1.schema.json"
+    WAIVER_SCHEMA = "waiver-v1.schema.json"
+    WAIVERS_SCHEMA = "waivers-v1.schema.json"
+    REPAIR_PACKET_SCHEMA = "repair-packet-v1.schema.json"
+
+    def self.schema_dir
+      File.expand_path("../../schemas", __dir__)
+    end
+
+    def self.validate_configuration(data)
+      schema_name = if data.is_a?(Hash) && data["version"] == 1.4
+                      CONFIGURATION_V14_SCHEMA
+                    elsif data.is_a?(Hash) && data["version"] == 1.3
+                      CONFIGURATION_V13_SCHEMA
+                    elsif data.is_a?(Hash) && data["version"] == 1.2
+                      CONFIGURATION_V12_SCHEMA
+                    elsif data.is_a?(Hash) && data["version"] == 1.1
+                      CONFIGURATION_V11_SCHEMA
+                    else
+                      CONFIGURATION_SCHEMA
+                    end
+      validate(data, schema_name)
+    end
+
+    def self.validate_ai_analysis(data)
+      validate(data, AI_ANALYSIS_SCHEMA)
+    end
+
+    def self.validate_finding(data)
+      validate(data, FINDING_SCHEMA)
+    end
+
+    def self.validate_result(data)
+      validate(data, RESULT_SCHEMA)
+    end
+
+    def self.validate_baseline(data)
+      validate(data, BASELINE_SCHEMA)
+    end
+
+    def self.validate_waiver(data)
+      validate(data, WAIVER_SCHEMA)
+    end
+
+    def self.validate_waivers(data)
+      validate(data, WAIVERS_SCHEMA)
+    end
+
+    def self.validate_repair_packet(data)
+      validate(data, REPAIR_PACKET_SCHEMA)
+    end
+
+    def self.validate(data, schema_name)
+      schema = load_schema(schema_name)
+      JSONSchemer.schema(schema).validate(data).map { |error| format_error(error) }
+    end
+
+    def self.load_schema(schema_name)
+      JSON.parse(File.read(File.join(schema_dir, schema_name)))
+    end
+
+    def self.format_error(error)
+      pointer = error["data_pointer"].to_s
+      location = pointer.empty? ? "$" : "$#{pointer.gsub('/', '.')}"
+      "#{location}: #{error["error"]}"
+    end
+
+    private_class_method :load_schema, :format_error
+  end
+end

data/lib/rail_verdict/strict_yaml.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "psych"
+
+module RailVerdict
+  module StrictYaml
+    class Error < RailVerdict::Error
+      attr_reader :property_path
+
+      def initialize(message, property_path: nil)
+        super(message)
+        @property_path = property_path
+      end
+    end
+
+    PLAIN = Psych::Nodes::Scalar::PLAIN
+    INTEGER = /\A[-+]?[0-9]+\z/
+    FLOAT = /\A[-+]?[0-9]*\.[0-9]+(?:[eE][-+]?[0-9]+)?\z/
+    FLOAT_EXPONENT = /\A[-+]?[0-9]+[eE][-+]?[0-9]+\z/
+
+    def self.parse(text, source_path)
+      document =
+        begin
+          Psych.parse(text)
+        rescue Psych::SyntaxError => error
+          raise Error.new(
+            "#{source_path}: YAML syntax error: #{error.message.lines.first.to_s.strip}",
+            property_path: "$"
+          )
+        end
+
+      materialize(document&.root, "$")
+    end
+
+    def self.materialize(node, path)
+      case node
+      when nil
+        nil
+      when Psych::Nodes::Mapping
+        materialize_mapping(node, path)
+      when Psych::Nodes::Sequence
+        materialize_sequence(node, path)
+      when Psych::Nodes::Scalar
+        materialize_scalar(node, path)
+      when Psych::Nodes::Alias
+        raise Error.new("#{path}: aliases are not permitted", property_path: path)
+      else
+        raise Error.new("#{path}: unsupported YAML node", property_path: path)
+      end
+    end
+
+    def self.materialize_mapping(node, path)
+      reject_tag(node, path)
+      reject_anchor(node, path)
+      children = node.children || []
+      result = {}
+      seen = {}
+      children.each_slice(2) do |key_node, value_node|
+        raise Error.new("#{path}: mapping entries require a key and a value", property_path: path) if value_node.nil?
+
+        key = mapping_key(key_node, path)
+        if seen.key?(key)
+          raise Error.new("#{path}.#{key}: duplicate key #{key.inspect}", property_path: "#{path}.#{key}")
+        end
+
+        seen[key] = true
+        result[key] = materialize(value_node, "#{path}.#{key}")
+      end
+      result
+    end
+
+    def self.materialize_sequence(node, path)
+      reject_tag(node, path)
+      reject_anchor(node, path)
+      (node.children || []).each_with_index.map do |child, index|
+        materialize(child, "#{path}[#{index}]")
+      end
+    end
+
+    def self.materialize_scalar(node, path)
+      reject_tag(node, path)
+      reject_anchor(node, path)
+      return node.value.dup.force_encoding(Encoding::UTF_8) unless node.style == PLAIN
+
+      resolve_plain_scalar(node.value)
+    end
+
+    def self.mapping_key(node, path)
+      case node
+      when Psych::Nodes::Scalar
+        node.value.to_s
+      when Psych::Nodes::Alias
+        raise Error.new("#{path}: aliases are not permitted in mapping keys", property_path: path)
+      else
+        raise Error.new("#{path}: mapping keys must be scalars", property_path: path)
+      end
+    end
+
+    def self.resolve_plain_scalar(value)
+      case value
+      when "", "~", "null", "Null", "NULL"
+        nil
+      when "true", "True", "TRUE"
+        true
+      when "false", "False", "FALSE"
+        false
+      when INTEGER
+        Integer(value)
+      when FLOAT, FLOAT_EXPONENT
+        Float(value)
+      else
+        value.dup
+      end
+    end
+
+    def self.reject_tag(node, path)
+      tag = node.tag
+      return if tag.nil? || tag.empty?
+
+      raise Error.new("#{path}: explicit YAML tags are not permitted", property_path: path)
+    end
+
+    def self.reject_anchor(node, path)
+      anchor = node.respond_to?(:anchor) ? node.anchor : nil
+      return if anchor.nil? || anchor.empty?
+
+      raise Error.new("#{path}: anchors are not permitted", property_path: path)
+    end
+
+    private_class_method :materialize, :materialize_mapping, :materialize_sequence,
+                         :materialize_scalar, :mapping_key, :resolve_plain_scalar,
+                         :reject_tag, :reject_anchor
+  end
+end