ruby_native 0.17.2 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a20e456fe2c38a3885bd29bc796da70a6ef238bf30de87297ca14f9f407d783d
-  data.tar.gz: b266e12b4c911bb57ba5c21eb6748f270a13a7449e27296fb5bf5fefb4b20d96
+  metadata.gz: 6943c548d9910886fefa4a121b493c1cdc40b06ab34059c4deac3fac3ac86018
+  data.tar.gz: def52388edde0250a098f4ffa4c02e0fe691d7aa0383b1049c2ac1c178be559b
 SHA512:
-  metadata.gz: 7a59080e79c82b040910d146ad1b3f214ef247a1f251783ba951400bf099bc1f161b41195b2230bb0da977988ae7850be1be6aff1e4f89c16a539b7b7dcef8f3
-  data.tar.gz: 289783ff033617cc3b77f697334e861985f98786562d978b923118c56638c0411931df89929bf9c771cbe77a88d71f38d6f177fbb1762c66badfdb039fa7379c
+  metadata.gz: 7bdaecaa1892409cfdde1f9e6f7161acd430065e470c35a73e95a25ace1bad76f303802226952965fa8e109b8848ee4fc42c6a6db3fefb5bc0b691140b705bb1
+  data.tar.gz: b67256819c46021c2de3e11e89fa5d6c7acc51064256913d5c9e5b44ebec3184c9b0b68e9461e0d4141246c32f0363da6f423fb306781287d78f3d04b23982bd

data/README.md

