agentilda 2.0.1 → 2.0.4

data/lib/agentilda/linear/attribution.rb

@@ -24,9 +24,9 @@ module Agentilda
       # One pull request, placed.
       #
       # @!attribute [r] pull
-      #   @return [Agentilda::PullRequest]
+      #   @return [Agentilda::Plans::PullRequest]
       # @!attribute [r] subject
-      #   @return [Agentilda::Subject, nil] nil when nothing matched
+      #   @return [Agentilda::Plans::Subject, nil] nil when nothing matched
       # @!attribute [r] score
       #   @return [Integer] words the title and the folder name shared
       # @!attribute [r] rivals
@@ -77,7 +77,7 @@ module Agentilda
       NOISE = %w[the and for with from into that this add adds added fix fixes
                  update updates use uses spec plan pull request pr tax app web api].freeze
 
-      # @param tree [Agentilda::Tree]
+      # @param tree [Agentilda::Plans::Tree]
       def initialize(tree:)
         @tree = tree
       end
@@ -89,7 +89,7 @@ module Agentilda
       # the repository and match everything equally.
       OPENING_WORDS = 20
 
-      # @param pulls [Array<Agentilda::PullRequest>] the ones with no number
+      # @param pulls [Array<Agentilda::Plans::PullRequest>] the ones with no number
       # @param bodies [Hash{String => String}] descriptions, by pull request number
       # @return [Array<Agentilda::Linear::Attribution::Placed>]
       def call(pulls, bodies: {})
@@ -121,10 +121,10 @@ module Agentilda
 
       private
 
-      # @return [Agentilda::Tree]
+      # @return [Agentilda::Plans::Tree]
       attr_reader :tree
 
-      # @param pull [Agentilda::PullRequest]
+      # @param pull [Agentilda::Plans::PullRequest]
       # @param wanted [Array<String>] the words to match on
       # @param floor [Float] how much of a folder name is enough
       # @return [Agentilda::Linear::Attribution::Placed]
@@ -150,7 +150,7 @@ module Agentilda
         Placed.new(pull:, subject: nil, score:, rivals: tied.map { |s, _| s.feature.dirname }, widened: false)
       end
 
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Array<String>]
       def folder_words(subject)
         (@folder_words ||= {})[subject.feature.path] ||=

data/lib/agentilda/linear/import.rb

@@ -59,10 +59,10 @@ module Agentilda
     # disagree. Everything that needs the network — the project, the repository
     # pull request list — is handed in.
     class Import
-      # @param tree [Agentilda::Tree]
+      # @param tree [Agentilda::Plans::Tree]
       # @param team [String] the team key, e.g. "TAX"
       # @param project [Hash] the Linear project, `{"id", "name", "url"}`
-      # @param adopted [Hash{String => Array<Agentilda::PullRequest>}]
+      # @param adopted [Hash{String => Array<Agentilda::Plans::PullRequest>}]
       #   pull requests {Attribution} placed, by folder name
       # @param since [String, nil] skip plans numbered below this
       # @param statuses [Array<Symbol>, nil] only these states
@@ -72,7 +72,7 @@ module Agentilda
         @team = team.to_s.strip.upcase
         @project = project
         @adopted = adopted
-        @since = since && Ordinal.parse(since)
+        @since = since && Plans::Ordinal.parse(since)
         @statuses = statuses
         @force = force
       end
@@ -100,7 +100,7 @@ module Agentilda
 
       # Plans in a state nobody has decided how to file, and why not.
       #
-      # @return [Hash{Agentilda::Status => Array<String>}] state => ordinals
+      # @return [Hash{Agentilda::Plans::Status => Array<String>}] state => ordinals
       def unplaced
         @unplaced ||= (chosen - subjects).group_by(&:status)
                                          .transform_values { |group| group.map { |s| s.feature.ordinal.to_s } }
@@ -108,13 +108,13 @@ module Agentilda
 
       private
 
