brut 0.17.0 → 0.18.1

data/specs/brut/front_end/forms/radio_button_group_input.spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Brut::FrontEnd::Forms::RadioButtonGroupInput do
-  describe "#value=" do
-    let(:name) { "test-input" }
-    context "value is present" do
-      it "does not set any violations" do
-        input = described_class.new(
-          input_definition: Brut::FrontEnd::Forms::RadioButtonGroupInputDefinition.new(
-            name:,
-            required: true,
-          ),
-          index: 0,
-          value: "DC"
-        )
-        expect(input.valid?).to eq(true)
-        expect(input.value).to eq("DC")
-        expect(input.typed_value).to eq("DC")
-      end
-    end
-    context "value is not present" do
-      context "required" do
-        it "sets valueMissing violation" do
-          input = described_class.new(
-            input_definition: Brut::FrontEnd::Forms::RadioButtonGroupInputDefinition.new(
-              name:,
-              required: true,
-            ),
-            index: 0,
-            value: ""
-          )
-          expect(input.validity_state).to have_constraint_violation(:valueMissing)
-          expect(input.value).to eq("")
-          expect(input.typed_value).to eq(nil)
-        end
-      end
-      context "not required" do
-        it "does not set any violations" do
-          input = described_class.new(
-            input_definition: Brut::FrontEnd::Forms::RadioButtonGroupInputDefinition.new(
-              name:,
-              required: false,
-            ),
-            index: 0,
-            value: ""
-          )
-          expect(input.valid?).to eq(true)
-          expect(input.value).to eq("")
-          expect(input.typed_value).to eq(nil)
-        end
-      end
-    end
-  end
-end

data/specs/brut/front_end/forms/select_input.spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Brut::FrontEnd::Forms::SelectInput do
-  describe "#value=" do
-    let(:name) { "test-input" }
-    context "value is present" do
-      it "does not set any violations" do
-        input = described_class.new(
-          input_definition: Brut::FrontEnd::Forms::SelectInputDefinition.new(
-            name:,
-            required: true,
-          ),
-          index: 0,
-          value: "DC"
-        )
-        expect(input.valid?).to eq(true)
-        expect(input.value).to eq("DC")
-        expect(input.typed_value).to eq("DC")
-      end
-    end
-    context "value is not present" do
-      context "required" do
-        it "sets valueMissing violation" do
-          input = described_class.new(
-            input_definition: Brut::FrontEnd::Forms::SelectInputDefinition.new(
-              name:,
-              required: true,
-            ),
-            index: 0,
-            value: ""
-          )
-          expect(input.validity_state).to have_constraint_violation(:valueMissing)
-          expect(input.value).to eq("")
-          expect(input.typed_value).to eq(nil)
-        end
-      end
-      context "not required" do
-        it "does not set any violations" do
-          input = described_class.new(
-            input_definition: Brut::FrontEnd::Forms::SelectInputDefinition.new(
-              name:,
-              required: false,
-            ),
-            index: 0,
-            value: ""
-          )
-          expect(input.valid?).to eq(true)
-          expect(input.value).to eq("")
-          expect(input.typed_value).to eq(nil)
-        end
-      end
-    end
-  end
-end

data/specs/brut/instrumentation/methods.spec.rb

@@ -1,399 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Brut::Instrumentation::Methods do
-  describe "#instrument" do
-    it "instruments only those methods specified" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-
-        instrument :save, :delete
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#delete",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "delete",
-        }
-      )
-      expect(instrumentation).not_to have_received(:span).with(
-        /\#search/,
-        attributes: kind_of(Hash)
-      )
-    end
-    it "works when called on a method definition" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-
-        instrument def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        instrument def delete
-          @delete_called = true
-        end
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#delete",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "delete",
-        }
-      )
-      expect(instrumentation).not_to have_received(:span).with(
-        /\#search/,
-        attributes: kind_of(Hash)
-      )
-    end
-
-    it "calling it twice raises an error" do
-      expect {
-        Class.new do
-          include Brut::Instrumentation::Methods
-
-          def save
-            @save_called = true
-          end
-
-          def self.name # since this is an anonymous class, need some name to show up
-            "TestClass"
-          end
-
-          instrument :save
-          instrument :save
-        end
-      }.to raise_error(ArgumentError, /already instrumented/)
-    end
-
-    it "instrumenting a nonexistent method raises an error" do
-      expect {
-        Class.new do
-          include Brut::Instrumentation::Methods
-
-          def save
-            @save_called = true
-          end
-
-          def self.name # since this is an anonymous class, need some name to show up
-            "TestClass"
-          end
-
-          instrument :foo
-        end
-      }.to raise_error(ArgumentError)
-    end
-  end
-  describe "#instrument_all" do
-    it "instruments all methods" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-
-        instrument_all
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#delete",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "delete",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#search",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "search",
-        }
-      )
-    end
-    it "instruments all methods defined after it is called" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-        instrument_all
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#delete",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "delete",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#search",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "search",
-        }
-      )
-    end
-  end
-  describe "#instrument_public" do
-    it "instruments only public methods" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-
-        instrument_public
-
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#search",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "search",
-        }
-      )
-      expect(instrumentation).not_to have_received(:span).with(
-        "TestClass#delete",
-        attributes: kind_of(Hash)
-      )
-    end
-    it "instruments only public methods defined after it is called" do
-      mock_container = double("Brut::Framework::Container")
-      instrumentation = instance_double(Brut::Instrumentation::OpenTelemetry)
-      allow(Brut).to receive(:container).and_return(mock_container)
-      allow(mock_container).to receive(:instrumentation).and_return(instrumentation)
-      allow(instrumentation).to receive(:span).and_yield(double("span that should not be used"))
-
-      class_to_instrument = Class.new do
-        include Brut::Instrumentation::Methods
-        instrument_public
-
-        def save
-          @save_called = true
-        end
-
-        def search
-          @search_called = true
-        end
-
-        def self.name # since this is an anonymous class, need some name to show up
-          "TestClass"
-        end
-
-        private
-
-        def delete
-          @delete_called = true
-        end
-
-      end
-      object = class_to_instrument.new
-
-      object.save
-      object.search
-      object.send(:delete)
-
-      expect(object.instance_variable_get(:@save_called)).to   eq(true)
-      expect(object.instance_variable_get(:@search_called)).to eq(true)
-      expect(object.instance_variable_get(:@delete_called)).to eq(true)
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#save",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "save",
-        }
-      )
-      expect(instrumentation).to have_received(:span).with(
-        "TestClass#search",
-        attributes: {
-          "brut.class" => "TestClass",
-          "brut.method" => "search",
-        }
-      )
-      expect(instrumentation).not_to have_received(:span).with(
-        "TestClass#delete",
-        attributes: kind_of(Hash)
-      )
-    end
-  end
-end

