eskimo 1.0.0 → 2.0.0

data/lib/eskimo/components/wrap.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Eskimo
+  module Components
+    # Wrap a block text with newlines at a certain threshold.
+    #
+    #     Wrap.new(width: 3) do
+    #       "foobar"
+    #     end
+    #     # => "foo"
+    #     #    "bar"
+    #
+    class Wrap < Component
+      attr_reader :width
+
+      def initialize(width: Constants::SCREEN_COLUMNS, &children)
+        @width = width
+        super
+      end
+
+      def render(**)
+        Strings.wrap(super, width)
+      end
+    end
+  end
+end

data/lib/eskimo/constants.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Eskimo
+  module Constants
+    SCREEN_COLUMNS = [TTY::Screen.width, 72].min
+  end
+end

data/lib/eskimo/renderer.rb

@@ -18,22 +18,23 @@ module Eskimo
     private
 
     def render(*components)
-      components.select(&NOT_FALSEY).reduce('') do |buf, component|
-        case component
-        when String
-          buf + component
-        when Array
-          buf + render(*component)
-        when Proc
-          buf + render(component[**@props])
-        else
-          if component.respond_to?(:render)
-            buf + render(component.render(**@props))
-          else
-            bail(component)
-          end
+      buf = +''
+
+      for component in components do
+        if component.is_a?(String)
+          buf << component
+        elsif component.is_a?(Array)
+          buf << render(*component)
+        elsif component.is_a?(Proc)
+          buf << render(component[**@props])
+        elsif component.respond_to?(:render)
+          buf << render(component.render(**@props))
+        elsif component
+          bail(component)
         end
       end
+
+      buf
     end
 
     def bail(component)
@@ -41,8 +42,5 @@ module Eskimo
         "Eskimo: don't know how to render #{component.class} => #{component}"
       )
     end
-
-    NOT_FALSEY = ->(x) { !!x }.freeze
-    private_constant :NOT_FALSEY
   end
 end

data/lib/eskimo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Eskimo
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/spec/component_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Component do
+  it 'accepts a block of children' do
+    expect(
+      Eskimo::Renderer.new.apply {
+        Eskimo::Component.new { ['hello', "\n", 'world!'] }
+      }
+    ).to eq("hello\nworld!")
+  end
+end

data/spec/components/did_you_mean_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::DidYouMean do
+  it 'renders a suggestion' do
+    expect(
+      renderer.apply {
+        described_class.new(dictionary: [ 'abc', 'bca' ], item: 'abd')
+      }
+    ).to eq("Did you mean? abc")
+  end
+
+  it 'renders nothing if no suggestions were found' do
+    expect(
+      renderer.apply {
+        described_class.new(dictionary: [ 'abc', 'bca' ], item: 'asdf')
+      }
+    ).to eq("")
+  end
+end

data/spec/components/either_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::Either do
+  it 'renders the primary component' do
+    expect(
+      renderer.apply {
+        described_class.new(->(**) { false }, "Fallback here")
+      }
+    ).to eq("Fallback here")
+  end
+
+  it 'renders the fallback if the primary does not' do
+    expect(
+      renderer.apply {
+        described_class.new(->(**) { "Hi!" }, "Fallback here")
+      }
+    ).to eq("Hi!")
+  end
+end

data/spec/components/highlight_column_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::HighlightColumn do
+  it 'highlights the character' do
+    style = [ :bold, :red ]
+
+    expect(
+      renderer.apply {
+        described_class.new(column: 1, line: 1, style: style) { "number:\nfour" }
+      }
+    ).to include("f#{pastel.decorate('o', *style)}ur")
+  end
+
+  it 'highlights the first character' do
+    style = [ :bold, :red ]
+
+    expect(
+      renderer.apply {
+        described_class.new(column: 0, line: 0, style: style) { "four" }
+      }
+    ).to include("#{pastel.decorate('f', *style)}our")
+  end
+
+  it 'highlights the last character' do
+    style = [ :bold, :red ]
+
+    expect(
+      renderer.apply {
+        described_class.new(column: 3, line: 0, style: style) { "four" }
+      }
+    ).to include("fou#{pastel.decorate('r', *style)}")
+  end
+
+  it 'highlights nothing' do
+    expect(
+      renderer.apply {
+        described_class.new(column: 1234, line: 0) { "four" }
+      }
+    ).to eq("four")
+
+    expect(
+      renderer.apply {
+        described_class.new(column: 0, line: 1234) { "four" }
+      }
+    ).to eq("four")
+  end
+
+  it 'inserts the arrow' do
+    expect(
+      strip_styles(
+        renderer.apply {
+          described_class.new(column: 1, line: 0) { "four" }
+        }
+      )
+    ).to eq(
+      "four"  + "\n" +
+      " ^"    + "\n" +
+      " here" + "\n"
+    )
+  end
+end

