brut 0.16.0.pre.pre → 0.17.0

data/lib/brut/tui/terminal_theme.rb

@@ -0,0 +1,140 @@
+# A terminal theme is a set of semantic styles for the terminal that
+# map to actual colors or styles based on the terminal's metadata or
+# the user's preferences or both.
+#
+# This class is coupled to the behavior of ANSI escape
+# codes in the terminal, in that they aren't markup, but more
+# like drawing with a pen.
+
+# That said, this class' API does abstract from the codes
+# themselves and creates a semantic layer, for example
+# the definition of "succes" or "weak".
+
+# For subclass implementors, there are various private
+# methods that do encapsulate the ANSI escape codes, and these
+# can be used or overridden.
+#
+# This particular implementation avoids the use of black or white, and uses
+# the normal ANSI colors.  This should, in theory, work with any terminal
+# theme where all colors are legible on the chosen background.
+class Brut::TUI::TerminalTheme
+
+  def self.based_on_background(terminal)
+    if dark_background?(terminal)
+      Brut::TUI::Themes::Dark.new(terminal)
+    else
+      Brut::TUI::Themes::Light.new(terminal)
+    end
+  end
+
+  def self.dark_background?(terminal)
+    r, g, b = terminal.background_color.map { it / 255.0 }
+    luminance = (0.21 * r) + (0.72 * g) + (0.07 * b)
+
+    return luminance < 0.5  
+  end
+
+  def initialize(terminal)
+    @terminal = terminal
+  end
+
+  # Returns a string with its markup turned into escape codes.
+  # Note that due to the way ANSI escape codes work, the state
+  # of the terminal may not be in the same state you found it.
+  #
+  # This method tries to turn features on and off (e.g. after a bold
+  # string, the codes to turn off bold are applied), but if a subclass
+  # mixes colors and styles, any text output after this one may
+  # not look like the text before it.
+  def with_markup(string, text: :normal, reset: true)
+    result = +""
+    result << send(text)
+    Brut::TUI::MarkupString.from_string(string).parse do |directive, value|
+      case directive
+      in :start
+        case value
+        in :bold
+          result << bold
+        in :strike
+          result << strike
+        in :code
+          result << code
+        in :weak
+          result << weak
+        end
+      in :stop
+        case value
+        in :bold
+          result << bold_off << send(text)
+        in :strike
+          result << strike_off << send(text)
+        in :code
+          result << code_off << send(text)
+        in :weak
+          result << weak_off << send(text)
+        end
+      in :text
+        result << value
+      end
+    end
+    if reset
+      result << self.reset
+    end
+    result
+  end
+
+  def success = bold + bright_green
+  def error   = bold + bright_red
+  def warning = bold + yellow
+
+  def bold     = esc("1")
+  def bold_off = normal
+
+  def bright     = esc("1")
+  def bright_off = normal
+
+  def italic     = esc("3")
+  def italic_off = esc("23")
+
+  def strike     = esc("9")
+  def strike_off = esc("29")
+
+  def weak     = esc("2")
+  def weak_off = normal
+
+  def code     = underline
+  def code_off = underline_off
+
+  def normal = esc("22")
+
+  def reset = esc("0")
+
+  def heading = bold + underline + bright_blue
+
+private
+
+  def underline     = esc("4")
+  def underline_off = esc("24")
+
+  def black   = esc("30")
+  def red     = esc("31")
+  def green   = esc("32")
+  def yellow  = esc("33")
+  def blue    = esc("34")
+  def magenta = esc("35")
+  def cyan    = esc("36")
+  def white   = esc("37")
+
+  def bright_black   = esc("90")
+  def bright_red     = esc("91")
+  def bright_green   = esc("92")
+  def bright_yellow  = esc("93")
+  def bright_blue    = esc("94")
+  def bright_magenta = esc("95")
+  def bright_cyan    = esc("96")
+  def bright_white   = esc("97")
+
+  def esc(code)
+    "\e[#{code}m"
+  end
+end

data/lib/brut/tui/themes/dark.rb

