styles 0.0.1

data/test/engine_test.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class EngineTest < MiniTest::Unit::TestCase
+  def test_later_rules_from_same_stylesheet_take_precedence
+    hide_all_rule = ':all - { display: none }'
+    show_line_rule = "'show' - { display: block }"
+
+    hide_all_stylesheet = Styles::Stylesheet.from_string("#{show_line_rule}\n#{hide_all_rule}")
+
+    hide_all_engine = Styles::Engine.new(hide_all_stylesheet)
+    assert_equal nil, hide_all_engine.process('show this line')
+
+    show_a_line_stylesheet = Styles::Stylesheet.from_string("#{hide_all_rule}\n#{show_line_rule}")
+
+    show_a_line_engine = Styles::Engine.new(show_a_line_stylesheet)
+    assert_equal 'show this line', show_a_line_engine.process('show this line')
+  end
+
+  def test_rules_from_later_stylesheets_take_precedence
+    hide_all_rule = ':all - { display: none }'
+    show_line_rule = "'show' - { display: block }"
+
+    hide_all_stylesheet = Styles::Stylesheet.from_string(hide_all_rule)
+    show_stylesheet = Styles::Stylesheet.from_string(show_line_rule)
+
+    # First one stylesheet at a time
+    assert_equal nil, Styles::Engine.new(hide_all_stylesheet).process('just some text')
+    assert_equal 'show this line', Styles::Engine.new(show_stylesheet).process('show this line')
+
+    # Now use multiple Stylesheets and make sure the Rules of the last one takes precedence
+    assert_equal nil, Styles::Engine.new(show_stylesheet, hide_all_stylesheet).process('show this line')
+    assert_equal 'show this line', Styles::Engine.new(hide_all_stylesheet, show_stylesheet).process('show this line')
+  end
+
+  def test_rules_can_hide_lines
+    stylesheet_text = <<-STYLESHEET
+      'ANNOYING' - {
+        display: none
+      }
+
+      /hide this/ - {
+        display: none
+      }
+    STYLESHEET
+
+    engine = Styles::Engine.new(Styles::Stylesheet.from_string(stylesheet_text))
+
+    assert_equal 'this is a line', engine.process('this is a line')
+    assert_nil engine.process('THIS LINE IS ANNOYING')
+    assert_nil engine.process('this line has hide this in it')
+  end
+
+  private
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,136 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'stringio'
+require 'term/ansicolor'
+
+# Tests everything together.
+# Parse stylesheet text, apply those to input, and confirm correct output.
+class IntegrationTest < MiniTest::Unit::TestCase
+  def test_rules_can_hide_lines
+    @stylesheet = <<-STYLESHEET
+      'ANNOYING' - {
+        display: none
+      }
+
+      /hide this/ - {
+        display: none
+      }
+
+      :blank - {
+        display: none
+      }
+    STYLESHEET
+
+    @input = <<-INPUT
+this is a line
+THIS LINE IS ANNOYING
+this line has hide this in it
+this one is also visible
+
+the line before this is blank
+    INPUT
+
+    @expected_output = <<-OUTPUT
+this is a line
+this one is also visible
+the line before this is blank
+    OUTPUT
+
+    assert_correct_output
+  end
+
+  def test_various_line_colors_and_styles
+    @stylesheet = <<-STYLESHEET
+      'red' - {
+        color: red
+      }
+
+      'fantastic' - {
+        color: cyan,
+        background_color: yellow
+      }
+
+      /important/ - {
+        font_weight: bold
+      }
+
+      /tons/i - {
+        color: green,
+        background_color: red,
+        font_weight: bold,
+        text_decoration: underline
+      }
+    STYLESHEET
+
+    @input = <<-INPUT
+this line is red
+no color here
+this has fantastic colors
+this line is important
+this has TONS going on
+    INPUT
+
+    @expected_output = <<-OUTPUT
+#{color.red}this line is red#{color.reset}
+no color here
+#{color.cyan}#{color.on_yellow}this has fantastic colors#{color.reset}
+#{color.bold}this line is important#{color.reset}
+#{color.bold}#{color.green}#{color.on_red}#{color.underline}this has TONS going on#{color.reset}
+    OUTPUT
+
+    assert_correct_output
+  end
+
+  def test_various_line_and_match_color_combos
+    @stylesheet = <<-STYLESHEET
+      'cyanify' - {
+        match_color: cyan
+      }
+
+      /(number) (\\d\\d)/ - {
+        match_color: [red, green]
+      }
+
+      'blue' - {
+        color: blue
+      }
+
+      'on yellow' - {
+        background_color: yellow
+      }
+    STYLESHEET
+
+    @input = <<-INPUT
+cyanify this
+the number 25 is here
+the number 25 is here, blue otherwise
+the number 25 is here on yellow
+    INPUT
+
+    @expected_output = <<-OUTPUT
+#{color.cyan}cyanify#{color.reset} this
+the #{color.red}number#{color.reset} #{color.green}25#{color.reset} is here
+#{color.blue}the #{color.red}number#{color.blue} #{color.green}25#{color.blue} is here, blue otherwise#{color.reset}
+#{color.on_yellow}the #{color.red}number#{color.reset}#{color.on_yellow} #{color.green}25#{color.reset}#{color.on_yellow} is here on yellow#{color.reset}
+    OUTPUT
+
+    assert_correct_output
+  end
+
+  private
+
+  def assert_correct_output
+    engine = Styles::Engine.new(Styles::Stylesheet.from_string(@stylesheet))
+
+    output = StringIO.new
+    @input.each_line do |line|
+      processed_line = engine.process(line)
+      output.puts processed_line if processed_line
+    end
+
+    assert_equal @expected_output, output.string
+  end
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/line_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class LineTest < MiniTest::Unit::TestCase
+  include Styles
+
+  def test_can_update
+    original = 'this is a line'
+    updated = 'this is an updated line'
+    line = Line.new original
+    assert_equal original, line.to_s
+    assert_equal original, line.text
+
+    line.text = updated
+    assert_equal updated, line.to_s
+    assert_equal updated, line.text
+    assert_equal original, line.original
+
+    line = Line.new original
+    line.text = updated
+    assert_equal updated, line.to_s
+    assert_equal original, line.original
+  end
+end

