seams 0.1.0 → 0.2.0

data/lib/generators/seams/permissions/permissions_generator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "seams"
+require "seams/permissions"
+require "seams/generators/host_injector"
+require "seams/generators/eject_aware"
+
+module Seams
+  module Generators
+    # Writes ONE host-editable initializer that spells out the default
+    # role -> ability grant map and assigns it through
+    # `Seams.configure { |c| c.permission_grants = {...} }`.
+    #
+    # This is the deferred-friendly seam of the permissions layer (Wave
+    # 11B / issue #37): there is no database table and no YAML DSL — a
+    # host changes who-can-do-what by editing this one Ruby file. The
+    # generated map is a readable copy of Seams::Permissions::DEFAULT_GRANTS
+    # rendered at generate time, so the host starts from the same defaults
+    # the gem ships and edits from there.
+    #
+    # The catalog of ability CODES is engine-owned: each engine registers
+    # the `resource.action.engine` codes it understands from its engine.rb
+    # (mirroring the event bus). This file only decides which ROLES hold
+    # which already-registered codes. Referencing a code no engine has
+    # registered makes `Seams::Permissions.can?` raise — deny-by-default,
+    # loudly.
+    #
+    # Run with: bin/seams permissions   (or bin/rails generate seams:permissions)
+    class PermissionsGenerator < Rails::Generators::Base
+      include Seams::Generators::HostInjector
+      include Seams::Generators::EjectAware
+
+      source_root File.expand_path("templates", __dir__)
+
+      INITIALIZER_RELATIVE = "config/initializers/seams_permissions.rb"
+
+      # The single deliverable: the host-editable grant map. Eject-aware
+      # so a host that has stamped the eject header (to fully own the file
+      # and never be prompted again) keeps their version on a re-run.
+      def create_initializer
+        template_unless_ejected "config/initializers/seams_permissions.rb.tt",
+                                host_path(INITIALIZER_RELATIVE)
+      end
+
+      def report_summary
+        say report_summary_text, :green
+      end
+
+      def report_summary_text
+        <<~TXT
+
+          Permissions grant map generated at #{INITIALIZER_RELATIVE}
+
+          Next steps:
+            1. Edit the role -> ability map in
+                 #{INITIALIZER_RELATIVE}
+               Each role lists the registered ability codes it holds. Roles
+               inherit downward (owner inherits admin inherits member), so a
+               code only needs to appear at the lowest role that should hold it.
+
+            2. List the ability codes every installed engine registers:
+                 bin/rails runner 'pp Seams::PermissionRegistry.all'
+               You can only grant codes that appear there — `can?` raises on
+               an unregistered code (deny-by-default, loudly).
+
+            3. Guard a controller action with a code:
+                 before_action -> { authorize_permission!("invoice.read.billing") }
+
+          To fully own this file (skip it on future generator runs):
+            bin/seams resolve --eject (or add the `# seams:ejected from` header).
+
+          See doc/reference/PERMISSIONS.md for the model, the role hierarchy, the bypass
+          tiers, and what is deliberately deferred (YAML DSL, DB custom roles,
+          per-ability grants).
+
+        TXT
+      end
+
+      private
+
+      # A readable Ruby literal for the default grant map, rendered from
+      # Seams::Permissions::DEFAULT_GRANTS so the generated file always
+      # matches the gem's shipped defaults. Each role becomes a
+      # `"role" => %w[...]` block (4-space indent), one ability code per
+      # line (6-space indent), so it sits cleanly inside the
+      # `config.permission_grants = {` hash in the template. Entries are
+      # joined with a trailing comma + newline.
+      def grant_map_body
+        Seams::Permissions::DEFAULT_GRANTS.map do |role, abilities|
+          codes = abilities.map { |code| "      #{code}" }.join("\n")
+          %(    "#{role}" => %w[\n#{codes}\n    ])
+        end.join(",\n")
+      end
+    end
+  end
+end

data/lib/generators/seams/permissions/templates/config/initializers/seams_permissions.rb.tt

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Seams permissions — the host-editable role -> ability grant map.
+#
+# This is the ONE place you decide who-can-do-what. There is no database
+# table and no DSL: authorisation is a code-defined role hierarchy plus
+# this map. Edit the hash below, restart, done.
+#
+# How it resolves (Seams::Permissions.can?):
+#   - Roles inherit DOWNWARD: owner inherits admin inherits member. So a
+#     code only needs to appear at the LOWEST role that should hold it —
+#     anything granted to "member" is automatically held by admin + owner.
+#   - "system" is a pseudo-role that bypasses every check (background
+#     jobs, trusted internal actors). It needs no entry here.
+#   - Platform staff (Auth::Identity#staff?) are bypassed at the REQUEST
+#     layer by the caller (e.g. authorize_permission!), not here.
+#   - Deny-by-default: a role that is not granted a code does not hold it.
+#
+# The catalog of ability CODES is engine-owned. Each engine registers the
+# `resource.action.engine` codes it understands from its engine.rb
+# (mirroring the event bus). You can only grant codes that some engine has
+# registered — referencing an unregistered code makes `can?` RAISE, not
+# quietly allow. List the live catalog with:
+#
+#   bin/rails runner 'pp Seams::PermissionRegistry.all'
+#
+# The map below is a copy of Seams::Permissions::DEFAULT_GRANTS as shipped
+# by the gem at the time this file was generated. Add, remove, or move
+# codes between roles to fit your product. To add a brand-new code, first
+# register it from the owning engine's engine.rb, then grant it here.
+Seams.configure do |config|
+  config.permission_grants = {
+<%= grant_map_body %>
+  }
+end

data/lib/generators/seams/teams/templates/app/controllers/invitations_controller.rb.tt

@@ -41,7 +41,18 @@ module Teams
     # Wraps the lookup in a row lock and short-circuits if the
     # invitation has already been accepted, so a double-click on the
     # email link returns a friendly redirect instead of a 500.
+    #
+    # Unauthenticated requests stash the token in the session and
+    # redirect to the sign-in path with a `return_to` parameter equal
+    # to the current request URL. The host's sign-in flow is responsible
+    # for reading `return_to` and redirecting the user back after
+    # authentication.
     def accept
+      unless current_identity_id
+        session[:pending_invitation_token] = params[:token]
+        return redirect_to(main_app.new_session_path(return_to: request.url))
+      end
+
       Teams::Invitation.transaction do
         @invitation = Teams::Invitation.lock.find_by!(token: params[:token])
 
@@ -53,6 +64,18 @@ module Teams
           return redirect_to root_path, alert: "Invitation expired"
         end
 
+        # Prevent a holder of a stolen token from accepting the
+        # invitation under a different identity. Compare
+        # case-insensitively to guard against trivial casing bypasses.
+        current_email = if defined?(Auth::Current) && Auth::Current.respond_to?(:identity) && Auth::Current.identity
+                          Auth::Current.identity.email.to_s.downcase
+                        else
+                          ""
+                        end
+        unless current_email == @invitation.email.to_s.downcase
+          return redirect_to teams_path, alert: "This invitation was sent to a different email address."
+        end
+
         @invitation.team.memberships.create!(identity_id: current_identity_id, role: @invitation.role)
         @invitation.update!(accepted_at: Time.current)
       end
@@ -87,16 +110,9 @@ module Teams
       Teams::Membership::ROLES.include?(candidate) ? candidate : "member"
     end
 
-    # Resolves the signed-in human's id from `Auth::Current.identity`
-    # (the Auth engine's per-request namespace). Gated on
-    # `defined?(Auth::Current)` so it's safe in hosts that don't ship
-    # auth. Override in your host if you wire auth differently.
-    def current_identity_id
-      if defined?(Auth::Current) && Auth::Current.respond_to?(:identity) && Auth::Current.identity
-        return Auth::Current.identity.id
-      end
-
-      nil
-    end
+    # current_identity_id is provided by Teams::Authorization (included
+    # at the top of the class). Do not redefine here — keep the concern
+    # as the single source of truth so a future change to identity
+    # resolution lands in one place.
   end
 end

data/lib/generators/seams/teams/templates/app/controllers/teams_controller.rb.tt

@@ -2,7 +2,11 @@
 
 module Teams
   class TeamsController < ApplicationController
-    before_action :set_team, only: %i[show edit update destroy]
+    include Teams::Authorization
+
+    before_action :set_team,              only: %i[show edit update destroy]
+    before_action :require_team_member!,  only: %i[show]
+    before_action :require_team_admin!,   only: %i[edit update destroy]
 
     def index
       @teams = Teams::Team.joins(:memberships).where(memberships: { identity_id: current_identity_id })
@@ -52,17 +56,5 @@ module Teams
     def team_params
       params.require(:team).permit(:name, :slug)
     end
-
-    # Resolves the signed-in human's id from `Auth::Current.identity`
-    # (the Auth engine's per-request namespace). Gated on
-    # `defined?(Auth::Current)` so it's safe in hosts that don't ship
-    # auth. Override in your host if you wire auth differently.
-    def current_identity_id
-      if defined?(Auth::Current) && Auth::Current.respond_to?(:identity) && Auth::Current.identity
-        return Auth::Current.identity.id
-      end
-
-      nil
-    end
   end
 end

data/lib/generators/seams/teams/templates/lib/concerns/authorization.rb.tt

@@ -18,13 +18,11 @@ module Teams
     private
 
     def require_team_member!
-      head :forbidden and return false unless team_member?
-      true
+      redirect_to teams_path, alert: "Not a member of that team." unless team_member?
     end
 
     def require_team_admin!
-      head :forbidden and return false unless team_admin?
-      true
+      redirect_to teams_path, alert: "Admin access required." unless team_admin?
     end
 
     def team_member?

data/lib/generators/seams/teams/templates/lib/engine.rb.tt

@@ -18,6 +18,19 @@ module Teams
       # seams:insertion-point teams.engine.events
     end
 
+    initializer "teams.register_abilities" do
+      # Ability codes this engine owns, registered exactly like events
+      # (resource.action.engine). `read` is the member-level view;
+      # `manage` is the admin-level mutate. Host grant maps reference
+      # these codes; see Seams::Permissions::DEFAULT_GRANTS.
+      Seams::PermissionRegistry.register("team.read.teams",         owned_by: "Teams")
+      Seams::PermissionRegistry.register("team.manage.teams",       owned_by: "Teams")
+      Seams::PermissionRegistry.register("member.manage.teams",     owned_by: "Teams")
+      Seams::PermissionRegistry.register("invitation.manage.teams", owned_by: "Teams")
+      # Follow-up generators that ship new teams abilities register them here.
+      # seams:insertion-point teams.engine.abilities
+    end
+
     initializer "teams.append_migrations" do |app|
       unless app.root == root
         config.paths["db/migrate"].expanded.each do |expanded_path|

data/lib/seams/cli/list.rb

@@ -8,15 +8,29 @@ module Seams
     # engine under engines/, looks up its registered events in
     # Seams::EventRegistry, and prints a summary.
     class List
+      # Default directory that holds the generated engines.
       DEFAULT_ENGINES_ROOT = "engines"
 
+      # Matches the top-level `module Foo` declaration in an engine file.
       MODULE_DECLARATION = /\bmodule\s+([A-Z][A-Za-z0-9_]*)\b/
 
+      # The canonical event-name convention: at least three
+      # dot-separated word segments ("subscription.created.billing").
+      # Used to reject regex captures that are NOT event names — the
+      # subscription scan is textual and multiline, so when an event
+      # name is passed as a variable it would otherwise grab the next
+      # unrelated string literal downstream (e.g. a subscriber's
+      # owner-class fallback like "Accounts::Account") and report a
+      # phantom subscription/dependency.
+      EVENT_NAME = /\A\w+(\.\w+){2,}\z/
+
       def initialize(engines_root: DEFAULT_ENGINES_ROOT, output: $stdout)
         @engines_root = engines_root
         @output       = output
       end
 
+      # Discover the engines, gather their events, and print the report.
+      # @return [Boolean] true on success.
       def call
         engines = discover_engines
         @output.puts("seams: #{engines.size} engine(s) installed")
@@ -69,6 +83,7 @@ module Seams
             content.scan(/Publisher\.(?:subscribe|attach_once|attach_class)\([^"']*["']([^"']+)["']/m)
                    .flatten
           end
+          .grep(EVENT_NAME)
           .uniq
       end
 

data/lib/seams/cli/quality.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "open3"
 require "seams"
 
 module Seams
@@ -14,7 +15,10 @@ module Seams
     #
     # Returns true when every gate that ran passed; false otherwise.
     class Quality
+      # Default directory that holds the generated engines.
       DEFAULT_ENGINES_ROOT = "engines"
+      # Gate statuses that count as a pass for the overall result.
+      PASSING_STATUSES = %i[pass skipped].freeze
 
       def initialize(engines_root: DEFAULT_ENGINES_ROOT, output: $stdout)
         @engines_root = engines_root
@@ -22,6 +26,8 @@ module Seams
         @results      = {}
       end
 
+      # Run the quality gates across every engine.
+      # @return [Boolean] true when every gate that ran passed.
       def call
         run_rubocop
         run_brakeman
@@ -29,19 +35,54 @@ module Seams
         run_simplecov_collation
 
         print_summary
-        @results.values.all? { |status| %i[pass skipped].include?(status) }
+        @results.values.all? { |status| PASSING_STATUSES.include?(status) }
       end
 
       private
 
+      # Runs RuboCop twice over: once host-wide, then once per engine.
+      #
+      # The per-engine runs are NOT redundant: the generated host
+      # .rubocop.yml excludes `engines/**/*` (engines lint themselves),
+      # and RuboCop merges the project root's `AllCops: Exclude` into
+      # any run started from a subdirectory unless
+      # `--ignore-parent-exclusion` is passed. A single host-wide run
+      # therefore inspects ZERO engine files, silently skipping the
+      # Seams boundary cops. Each engine with its own .rubocop.yml is
+      # linted from inside its directory with parent exclusion ignored.
       def run_rubocop
-        if gem_installed?("rubocop")
-          @output.puts("=== rubocop --parallel ===")
-          @results[:rubocop] = system("bundle", "exec", "rubocop", "--parallel") ? :pass : :fail
-        else
+        unless gem_installed?("rubocop")
           @output.puts("rubocop not installed — skipping.")
           @results[:rubocop] = :skipped
+          return
         end
+
+        @output.puts("=== rubocop --parallel ===")
+        host_ok = system("bundle", "exec", "rubocop", "--parallel")
+
+        # Run every engine even after a failure so the summary shows
+        # all offending engines, not just the first.
+        engines_ok = engine_rubocop_dirs.map { |dir| engine_rubocop_passed?(dir) }.all?
+
+        @results[:rubocop] = host_ok && engines_ok ? :pass : :fail
+      end
+
+      def engine_rubocop_passed?(dir)
+        @output.puts("=== rubocop --ignore-parent-exclusion (#{dir}) ===")
+        out, status = Open3.capture2e(
+          "bundle", "exec", "rubocop", "--ignore-parent-exclusion", chdir: dir
+        )
+        @output.puts(out)
+        status.success?
+      end
+
+      # Engines that ship their own .rubocop.yml (the generated
+      # default). Engines without one fall back to whatever the host
+      # run covers, so they are skipped here.
+      def engine_rubocop_dirs
+        Dir.glob(File.join(@engines_root, "*"))
+           .select { |dir| File.directory?(dir) && File.exist?(File.join(dir, ".rubocop.yml")) }
+           .sort
       end
 
       def run_brakeman

data/lib/seams/cli/resolve.rb

@@ -41,16 +41,19 @@ module Seams
     # with a trailing `?`, but that's wrong for the run_* dispatchers
     # (they're imperative, not predicates). AbcSize / CyclomaticComplexity
     # likewise trigger on the run_* methods because CLI command
-    # branches are inherently branchy. The cops are disabled at file
-    # scope and the methods are kept linear and well-commented.
-    # rubocop:disable Naming/PredicateMethod, Metrics/AbcSize, Metrics/CyclomaticComplexity
+    # branches are inherently branchy. The cops are disabled for the
+    # whole class and the methods are kept linear and well-commented.
+    # rubocop:disable-next Naming/PredicateMethod, Metrics/AbcSize, Metrics/CyclomaticComplexity
     class Resolve
+      # Default directory that holds the generated engines.
       DEFAULT_ENGINES_ROOT = "engines"
 
       # Header injected at the top of every ejected file. Position
       # matters: future regenerations check the FIRST line of an
       # existing destination file for this exact prefix.
       EJECT_HEADER_PREFIX = "# seams:ejected from"
+
+      # Builds the full ejected-file header block for a given event/source.
       EJECT_HEADER_LINES  = lambda do |from|
         <<~HEADER
           #{EJECT_HEADER_PREFIX} #{from}
@@ -78,6 +81,8 @@ module Seams
         @error        = error
       end
 
+      # Execute the selected resolve mode (:eject / :list_markers / :list_ejected).
+      # @return [Boolean] true on success, false on a handled failure.
       def call
         case @mode
         when :eject         then run_eject
@@ -138,7 +143,7 @@ module Seams
         fail_with(
           "refusing to eject #{engine}/#{relative}: this file is framework-managed " \
           "(migrations, engine.rb, version.rb, Gemfile, .gemspec) and is not eject-eligible. " \
-          "See doc/INSERTION_POINTS.md and Seams::Generators::EjectAware for the rule."
+          "See doc/reference/INSERTION_POINTS.md and Seams::Generators::EjectAware for the rule."
         )
         false
       end
@@ -271,6 +276,5 @@ module Seams
         false
       end
     end
-    # rubocop:enable Naming/PredicateMethod, Metrics/AbcSize, Metrics/CyclomaticComplexity
   end
 end

data/lib/seams/cli/test_changed.rb

@@ -17,7 +17,9 @@ module Seams
     # The caller (rake task or bin/seams) translates that to an exit
     # code.
     class TestChanged
+      # Default git ref to diff the working tree against.
       DEFAULT_BASE         = "main"
+      # Default directory that holds the generated engines.
       DEFAULT_ENGINES_ROOT = "engines"
 
       def initialize(base: DEFAULT_BASE, engines_root: DEFAULT_ENGINES_ROOT, output: $stdout)
@@ -26,6 +28,8 @@ module Seams
         @output       = output
       end
 
+      # Run the specs of every engine changed since {DEFAULT_BASE}.
+      # @return [Boolean] true if all selected suites pass.
       def call
         engines = changed_engines
         if engines.empty?
@@ -59,7 +63,7 @@ module Seams
       end
 
       # Array-form shell-out: no interpolation into a shell, so a
-      # @base value like `; rm -rf /` passes as one argv element to
+      # +@base+ value like `; rm -rf /` passes as one argv element to
       # git rather than getting evaluated. shell_escape is defence in
       # depth on top of that.
       def resolve_merge_base

data/lib/seams/cli.rb

@@ -19,10 +19,19 @@ module Seams
   module CLI
     module_function
 
+    # List every engine and the events it emits/subscribes to.
+    # @param engines_root [String] directory holding the engines.
+    # @param output [IO] stream to write the report to.
+    # @return [Boolean] true on success.
     def list(engines_root: "engines", output: $stdout)
       Seams::CLI::List.new(engines_root: engines_root, output: output).call
     end
 
+    # Run the specs of every engine changed since +base+.
+    # @param base [String] the git ref to diff against.
+    # @param engines_root [String] directory holding the engines.
+    # @param output [IO] stream to write progress to.
+    # @return [Boolean] true if all selected suites pass.
     def test_changed(base: "main", engines_root: "engines", output: $stdout)
       Seams::CLI::TestChanged.new(
         base: base,
@@ -31,10 +40,21 @@ module Seams
       ).call
     end
 
+    # Run rubocop across every engine.
+    # @param engines_root [String] directory holding the engines.
+    # @param output [IO] stream to write progress to.
+    # @return [Boolean] true if every engine lints clean.
     def quality(engines_root: "engines", output: $stdout)
       Seams::CLI::Quality.new(engines_root: engines_root, output: output).call
     end
 
+    # Drive the eject / insertion-point escape hatch.
+    # @param mode [Symbol] :eject, :list_markers, or :list_ejected.
+    # @param argument [String, nil] mode-specific argument (e.g. "<engine>/<file>").
+    # @param engines_root [String] directory holding the engines.
+    # @param output [IO] stream for normal output.
+    # @param error [IO] stream for error output.
+    # @return [Boolean] true on success.
     def resolve(mode:, argument: nil, engines_root: "engines", output: $stdout, error: $stderr)
       Seams::CLI::Resolve.new(
         mode: mode,

data/lib/seams/configuration.rb

@@ -1,19 +1,42 @@
 # frozen_string_literal: true
 
+require "seams/permissions"
+
 module Seams
   # Global Seams configuration. Set via Seams.configure { |c| ... } in
   # config/initializers/seams.rb of the host application.
+  #
+  # @example
+  #   Seams.configure do |c|
+  #     c.host_app_name = "Acme"
+  #     c.event_bus_adapter = "MyApp::Events::SidekiqAdapter"
+  #   end
   class Configuration
+    # @!attribute [rw] event_bus_adapter
+    #   @return [String] class name of the event-bus adapter (default
+    #     "Seams::Events::Adapters::ActiveSupport").
+    # @!attribute [rw] observability_adapter
+    #   @return [String] class name of the observability adapter (default
+    #     "Seams::Observability::Adapters::RailsLogger").
+    # @!attribute [rw] event_namespace_separator
+    #   @return [String] separator between event-name segments (default ".").
+    # @!attribute [rw] host_app_name
+    #   @return [String, nil] the host application's name, for reporting.
+    # @!attribute [rw] permission_grants
+    #   @return [Hash] the role -> ability grant map (default
+    #     {Seams::Permissions::DEFAULT_GRANTS}).
     attr_accessor :event_bus_adapter,
                   :observability_adapter,
                   :event_namespace_separator,
-                  :host_app_name
+                  :host_app_name,
+                  :permission_grants
 
     def initialize
       @event_bus_adapter = "Seams::Events::Adapters::ActiveSupport"
       @observability_adapter = "Seams::Observability::Adapters::RailsLogger"
       @event_namespace_separator = "."
       @host_app_name = nil
+      @permission_grants = Seams::Permissions::DEFAULT_GRANTS
     end
   end
 end

data/lib/seams/cops/no_cross_engine_dependency.rb

@@ -10,19 +10,22 @@ module RuboCop
       # through public events (Seams::Events::Publisher) and
       # explicitly-exposed concerns — not by requiring private files.
       class NoCrossEngineDependency < Base
+        # Path segments that climb (or stay in) the directory tree.
+        CLIMB_SEGMENTS = [".", ".."].freeze
+
         MSG = "Engine `%<own>s` must not require `%<path>s` from another engine. " \
               "Communicate via events or via `%<other>s`'s exposed concerns."
 
         # @!method require_call?(node)
         def_node_matcher :require_call?, <<~PATTERN
-          (send nil? {:require :require_relative} (str $_))
+          (send nil? ${:require :require_relative} (str $_))
         PATTERN
 
         def on_send(node)
-          path = require_call?(node)
+          method, path = require_call?(node)
           return unless path
 
-          offending_engine = other_engine_for(path)
+          offending_engine = other_engine_for(method, path)
           return unless offending_engine
 
           add_offense(
@@ -42,11 +45,40 @@ module RuboCop
           Array(cop_config["OtherEngines"]).map(&:to_s)
         end
 
-        def other_engine_for(path)
-          # Match either "billing/foo" or "../../billing/foo" — the engine
-          # name is whichever directory segment matches another engine.
+        # For a plain `require`, only the FIRST path segment identifies
+        # the library — `require "billing/foo"` loads the sibling engine,
+        # but `require "rspec/core/rake_task"` loads rspec-core no matter
+        # what its deeper segments are called. Matching ANY segment (the
+        # old behaviour) false-fired on every generated host with an
+        # engine named `core`, because engine Rakefiles require
+        # "rspec/core/rake_task".
+        #
+        # For `require_relative`, the path is anchored inside the
+        # engine's own tree: it only reaches a sibling engine when it
+        # first climbs OUT via `../`. Resolve the climb and check the
+        # first segment after it — `../../billing/foo` is a genuine
+        # cross-engine reach, while `core/something` (no climb) is just
+        # a subdirectory of the requiring file.
+        def other_engine_for(method, path)
+          candidate =
+            if method == :require_relative
+              first_segment_after_climb(path)
+            else
+              path.split("/").first
+            end
+
+          other_engines.find { |engine| engine == candidate }
+        end
+
+        # Returns the first path segment after the leading `../` (or
+        # `./`) climb, or nil when the path never leaves the requiring
+        # file's own directory.
+        def first_segment_after_climb(path)
           segments = path.split("/")
-          other_engines.find { |engine| segments.include?(engine) }
+          climbed  = segments.take_while { |segment| CLIMB_SEGMENTS.include?(segment) }
+          return nil unless climbed.include?("..")
+
+          segments.drop(climbed.size).first
         end
 
         def capitalize(name)