interscript 3.3.0 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7222468ba9bbd27444aea9c8fe0f7e3378b053a500d9f03c925a4c2a39cc9f1
-  data.tar.gz: b6c1e37c348f2bb42d4358ca83fa332f83a29b41b9ff88241a1e171b20c4225c
+  metadata.gz: c07cde4f6168fc8fefa3ea522ffa3ecf809801492861a18fc6456deb0baa36bb
+  data.tar.gz: 9cea9f897db3900314f2c41209d75e19c6a91aae513d2ae4b7c74a5cdd10ccdf
 SHA512:
-  metadata.gz: a0cf0d2d1f75e3dd9b30b2282eae24b58572c002ae5fde9cac4b26debe7bb457f97b83193c965a8936e92f8c9e673c5fad36c051804accd3f0fd708679b60efe
-  data.tar.gz: bcb8654fb9af857a41e469d284c825d07ada2c62c9c21732c7d510b07a3186afcd7bdc37a631048d98bd30e967f768c359020189e8d5cb974f56fff5781e8775
+  metadata.gz: 9fe0d7425cc3890e0e70ca12c2482b98280b27c7d3700b1092c9c3f78db24fd1984da7f8d18d41934f267f25181c8b12a10831c3c6f0c74e35785bae6481a20a
+  data.tar.gz: f4302ba9d6722cb9f96e2e766b08a09e0b02cb5387da7aab5f06b6fb4ac6cd3670f92828d20c7bbf033abb43f1fd7a477bdf44f236ab1e7a5dd6a4e50289fa10

data/README.md

@@ -33,6 +33,32 @@ Interscript.transliterate("odni-rus-Cyrl-Latn-2015", "привет")
 # => "privet"
 ----
 
+== Workflow extension (ISC-WF-1)
+
+Maps can reuse rule blocks and condition rows on a language. A
+`ruleset` is spliced at a `use` position (recursively, across
+declared dependencies); `use ... override { ... }` replaces rows on
+byte-exact from-equality; a `languages` declaration plus `when`
+guards let the caller select a language per call — guards are inert
+without a selection:
+
+[source,ruby]
+----
+# alalc-tha and bgnpcgn-tha share their leading-vowel machinery
+# through libs/thai-latn.isc — one ruleset, per-map overrides
+Interscript.transliterate("bgnpcgn-tha-Thai-Latn-2002", "กรุงเทพ")
+
+# language conditioning: select one of the map's declared languages;
+# guards are inert when no (or an undeclared) language is passed
+Interscript.transliterate("some-map-id", "...", {}, language: "kur")
+----
+
+The constructs are additive: maps that don't use them transliterate
+identically. The corpus adoption so far is the Thai leading-vowel
+shared ruleset (W1/W2); W3 conditioning is exercised by the
+conformance fixtures. Normative text: interscript/maps
+`docs/isc-wf-1.md`.
+
 == Neural models (Interscript::ML)
 
 The gem embeds the IMF v1 model runtime — resolve a model id through

data/interscript.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "thor"
-  spec.add_dependency "interscript-maps", "~> 2.5"
+  spec.add_dependency "interscript-maps", "~> 3.0"
   spec.add_dependency "text"
   spec.add_dependency "parsanol", ">= 1.3.61", "< 2"
 end

data/lib/interscript/interpreter.rb

@@ -5,7 +5,7 @@ class Interscript::Interpreter < Interscript::Compiler
     self
   end
 
-  def call(str, stage = :main, each: false, &block)
+  def call(str, stage = :main, each: false, language: nil, &block)
     stage = @map.stages[stage]
     if each
       e = Enumerator.new do |yielder|
@@ -22,7 +22,7 @@ class Interscript::Interpreter < Interscript::Compiler
             # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
             $select_nth_string = true
             # standard:enable Style/GlobalVars
-            result = Stage.new(@map, str).execute_rule(stage)
+            result = Stage.new(@map, str, language: language).execute_rule(stage)
             # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
             $select_nth_string = false
             # standard:enable Style/GlobalVars
@@ -68,20 +68,72 @@ class Interscript::Interpreter < Interscript::Compiler
         e
       end
     else
-      Stage.new(@map, str).execute_rule(stage)
+      Stage.new(@map, str, language: language).execute_rule(stage)
     end
   end
 