@@ -0,0 +1,14 @@
+# A theme designed to work on a dark background terminal.
+class Brut::TUI::Themes::Dark < Brut::TUI::TerminalTheme
+  def black         = esc("38;2;96;96;96")
+  def bright_black  = esc("38;2;128;128;128")
+  def white         = esc("38;2;233;233;233")
+  def bright_white  = esc("38;2;255;255;255")
+  def yellow        = esc("38;2;191;191;0")
+  def bright_yellow = esc("38;2;255;255;0")
+  def normal        = super + white
+  def code          = esc("38;2;0;255;0")
+  def code_off      = normal
+  def bright        = bright_white
+  def bright_off    = normal
+end

data/lib/brut/tui/themes/light.rb

@@ -0,0 +1,17 @@
+# A theme designed to work on a white background terminal.
+class Brut::TUI::Themes::Light < Brut::TUI::TerminalTheme
+  def black         = esc("38;2;0;0;0")
+  def bright_black  = esc("38;2;64;64;64")
+  def bright_white  = esc("38;2;128;128;128")
+  def white         = esc("38;2;191;191;191")
+  def yellow        = esc("38;2;191;191;0")
+  def bright_yellow = esc("38;2;255;255;0")
+  def normal        = super + black
+  def code          = esc("38;2;0;128;0")
+  def code_off      = normal
+  def green         = esc("38;2;25;105;0")
+  def bright_green  = esc("38;2;34;155;0")
+  def bright        = bright_blue
+  def bright_off    = normal
+end
+

data/lib/brut/tui/themes/none.rb

@@ -0,0 +1,9 @@
+# A theme without any ANSI styling at all.  This is suitable
+# for showing to a user who does not want any colors or styles, but
+# still wants to see output in a somewhat conventional way.
+class Brut::TUI::Themes::None < Brut::TUI::TerminalTheme
+  def esc(*) = ""
+end
+
+
+

data/lib/brut/tui/themes.rb

@@ -0,0 +1,5 @@
+module Brut::TUI::Themes
+  autoload(:Light , "brut/tui/themes/light")
+  autoload(:Dark  , "brut/tui/themes/dark")
+  autoload(:None  , "brut/tui/themes/none")
+end

data/lib/brut/tui.rb

@@ -0,0 +1,15 @@
+module Brut
+  # Brut provides a basic API for creating rich text user interfaces. Currently, Brut
+  # provides {Brut::TUI::Script} to create more user-friendly scripts like `bin/setup` or
+  # `bin/ci`.
+  module TUI
+    autoload(:EventLoop, "brut/tui/event_loop")
+    autoload(:Events, "brut/tui/events")
+    autoload(:AnsiEscapeCode, "brut/tui/ansi_escape_code")
+    autoload(:Script, "brut/tui/script")
+    autoload(:Terminal, "brut/tui/terminal")
+    autoload(:TerminalTheme, "brut/tui/terminal_theme")
+    autoload(:Themes, "brut/tui/themes")
+    autoload(:MarkupString, "brut/tui/markup_string")
+  end
+end

data/lib/brut/version.rb

@@ -1,4 +1,4 @@
 module Brut
   # @!visibility private
-  VERSION = "0.16.0-pre"
+  VERSION = "0.17.0"
 end

data/lib/brut.rb

@@ -16,5 +16,6 @@ module Brut
   autoload(:Instrumentation,"brut/instrumentation")
   autoload(:SinatraHelpers, "brut/sinatra_helpers")
   # DO NOT autoload(:CLI) - that is intended to be require-able on its own
+  # DO NOT autoload(:TUI) - that is intended to be require-able on its own
 end
 require "sequel/plugins"

data/mkbrut/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mkbrut (0.16.0.pre.pre)
+    mkbrut (0.17.0)
 
 GEM
   remote: https://rubygems.org/
@@ -10,6 +10,7 @@ GEM
 
 PLATFORMS
   aarch64-linux
+  ruby
 
 DEPENDENCIES
   mkbrut!

data/mkbrut/lib/mkbrut/version.rb

@@ -1,3 +1,3 @@
 module MKBrut
-  VERSION = "0.16.0-pre"
+  VERSION = "0.17.0"
 end

data/mkbrut/templates/segments/Heroku/deploy/Dockerfile