data/test/properties/background_color_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class BackgroundColorTest < MiniTest::Unit::TestCase
+  def test_applies_correct_background_colors_to_lines
+    test_line = 'this is a test line, to be background colored'
+
+    assert_equal "#{color.on_blue}#{test_line}#{color.reset}", process('test', :blue, test_line)
+    assert_equal "#{color.on_cyan}#{test_line}#{color.reset}", process('test', :cyan, test_line)
+    assert_equal test_line, process('test', :none, test_line)
+  end
+
+  def test_works_with_on_prefixed_colors
+    test_line = 'this is a test line, to be background colored'
+
+    assert_equal "#{color.on_red}#{test_line}#{color.reset}", process('test', :on_red, test_line)
+    assert_equal "#{color.on_cyan}#{test_line}#{color.reset}", process('test', :on_cyan, test_line)
+  end
+
+  def test_line_passes_through_with_invalid_color
+    test_line = 'this is a test line, to be colored?'
+    assert_equal test_line, process('test', :sunshine, test_line)
+  end
+
+  private
+
+  def process(selector, value, line)
+    sub_engine = ::Styles::SubEngines::Color.new
+    line = ::Styles::Line.new(line, [::Styles::Properties::BackgroundColor.new(selector, :background_color, value)])
+    sub_engine.process(line).to_s
+  end
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/properties/base_test.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class PropertyBaseTest < MiniTest::Unit::TestCase
+
+  def test_to_sym
+    assert_equal :color, ::Styles::Properties::Color.to_sym
+    assert_equal :text_align, ::Styles::Properties::TextAlign.to_sym
+  end
+
+end

data/test/properties/border_test.rb