+  # ISC-WF-1 W3: effective language for a run. A selection outside the
+  # map's `languages` declaration (or any selection on a map without a
+  # declaration) means every `when` guard is inert (spec §5.1).
+  def self.select_language(map, language)
+    return nil if language.nil?
+
+    declared = map.languages
+    return nil unless declared.is_a?(Interscript::Node::LanguagesDecl) &&
+      declared.include?(language.to_sym)
+
+    language.to_sym
+  end
+
   class Stage
-    def initialize(map, str)
+    attr_reader :language
+
+    def initialize(map, str, language: nil)
       @str = str
       @map = map
+      @language = Interscript::Interpreter.select_language(map, language)
+    end
+
+    # ISC-WF-1 W3 guard applicability. Unguarded rules always apply; a
+    # guarded rule applies only under a selected language that its `when`
+    # list contains. Inert rules are absent from the pass (spec §5.1).
+    def guard_applies? rule
+      return true unless Interscript::Node::Rule::Sub === rule && rule.when_languages
+      return false unless @language
+
+      rule.when_languages.include?(@language)
+    end
+
+    # ISC-WF-1 W3: the effective rule set of a parallel pass = unguarded
+    # rules ∪ guard-applicable rules; where an unguarded rule and a
+    # guard-applicable rule share the same from-string, the
+    # guard-applicable rule wins (spec §5.2). Passes without any guard
+    # return the group untouched — zero change for pre-WF1 maps. Filtered
+    # variants are memoized per selected language on the group so the
+    # compiled-tree cache below stays per-language.
+    def resolve_parallel_guards r
+      return r unless r.children.any? { |c| Interscript::Node::Rule::Sub === c && c.when_languages }
+
+      r.wf1_variants ||= {}
+      r.wf1_variants[@language] ||= begin
+        applicable = r.children.select { |c| guard_applies?(c) }
+        guarded_froms = applicable
+          .select { |c| Interscript::Node::Rule::Sub === c && c.when_languages }
+          .map { |c| c.from.inspect }
+        filtered = Interscript::Node::Group::Parallel.new
+        filtered.children = applicable.reject do |c|
+          Interscript::Node::Rule::Sub === c && !c.when_languages &&
+            guarded_froms.include?(c.from.inspect)
+        end
+        filtered
+      end
     end
 
     def execute_rule r
       return if r.reverse_run == true
       case r
       when Interscript::Node::Group::Parallel
+        r = resolve_parallel_guards(r)
         if r.cached_tree
           @str = Interscript::Stdlib.parallel_replace_tree(@str, r.cached_tree)
         elsif r.subs_regexp && r.subs_replacements
@@ -135,9 +187,12 @@ class Interscript::Interpreter < Interscript::Compiler
         end
       when Interscript::Node::Group
         r.children.each do |t|
+          # ISC-WF-1 W3: in sequence, an inert guarded rule is skipped.
+          next unless guard_applies?(t)
           execute_rule(t)
         end
       when Interscript::Node::Rule::Sub
+        return @str unless guard_applies?(r)
         @str = if r.to == :upcase
           @str.gsub(Regexp.new(build_regexp(r)), &:upcase)
         elsif r.to == :downcase
@@ -151,10 +206,10 @@ class Interscript::Interpreter < Interscript::Compiler
         if r.stage.map
           doc = @map.dep_aliases[r.stage.map].document
           stage = doc.imported_stages[r.stage.name]
-          @str = Stage.new(doc, @str).execute_rule(stage)
+          @str = Stage.new(doc, @str, language: @language).execute_rule(stage)
         else
           stage = @map.imported_stages[r.stage.name]
-          @str = Stage.new(@map, @str).execute_rule(stage)
+          @str = Stage.new(@map, @str, language: @language).execute_rule(stage)
         end
       end
 

data/lib/interscript/isc/document_builder.rb

@@ -37,6 +37,8 @@ module Interscript
         tests_arr = []
         stages_arr = []
         dependencies_arr = []
+        rulesets_arr = []
+        languages_arr = []
 
         body.each do |item|
           if item[:metadata]
@@ -45,6 +47,12 @@ module Interscript
             aliases_arr.concat(extract_aliases(item[:aliases]))
           elsif item[:tests]
             tests_arr.concat(extract_tests(item[:tests]))