@@ -55,8 +55,8 @@ RUN --mount=type=cache,target=/var/cache/apt \
 #
 # Incancation is based on: https://www.postgresql.org/download/linux/debian/
 RUN /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y && \
-    apt-get update && \
-    apt-get --yes --quiet install postgresql-client-16 && \
+    apt-get update --quiet --yes && \
+    apt-get --yes --quiet --no-install-recommends install postgresql-client-16 && \
 		rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*
 
 # Set basic env vars for production
@@ -65,6 +65,8 @@ ENV RACK_ENV="production" \
     BUNDLE_PATH="/usr/local/bundle" \
     BUNDLE_WITHOUT="development"
 
+RUN rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*
+
 # This makes a new image that we'll throw away after building
 # needed artifacts.
 FROM base AS build
@@ -82,9 +84,11 @@ RUN --mount=type=cache,target=/var/cache/apt \
       libpq-dev \
 			pkg-config
 
-# Install NodeJS from their Docker image
+# Copy NodeJS from the official image. This should be faster than
+# installing it via e.g. nvm
 COPY --from=node:22-slim /usr/local /usr/local
 
+# Copy Gemfile only as it may not change between deploys
 COPY Gemfile Gemfile.lock .
 
 # Install RubyGems from app's Gemfile
@@ -99,9 +103,7 @@ RUN npm clean-install --no-audit --no-fund --verbose
 COPY . .
 
 # Build all assets
-RUN \. "$HOME/.nvm/nvm.sh" && \
-    nvm use default && \
-    bin/build-assets && \
+RUN bin/build-assets && \
     rm -rf node_modules
 
 # We are now switching back to building the image that will be deployed.
@@ -118,7 +120,7 @@ RUN groupadd --system --gid 1000 brut && \
 USER 1000:1000
 
 ENV APP_GIT_SHA1="${app_git_sha1}"
+
 # This is used to execute other commands.  When the app is run in production,
 # this script is used to run it.
 ENTRYPOINT ["/brut-app/deploy/docker-entrypoint"]
-

data/mkbrut/templates/segments/Heroku/deploy/heroku_config.rb

@@ -13,12 +13,12 @@ class HerokuConfig
   #   }
   # }
   #
-  # For example, if you have the Sidekiq segment installed, `bin/run-sidekiq`
+  # For example, if you have the Sidekiq segment installed, `bin/run sidekiq`
   # runs Sidekiq, so you would return this hash:
   #
   # {
   #   "sidekiq" => {
-  #     cmd: "bin/run-sidekiq",
+  #     cmd: "bin/run sidekiq",
   #   }
   # }
   #

data/specs/brut/tui/ansi_escape_code.spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+require "brut/tui"
+
+RSpec.describe Brut::TUI::AnsiEscapeCode do
+  describe "#to_s" do
+    it "returns the ANSI escape code as a string" do
+      code = Brut::TUI::AnsiEscapeCode.new(:red, "31")
+      expect(code.to_s).to eq("\e[31m")
+    end
+  end
+
+  describe ".ansi" do
+    it "returns the correct ANSI escape code for a given name" do
+      red_code = Brut::TUI::AnsiEscapeCode.ansi(:red)
+      expect(red_code.to_s).to eq("\e[31m")
+    end
+
+    it "returns an RGB ANSI escape code when given RGB values" do
+      rgb_code = Brut::TUI::AnsiEscapeCode.ansi(255, 0, 0)
+      expect(rgb_code.to_s).to eq("\e[38;2;255;0;0m")
+    end
+
+    it "returns a fluent objects when called without arguments" do
+      fluent = Brut::TUI::AnsiEscapeCode.ansi
+      expect(fluent.bold.to_s).to eq("\e[1m")
+      expect(fluent.red.to_s).to eq("\e[31m")
+    end
+
+  end
+end