@@ -18,7 +18,13 @@ Run the install generator:
 rails generate ruby_native:install
 ```
 
-This creates `config/ruby_native.yml`. Then:
+This creates `config/ruby_native.yml` with tabs taken from your routes. If you use a coding agent, hand it the rest here:
+
+```bash
+bundle exec ruby_native mcp install
+```
+
+Then say: set up Ruby Native in this app. It wires the layout, checks its own work, and later drafts the listing, captures screenshots, and submits for review, stopping only for the few clicks Apple keeps for a person. By hand, the same steps are:
 
 1. Edit the config with your colors and tabs (see below).
 2. Add the stylesheet and `viewport-fit=cover` to your layout `<head>`:
@@ -84,6 +90,52 @@ Building with Inertia instead of ERB? `@ruby-native/react` and `@ruby-native/vue
 
 Every docs page serves markdown: append `.md` to the URL or request `Accept: text/markdown`. For an index of everything, fetch [rubynative.com/llms.txt](https://rubynative.com/llms.txt), or [llms-full.txt](https://rubynative.com/llms-full.txt) for the complete docs as a single file.
 
+### MCP server
+
+Docs tell an agent what to write. They don't tell it whether what it wrote works, and Ruby Native's signals fail silently on purpose: an app that doesn't recognize a `data-native-*` attribute ignores it. A typo renders nothing, raises nothing, and logs nothing, so it survives right up until someone opens the build and notices the missing button.
+
+`ruby_native mcp` closes that loop. It speaks [MCP](https://modelcontextprotocol.io) over stdin and stdout. Three tools answer from your working copy, with no account involved:
+
+| Tool | Answers |
+|---|---|
+| `check_views` | Which signals in your templates are misspelled, duplicated, or newer than the installed gem |
+| `lookup_signals` | Every `data-native-*` attribute, the gem version it needs, and the helper that emits it |
+| `validate_config` | What in `config/ruby_native.yml` the apps reject outright, and what they quietly ignore |
+
+Four more read your account, using the token `ruby_native login` already stored:
+
+| Tool | Answers |
+|---|---|
+| `status` | Where the app is on the way to the App Store, and what is in the way, with who clears each thing |
+| `config_errors` | What real devices reported failing over the last 48 hours, with the decode error behind each one |
+| `deployed_builds` | The build your users can actually install, and which signals it's too old to understand |
+| `build_status` | Whether one build succeeded, and the error if it didn't |
+
+The pairs are the point. `validate_config` says what *will* fail to decode; `config_errors` says what did, on which devices. `check_views` compares your templates against the gem in your Gemfile; `deployed_builds` compares them against the binary in the store, which is usually the answer to "the attribute is right but nothing happens on my phone".
+
+Full reference at [rubynative.com/docs/cli](https://rubynative.com/docs/cli#mcp-server). Register it in the project's `.mcp.json`, which Claude Code reads:
+
+```bash
+bundle exec ruby_native mcp install
+```
+
+Then say: set up Ruby Native in this app.
+
+Or, in a client that takes JSON:
+
+```json
+{
+  "mcpServers": {
+    "ruby-native": {
+      "command": "bundle",
+      "args": ["exec", "ruby_native", "mcp"]
+    }
+  }
+}
+```
+
+The rest stage things with Ruby Native and reach Apple only on a build or a click on the dashboard: `permissions_set`, `testers_add`, `icon_set`, `screenshots_setup`, `screenshots_capture`, `listing_push`, `listing_pull`, and `demo_account_set`, each the same as its CLI command. `submit` is the one tool that reaches Apple on its own: it takes two calls with a token in between, so the agent has to show you what is going before it can send it, and `withdraw` takes it back out of the queue until Apple approves. The first three tools never leave your machine; the rest send your CLI token to rubynative.com. `check_views` needs the `herb` gem, same as `ruby_native check`.
+
 ## License
 
 MIT.

data/config/signals.yml

@@ -7,6 +7,15 @@
 #
 # `owner: shell` marks a signal the app writes into the page rather than one
 # your views emit.
+#
+# `helper` names the helper that can emit the signal; `always: true` means every
+# call to that helper emits it. Without `always`, `check` cannot count a helper
+# call against the signal: native_fab_tag emits data-native-color only when you
+# pass `color:`, so counting it would report markup the view never renders.
+#
+# `renders_when` covers the helpers that can render nothing at all, naming the
+# keyword values they need in order to emit anything. A call that passes
+# something else, or something only known at request time, is left uncounted.
 ---
 signals:
   data-native-action:
@@ -19,6 +28,7 @@ signals:
   data-native-badge:
     since: "0.3.2"
     helper: native_badge_tag
+    always: true
     singleton: true
   data-native-badge-home:
     since: "0.3.2"
@@ -42,50 +52,63 @@ signals:
   data-native-fab:
     since: "0.8.0"
     helper: native_fab_tag
+    always: true
     singleton: true
   data-native-form:
     since: "0.1.2"
     helper: native_form_tag
+    always: true
     singleton: true
   data-native-haptic:
     since: "0.2.7"
     helper: native_haptic_data
+    always: true
   data-native-href:
     since: "0.4.0"
     helper: native_fab_tag
   data-native-icon:
     since: "0.4.0"
     helper: native_fab_tag
+    always: true
   data-native-identity:
     since: "0.12.0"
     helper: native_identity_tag
+    always: true
     singleton: true
   data-native-keyboard-toolbar:
     since: "0.15.0"
     helper: native_keyboard_tag
+    always: true
+    renders_when:
+      toolbar: false
     singleton: true
   data-native-menu:
     since: "0.14.0"
     helper: native_menu_tag
+    always: true
   data-native-menu-item:
     since: "0.4.0"
   data-native-navbar:
     since: "0.4.0"
     helper: native_navbar_tag
+    always: true
     singleton: true
   data-native-overscroll-bottom:
     since: "0.5.0"
     helper: native_overscroll_tag
+    always: true
     singleton: true
   data-native-overscroll-top:
     since: "0.5.0"
     helper: native_overscroll_tag
+    always: true
     singleton: true
   data-native-position:
     since: "0.4.0"
   data-native-presentation:
     since: "0.11.2"
     helper: native_presentation_tag
+    always: true
     singleton: true
   data-native-price:
     since: "0.5.3"
@@ -97,12 +120,14 @@ signals:
   data-native-push:
     since: "0.1.2"
     helper: native_push_tag
+    always: true
     singleton: true
   data-native-restore:
     since: "0.5.3"
   data-native-review:
     since: "0.9.3"
     helper: native_review_tag
+    always: true
   data-native-segment:
     since: "0.10.12"
   data-native-selected:
@@ -120,6 +145,9 @@ signals:
   data-native-tabs:
     since: "0.1.2"
     helper: native_tabs_tag
+    always: true
+    renders_when:
+      enabled: true
     singleton: true
   data-native-title:
     since: "0.4.0"

data/lib/generators/ruby_native/install_generator.rb

@@ -5,7 +5,44 @@ module RubyNative
 
       desc "Creates a Ruby Native config file at config/ruby_native.yml"
 
+      # The tab bar only appears with two or more tabs (the shell hides it
+      # otherwise), and a tab pointing at a path the app does not route 404s
+      # on first launch. Both failures land in the first five minutes, so tabs
+      # come from the app's own routes, and only from routes that exist.
+      MAX_TABS = 4
+
+      # Route segments that are never a tab: auth, framework, and Ruby Native's
+      # own mounts.
+      SKIPPED_SEGMENTS = %w[
+        rails up cable native assets manifest service-worker pwa admin api webhooks
+        session sessions sign_in sign_up signin signup login logout password passwords
+        registration registrations users auth oauth
+      ].freeze
+
+      TAB_ICONS = {
+        "" => "house",
+        "home" => "house",
+        "dashboard" => "house",
+        "profile" => "person",
+        "account" => "person",
+        "me" => "person",
+        "settings" => "gear",
+        "preferences" => "gear",
+        "inbox" => "envelope",
+        "messages" => "envelope",
+        "notifications" => "bell",
+        "search" => "magnifyingglass",
+        "calendar" => "calendar",
+        "events" => "calendar",
+        "orders" => "shippingbox",
+        "favorites" => "star",
+        "bookmarks" => "star"
+      }.freeze
+
+      DEFAULT_ICON = "list.bullet".freeze
+
       def copy_config
+        @tabs = proposed_tabs
         template "ruby_native.yml", "config/ruby_native.yml"
       end
 
@@ -41,23 +78,79 @@ module RubyNative
 
       def print_next_steps
         say ""
-        say "Ruby Native installed! Next steps:", :green
+        say "Ruby Native installed.", :green
+        say ""
+        say "  Tabs, from your routes: #{@tabs.map { |tab| "#{tab[:path]} (#{tab[:title]})" }.join(", ")}"
+        if @tabs.size < 2
+          say "  The tab bar stays hidden until config/ruby_native.yml has a second tab.", :yellow
+        else
+          say "  Change them in config/ruby_native.yml."
+        end
         say ""
-        say "  1. Edit config/ruby_native.yml with your app name, colors, and tabs"
-        say "  2. Add to your layout <head>:"
-        say "       <%= stylesheet_link_tag :ruby_native %>"
-        say "  3. Add viewport-fit=cover to your viewport meta tag:"
-        say "       <meta name=\"viewport\" content=\"width=device-width,initial-scale=1,viewport-fit=cover\">"
-        say "  4. Add to your layout <body>:"
-        say "       <%= native_tabs_tag %>"
-        say "       <%= native_identity_tag(current_user&.id) %>"
-        say "  5. Preview on your device:"
-        say "       bundle exec ruby_native preview"
+        say "By hand:"
+        say "  1. Add <%= stylesheet_link_tag :ruby_native %> to your layout <head>"
+        say "  2. Add viewport-fit=cover to your viewport meta tag"
+        say "  3. Add <%= native_tabs_tag %> and <%= native_identity_tag(current_user&.id) %> to your layout <body>"
+        say "  4. Preview on your phone: bundle exec ruby_native preview"
         say ""
         say "  Docs: https://rubynative.com/docs"
-        say "  AI agents: fetch https://rubynative.com/llms.txt for a docs index,"
-        say "  or https://rubynative.com/llms-full.txt for the full docs as plain text."
+        say "  Agents: https://rubynative.com/llms.txt for a docs index, llms-full.txt for all of it as plain text"
         say ""
+        say "Or hand it to your agent:", :green
+        say ""
+        say "    bundle exec ruby_native mcp install"
+        say ""
+        say "Then, in your agent: /mcp__ruby-native__ship"
+        say ""
+      end
+
+      private
+
+      def proposed_tabs
+        paths = routable_paths
+        paths = [ "/" ] if paths.empty?
+
+        paths.first(MAX_TABS).map do |path|
+          segment = path.delete_prefix("/")
+          { title: title_for(segment), path: path, icon: TAB_ICONS.fetch(segment, DEFAULT_ICON) }
+        end
+      end
+
+      # Routes a library draws into the app for its own use. Turbo's
+      # historical-location routes and the PWA manifest are GET, static, and
+      # one segment, so without this a fresh app's tabs were three Turbo
+      # internals.
+      LIBRARY_CONTROLLERS = %r{\A(turbo|rails|active_storage|action_mailbox|action_cable|action_text)/}
+
+      # Static, single-segment GET routes, root first, in the order the routes
+      # file declares them. Anything with a parameter, a glob, or a second
+      # segment is a page you reach from a tab, not a tab.
+      def routable_paths
+        paths = Rails.application.routes.routes.filter_map do |route|
+          next if route.respond_to?(:internal) && route.internal
+          next unless route.verb.to_s.match?(/\bGET\b/)
+          next if route.defaults[:controller].to_s.match?(LIBRARY_CONTROLLERS)
+
+          path = route.path.spec.to_s.sub(/\(\.:format\)\z/, "")
+          next unless path.start_with?("/")
+          next if path.match?(/[:*]/)
+
+          segments = path.delete_prefix("/").split("/")
+          next if segments.size > 1
+          next if SKIPPED_SEGMENTS.include?(segments.first)
+
+          path
+        end.uniq
+
+        paths.partition { |path| path == "/" }.flatten
+      rescue StandardError
+        []
+      end
+
+      def title_for(segment)
+        return "Home" if segment.empty?
+
+        segment.tr("_-", "  ").split.map(&:capitalize).join(" ")
       end
     end
   end

data/lib/generators/ruby_native/templates/ruby_native.yml

@@ -93,12 +93,11 @@ appearance:
 tabs:
   # Icons are SF Symbols on iOS and Material Icons on Android.
   # https://rubynative.com/docs/icons
-  - title: Home
-    path: /
-    icon: house
-  - title: Profile
-    path: /profile
-    icon: person
+<% @tabs.each do |tab| -%>
+  - title: <%= tab[:title] %>
+    path: <%= tab[:path] %>
+    icon: <%= tab[:icon] %>
+<% end -%>
 
   # Per-tab options (add to any tab above):
   #
@@ -145,7 +144,7 @@ tabs:
 #   team_id: ABCD123456
 # android:
 #   package: com.example.myapp
-#   # Play Console -> Setup -> App integrity -> App signing key certificate.
+#   # Google Play Console -> Setup -> App integrity -> App signing key certificate.
 #   cert_fingerprint: "AA:BB:CC:..."
 
 # Link only these path prefixes instead of the whole domain. Links outside

data/lib/ruby_native/cli/apple.rb

@@ -0,0 +1,76 @@
+require "ruby_native/cli/command"
+
+module RubyNative
+  class CLI
+    # The App Store Connect key. Only a person can mint it, in App Store
+    # Connect; this is how they hand it over without opening the dashboard.
+    # The file is read here and sent once; nothing reads it back, and the
+    # MCP tool takes a path for the same reason, so an agent never holds the
+    # key itself.
+    class Apple < Command
+      POLL_INTERVAL = 2
+      MAX_WAIT = 90
+
+      USAGE = "Usage: ruby_native apple key <path/to/AuthKey.p8> --key-id=KEY --issuer-id=ISSUER --team-id=TEAM".freeze
+
+      def run
+        ensure_authenticated!
+        app_id = app_id!
+
+        unless positional.first == "key" && positional[1] && flag("key-id") && flag("issuer-id") && flag("team-id")
+          puts USAGE
+          exit 1
+        end
+
+        finish(self.class.set_key(app_id, path: positional[1], key_id: flag("key-id"), issuer_id: flag("issuer-id"), team_id: flag("team-id")))
+      end
+
+      def self.set_key(app_id, path:, key_id:, issuer_id:, team_id:, wait: MAX_WAIT)
+        return Outcome.new(ok: false, text: "No file at #{path}.", data: {}) unless File.file?(path)
+
+        result = Mcp::Platform.patch("/api/v1/apps/#{app_id}/credentials",
+          { team_id: team_id, asc_key_id: key_id, asc_issuer_id: issuer_id, asc_key: File.read(path).strip })
+        return failure(result) unless result.ok?
+
+        settle(app_id, wait: wait)
+      end
+
+      # Validation runs against Apple in the background. Wait for it here,
+      # because "sent" is not the answer anybody wants; "Apple took it" is.
+      def self.settle(app_id, wait:)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + wait
+
+        loop do
+          result = Mcp::Platform.get("/api/v1/apps/#{app_id}/credentials")
+          return failure(result) unless result.ok?
+
+          state = result.value.is_a?(Hash) ? result.value : {}
+          case state["state"]
+          when "passed"
+            return success("Key verified: a Team key with the Admin role, and your agreements are signed. Ruby Native can sign and ship this app.", state)
+          when "failed"
+            return Outcome.new(ok: false, text: "Apple rejected the key: #{state["error"]}", data: state)
+          end
+
+          if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+            return success("Still checking the key with Apple. Read `ruby_native status` in a minute; it says when the key checks out.", state)
+          end
+
+          pause
+        end
+      end
+
+      # Two seconds between reads, and none in a test.
+      def self.pause
+        sleep POLL_INTERVAL unless @sleepless
+      end
+
+      def self.stub_const_sleep
+        @sleepless = true
+        yield
+      ensure
+        @sleepless = false
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/check/signal_collector.rb

@@ -1,29 +1,131 @@
+require "prism"
+
 module RubyNative
   class CLI
     class Check
-      # Walks a parsed template and records every data-native-* attribute with
-      # the lines it appears on. Attribute names built out of ERB cannot be
-      # resolved statically and are skipped rather than guessed at.
+      # Walks a parsed template and records every data-native-* signal with the
+      # lines it appears on, whether the view writes the attribute by hand or
+      # calls the helper that emits it. Attribute names built out of ERB cannot
+      # be resolved statically and are skipped rather than guessed at.
       #
       # Subclasses Herb::Visitor, so this file is only loaded once `herb` is
       # known to be present.
       class SignalCollector < Herb::Visitor
-        attr_reader :signals
+        COMMENT_OPENING = "<%#".freeze
 
         def initialize
           @signals = {}
           super
         end
 
+        # Attributes and helper calls arrive from different visits, so the lines
+        # for one signal are not collected in document order.
+        def signals
+          @signals.transform_values(&:sort)
+        end
+
         def visit_html_attribute_name_node(node)
           name = node.children.filter_map { |child| child.content if child.respond_to?(:content) }.join
 
-          if name.start_with?("data-native-")
-            (@signals[name] ||= []) << node.location.start.line
-          end
+          record(name, node.location.start.line) if name.start_with?("data-native-")
+
+          super
+        end
+
+        def visit_erb_content_node(node)
+          record_helper_calls(node)
+
+          super
+        end
+
+        # `<%= native_navbar_tag "Orders" do |navbar| %>` opens a block, so its
+        # Ruby arrives here instead, without the `end` that would let it parse
+        # on its own.
+        def visit_erb_block_node(node)
+          record_helper_calls(node, suffix: "\nend")
 
           super
         end
+
+        private
+
+        def record_helper_calls(node, suffix: "")
+          return if node.tag_opening&.value == COMMENT_OPENING
+
+          source = node.content&.value
+          return if source.nil?
+
+          # Ruby that does not parse is the app's own syntax error, which Rails
+          # raises on render and `herb lint` reports properly. Staying quiet
+          # here keeps `check` to the one job it claims.
+          result = Prism.parse(source + suffix)
+          return unless result.success?
+
+          line = node.location.start.line
+          calls(result.value).each do |call|
+            helper = call.name.to_s
+            signals = RubyNative::Signals.signals_for_helper(helper)
+            next if signals.empty? || !renders?(call, helper)
+
+            signals.each { |signal| record(signal, line) }
+          end
+        end
+
+        # A helper that can render nothing only counts when its arguments prove
+        # it renders. `native_tabs_tag(enabled: @show)` decides at request time,
+        # so it is skipped rather than guessed at, the same as an attribute name
+        # built out of ERB.
+        def renders?(call, helper)
+          condition = RubyNative::Signals.render_condition(helper)
+          return true unless condition
+
+          condition.all? do |keyword, required|
+            given = keyword_value(call, keyword)
+
+            given.nil? ? true : given == required
+          end
+        end
+
+        # nil when the keyword is absent, which leaves the helper's own default
+        # in charge. :unknown for anything that is not a literal, so it never
+        # equals what the condition requires.
+        def keyword_value(call, keyword)
+          pairs = call.arguments&.arguments&.grep(Prism::KeywordHashNode)&.flat_map(&:elements)
+          return nil if pairs.nil?
+
+          assoc = pairs.find do |pair|
+            pair.is_a?(Prism::AssocNode) && pair.key.is_a?(Prism::SymbolNode) &&
+              pair.key.unescaped == keyword.to_s
+          end
+          return nil unless assoc
+
+          case assoc.value
+          when Prism::TrueNode then true
+          when Prism::FalseNode then false
+          else :unknown
+          end
+        end
+
+        # A literal in an argument is not a call, so `placeholder: "native_tabs_tag"`
+        # reads as the string it is. That is the whole reason for parsing rather
+        # than scanning the source for helper names.
+        def calls(root)
+          found = []
+          stack = [root]
+
+          while (node = stack.pop)
+            next unless node.is_a?(Prism::Node)
+
+            found << node if node.is_a?(Prism::CallNode)
+            stack.concat(node.compact_child_nodes)
+          end
+
+          found
+        end
+
+        def record(name, line)
+          (@signals[name] ||= []) << line
+        end
       end
     end
   end

data/lib/ruby_native/cli/check.rb

@@ -30,7 +30,43 @@ module RubyNative
 
         check = new([], paths: paths)
 
-        check.send(:template_files).flat_map { |file| check.send(:check_file, file) }
+        template_files(paths: paths).flat_map { |file| check.send(:check_file, file) }
+      end
+
+      # The templates a run covers. Public so a caller can count them without
+      # running the checks, and so there is one definition of what gets scanned.
+      def self.template_files(paths: DEFAULT_PATHS)
+        paths.flat_map { |path| Dir.glob(File.join(path, "**", "*.html.erb")) }.sort
+      end
+
+      # The report `run` prints, as lines, so another front end renders
+      # offenses the way the CLI does instead of inventing a second format.
+      def self.report_lines(files, offenses)
+        lines = []
+
+        offenses.group_by(&:file).sort.each do |file, file_offenses|
+          lines << file
+          file_offenses.sort_by(&:line).each do |offense|
+            location = "#{offense.line}:".ljust(5)
+            marker = offense.severity.to_s.ljust(8)
+            lines << "  #{location}#{marker}#{offense.message}"
+          end
+          lines << ""
+        end
+
+        lines << summary_line(files, offenses)
+      end
+
+      def self.summary_line(files, offenses)
+        errors, warnings = offenses.partition { |offense| offense.severity == :error }
+        summary = "Checked #{files.size} #{files.size == 1 ? "template" : "templates"}"
+
+        if offenses.empty?
+          "#{summary}. No problems found."
+        else
+          "#{summary}: #{errors.size} #{errors.size == 1 ? "error" : "errors"}, " \
+            "#{warnings.size} #{warnings.size == 1 ? "warning" : "warnings"}."
+        end
       end
 
       def self.herb_available?
@@ -79,7 +115,7 @@ module RubyNative
       end
 
       def template_files
-        @paths.flat_map { |path| Dir.glob(File.join(path, "**", "*.html.erb")) }.sort
+        self.class.template_files(paths: @paths)
       end
 
       # --- Per-file checks ---
@@ -158,7 +194,11 @@ module RubyNative
         end
 
         used = signals_in(files)
-        PLATFORMS.flat_map { |platform| deployed_offenses_for(platform, app_id, used) }
+        offenses = PLATFORMS.flat_map { |platform| deployed_offenses_for(platform, app_id, used) }
+        if (scan = Permissions.scan_without_camera(app_id))
+          offenses << Offense.new(file: scan[0], line: scan[1], severity: :warning, message: Permissions.scan_without_camera_message(*scan).sub(/\A\S+ /, ""))
+        end
+        offenses
       end
 
       def deployed_offenses_for(platform, app_id, used)
@@ -222,25 +262,7 @@ module RubyNative
       # --- Reporting ---
 
       def report(files, offenses)
-        errors, warnings = offenses.partition { |offense| offense.severity == :error }
-
-        offenses.group_by(&:file).sort.each do |file, file_offenses|
-          puts file
-          file_offenses.sort_by(&:line).each do |offense|
-            location = "#{offense.line}:".ljust(5)
-            marker = offense.severity.to_s.ljust(8)
-            puts "  #{location}#{marker}#{offense.message}"
-          end
-          puts ""
-        end
-
-        summary = "Checked #{files.size} #{files.size == 1 ? "template" : "templates"}"
-        if offenses.empty?
-          puts "#{summary}. No problems found."
-        else
-          puts "#{summary}: #{errors.size} #{errors.size == 1 ? "error" : "errors"}, " \
-               "#{warnings.size} #{warnings.size == 1 ? "warning" : "warnings"}."
-        end
+        puts self.class.report_lines(files, offenses)
       end
 
       def parse_paths(argv)