-      # @return [Agentilda::Tree]
+      # @return [Agentilda::Plans::Tree]
       attr_reader :tree
 
       # @return [Hash]
       attr_reader :adopted
 
-      # @return [Agentilda::Ordinal, nil]
+      # @return [Agentilda::Plans::Ordinal, nil]
       attr_reader :since
 
       # @return [Array<Symbol>, nil]
@@ -123,10 +123,10 @@ module Agentilda
       # @return [Boolean]
       attr_reader :force
 
-      # @return [Array<Agentilda::Subject>]
+      # @return [Array<Agentilda::Plans::Subject>]
       def subjects = @subjects ||= chosen.select { |s| Agentilda::Linear.placement(s.status) }
 
-      # @return [Array<Agentilda::Subject>] before the placement question
+      # @return [Array<Agentilda::Plans::Subject>] before the placement question
       def chosen
         @chosen ||= tree.subjects.select { |s|
           (since.nil? || s.feature.ordinal >= since) &&
@@ -138,7 +138,7 @@ module Agentilda
       # `plan.md` declares, plus any pull request {Attribution} placed here
       # that none of them already claims.
       #
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Array<Agentilda::Linear::Unit>]
       def units_for(subject)
         (@units ||= {})[subject.feature.path] ||= begin
@@ -149,7 +149,7 @@ module Agentilda
         end
       end
 
-      # @param pull [Agentilda::PullRequest]
+      # @param pull [Agentilda::Plans::PullRequest]
       # @return [Agentilda::Linear::Unit]
       def adopted_unit(pull)
         Unit.new(key: "##{pull.number}",
@@ -158,11 +158,11 @@ module Agentilda
           pull_requests: [pull])
       end
 
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Agentilda::Linear::Issues]
       def record_for(subject) = (@records ||= {})[subject.feature.path] ||= Issues.new(dir: subject.feature.path)
 
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Array<Agentilda::Linear::Action>]
       def actions_for(subject)
         [plan_action(subject)] + units_for(subject).map { |unit| unit_action(subject, unit) }
@@ -170,7 +170,7 @@ module Agentilda
 
       # The issue that stands for the whole plan folder.
       #
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Agentilda::Linear::Action]
       def plan_action(subject)
         placement = Agentilda::Linear.placement(subject.status)
@@ -195,7 +195,7 @@ module Agentilda
           reason:)
       end
 
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @param unit [Agentilda::Linear::Unit]
       # @return [Agentilda::Linear::Action]
       def unit_action(subject, unit)
@@ -238,7 +238,7 @@ module Agentilda
         [:update, "the plan has changed since #{existing} was pushed"]
       end
 
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [String]
       def plan_title(subject) = "[#{subject.feature.ordinal}] #{heading(subject)}"
 