+          elsif item[:languages]
+            # ISC-WF-1 W3: map-declared languages.
+            languages_arr.concat(Array(item[:languages]).map { |l| ident(l) })
+          elsif item[:ruleset]
+            # ISC-WF-1 W1: named ruleset declaration.
+            rulesets_arr << extract_ruleset(item)
           elsif item[:stage]
             stages_arr << extract_stage(item)
           elsif item[:target]
@@ -52,7 +60,7 @@ module Interscript
           end
         end
 
-        {
+        doc = {
           schemaVersion: SCHEMA_VERSION,
           filename: @filename,
           systemCode: code,
@@ -63,6 +71,11 @@ module Interscript
           stages: stages_arr,
           dependencies: dependencies_arr
         }
+        # ISC-WF-1 keys are present only when the map uses the constructs —
+        # documents of maps that don't keep their exact pre-WF1 shape.
+        doc[:languages] = languages_arr if languages_arr.any?
+        doc[:rulesets] = rulesets_arr if rulesets_arr.any?
+        doc
       end
 
       private
@@ -254,6 +267,15 @@ module Interscript
         {name: name, body: body}
       end
 
+      # ISC-WF-1 W1: a named ruleset declaration — same body shape as a
+      # stage, addressed by name through `use` expansion.
+      def extract_ruleset(item)
+        node = item[:ruleset]
+        name = ident(item[:ruleset_name])
+        body = Array(node).flat_map { |n| extract_stage_items(n) }
+        {name: name, body: body}
+      end
+
       def extract_stage_items(n)
         return [] unless n.is_a?(Hash)
         if n[:sequence]
@@ -279,6 +301,10 @@ module Interscript
           [{kind: :run, dependency: nil, stage: ident(n[:run_stage_only][:stage])}]
         elsif n[:bare_rule]
           [{kind: :bare_rule, rule: extract_rule(n[:bare_rule])}]
+        elsif n[:use]
+          # ISC-WF-1 W1/W2: `use <ident>` or `use <alias>.<ident>` with an
+          # optional override block.
+          [extract_use(n[:use])]
         elsif n[:comment]
           []
         elsif n[:noop]
@@ -288,6 +314,19 @@ module Interscript
         end
       end
 
+      # `use <name>` (same-map ruleset) or `use <dep>.<name>` (dependency-
+      # declared ruleset), plus the optional override rows (W2).
+      def extract_use(u)
+        dep = u[:qualified_name] ? ident(u[:use_alias]) : nil
+        name = ident(u[:qualified_name] || u[:use_alias])
+        item = {kind: :use, ruleset: name, dependency: dep}
+        overrides = Array(u[:use_overrides])
+          .select { |r| r.is_a?(Hash) && r.key?(:from) }
+          .map { |r| extract_rule(r) }
+        item[:overrides] = overrides if overrides.any?
+        item
+      end
+
       # Filter out noop rules (from: None, to: None) created by empty
       # parallel/sequence blocks that contain only comments or whitespace.
       def filter_noop(rules)
@@ -302,11 +341,17 @@ module Interscript
         from_val = r.is_a?(Hash) ? r[:from] : nil
         to_val = r.is_a?(Hash) ? r[:to] : nil
         constraints_val = r.is_a?(Hash) ? r[:constraints] : nil
-        {
+        rule = {
           from: from_val ? materialize(from_val) : Items::None.new,
           to: to_val ? materialize(to_val) : Items::None.new,
           constraints: extract_constraints(constraints_val)
         }
+        # ISC-WF-1 W3: a `when` guard folds to the list of language names.
+        # The rule hash never goes through Transform as a whole (from/to/
+        # constraints are materialized individually), so the guard fragment
+        # gets its own apply.
+        rule[:when_languages] = @transform.apply(when: r[:when]) if r.is_a?(Hash) && r[:when]
+        rule
       end
 
       def extract_constraints(arr)

data/lib/interscript/isc/grammar/concerns/items.rb

@@ -125,7 +125,14 @@ module Interscript
               str("line_end") | str("word_boundary") |
               str("downcase") | str("upcase") | str("title_case") |
               str("capture") | str("maybe") | str("some") | str("ref") |
-              str("any_character")
+              str("any_character") |
+              # ISC-WF-1: ruleset / use / override / languages / when join
+              # the keyword table (spec §2). Prefix matching follows the
+              # existing table behavior; quoted-string forms remain the
+              # pass-through escape hatch. Verified against the 404-map
+              # corpus: no bare identifier starts with any of these words.
+              str("ruleset") | str("use") | str("override") |
+              str("languages") | str("when")
           end
 
           # Concatenation: one or more atoms. The continuation pattern

data/lib/interscript/isc/grammar/concerns/stages.rb

@@ -17,11 +17,44 @@ module Interscript
               braced(stage_item.repeat(0)).as(:stage)
           end
 
+          # ISC-WF-1 W1: a named, reusable block of stage items. Declared at
+          # map top level anywhere a stage may appear; never executes on its
+          # own (only `use` expansion reaches the runtime).
+          rule(:ruleset_block) do
+            str("ruleset") >> whitespace >>
+              identifier.as(:ruleset_name) >> whitespace? >>
+              braced(stage_item.repeat(0)).as(:ruleset)
+          end
+
+          # ISC-WF-1 W1/W2: `use <ident>` (same-map ruleset) or
+          # `use <alias>.<ident>` (dependency-declared ruleset), with an
+          # optional override block of full replacement rows (child-wins on
+          # exact from-equality).
+          rule(:use_directive) do
+            (str("use") >> whitespace >>
+              identifier.as(:use_alias) >>
+              (str(".") >> identifier.as(:qualified_name)).maybe >>
+              (whitespace >> str("override") >> whitespace? >>
+                braced(rule_line.repeat(0)).as(:use_overrides)).maybe
+            ).as(:use)
+          end
+
+          # ISC-WF-1 W3: `when <ident> (","|ws <ident>)*` — a language guard
+          # on a sub rule. Inert unless the caller selects a language the
+          # map declares (spec §5.1). Identifiers are keyword-guarded so the
+          # repeat stops at the next rule instead of swallowing it.
+          rule(:when_guard) do
+            (whitespace >> str("when") >> whitespace >>
+              keyword.absent? >> identifier.as(:when_lang) >>
+              ((comma | whitespace) >> (keyword.absent? >> identifier.as(:when_lang))).repeat
+            ).as(:when)
+          end
+
           rule(:stage_item) do
             whitespace? >>
               (sequence_block | parallel_block | run_rule | separate_directive |
                 string_case_directive | compose_directive | rababa_directive |
-                bare_rule | comment_item) >>
+                use_directive | bare_rule | comment_item) >>
               whitespace?
           end
 
@@ -105,7 +138,8 @@ module Interscript
             str("sub") >> whitespace >>
               item_atom.as(:from) >> whitespace >>
               item_atom.as(:to) >>
-              constraints
+              constraints >>
+              when_guard.maybe
           end
 
           rule(:block_rule) do
@@ -114,6 +148,7 @@ module Interscript
               str("from") >> whitespace >> item.as(:from) >> whitespace? >>
               str("to") >> whitespace >> item.as(:to) >>
               (whitespace >> constraint).repeat.as(:constraints) >>
+              when_guard.maybe >>
               whitespace? >> str("}")
           end
 

data/lib/interscript/isc/grammar/concerns/system.rb

@@ -10,12 +10,23 @@ module Interscript
         module System
           include Parsanol
 
+          # ISC-WF-1 W3: the languages a map serves, declared once per map
+          # inside the system block alongside metadata (spec §5.1). List
+          # identifiers are keyword-guarded so the repeat stops at the next
+          # block item (`stage`, `ruleset`, …) instead of swallowing it.
+          rule(:languages_decl) do
+            str("languages") >> whitespace >>
+              (keyword.absent? >> identifier.as(:language) >>
+                ((comma | whitespace) >> (keyword.absent? >> identifier.as(:language))).repeat
+              ).as(:languages)
+          end
+
           # A block-item is any of the top-level constructs that may appear
           # inside `system "<code>" { ... }`.
           rule(:block_item) do
             whitespace? >>
-              (metadata_block | aliases_block | tests_block |
-                stage_block | dependency_decl) >>
+              (metadata_block | aliases_block | tests_block | languages_decl |
+                ruleset_block | stage_block | dependency_decl) >>
               whitespace?
           end
 

data/lib/interscript/isc/grammar/isc.parg

@@ -28,7 +28,7 @@ grammar InterscriptIsc version "0.1.0" {
   ident_rest = %x41-5A / %x61-7A / %x30-39 / %x5F
   identifier = (ident_first 0*ident_rest) as identifier
 
-  keyword = "parallel" / "sequence" / "stage" / "compose" / "separate" / "system" / "metadata" / "aliases" / "tests" / "notes" / "description" / "any_character" / "authority" / "dependency" / "run" / "sub" / "before" / "after" / "not_before" / "not_after" / "any" / "none" / "boundary" / "line_start" / "line_end" / "word_boundary" / "downcase" / "upcase" / "title_case" / "capture" / "maybe" / "some" / "ref" / "name"
+  keyword = "parallel" / "sequence" / "stage" / "compose" / "separate" / "system" / "metadata" / "aliases" / "tests" / "notes" / "description" / "any_character" / "authority" / "dependency" / "run" / "sub" / "before" / "after" / "not_before" / "not_after" / "any" / "none" / "boundary" / "line_start" / "line_end" / "word_boundary" / "downcase" / "upcase" / "title_case" / "capture" / "maybe" / "some" / "ref" / "name" / "ruleset" / "use" / "override" / "languages" / "when"
 
   # -- string literals ----------------------------------------------------
 
@@ -143,9 +143,12 @@ grammar InterscriptIsc version "0.1.0" {
   constraint = constraint_after / constraint_before / constraint_not_before / constraint_not_after
   constraints = *(whitespace constraint)
 
-  compact_rule = "sub" whitespace (item_atom as from) whitespace (item_atom as to) ((*(whitespace constraint)) as constraints)
+  compact_rule = "sub" whitespace (item_atom as from) whitespace (item_atom as to) ((*(whitespace constraint)) as constraints) [(when_guard)]
 
-  block_rule = "sub" [ws] "{" [ws] "from" whitespace (item as from) [ws] "to" whitespace (item as to) ((*(whitespace constraint)) as constraints) [ws] "}"
+  block_rule = "sub" [ws] "{" [ws] "from" whitespace (item as from) [ws] "to" whitespace (item as to) ((*(whitespace constraint)) as constraints) [(when_guard)] [ws] "}"
+
+  when_lang = (!(keyword) identifier) as when_lang
+  when_guard = (whitespace "when" whitespace (when_lang) *(((comma_ws / whitespace) (when_lang)))) as when
 
   rule = block_rule / compact_rule
 
@@ -172,12 +175,21 @@ grammar InterscriptIsc version "0.1.0" {
   run_rule = "run" whitespace ((run_dep) / run_stage_only)
 
   bare_rule = (rule) as bare_rule
-  stage_item = [ws] (sequence_block / parallel_block / run_rule / separate_directive / string_case_directive / compose_directive / rababa_directive / bare_rule / comment_item) [ws]
+
+  use_alias = (identifier) as use_alias
+  use_qualified = "." (identifier as qualified_name)
+  use_overrides_part = whitespace "override" [ws] "{" [ws] ((*(rule_line)) as use_overrides) [ws] "}"
+  use_directive = (("use" whitespace (use_alias) [(use_qualified)] [(use_overrides_part)]) as use)
+
+  stage_item = [ws] (sequence_block / parallel_block / run_rule / separate_directive / string_case_directive / compose_directive / rababa_directive / use_directive / bare_rule / comment_item) [ws]
   stage_items = *(stage_item)
   stage_name_paren = "(" (identifier as stage_name) ")"
   stage_name_ws = whitespace (identifier as stage_name)
   stage_block = "stage" (stage_name_paren / stage_name_ws) [ws] "{" [ws] (stage_items as stage) [ws] "}"
 
+  ruleset_name_ws = whitespace (identifier as ruleset_name)
+  ruleset_block = "ruleset" (ruleset_name_ws) [ws] "{" [ws] (stage_items as ruleset) [ws] "}"
+
   # -- tests ---------------------------------------------------------------
 
   test_note = whitespace "note" whitespace (quoted_string as note)
@@ -187,7 +199,10 @@ grammar InterscriptIsc version "0.1.0" {
 
   # -- system --------------------------------------------------------------
 
-  block_item = [whitespace] (metadata_block / aliases_block / tests_block / stage_block / dependency_decl) [whitespace]
+  language_ident = (!(keyword) identifier) as language
+  languages_decl = ("languages" whitespace ((language_ident *(((comma_ws / whitespace) (language_ident))))) as languages)
+
+  block_item = [whitespace] (metadata_block / aliases_block / tests_block / languages_decl / ruleset_block / stage_block / dependency_decl) [whitespace]
   body_items = *(block_item)
   system_block = "system" whitespace ((quoted_string) as system_code) [whitespace] "{" [ws] ((*(block_item)) as body) [ws] "}" [whitespace]
   isc_source = [whitespace] ((system_block) as system) [whitespace]

data/lib/interscript/isc/model/document.rb

@@ -4,6 +4,7 @@ require "lutaml/model"
 require "interscript/isc/model/test"
 require "interscript/isc/model/alias"
 require "interscript/isc/model/stage"
+require "interscript/isc/model/ruleset"
 require "interscript/isc/model/dependency"
 
 module Interscript
@@ -15,6 +16,8 @@ module Interscript
         attribute :tests, Test, collection: true
         attribute :aliases, Alias, collection: true
         attribute :stages, Stage, collection: true
+        attribute :rulesets, Ruleset, collection: true
+        attribute :languages, :string, collection: true
         attribute :dependencies, Dependency, collection: true
 
         yaml do
@@ -23,6 +26,8 @@ module Interscript
           map "tests", to: :tests
           map "aliases", to: :aliases
           map "stages", to: :stages
+          map "rulesets", to: :rulesets
+          map "languages", to: :languages
           map "dependencies", to: :dependencies
         end
       end

data/lib/interscript/isc/model/rule.rb

@@ -11,11 +11,13 @@ module Interscript
         attribute :from, Item
         attribute :to, Item
         attribute :constraints, Constraint, collection: true
+        attribute :when_languages, :string, collection: true
 
         yaml do
           map "from", to: :from
           map "to", to: :to
           map "constraints", to: :constraints
+          map "when_languages", to: :when_languages
         end
       end
     end

data/lib/interscript/isc/model/ruleset.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "interscript/isc/model/stage_item"
+
+module Interscript
+  module Isc
+    module Model
+      # ISC-WF-1 W1: a named, reusable block of stage items (spec §3).
+      class Ruleset < Lutaml::Model::Serializable
+        attribute :name, :string
+        attribute :body, StageItem, collection: true
+
+        yaml do
+          map "name", to: :name
+          map "body", to: :body
+        end
+      end
+    end
+  end
+end

data/lib/interscript/isc/model/stage_item.rb

@@ -8,7 +8,8 @@ module Interscript
   module Isc
     module Model
       # A single item in a stage body. Discriminated by `kind`:
-      #   parallel, sequence, bare_rule, run, separate, compose, string_case
+      #   parallel, sequence, bare_rule, run, use, separate, compose,
+      #   string_case
       class StageItem < Lutaml::Model::Serializable
         attribute :kind, :string
         attribute :rules, Rule, collection: true
@@ -17,6 +18,11 @@ module Interscript
         attribute :stage, :string
         attribute :separator, Item
         attribute :op, :string
+        # ISC-WF-1 W1/W2: the referenced ruleset and the per-site
+        # override rows; `dependency` carries the alias for qualified
+        # references (`use alias.<ruleset>`).
+        attribute :ruleset, :string
+        attribute :overrides, Rule, collection: true
 
         yaml do
           map "kind", to: :kind
@@ -26,6 +32,8 @@ module Interscript
           map "stage", to: :stage
           map "separator", to: :separator
           map "op", to: :op
+          map "ruleset", to: :ruleset
+          map "overrides", to: :overrides
         end
       end
     end

data/lib/interscript/isc/model.rb

@@ -10,6 +10,7 @@ module Interscript
       autoload :Rule, "interscript/isc/model/rule"
       autoload :StageItem, "interscript/isc/model/stage_item"
       autoload :Stage, "interscript/isc/model/stage"
+      autoload :Ruleset, "interscript/isc/model/ruleset"
       autoload :Alias, "interscript/isc/model/alias"
       autoload :Test, "interscript/isc/model/test"
       autoload :Dependency, "interscript/isc/model/dependency"