data/specs/brut/junk_drawer.spec.rb

@@ -1,79 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "RichString" do
-  describe ".from_string" do
-    context "nil" do
-      it "returns nil when blank_is_nil is true" do
-        expect(RichString.from_string(nil)).to eq(nil)
-      end
-      it "returns nil when blank_is_nil is false" do
-        expect(RichString.from_string(nil, blank_is_nil: false)).to eq(nil)
-      end
-    end
-    context "empty string" do
-      it "returns nil when blank_is_nil is true" do
-        expect(RichString.from_string("     ")).to eq(nil)
-      end
-      it "returns the string when blank_is_nil is false" do
-        expect(RichString.from_string("     ", blank_is_nil: false)).to eq("     ")
-      end
-    end
-    context "non-empty string" do
-      it "returns a RichString containing the string" do
-        rich_string = RichString.from_string(" foo    ")
-        expect(rich_string.to_str).to eq(" foo    ")
-      end
-    end
-  end
-  describe "#underscorized" do
-    it "returns self if there's nothing to convert" do
-      rich_string = RichString.new("alreadydone")
-      expect(rich_string.underscorized).to eq(rich_string)
-    end
-    it "splits up CamelCase, turns - into _ and downcases everything" do
-      rich_string = RichString.new("DashBoardPage")
-      expect(rich_string.underscorized.to_s).to eq("dash_board_page")
-    end
-    it "handles weird situations" do
-      rich_string = RichString.new("Dash--BoardHTMLPage---")
-      expect(rich_string.underscorized.to_s).to eq("dash_board_h_t_m_l_page")
-    end
-    it "handles namespaces" do
-      rich_string = RichString.new("WebHooks::Stripe")
-      expect(rich_string.underscorized.to_s).to eq("web_hooks/stripe")
-    end
-  end
-  describe "#camelize" do
-    it "splits on _ and -, captializes each part and joins them" do
-      expect(RichString.new("a-normal-base-case").camelize).to eq("ANormalBaseCase")
-      expect(RichString.new("an__odd-_-----_one").camelize).to eq("AnOddOne")
-      expect(RichString.new("Somewhat-Close").camelize).to eq("SomewhatClose")
-      expect(RichString.new("AlreadyDone").camelize).to eq("AlreadyDone")
-    end
-  end
-  describe "#capitalize" do
-    context "first_only" do
-      it "capitalizes the first letter, but does not affect the case of remaining letters" do
-        expect(RichString.new("this is a String").capitalize(:first_only).to_s).to eq("This is a String")
-      end
-    end
-    context "no first_only" do
-      it "behaves as Ruby's stdlib does, which is to capitalize the first letter and downcase the rest" do
-        expect(RichString.new("this is a String").capitalize.to_s).to eq("This is a string")
-      end
-    end
-  end
-  describe "#humanized" do
-    it "replaces - and _ with spaces" do
-      expect(RichString.new("this-is-a-string").humanized).to eq("this is a string")
-    end
-  end
-  describe "#to_s_or_nil" do
-    it "returns nil if the string is empty" do
-      expect(RichString.new("   ").to_s_or_nil).to eq(nil)
-    end
-    it "returns the string if the string is not empty" do
-      expect(RichString.new(" foo ").to_s_or_nil).to eq(" foo ")
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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