@@ -246,7 +246,7 @@ module Agentilda
       # `spec.md` gives it a real sentence — "Tenancy: users, households,
       # memberships" — while the folder slug can only carry kebab-case.
       #
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [String]
       def heading(subject)
         line = subject.read("spec.md").to_s[/^[ \t]{0,3}#[ \t]+(.+)$/, 1]
@@ -254,7 +254,7 @@ module Agentilda
         cleaned.empty? ? subject.feature.title : cleaned
       end
 
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [String]
       def plan_description(subject)
         [
@@ -265,7 +265,7 @@ module Agentilda
         ].compact.reject(&:empty?).join("\n\n")
       end
 
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @param unit [Agentilda::Linear::Unit]
       # @return [String]
       def unit_description(subject, unit)

data/lib/agentilda/linear/mapping.rb

@@ -31,9 +31,9 @@ module Agentilda
     TYPES = %w[backlog unstarted started completed canceled].freeze
 
     # Every plan state this tool is willing to place, keyed by
-    # {Agentilda::Status#key}.
+    # {Agentilda::Plans::Status#key}.
     #
-    # Between this and {UNPLACED} every entry in {Agentilda::STATUSES} is
+    # Between this and {UNPLACED} every entry in {Agentilda::Plans::STATUSES} is
     # named exactly once, and a spec asserts it. That is the guard against the
     # failure this file is most prone to: a sixteenth state gets added,
     # nothing here changes, and its plans quietly import as Backlog with no
@@ -86,8 +86,8 @@ module Agentilda
     # unit's pull requests are the better evidence, so they are used when
     # there are any.
     #
-    # @param status [Agentilda::Status] the plan's state
-    # @param pulls [Array<Agentilda::PullRequest>] the unit's
+    # @param status [Agentilda::Plans::Status] the plan's state
+    # @param pulls [Array<Agentilda::Plans::PullRequest>] the unit's
     # @return [Agentilda::Linear::Placement, nil]
     def self.placement_for(status, pulls)
       return placement(status) if pulls.empty?
@@ -99,13 +99,13 @@ module Agentilda
 
     # Where a plan in this state belongs on a Linear board.
     #
-    # @param status [Agentilda::Status]
+    # @param status [Agentilda::Plans::Status]
     # @return [Agentilda::Linear::Placement, nil] nil when nobody has decided
     def self.placement(status) = PLACEMENTS[status.key]
 
     # Why a state is not imported, for the report that says so.
     #
-    # @param status [Agentilda::Status]
+    # @param status [Agentilda::Plans::Status]
     # @return [String] the reason, or the louder one for a state nobody has considered at all
     def self.reason_unplaced(status)
       UNPLACED.fetch(status.key) do

data/lib/agentilda/linear/push.rb

@@ -28,7 +28,7 @@ module Agentilda
     class Push
       # @param import [Agentilda::Linear::Import]
       # @param api [Agentilda::Linear::API]
-      # @param tree [Agentilda::Tree]
+      # @param tree [Agentilda::Plans::Tree]
       def initialize(import:, api:, tree:)
         @import = import
         @api = api
@@ -49,7 +49,7 @@ module Agentilda
       # @return [Agentilda::Linear::API]
       attr_reader :api
 
-      # @return [Agentilda::Tree]
+      # @return [Agentilda::Plans::Tree]
       attr_reader :tree
 
       # @return [Hash] the team, its states and its labels
@@ -73,7 +73,7 @@ module Agentilda
       end
 
       # @param action [Agentilda::Linear::Action]
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @param parent [Agentilda::Linear::Result, nil]
       # @return [Agentilda::Linear::Result]
       def apply(action, subject, parent)
@@ -123,7 +123,7 @@ module Agentilda
       end
 
       # @param action [Agentilda::Linear::Action]
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Hash]
       def recorded(action, subject)
         was = Issues.new(dir: subject.feature.path).by_unit[action.unit]
@@ -174,7 +174,7 @@ module Agentilda
       # skips — a row dropped because its action was a no-op is a row the next
       # run would recreate from scratch.
       #
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @param results [Array<Agentilda::Linear::Result>]
       # @return [void]
       def record(subject, results)

data/lib/agentilda/linear/survey.rb

@@ -25,7 +25,7 @@ module Agentilda
         def why = { ordinal: "its name carries the plan number", slug: "its name is the plan's slug" }.fetch(rule)
       end
 
-      # @param tree [Agentilda::Tree]
+      # @param tree [Agentilda::Plans::Tree]
       # @param projects [Array<Hash>] `{"id", "name", "url", "status"}` from {API#projects}
       def initialize(tree:, projects:)
         @tree = tree
@@ -46,13 +46,13 @@ module Agentilda
 
       # Plans with no project. An import would create one for each.
       #
-      # @return [Array<Agentilda::Subject>]
+      # @return [Array<Agentilda::Plans::Subject>]
       def uncovered = tree.subjects - matches.map(&:subject)
 
       # Projects whose name shares the plan's words without matching either
       # rule, best first.
       #
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Array<Hash>]
       def near(subject) = scored(subject).map(&:first)
 