data/specs/brut/tui/event_loop.spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+require "brut/tui"
+
+RSpec.describe Brut::TUI::EventLoop do
+  subject(:event_loop) { described_class.new(tick: false) }
+
+  class ExitEvent < Brut::TUI::Events::BaseEvent
+    def exit? = true
+  end
+
+  class RaiseExceptionEvent < Brut::TUI::Events::BaseEvent
+    def initialize(message)
+      @message = message
+    end
+    def raise_exception!
+      raise StandardError.new(@message)
+    end
+  end
+
+  class GeneralSubscriber
+    attr_reader :events
+    def initialize
+      @events = []
+    end
+    def on_any_event(event)
+      if event.respond_to?(:raise_exception!)
+        event.raise_exception!
+      else
+        @events << event
+      end
+    end
+  end
+
+  it "stops the loop when an event returns true for exit?" do
+    main_thread = Thread.new {
+      event_loop.run
+    }
+    event_loop << ExitEvent.new
+    main_thread.join(0.1)
+    expect(main_thread.alive?).to eq(false)
+  end
+
+  def start_loop(event_loop, wait_time: 0.1)
+    exception = nil
+    main_thread = Thread.new {
+      begin
+      event_loop.run
+      rescue => ex
+        exception = ex
+      end
+    }
+    main_thread.join(wait_time)
+    expect(exception).to eq(nil)
+  end
+
+  it "fires the event LoopStarted event when run" do
+    general_subscriber = GeneralSubscriber.new
+    event_loop.subscribe_to_all(general_subscriber)
+    start_loop(event_loop)
+    expect(general_subscriber.events[0].class).to eq(Brut::TUI::Events::EventLoopStarted)
+  end
+
+  it "fires exception events when errors are raised" do
+    general_subscriber = GeneralSubscriber.new
+    event_loop.subscribe_to_all(general_subscriber)
+    event_loop << RaiseExceptionEvent.new("Test exception")
+    start_loop(event_loop)
+    expect(general_subscriber.events[1].class).to eq(Brut::TUI::Events::Exception)
+  end
+end

data/specs/brut/tui/events/base_event.spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "brut/tui"
+
+RSpec.describe Brut::TUI::Events::BaseEvent do
+  class TestEvent < Brut::TUI::Events::BaseEvent; end
+  module Deeply
+    module Nested
+      class TestEvent < Brut::TUI::Events::BaseEvent; end
+    end
+  end
+
+  describe ".handler_method_name" do
+    it "returns the underscorized simple class name prefixed with 'on_'" do
+
+      expect(TestEvent.handler_method_name).to eq("on_test_event")
+      expect(Deeply::Nested::TestEvent.handler_method_name).to eq("on_test_event")
+    end
+  end
+
+  describe "#exit?" do
+    it "returns false by default" do
+      event = Brut::TUI::Events::BaseEvent.new
+      expect(event.exit?).to be false
+    end
+  end
+end

data/specs/brut/tui/events/event_bus.spec.rb