data/spec/components/highlight_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::Highlight do
+  it 'styles a substring' do
+    style = [ :bold, :red ]
+
+    expect(
+      renderer.apply {
+        described_class.new(pattern: /ou/, style: style) { 'four' }
+      }
+    ).to eq("f#{Pastel.new.decorate('ou', *style)}r")
+  end
+
+  it 'is a no-op if no match' do
+    input = 'four'
+
+    expect(
+      renderer.apply {
+        described_class.new(pattern: /asdf/) { input }
+      }
+    ).to eq(input)
+  end
+end

data/spec/components/indent_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::Indent do
+  it 'indents each line' do
+    expect(
+      renderer.apply do
+        ESK::Indent.new(width: 2) do
+          "hello\nworld"
+        end
+      end
+    ).to eq("  hello\n  world")
+  end
+end

data/spec/components/line_break_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::LineBreak do
+  it 'inserts a hard linebreak' do
+    expect(
+      renderer.apply {
+        [
+          'hello',
+          ESK::LineBreak.new,
+          'world'
+        ]
+      }
+    ).to eq("hello\n \nworld")
+  end
+end

data/spec/components/soft_break_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::SoftBreak do
+  it 'inserts a soft linebreak' do
+    expect(
+      renderer.apply {
+        [
+          'hello',
+          ESK::SoftBreak.new,
+          'world'
+        ]
+      }
+    ).to eq("hello\nworld")
+  end
+end

data/spec/components/squeeze_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::Squeeze do
+  it 'swallows consecutive newlines' do
+    expect(
+      renderer.apply do
+        ESK::Squeeze.new([
+          ESK::SoftBreak.new,
+          false && '1',
+
+          ESK::SoftBreak.new,
+          false && '2',
+
+          ESK::SoftBreak.new,
+          '3',
+
+          ESK::SoftBreak.new,
+          '4',
+        ])
+      end
+    ).to eq("\n3\n4")
+  end
+
+  it 'does not swallow consecutive newlines in inner children' do
+    expect(
+      renderer.apply do
+        ESK::Squeeze.new([
+          ESK::Indent.new(width: 0) do
+            [
+              ESK::SoftBreak.new,
+              false && '1',
+
+              ESK::SoftBreak.new,
+              false && '2',
+
+              ESK::SoftBreak.new,
+              '3',
+
+              ESK::SoftBreak.new,
+              '4',
+            ]
+          end
+        ])
+      end
+    ).to eq("\n\n\n3\n4")
+  end
+
+  it 'bails if not given an array of children' do
+    expect { ESK::Squeeze.new('') }.to raise_error(ArgumentError,
+      "Squeeze works only with an Array of components"
+    )
+  end
+
+  it 'bails if given a block' do
+    expect { ESK::Squeeze.new([]) {} }.to raise_error(ArgumentError,
+      "Squeeze works only with an Array of components"
+    )
+  end
+end

data/spec/components/strip_left_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::StripLeft do
+  it 'strips whitespace from the head' do
+    expect(
+      renderer.apply do
+        ESK::StripLeft.new do
+          "  hello world  "
+        end
+      end
+    ).to eq("hello world  ")
+  end
+end

data/spec/components/strip_right_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::StripRight do
+  it 'strips whitespace from the rear' do
+    expect(
+      renderer.apply do
+        ESK::StripRight.new do
+          "  hello world  "
+        end
+      end
+    ).to eq("  hello world")
+  end
+end

data/spec/components/strip_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::Strip do
+  it 'strips surrounding whitespace' do
+    expect(
+      renderer.apply do
+        ESK::Strip.new do
+          "  hello world  "
+        end
+      end
+    ).to eq("hello world")
+  end
+end

data/spec/components/style_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::Style do
+  it 'applies ANSI styling to text' do
+    expect(
+      renderer.apply {
+        [
+          ESK::Style.new([:bold, :green]) { 'hai' },
+        ]
+      }
+    ).to eq("\e[1;32mhai\e[0m")
+  end
+
+  it 'accepts a splat' do
+    expect(
+      renderer.apply {
+        [
+          ESK::Style.new(:bold, :green) { 'hai' },
+        ]
+      }
+    ).to eq("\e[1;32mhai\e[0m")
+  end
+end

data/spec/components/truncate_rear_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Eskimo::Components::TruncateRear do
+  it 'truncates a string from the rear if it exceeds the length' do
+    expect(
+      renderer.apply do
+        ESK::TruncateRear.new(width: 5) do
+          "hello world"
+        end
+      end
+    ).to eq("hello...")
+  end
+
+  it 'reserves chars from the width' do
+    expect(
+      renderer.apply do
+        ESK::TruncateRear.new(width: 10, reserve: 5) do
+          ("hello world")
+        end
+      end
+    ).to eq("hello...")
+  end
+
+  it 'is a no-op if text fits' do
+    expect(
+      renderer.apply do
+        ESK::TruncateRear.new(width: 62, reserve: 5) do
+          ("hello world")
+        end
+      end
+    ).to eq("hello world")
+  end
+end