@@ -65,7 +65,7 @@ module Agentilda
       # obvious to a person and, to this, indistinguishable from
       # `tax-engine-consolidation` matching `Tax Law Engine`, which is wrong.
       #
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Array(Hash, Integer), nil] the project and its score
       def guess(subject)
         best, score = scored(subject).first
@@ -109,7 +109,7 @@ module Agentilda
 
       private
 
-      # @return [Agentilda::Tree]
+      # @return [Agentilda::Plans::Tree]
       attr_reader :tree
 
       # @param project [Hash]
@@ -126,7 +126,7 @@ module Agentilda
 
       # Every project that shares a word with this plan, best first.
       #
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Array<Array(Hash, Integer)>]
       def scored(subject)
         wanted = plan_words(subject)
@@ -138,7 +138,7 @@ module Agentilda
         }.sort_by { |_, overlap| -overlap }
       end
 
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       # @return [Array<String>]
       def plan_words(subject)
         words(subject.feature.slug) | words(slugify(subject.feature.title)) |

data/lib/agentilda/linear/unit.rb

@@ -11,7 +11,7 @@ module Agentilda
     # @!attribute [r] body
     #   @return [String] everything under the heading, as written
     # @!attribute [r] pull_requests
-    #   @return [Array<Agentilda::PullRequest>] the ones this unit claims
+    #   @return [Array<Agentilda::Plans::PullRequest>] the ones this unit claims
     Unit = Data.define(:key, :title, :body, :pull_requests)
 
     # Reads the work units out of a plan folder.
@@ -65,7 +65,7 @@ module Agentilda
       # Pull request numbers named in the heading: "(✔ #38)".
       NUMBERED = /#(\d+)\b/
 
-      # @param subject [Agentilda::Subject]
+      # @param subject [Agentilda::Plans::Subject]
       def initialize(subject:)
         @subject = subject
       end
@@ -101,7 +101,7 @@ module Agentilda
 
       private
 
-      # @return [Agentilda::Subject]
+      # @return [Agentilda::Plans::Subject]
       attr_reader :subject
 
       # @return [Array<Agentilda::Linear::Unit>] possibly empty
@@ -208,7 +208,7 @@ module Agentilda
       # The heading said so: `### PR 020.03 — Clerk webhooks (✔ #44)`.
       #
       # @param unit [Agentilda::Linear::Unit]
-      # @return [Array<Agentilda::PullRequest>]
+      # @return [Array<Agentilda::Plans::PullRequest>]
       def numbered(unit)
         wanted = heading_for(unit.key).to_s.scan(NUMBERED).flatten
         subject.pull_requests.select { |pr| wanted.include?(pr.number.to_s) }
@@ -217,7 +217,7 @@ module Agentilda
       # The pull request title said so: "Spec 010 PR-2: MAGI registry".
       #
       # @param unit [Agentilda::Linear::Unit]
-      # @return [Array<Agentilda::PullRequest>]
+      # @return [Array<Agentilda::Plans::PullRequest>]
       def named(unit)
         pattern = /\bPR[\s_-]?#{unit.key[/\d+\z/]}\b/i
         subject.pull_requests.select { |pr| pr.title.match?(pattern) }