@@ -0,0 +1,141 @@
+require "spec_helper"
+require "brut/tui"
+require_relative "test_event"
+
+RSpec.describe Brut::TUI::Events::EventBus do
+  class OtherTestEvent < Brut::TUI::Events::BaseEvent
+    def self.handler_method_name
+      :on_other_test_event
+    end
+  end
+
+  class SubscriberToTestEvent
+    def notified = @notified
+    def notified_method = @notified_method
+    def on_test_event(event)
+      @notified = event
+      @notified_method = :on_test_event
+    end
+  end
+  class SubscriberToAnyEventOnly
+    def notified = @notified
+    def notified_method = @notified_method
+    def on_any_event(event)
+      @notified = event
+      @notified_method = :on_any_event
+    end
+  end
+  class SubscriberToTestEventAndAnyEvent
+    def notified = @notified
+    def notified_method = @notified_method
+    def on_test_event(event)
+      @notified = event
+      @notified_method = :on_test_event
+    end
+    def on_any_event(event)
+      @notified = event
+      @notified_method = :on_any_event
+    end
+  end
+
+  class RaisesErrorInTestEvent
+    def on_test_event(event)
+      raise "Error in on_test_event"
+    end
+  end
+
+  class RaisesErrorInAnyEvent
+    def on_any_event(event)
+      raise "Error in on_any_event"
+    end
+  end
+
+  subject(:event_bus) { described_class.new }
+
+  describe "#subscribe" do
+    context "subscriber implements the handler method" do
+      it "is notified" do
+        subscriber = SubscriberToTestEvent.new
+        event_bus.subscribe(SpecSupport::TestEvent, subscriber)
+        event = SpecSupport::TestEvent.new
+
+        errors = event_bus.notify(event)
+
+        expect(errors).to                     eq([])
+        expect(subscriber.notified).to        eq(event)
+        expect(subscriber.notified_method).to eq(:on_test_event)
+      end
+    end
+    context "subscriber does not implement the handler method" do
+      it "is raises when subscribing" do
+        subscriber = SubscriberToAnyEventOnly.new
+        expect {
+          event_bus.subscribe(SpecSupport::TestEvent, subscriber)
+        }.to raise_error(ArgumentError, /does not implement handler method/)
+      end
+    end
+  end
+  describe "#subscribe_to_all" do
+    context "subscriber implements the handler method" do
+      it "is notified via that method" do
+        subscriber = SubscriberToTestEventAndAnyEvent.new
+        event_bus.subscribe_to_all(subscriber)
+        event = SpecSupport::TestEvent.new
+
+        errors = event_bus.notify(event)
+
+        expect(errors).to                     eq([])
+        expect(subscriber.notified).to        eq(event)
+        expect(subscriber.notified_method).to eq(:on_test_event)
+      end
+    end
+    context "subscriber does not implement the handler method" do
+      context "subscriber implements on_any_event" do
+        it "calls on_any_event when notified" do
+          subscriber = SubscriberToAnyEventOnly.new
+          event_bus.subscribe_to_all(subscriber)
+          event = SpecSupport::TestEvent.new
+
+          errors = event_bus.notify(event)
+
+          expect(errors).to                     eq([])
+          expect(subscriber.notified).to        eq(event)
+          expect(subscriber.notified_method).to eq(:on_any_event)
+        end
+      end
+      context "subscriber does not implement on_any_event" do
+        it "nothing happens" do
+          subscriber = SubscriberToTestEvent.new
+          event_bus.subscribe_to_all(subscriber)
+          event = OtherTestEvent.new
+
+          errors = event_bus.notify(event)
+
+          expect(errors).to                     eq([])
+          expect(subscriber.notified).to        eq(nil)
+          expect(subscriber.notified_method).to eq(nil)
+        end
+      end
+    end
+  end
+  describe "#notify" do
+
+    # some of this method's behavior is covered by the tests above
+    
+    context "when subscribers raise errors" do
+      it "returns them as an array" do
+        event_bus.subscribe(SpecSupport::TestEvent, RaisesErrorInTestEvent.new)
+        event_bus.subscribe_to_all(RaisesErrorInAnyEvent.new)
+        event_bus.subscribe_to_all(SubscriberToAnyEventOnly.new)
+
+        event = SpecSupport::TestEvent.new
+
+        errors = event_bus.notify(event)
+
+        expect(errors.length).to         eq(2)
+        expect(errors.map(&:message)).to include("Error in on_test_event")
+        expect(errors.map(&:message)).to include("Error in on_any_event")
+      end
+    end
+  end
+end

data/specs/brut/tui/events/exception.spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+require "brut/tui"
+
+RSpec.describe Brut::TUI::Events::Exception do
+
+  describe ":#exit?" do
+    it "is true" do
+      event = described_class.new(StandardError.new("Test exception"))
+      expect(event.exit?).to eq(true)
+    end
+  end
+  describe ":#drain_then_exit?" do
+    it "is false" do
+      event = described_class.new(StandardError.new("Test exception"))
+      expect(event.drain_then_exit?).to eq(false)
+    end
+  end
+
+end

data/specs/brut/tui/events/test_event.rb

@@ -0,0 +1,5 @@
+module SpecSupport
+  class TestEvent < Brut::TUI::Events::BaseEvent
+    def self.handler_method_name = :on_test_event
+  end
+end

data/specs/spec_helper.rb

@@ -1,7 +1,11 @@
 require "brut"
+require "confidence_check/for_rspec"
+
 require_relative "support"
 
 RSpec.configure do |config|
+  config.include ConfidenceCheck::ForRSpec
+
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end