guard-status 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8d1d43c035152dcc6fe5d7e944e429a6ffb1503099b12b5602a4020b279e9c86
+  data.tar.gz: f9718158df1ba30f57587dc3afa499a32938847d80caf5abe0b9167dcf9a092e
+SHA512:
+  metadata.gz: e09f1996627a242367636170748283fa3394e528636cfa9a4bc2c5ea8b1a69c0ad110c77900463e045790c0e422ce64c8818dd363f92b0d730060141c464f3e8
+  data.tar.gz: 742ad2486c3e563f8ba6ccec669ec740e60a6a784833b40452436c06f8d6acad98def94d2eae8d76e02d5287eadf4ec0e3e1929f47ab22787300bf7105164ac2

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-10-26
+
+### ✨ Features
+- **`guard :status` plugin:** prints one status line after the other guards have run.
+- **`rubocop:` and `rspec:` segments:** read the JSON reports of those tools.
+- **`file:` segments:** read `<state> <args>` status files, with `states:` for custom states.
+- **`title`, `prefix`, `title_color` and `notify` options.**
+- **Print only when needed:** prints after a change only when another guard has run for it, learned from Guard's callbacks instead of the changed files.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"guard-status" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["joesharp13@gmail.com"](mailto:"joesharp13@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Joe Sharp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,143 @@
+# guard-status
+
+A one line status to complete your Guard output. Ideal when you have more than one Guard Plugin.
+
+![🔮 Status:  RuboCop: ✅ | Tests: ❌ (2) | Docs: ✅ | Bench: 🐢 (0.47s vs 0.32s)](docs/status.svg)
+
+## Setup
+
+```ruby
+# Gemfile
+group :development do
+  gem 'guard-status'
+end
+```
+
+```sh
+bundle exec guard init status   # adds `guard :status` to your Guardfile
+bundle exec guard
+```
+
+> [!IMPORTANT]
+> **Put `guard :status` last in your Guardfile.** Guard runs plugins in the order they appear, so the last one
+> sees what the others just recorded.
+
+## Segments
+
+Each segment is a label and where its result comes from. They are shown in the order given:
+
+```ruby
+guard :status, segments: {
+  'RuboCop' => { rubocop: 'tmp/rubocop.json' },
+  'Tests'   => { rspec: 'tmp/rspec.json' },
+  'Docs'    => 'tmp/docs_status.txt',
+  'Bench'   => { file: 'tmp/benchmark_status.txt',
+                 states: { slow: { display: '🐢 (%{1}s vs %{2}s)', severity: :failed } } }
+}
+```
+
+Without `segments`, the RuboCop and Tests segments above are shown.
+
+### RuboCop and RSpec
+
+These read the JSON reports of the tools, so the other guards need to write them. Put `--format json --out <path>`
+after any other format:
+
+```ruby
+guard :rubocop, cli: '--format progress --format json --out tmp/rubocop.json'
+guard :rspec, cmd: 'bundle exec rspec --format progress --format json --out tmp/rspec.json'
+```
+
+| Segment | Shows |
+|---|---|
+| no problems | ✅ |
+| problems | ⚠️ (3) offenses for RuboCop, ❌ (2) failures for RSpec (errors outside examples count) |
+| no report yet | … |
+| a report that can't be read | ? |
+
+### Status files
+
+A string, or `file:`, reads a status file. The first word is the state and the rest are its arguments:
+
+```
+ok
+slow 0.47 0.32
+error something went wrong
+```
+
+[guard-boondoc](https://github.com/joe-sharp/guard-boondoc) writes this format with its `status_file` option, and
+any script can write it.
+
+| State | Shows | Severity |
+|---|---|---|
+| `ok` | ✅ | success |
+| `error` | ❌ | failed |
+| an empty or missing file | … | pending |
+| anything not declared | `? <state>` | failed |
+| a file that can't be read | `?` | failed |
+
+Control characters in the file, such as terminal escape sequences, are treated as spaces.
+
+### Your own states
+
+Declare a state with the `states:` option of a `file:` segment. `display` is what to show, in which `%{1}`, `%{2}`
+and so on stand for the arguments after the state, counting from 1, and `severity` is one of `:success`,
+`:pending` or `:failed`:
+
+```ruby
+'Card' => { file: 'tmp/card_status.txt',
+            states: { changed: { display: '🔄', severity: :failed } } }
+```
+
+Declaring `ok` or `error` replaces the built-in. A typo in a status file shows up as `? slwo` instead of passing
+silently. A state without a `display` or a valid `severity`, or a display that uses `%{0}`, raises an
+`ArgumentError` when Guard starts.
+
+## Options
+
+| Option | Default | |
+|---|---|---|
+| `segments` | RuboCop and Tests | the labels and their sources, in order |
+| `title` | `'Status'` | |
+| `prefix` | `'🔮'` | shown before the title |
+| `title_color` | `93` | `:black`, `:red`, `:green`, `:yellow`, `:blue`, `:magenta`, `:cyan` or `:white` (0 to 7), a 256-color number from 0 to 255, or `nil` for none. The title is plain when stdout is not a terminal or `NO_COLOR` is set |
+| `notify` | `false` | also send the summary as a Guard notification, with the worst severity as its image |
+
+For example, to change the title, prefix and title color:
+
+```ruby
+guard :status, title: 'Guard Status', prefix: '💻', title_color: :green
+```
+
+![💻 Guard Status:  RuboCop: ✅ | Tests: ✅](docs/modified-status.svg)
+
+To see the 256 colors and pick a number for `title_color`, run `bundle exec guard-status-colors`.
+
+> [!IMPORTANT]
+> **Always put quotes around emoji** (`prefix: '💻'`, not `prefix: 💻`). The Guardfile is Ruby, and an unquoted
+> emoji is parsed as a variable or method name, so it will raise an error instead of printing.
+
+## When it prints
+
+On start, reload and run all, and again whenever another guard starts a run in response to a change. It learns
+this from the callbacks Guard fires before each task (`run_on_modifications_begin` and the like), not from the files
+that changed, so a file nobody is watching, or one a tool writes as a side effect such as `.rspec_status`, prints
+nothing. A guard that goes on to fail still counts, since the callback fires before the run. One batch of changes
+prints one line, however many guards ran.
+
+RuboCop and RSpec only run the changed files when a file changes, and overwrite their reports, so those segments
+count just those files until a full run, such as `all_after_pass`, writes the report again.
+
+The plugin only reports, it never fails a Guard task. Because it prints from its own turn in the batch, it has to
+come after the guards it reports on, as described in Setup. Any `watch` lines you give it narrow which batches
+reach it.
+
+## Development
+
+```sh
+bundle exec rake   # specs and RuboCop
+```
+
+## License
+
+MIT, see [LICENSE.txt](LICENSE.txt).

data/bin/guard-status-colors

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Prints the 256 colors a `title_color:` number can pick, each number in its own color, 20 to a row.
+COLUMNS = 20
+
+(0..255).each_slice(COLUMNS) do |row|
+  puts row.map { |number| "\e[38;5;#{number}m#{number.to_s.rjust(3)}\e[0m" }.join(' ')
+end

data/lib/guard/status/json_reader.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'guard/compat/plugin'
+require_relative 'result'
+
+module Guard
+  class Status < Plugin
+    # Reads a count of problems from the `summary` of a tool's JSON report. Subclasses say how to find the count in it
+    # and how to show it.
+    class JsonReader
+      attr_reader :path
+
+      # @param path [String] the JSON report the tool writes
+      def initialize(path)
+        @path = path
+      end
+
+      # @return [Result]
+      def result
+        summary = JSON.parse(File.read(path))
+        summary = summary['summary'] if summary.is_a?(Hash)
+        return Result.unknown unless summary.is_a?(Hash)
+
+        count = count(summary)
+        return Result.unknown unless count.is_a?(Integer)
+
+        count.zero? ? Result.success : failure(count)
+      rescue Errno::ENOENT
+        Result.pending
+      rescue JSON::ParserError, SystemCallError
+        Result.unknown
+      end
+
+      private
+
+      def count(_summary) = raise(NotImplementedError)
+      def failure(_count) = raise(NotImplementedError)
+    end
+
+    # RuboCop's offenses, from `--format json --out <path>`.
+    class RubocopReader < JsonReader
+      private
+
+      def count(summary) = summary['offense_count']
+      def failure(count) = Result.new(:failed, "⚠️ (#{count})")
+    end
+
+    # RSpec's failures, including errors raised outside any example, from `--format json --out <path>`.
+    class RspecReader < JsonReader
+      private
+
+      def count(summary)
+        failures = summary['failure_count']
+        errors = summary['errors_outside_of_examples_count'] || 0
+        failures + errors if failures.is_a?(Integer) && errors.is_a?(Integer)
+      end
+
+      def failure(count) = Result.new(:failed, "❌ (#{count})")
+    end
+  end
+end

data/lib/guard/status/line.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'guard/compat/plugin'
+require_relative 'result'
+
+module Guard
+  class Status < Plugin
+    # The status line made from each segment's result.
+    class Line
+      # The names are the first eight of the 256 colors, so a name and its number are the same color.
+      COLORS = { black: 0, red: 1, green: 2, yellow: 3, blue: 4, magenta: 5, cyan: 6, white: 7 }.freeze
+
+      # @param results [Hash{String => Result}] in the order to show them
+      # @param title [String]
+      # @param prefix [String] shown before the title
+      # @param color [Symbol, Integer, nil] one of {COLORS}, a 256-color number from 0 to 255, or nil to leave the
+      #   title uncolored
+      # @param colorize [Boolean] false to print the title plain whatever the color, for output that is not a terminal
+      # @raise [ArgumentError] when the color is neither
+      def initialize(results, title:, prefix:, color: 93, colorize: true)
+        unless color.nil? || COLORS.key?(color) || (color.is_a?(Integer) && color.between?(0, 255))
+          raise ArgumentError, "unknown color #{color.inspect}, use #{COLORS.keys.join(', ')} or a number from 0 to 255"
+        end
+
+        @results = results
+        @title = title
+        @prefix = prefix
+        @color = color
+        @colorize = colorize
+      end
+
+      # @return [String] the labels and their results, without the title
+      def summary
+        @results.map { |label, result| "#{label}: #{result.text}" }.join(' | ')
+      end
+
+      # @return [Symbol] the worst severity of any result
+      def severity
+        @results.values.map(&:severity).max_by { |severity| SEVERITIES.index(severity) } || :success
+      end
+
+      # @return [String]
+      def to_s
+        "\n#{@prefix}#{colored_title}  #{summary}"
+      end
+
+      private
+
+      def colored_title
+        return "#{@title}:" unless @color && @colorize
+
+        "\e[38;5;#{COLORS.fetch(@color, @color)}m#{@title}:\e[0m"
+      end
+    end
+  end
+end

data/lib/guard/status/result.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'guard/compat/plugin'
+
+module Guard
+  class Status < Plugin
+    # What one segment shows, and how bad it is: a severity (`:success`, `:pending` or `:failed`, Guard's own
+    # notification types) and the text to display.
+    Result = Data.define(:severity, :text) do
+      def self.success = new(:success, '✅')
+
+      # Nothing recorded yet, for example before the first run.
+      def self.pending = new(:pending, '…')
+
+      # Something was recorded, but it could not be understood.
+      def self.unknown(detail = nil) = new(:failed, ['?', detail].compact.join(' '))
+    end
+
+    SEVERITIES = %i[success pending failed].freeze
+  end
+end

data/lib/guard/status/segment.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'guard/compat/plugin'
+require_relative 'json_reader'
+require_relative 'state_file'
+
+module Guard
+  class Status < Plugin
+    # One labelled part of the line, and where its result comes from.
+    class Segment
+      SOURCES = { rubocop: RubocopReader, rspec: RspecReader, file: StateFile }.freeze
+
+      attr_reader :label
+
+      # @param label [String] shown before the result
+      # @param config [String, Hash] a path to a status file, or a Hash with exactly one of `rubocop:`, `rspec:`
+      #   or `file:` set to a path, and for `file:` optionally `states:`
+      # @raise [ArgumentError] when the configuration cannot be made sense of
+      # @return [Segment]
+      def self.build(label, config)
+        config = { file: config } if config.is_a?(String)
+        raise ArgumentError, "segment #{label.inspect} must be a path or a Hash" unless config.is_a?(Hash)
+
+        config = config.transform_keys(&:to_sym)
+        source = sources(label, config)
+        new(label, reader(source, config))
+      end
+
+      def self.sources(label, config)
+        sources = SOURCES.keys & config.keys
+        raise ArgumentError, "segment #{label.inspect} needs exactly one of #{SOURCES.keys.inspect}" unless sources.one?
+
+        extra = config.keys - sources - (sources == [:file] ? [:states] : [])
+        raise ArgumentError, "segment #{label.inspect} has unknown keys #{extra.inspect}" unless extra.empty?
+
+        sources.first
+      end
+      private_class_method :sources
+
+      def self.reader(source, config)
+        source == :file ? StateFile.new(config[:file], config.fetch(:states, {})) : SOURCES[source].new(config[source])
+      end
+      private_class_method :reader
+
+      def initialize(label, reader)
+        @label = label.to_s
+        @reader = reader
+      end
+
+      # @return [Result]
+      def result = @reader.result
+
+      # @return [String] the file this segment reads
+      def path = @reader.path
+    end
+  end
+end

data/lib/guard/status/state_file.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'guard/compat/plugin'
+require_relative 'result'
+
+module Guard
+  class Status < Plugin
+    # Reads a status file: the first word is the state, the rest are its arguments.
+    #
+    #   ok
+    #   slow 0.47 0.32
+    #   error something went wrong
+    #
+    # `ok` and `error` are built in. Other states are declared with a display, in which `%{1}`, `%{2}` and so on
+    # stand for the arguments, counting from 1, and a severity. A state that is not declared shows as `? <state>` and
+    # counts as failed. A file that cannot be read shows as `?`, and control characters in it, such as terminal escape
+    # sequences, are treated as spaces.
+    class StateFile
+      BUILT_IN = {
+        'ok' => { display: '✅', severity: :success },
+        'error' => { display: '❌', severity: :failed }
+      }.freeze
+      ARGUMENT = /%\{(\d+)\}/
+
+      attr_reader :path
+
+      # @param path [String] the status file
+      # @param states [Hash{Symbol, String => Hash}] states to add to, or override, the built-in ones
+      # @raise [ArgumentError] when a state lacks a display, numbers its arguments from 0, or has a severity that is
+      #   not Guard's
+      def initialize(path, states = {})
+        @path = path
+        @states = BUILT_IN.merge(states.to_h { |name, definition| [name.to_s, normalize(name, definition)] })
+      end
+
+      # @return [Result]
+      def result
+        state, *arguments = File.read(path).scrub.gsub(/[[:cntrl:]]/, ' ').split
+        return Result.pending unless state
+
+        definition = @states[state] or return Result.unknown(state)
+        Result.new(definition[:severity], fill(definition[:display], arguments))
+      rescue Errno::ENOENT
+        Result.pending
+      rescue SystemCallError
+        Result.unknown
+      end
+
+      private
+
+      def fill(display, arguments)
+        display.gsub(ARGUMENT) { arguments[Regexp.last_match(1).to_i - 1] }
+      end
+
+      def normalize(name, definition)
+        definition = definition.to_h.transform_keys(&:to_sym)
+        raise ArgumentError, "state #{name.inspect} needs a display, a String" unless definition[:display].is_a?(String)
+        unless SEVERITIES.include?(definition[:severity])
+          raise ArgumentError, "state #{name.inspect} needs a severity, one of #{SEVERITIES.inspect}"
+        end
+
+        check_arguments(name, definition[:display])
+
+        definition
+      end
+
+      def check_arguments(name, display)
+        return unless display.scan(ARGUMENT).any? { |(number)| number.to_i < 1 }
+
+        raise ArgumentError, "state #{name.inspect} counts its arguments from 1"
+      end
+    end
+  end
+end

data/lib/guard/status/templates/Guardfile

@@ -0,0 +1,4 @@
+guard :status, segments: {
+  'RuboCop' => { rubocop: 'tmp/rubocop.json' },
+  'Tests' => { rspec: 'tmp/rspec.json' }
+}

data/lib/guard/status/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Guard
+  module StatusVersion
+    VERSION = '0.1.0'
+  end
+end

data/lib/guard/status.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'guard/compat/plugin'
+require_relative 'status/version'
+require_relative 'status/line'
+require_relative 'status/segment'
+
+module Guard
+  # Prints one line summarizing what the other guards recorded.
+  #
+  # Guard runs plugins in the order of the Guardfile, so this one goes last. It prints after a change only when
+  # another guard started a run for it, which it learns from the callbacks Guard fires before each task.
+  #
+  # @example Guardfile
+  #   guard :status, segments: {
+  #     'RuboCop' => { rubocop: 'tmp/rubocop.json' },
+  #     'Tests'   => { rspec: 'tmp/rspec.json' },
+  #     'Docs'    => 'tmp/docs_status.txt',
+  #     'Bench'   => { file: 'tmp/benchmark_status.txt',
+  #                    states: { slow: { display: '🐢 (%{1}s vs %{2}s)', severity: :failed } } }
+  #   }
+  class Status < Plugin
+    DEFAULT_SEGMENTS = {
+      'RuboCop' => { rubocop: 'tmp/rubocop.json' },
+      'Tests' => { rspec: 'tmp/rspec.json' }
+    }.freeze
+    # The tasks that run in response to changes. `_begin` fires even when the run goes on to fail, unlike `_end`.
+    RUN_EVENTS = %i[run_all_begin run_on_modifications_begin run_on_additions_begin run_on_removals_begin].freeze
+
+    # @param options [Hash]
+    # @option options [Hash{String => String, Hash}] :segments the labels and where their results come from, in the
+    #   order to show them
+    # @option options [String] :title ('Status')
+    # @option options [String] :prefix ('🔮') shown before the title
+    # @option options [Symbol, Integer, nil] :title_color (93) a color name from {Line::COLORS}, a 256-color
+    #   number from 0 to 255, or nil for none
+    # @option options [Boolean] :notify (false) also send the summary as a Guard notification
+    # @raise [ArgumentError] when a segment cannot be made sense of
+    def initialize(options = {})
+      super
+      @segments = options.fetch(:segments, DEFAULT_SEGMENTS).map { |label, config| Segment.build(label, config) }
+      self.watchers = [Guard::Watcher.new(/./)] if watchers.empty?
+      @title = options.fetch(:title, 'Status')
+      @others_ran = false
+      @followed = {}.compare_by_identity
+      build_line({}) # fail on a bad color when Guard starts
+    end
+
+    # @return [void]
+    def start
+      follow_others
+      print_status
+    end
+
+    # @return [void]
+    def reload
+      follow_others
+      print_status
+    end
+
+    # @return [void]
+    def run_all
+      @others_ran = false
+      print_status
+    end
+
+    # Prints if another guard has run since the last time, whatever changed.
+    #
+    # @return [void]
+    def run_on_modifications(_paths = nil)
+      return unless @others_ran
+
+      @others_ran = false
+      print_status
+    end
+    alias run_on_additions run_on_modifications
+    alias run_on_removals run_on_modifications
+
+    private
+
+    # Listens for the other plugins starting a run. Guard reuses the plugins on reload, but this is repeated in case
+    # the list has changed, and @followed gives each plugin one callback.
+    def follow_others
+      Guard.state.session.plugins.all.each do |plugin|
+        next if plugin.equal?(self) || @followed.key?(plugin)
+
+        @followed[plugin] = true
+        # Callbacks are kept per plugin class, and that is where Guard looks when it fires them
+        plugin.class.add_callback(method(:other_ran), plugin, RUN_EVENTS)
+      end
+    end
+
+    def other_ran(*)
+      @others_ran = true
+    end
+
+    def print_status
+      line = build_line(@segments.to_h { |segment| [segment.label, segment.result] })
+      $stdout.puts line
+      Compat::UI.notify(line.summary, title: @title, image: line.severity) if options[:notify]
+    end
+
+    def build_line(results)
+      Line.new(results, title: @title, prefix: options.fetch(:prefix, '🔮'),
+                        color: options.fetch(:title_color, 93), colorize: color?)
+    end
+
+    # Colors only a terminal, and not when NO_COLOR asks for none (https://no-color.org).
+    def color?
+      $stdout.tty? && ENV.fetch('NO_COLOR', '').empty?
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: guard-status
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joe Sharp
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+- !ruby/object:Gem::Dependency
+  name: guard-compat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: guard-status reads what your other Guard plugins recorded, such as RuboCop
+  and RSpec JSON reports or small status files, and prints a single line summarizing
+  them after every run.
+email:
+- joesharp13@gmail.com
+executables:
+- guard-status-colors
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- bin/guard-status-colors
+- lib/guard/status.rb
+- lib/guard/status/json_reader.rb
+- lib/guard/status/line.rb
+- lib/guard/status/result.rb
+- lib/guard/status/segment.rb
+- lib/guard/status/state_file.rb
+- lib/guard/status/templates/Guardfile
+- lib/guard/status/version.rb
+homepage: https://github.com/joe-sharp/guard-status
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/joe-sharp/guard-status
+  source_code_uri: https://github.com/joe-sharp/guard-status/tree/v0.1.0
+  bug_tracker_uri: https://github.com/joe-sharp/guard-status/issues
+  changelog_uri: https://github.com/joe-sharp/guard-status/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Guard plugin that prints one status line for all your other guards
+test_files: []