data/lib/agentilda/plans/dev_work.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Agentilda
+  module Plans
+    # Telling "this belongs to no specification" apart from "nobody could tell".
+    #
+    # Both end up without a plan number, and filing them under one marker loses
+    # the difference between a finished thought and an open question. A
+    # dependency bump genuinely implements no specification and never will —
+    # that is an assertion, and `[dev]` records it. A pull request that adds
+    # Schedule K-1 for four tax years plainly implements *something*; nothing
+    # here could work out what, and `[none]` records that instead, as a job left
+    # for a human rather than a verdict.
+    #
+    # The bar for `[dev]` is deliberately high. Marking real work as `[dev]`
+    # tells everyone afterwards it was never worth a plan, and nobody re-opens a
+    # question that looks settled. `[none]` is visibly unfinished, so the cost of
+    # guessing wrong in that direction is somebody spending a minute on it.
+    module DevWork
+      module_function
+
+      # Titles that say what they are: dependency bumps, release chores, CI.
+      TITLES = [
+        /\Abump\s+\S+\s+from\s+\S+\s+to\s+\S+/i,
+        /\A(?:chore|ci|build|deps|style|refactor)(?:\([^)]*\))?:/i,
+        /\Abump\s+(?:to\s+)?v?\d+\.\d+/i
+      ].freeze
+
+      # Paths that are how the project is built rather than what it does.
+      PLUMBING = %r{\A(?:\.github/|\.circleci/|\.devcontainer/|bin/|scripts/|
+                         Dockerfile|\.dockerignore|Gemfile(?:\.lock)?|justfile|Rakefile|
+                         \.rubocop\.ya?ml|\.standard\.ya?ml|\.gitignore|\.tool-versions)}x
+
+      # Files that say nothing either way, so they neither prove plumbing nor
+      # disprove it — every pull request in this tool's world touches `.plans`.
+      NEUTRAL = %r{\A(?:#{PLANS_DIR}/|CHANGELOG|README)}
+
+      # @param title [String]
+      # @param files [Array<String>] paths in the diff
+      # @return [Boolean] whether this can be *asserted* to implement no plan
+      def developer?(title, files = [])
+        return true if TITLES.any? { |pattern| title.to_s.match?(pattern) }
+
+        judged = Array(files).reject { |path| path.match?(NEUTRAL) }
+        return false if judged.empty?
+
+        judged.all? { |path| path.match?(PLUMBING) }
+      end
+
+      # @param title [String]
+      # @param files [Array<String>]
+      # @return [String] the marker to stamp on it
+      def marker(title, files = []) = developer?(title, files) ? NO_PLAN_PREFIX : NONE_PREFIX
+    end
+  end
+end

data/lib/agentilda/plans/feature.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Agentilda
+  module Plans
+    # Lowercase in the middle of a title, capitalised at the front.
+    SMALL_WORDS = %w[a an and as at but by for from in into nor of on or per the to via vs with].freeze
+
+    # Slug words that are really acronyms and should shout.
+    ACRONYMS = %w[
+      abac ai api aws cdn ci cd cli cms cors cpu crm css csv db dns dsl e2e ec2 etl gcp gdpr gpu gui
+      html http https iam id ide jwt json k8s llm ml mcp mvp npm oauth orm otp pdf pii poc pr prs qa
+      rbac rds rest rls rpc rss s3 saas sdk seo sns spa sql sqs sre ssh sso ssl ssr tls tui ts tsx ui
+      ux uuid vpc vpn xml yaml
+    ].freeze
+
+    # Words with a house spelling that neither capitalize nor upcase gets right.
+    SPECIAL_CASE = {
+      "github" => "GitHub", "gitlab" => "GitLab", "graphql" => "GraphQL", "ios" => "iOS",
+      "javascript" => "JavaScript", "macos" => "macOS", "nodejs" => "Node.js", "oauth" => "OAuth",
+      "openai" => "OpenAI", "postgres" => "PostgreSQL", "postgresql" => "PostgreSQL",
+      "typescript" => "TypeScript", "uuidv7" => "UUIDv7", "websocket" => "WebSocket"
+    }.freeze
+
+    # Turn a kebab slug into a proper name: `law-as-data` → "Law as Data".
+    #
+    # @param slug [String]
+    # @return [String]
+    def self.titleize(slug)
+      words = slug.to_s.split(/[-_\s.]+/).reject(&:empty?)
+      return "" if words.empty?
+
+      words.each_with_index.map { |word, i|
+        lower = word.downcase
+        if SPECIAL_CASE.key?(lower)
+          SPECIAL_CASE[lower]
+        elsif ACRONYMS.include?(lower)
+          lower.upcase
+        elsif i.positive? && SMALL_WORDS.include?(lower)
+          lower
+        elsif lower.match?(/\A\d+\z/)
+          lower
+        else
+          lower.sub(/\A./, &:upcase)
+        end
+      }.join(" ")
+    end
+
+    # The one place a plan folder's name is spelled out: `NNN.MM-<emoji> → <slug>`.
+    #
+    # The spaced arrow after the emoji is deliberate: an emoji renders two cells
+    # wide and visually swallows a bare dash beside it, so `🔎-refactor` reads
+    # as if the emoji and the slug were touching. Everything that mints or
+    # renames a folder goes through here; {Feature.parse} accepts the older
+    # `--` and single-dash spellings too, and `resync dirs` migrates them on
+    # contact.
+    #
+    # @param ordinal [Agentilda::Plans::Ordinal, String]
+    # @param status [Agentilda::Plans::Status]
+    # @param slug [String]
+    # @return [String]
+    def self.plan_dirname(ordinal, status, slug) = "#{ordinal}-#{status.emoji} → #{slug}"
+
+    # One `NNN.MM-<emoji> → <slug>` folder, decoded.
+    #
+    # @!attribute [r] ordinal
+    #   @return [Agentilda::Plans::Ordinal]
+    # @!attribute [r] status
+    #   @return [Agentilda::Plans::Status]
+    # @!attribute [r] slug
+    #   @return [String]
+    # @!attribute [r] dirname
+    #   @return [String] exactly as it is on disk
+    # @!attribute [r] path
+    #   @return [String] absolute
+    Feature = Data.define(:ordinal, :status, :slug, :dirname, :path) do
+      include Comparable
+
+      # Decode a folder name, or return nil when it is not a plan folder.
+      #
+      # @param path [String] absolute path to a candidate directory
+      # @return [Agentilda::Plans::Feature, nil]
+      def self.parse(path)
+        dirname = File.basename(path)
+        ordinal = Ordinal.from_dirname(dirname) or return nil
+
+        rest = dirname.sub(/\A[\d.]+[-_]/, "")
+        head, tail = rest.split(/\s*→\s*|[-_]/, 2)
+
+        # A leading segment with no ASCII word character is the status emoji.
+        # The slug strips any further separators: the canonical spelling puts
+        # a spaced arrow after the emoji, and folders from before that rule put
+        # two dashes, or one.
+        status = (Agentilda::Plans.status_for_emoji(head) if tail && !head.to_s.empty? && !head.match?(/[A-Za-z0-9]/))
+        slug = status ? tail.sub(/\A[-_\s]+/, "") : rest
+
+        new(ordinal:, status: status || STATUS_BY_KEY.fetch(:new), slug:, dirname:, path:)
+      end
+
+      # @return [String] proper name, e.g. "Law as Data"
+      def title = Agentilda::Plans.titleize(slug)
+
+      # The folder name this feature would carry in a given state — the slug
+      # never moves, and the number is always rendered canonically, so this is
+      # also what repairs a folder written `018-⚪️--foo` before the `NNN.MM` rule.
+      #
+      # @param status [Agentilda::Plans::Status]
+      # @return [String]
+      def dirname_as(status) = Agentilda::Plans.plan_dirname(ordinal, status, slug)
+
+      # The number exactly as the folder writes it, which is not always the
+      # canonical rendering: `018-⚪️--foo` yields "018" where {#ordinal} renders
+      # "018.00".
+      #
+      # @return [String]
+      def dirname_ordinal = dirname.to_s[/\A[\d.]+/].to_s
+
+      # @return [Boolean] whether the number is written in full `NNN.MM` form
+      def padded? = dirname_ordinal == ordinal.to_s
+
+      # Whether the folder is already named the way this tool would name it —
+      # number padded, emoji matching the state it claims, slug unchanged.
+      #
+      # @return [Boolean]
+      def canonical? = dirname == dirname_as(status)
+
+      # @param other [Object]
+      # @return [Integer, nil]
+      def <=>(other) = other.is_a?(self.class) ? [ordinal, dirname] <=> [other.ordinal, other.dirname] : nil
+    end
+  end
+end