@@ -0,0 +1,154 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class BorderTest < MiniTest::Unit::TestCase
+  def setup
+    @sub_engine = ::Styles::SubEngines::Layout.new 
+  end
+
+  def test_can_use_all_property_names
+    [:border, :border_left, :border_right, :border_top, :border_bottom].each do |prop_name|
+      assert_equal ::Styles::Properties::Border, ::Styles::Properties.find_class_by_property_name(prop_name)
+    end
+  end
+
+  def test_gives_correct_border_values
+    bl = prop(:border_left, 'solid green')
+    assert_equal :none, bl.top
+    assert_equal :none, bl.right
+    assert_equal :none, bl.bottom
+    assert_equal [:solid, :green], bl.left
+    assert_equal [:none, :none, :none, [:solid, :green]], bl.all_border_values
+
+    assert_equal [[:solid, :default], [:solid, :default], [:solid, :default], [:solid, :default]], prop(:border, :solid).all_border_values
+    assert_equal [[:solid, :default], [:solid, :default], [:solid, :default], [:solid, :default]], prop(:border, 'solid').all_border_values
+    assert_equal [[:solid, :blue], [:solid, :blue], [:solid, :blue], [:solid, :blue]], prop(:border, 'solid blue').all_border_values
+
+    assert_equal [:none, :none, :none, :none], prop(:border, :none).all_border_values
+    assert_equal [:none, :none, :none, :none], prop(:border_right, :none).all_border_values
+  end
+
+  def test_can_combine_border_properties
+    assert_equal [:none, [:dotted, :default], :none, [:solid, :default]],
+      combine([prop(:border_left, :solid), prop(:border_right, :dotted)]).all_border_values
+    assert_equal [:none, [:dotted, :green], :none, [:solid, :red]],
+      combine([prop(:border_left, 'solid red'), prop(:border_right, 'dotted green')]).all_border_values
+    assert_equal [[:double, :cyan], [:solid, :white], [:solid, :white], [:solid, :white]],
+      combine([prop(:border, 'solid white'), prop(:border_top, 'double cyan')]).all_border_values
+    assert_equal [[:double, :cyan], [:dotted, :red], [:solid, :white], [:solid, :white]],
+      combine([prop(:border, 'solid white'), prop(:border_top, 'double cyan'), prop(:border_right, 'dotted red')]).all_border_values
+    assert_equal [[:solid, :white], [:solid, :white], [:solid, :white], [:solid, :white]],
+      combine([prop(:border_top, 'double cyan'), prop(:border, 'solid white')]).all_border_values
+    assert_equal [:none, :none, :none, :none],
+      combine([prop(:border_top, 'double cyan'), prop(:border, :none)]).all_border_values
+    assert_equal [:none, [:solid, :white], [:solid, :white], [:solid, :white]],
+      combine([prop(:border, 'solid white'), prop(:border_top, :none)]).all_border_values
+  end
+
+  def test_produces_correct_border_characters
+    solid = ::Styles::Properties::Border::SOLID_CHARS
+
+    solid_prop = prop(:border, :solid)
+    assert_equal solid[:top], solid_prop.top_char
+    assert_equal solid[:left], solid_prop.left_char
+    assert_equal solid[:top_left], solid_prop.top_left_char
+    assert_equal solid[:top] * 4, solid_prop.top_char(4)
+
+    assert_equal "#{solid[:top_left]}#{solid[:top] * 4}#{solid[:top_right]}", solid_prop.top_line_chars(4)
+    assert_equal "#{solid[:bottom_left]}#{solid[:bottom] * 4}#{solid[:bottom_right]}", solid_prop.bottom_line_chars(4)
+
+    solid_green_prop = prop(:border, 'solid green')
+    assert_equal "#{color.green}#{solid[:top]}#{color.reset}", solid_green_prop.top_char
+    assert_equal "#{color.green}#{solid[:left]}#{color.reset}", solid_green_prop.left_char
+    assert_equal "#{color.green}#{solid[:top_left]}#{color.reset}", solid_green_prop.top_left_char
+    assert_equal "#{color.green}#{solid[:top] * 4}#{color.reset}", solid_green_prop.top_char(4)
+
+    assert_equal "#{color.green}#{solid[:top_left]}#{color.reset}#{color.green}#{solid[:top] * 4}" +
+      "#{color.reset}#{color.green}#{solid[:top_right]}#{color.reset}", solid_green_prop.top_line_chars(4)
+    assert_equal "#{color.green}#{solid[:bottom_left]}#{color.reset}#{color.green}#{solid[:bottom] * 4}" +
+      "#{color.reset}#{color.green}#{solid[:bottom_right]}#{color.reset}", solid_green_prop.bottom_line_chars(4)
+
+    none_prop = prop(:border, :none)
+    assert_equal '', none_prop.top_char
+    assert_equal '', none_prop.left_char
+    assert_equal '', none_prop.top_char(4)
+
+    none_prop = prop(:border_right, :solid)
+    assert_equal '', none_prop.top_char
+    assert_equal '', none_prop.left_char
+    assert_equal solid[:right], none_prop.right_char
+
+    bottom_right_prop = combine([prop(:border_bottom, :solid), prop(:border_right, :solid)])
+    assert_equal '', bottom_right_prop.top_char
+    assert_equal '', bottom_right_prop.left_char
+    assert_equal '', bottom_right_prop.top_left_char
+    assert_equal '', bottom_right_prop.top_right_char
+    assert_equal '', bottom_right_prop.bottom_left_char
+    assert_equal solid[:right], bottom_right_prop.right_char
+    assert_equal solid[:bottom_right], bottom_right_prop.bottom_right_char
+    assert_equal solid[:bottom], bottom_right_prop.bottom_char
+    assert_equal "#{solid[:bottom] * 4}#{solid[:bottom_right]}", bottom_right_prop.bottom_line_chars(4)
+  end
+
+  def test_can_apply_a_border
+    test_line = 'line for U'
+    solid = ::Styles::Properties::Border::SOLID_CHARS
+
+    solid_border_box = <<SOLID_BORDER
+#{solid[:top_left]}#{solid[:top] * test_line.size}#{solid[:top_right]}
+#{solid[:left]}#{test_line}#{solid[:right]}
+#{solid[:bottom_left]}#{solid[:bottom] * test_line.size}#{solid[:bottom_right]}
+SOLID_BORDER
+
+    assert_equal solid_border_box, process('line', :border, :solid, test_line)
+  end
+
+  def test_can_apply_a_colored_border
+    test_line = 'line for U, with color'
+    solid = ::Styles::Properties::Border::SOLID_CHARS
+
+    solid_blue_border_box = <<SOLID_BORDER
+#{color.blue}#{solid[:top_left]}#{color.reset}#{color.blue}#{solid[:top] * test_line.size}#{color.reset}#{color.blue}#{solid[:top_right]}#{color.reset}
+#{color.blue}#{solid[:left]}#{color.reset}#{test_line}#{color.blue}#{solid[:right]}#{color.reset}
+#{color.blue}#{solid[:bottom_left]}#{color.reset}#{color.blue}#{solid[:bottom] * test_line.size}#{color.reset}#{color.blue}#{solid[:bottom_right]}#{color.reset}
+SOLID_BORDER
+
+    assert_equal solid_blue_border_box, process('line', :border, 'solid blue', test_line)
+  end
+
+  def test_can_apply_partial_borders
+    test_line = 'line for U'
+    solid = ::Styles::Properties::Border::SOLID_CHARS
+
+    partial_border = <<PARTIAL_BORDER
+#{test_line}#{solid[:right]}
+#{solid[:bottom] * test_line.size}#{solid[:bottom_right]}
+PARTIAL_BORDER
+
+    line = ::Styles::Line.new(test_line, [::Styles::Properties::Border.new([prop(:border_right, :solid), prop(:border_bottom, :solid)])])
+    assert_equal partial_border, @sub_engine.process(line).to_s
+  end
+
+  private
+
+  def process(selector, property_name, value, line)
+    line = ::Styles::Line.new(line, [::Styles::Properties::Border.new(selector, property_name, value)])
+    result = @sub_engine.process(line)
+    result.to_s
+  end
+
+  def prop(name, value, selector='test')
+    ::Styles::Properties::Border.new(selector, name, value)
+  end
+
+  def combine(*props)
+    ::Styles::Properties::Border.new(props.flatten)
+  end
+
+  def stub_term_width(width)
+    @sub_engine.stubs(:terminal_width).returns(width)
+  end
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/properties/color_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class ColorTest < MiniTest::Unit::TestCase
+  def test_applies_correct_colors_to_lines
+    test_line = 'this is a test line, to be colored'
+
+    assert_equal "#{color.red}#{test_line}#{color.reset}", process('test', :red, test_line)
+    assert_equal "#{color.blue}#{test_line}#{color.reset}", process('test', :blue, test_line)
+  end
+
+  def test_line_passes_through_with_invalid_color
+    test_line = 'this is a test line, to be colored?'
+    assert_equal test_line, process('test', :sunshine, test_line)
+  end
+
+  private
+
+  def process(selector, value, line)
+    sub_engine = ::Styles::SubEngines::Color.new
+    line = ::Styles::Line.new(line, [::Styles::Properties::Color.new(selector, :color, value)])
+    sub_engine.process(line).to_s
+  end
+
+  def color
+    ::Term::ANSIColor
+  end
+end