styles 0.0.1

data/test/properties/display_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class DisplayTest < MiniTest::Unit::TestCase
+  def test_line_passes_through_with_show_values
+    test_line = 'this is a test line'
+
+    assert_equal test_line, process('test', :block, test_line)
+    assert_equal test_line, process('test', true, test_line)
+  end
+
+  def test_line_hidden_with_hide_values
+    test_line = 'this is a test line'
+
+    assert_nil process('test', :none, test_line)
+    assert_nil process('test', false, test_line)
+  end
+
+  private
+
+  def process(selector, value, line)
+    sub_engine = ::Styles::SubEngines::Layout.new
+    line = ::Styles::Line.new(line, [::Styles::Properties::Display.new(selector, :display, value)])
+    result = sub_engine.process(line)
+    result.text
+  end
+end

data/test/properties/font_weight_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class FontWeightTest < MiniTest::Unit::TestCase
+  def test_can_embolden_a_line
+    test_line = 'this is a test line'
+
+    assert_equal "#{color.bold}#{test_line}#{color.reset}", process('test', :bold, test_line)
+    assert_equal test_line, process('test', :normal, test_line)
+    assert_equal test_line, process('test', :invalid, test_line)
+  end
+
+  private
+
+  def process(selector, value, line)
+    sub_engine = ::Styles::SubEngines::Color.new
+    line = ::Styles::Line.new(line, [::Styles::Properties::FontWeight.new(selector, :font_weight, value)])
+    sub_engine.process(line).to_s
+  end
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/properties/function_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class FunctionTest < MiniTest::Unit::TestCase
+  def setup
+    @sub_engine = ::Styles::SubEngines::PreProcessor.new 
+  end
+
+  def test_all_callables_work
+    test_line = 'this is a line'
+    assert_equal test_line, process('line', :function, ->(line) { line }, test_line)
+    assert_equal test_line, process('line', :function, Proc.new {|line| line }, test_line)
+    assert_equal test_line, process('line', :function, proc {|line| line }, test_line)
+  end
+
+  def test_arbitrary_functions
+    test_line = 'this is a line'
+    assert_equal nil, process('line', :function, ->(line) { line.include?('this') ? nil : line }, test_line)
+    assert_equal test_line.upcase, process('line', :function, ->(line) { line.upcase }, test_line)
+  end
+
+  private
+
+  def process(selector, property_name, value, line)
+    line = ::Styles::Line.new(line, [::Styles::Properties::Function.new(selector, property_name, value)])
+    result = @sub_engine.process(line)
+    result.text
+  end
+end

data/test/properties/margin_test.rb

@@ -0,0 +1,98 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class MarginTest < MiniTest::Unit::TestCase
+  def setup
+    @sub_engine = ::Styles::SubEngines::Layout.new 
+  end
+
+  def test_can_use_all_property_names
+    [:margin, :margin_left, :margin_right, :margin_top, :margin_bottom].each do |prop_name|
+      assert_equal ::Styles::Properties::Margin, ::Styles::Properties.find_class_by_property_name(prop_name)
+    end
+  end
+
+  def test_gives_correct_margin_values
+    ml = prop(:margin_left, 2)
+    assert_equal 0, ml.top
+    assert_equal 0, ml.right
+    assert_equal 0, ml.bottom
+    assert_equal 2, ml.left
+    assert_equal [0, 0, 0, 2], ml.all_margins
+
+    assert_equal [4, 4, 4, 4], prop(:margin, 4).all_margins
+    assert_equal [2, 2, 2, 2], prop(:margin, 2).all_margins
+    assert_equal [5, 0, 0, 0], prop(:margin_top, 5).all_margins
+    assert_equal [0, 3, 0, 0], prop(:margin_right, 3).all_margins
+    assert_equal [0, 0, 10, 0], prop(:margin_bottom, 10).all_margins
+
+    assert_equal [0, 0, 0, 0], prop(:margin, :none).all_margins
+    assert_equal [0, 0, 0, 0], prop(:margin, :wat).all_margins
+    assert_equal [0, 0, 0, 0], prop(:margin_right, :none).all_margins
+
+    assert_equal [:auto, :auto, :auto, :auto], prop(:margin, :auto).all_margins
+  end
+
+  def test_can_configure_with_side_values
+    assert_equal [1, 2, 3, 4], prop(:margin, '1 2 3 4').all_margins
+    assert_equal [1, 2, 3, 0], prop(:margin, '1 2 3').all_margins
+    assert_equal [1, 2, 0, 0], prop(:margin, '1 2').all_margins
+    assert_equal [1, 0, 0, 0], prop(:margin, '1').all_margins
+
+    assert_equal [1, :auto, 0, 0], prop(:margin, '1 auto').all_margins
+    assert_equal [1, :auto, 3, :auto], prop(:margin, '1 auto 3 auto').all_margins
+    assert_equal [1, 0, 3, 0], prop(:margin, '1 wat 3 huh').all_margins
+  end
+
+  def test_can_combine_margin_properties
+    assert_equal [0, 3, 0, 2], combine([prop(:margin_left, 2), prop(:margin_right, 3)]).all_margins
+    assert_equal [0, 0, 0, 2], combine([prop(:margin_left, 2)]).all_margins
+    assert_equal [5, 2, 2, 2], combine([prop(:margin, 2), prop(:margin_top, 5)]).all_margins
+    assert_equal [5, 4, 2, 2], combine([prop(:margin, 2), prop(:margin_top, 5), prop(:margin_right, 4)]).all_margins
+    assert_equal [2, 2, 2, 2], combine([prop(:margin_top, 5), prop(:margin, 2)]).all_margins
+    assert_equal [0, 2, 2, 2], combine([prop(:margin, 2), prop(:margin_top, 0)]).all_margins
+
+    assert_equal [4, 0, 0, 0], combine([prop(:margin, :none), prop(:margin_top, 4)]).all_margins
+    assert_equal [0, 4, 4, 4], combine([prop(:margin, 4), prop(:margin_top, :none)]).all_margins
+
+    no_top = combine([prop(:margin, 3), prop(:margin_top, 0)])
+    left_and_right = combine([prop(:margin_left, 2), prop(:margin_right, 5)])
+    assert_equal [0, 5, 3, 2], combine([no_top, left_and_right]).all_margins
+  end
+
+  def test_margin_left
+    test_line = 'line needs margin'
+    stub_term_width(80)
+    assert_equal "  #{test_line}", process('line', :margin_left, 2, test_line)
+    assert_equal "          #{test_line}", process('line', :margin_left, 10, test_line)
+  end
+
+  def test_auto
+    test_line = 'the line'
+    stub_term_width(20)
+    assert_equal "      #{test_line}      ", process('line', :margin, :auto, test_line)
+    assert_equal "      #{test_line}      ", process('line', :margin_left, :auto, test_line)
+    assert_equal "      #{test_line}      ", process('line', :margin_right, :auto, test_line)
+    assert_equal "      #{test_line}      ", process('line', :margin, '0 auto', test_line)
+    assert_equal "      #{test_line}      ", process('line', :margin, '0 auto 0 auto', test_line)
+  end
+
+  private
+
+  def process(selector, property_name, value, line)
+    line = ::Styles::Line.new(line, [::Styles::Properties::Margin.new(selector, property_name, value)])
+    result = @sub_engine.process(line)
+    result.to_s
+  end
+
+  def prop(name, value, selector='test')
+    ::Styles::Properties::Margin.new(selector, name, value)
+  end
+
+  def combine(*props)
+    ::Styles::Properties::Margin.new(props.flatten)
+  end
+
+  def stub_term_width(width)
+    @sub_engine.stubs(:terminal_width).returns(width)
+  end
+end

data/test/properties/match_background_color_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class MatchBackgroundColorTest < MiniTest::Unit::TestCase
+  def test_applies_correct_colors_to_string_selector_matches
+    test_line = 'this is a test line'
+
+    assert_equal "this is a #{color.on_red}test#{color.reset} line",
+      process('test', :red, test_line)
+    assert_equal "#{color.on_blue}this is#{color.reset} a test line",
+      process('this is', :blue, test_line)
+  end
+
+  def test_applies_correct_colors_to_multiple_string_selector_matches
+    assert_equal "#{color.on_green}the#{color.reset} word #{color.on_green}the#{color.reset} is repeated",
+      process('the', :green, 'the word the is repeated')
+  end
+
+  def test_applies_correct_colors_to_regex_matches
+    assert_equal "the number #{color.on_green}89#{color.reset} is in this line",
+      process(/\d\d/, :green, 'the number 89 is in this line')
+  end
+
+  def test_applies_correct_colors_to_multiple_regex_matches
+    assert_equal "the numbers #{color.on_blue}89#{color.reset} and #{color.on_blue}22#{color.reset} are in this line",
+      process(/\d\d/, :blue, 'the numbers 89 and 22 are in this line')
+  end
+
+  def test_can_use_multiple_colors_to_match_groups
+    assert_equal "this has some color: #{color.on_red}this#{color.reset}",
+      process(/color: (\w+)/, [:red], 'this has some color: this')
+    assert_equal "numbers #{color.on_green}one#{color.reset} and #{color.on_yellow}two#{color.reset}",
+      process(/(one)[\s\w]+(two)/, [:green, :yellow], 'numbers one and two')
+    assert_equal "#{color.on_cyan}1#{color.reset} #{color.on_magenta}2#{color.reset} #{color.on_black}3#{color.reset}",
+      process(/(\d) (\d) (\d)/, [:cyan, :magenta, :black], '1 2 3')
+  end
+
+  def test_applies_colors_correctly_with_different_numbers_of_colors_and_match_groups
+    assert_equal "numbers #{color.on_green}one#{color.reset} and two",
+      process(/(one)[\s\w]+two/, [:green, :yellow], 'numbers one and two')
+    assert_equal "numbers #{color.on_green}one#{color.reset} and two",
+      process(/(one)[\s\w]+(two)/, [:green], 'numbers one and two')
+    assert_equal "numbers #{color.on_green}one#{color.reset} and #{color.on_red}two#{color.reset} and three",
+      process(/(one)[\s\w]+(two)[\s\w]+three/, [:green, :red], 'numbers one and two and three')
+  end
+
+  def test_can_specify_no_color_for_match
+    assert_equal 'no color here', process('color', :none, 'no color here')
+    assert_equal 'no color here', process(/color/, :none, 'no color here')
+  end
+
+  def test_can_specify_no_color_for_match_groups
+    assert_equal 'no color here', process(/(color)/, [:none], 'no color here')
+    assert_equal "the first and #{color.on_red}second#{color.reset} matches",
+      process(/(first)[\s\w]+(second)/, [:none, :red], 'the first and second matches')
+    assert_equal "the #{color.on_red}first#{color.reset} and second matches",
+      process(/(first)[\s\w]+(second)/, [:red, :none], 'the first and second matches')
+  end
+
+  private
+
+  def process(selector, value, line)
+    sub_engine = ::Styles::SubEngines::Color.new
+    line = ::Styles::Line.new(line, [::Styles::Properties::MatchBackgroundColor.new(selector, :match_background_color, value)])
+    sub_engine.process(line).to_s
+  end
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/properties/match_color_test.rb

@@ -0,0 +1,79 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class MatchColorTest < MiniTest::Unit::TestCase
+  def test_applies_correct_colors_to_string_selector_matches
+    test_line = 'this is a test line, to be colored'
+
+    assert_equal "this is a #{color.red}test#{color.reset} line, to be colored",
+      process('test', :red, test_line)
+    assert_equal "#{color.blue}this is#{color.reset} a test line, to be colored",
+      process('this is', :blue, test_line)
+  end
+
+  def test_invalid_values_are_ignored
+    test_line = 'this is a test line'
+    assert_equal 'this is a test line', process('test', :invalid, test_line)
+    assert_equal 'this is a test line', process(/test/, :invalid, test_line)
+    assert_equal 'this is a test line', process(/(test)/, :invalid, test_line)
+    assert_equal 'this is a test line', process(/(test) (line)/, [:invalid, :bogus], test_line)
+  end
+
+  def test_applies_correct_colors_to_multiple_string_selector_matches
+    assert_equal "#{color.green}the#{color.reset} word #{color.green}the#{color.reset} is repeated",
+      process('the', :green, 'the word the is repeated')
+  end
+
+  def test_applies_correct_colors_to_regex_matches
+    assert_equal "the number #{color.green}89#{color.reset} is in this line",
+      process(/\d\d/, :green, 'the number 89 is in this line')
+  end
+
+  def test_applies_correct_colors_to_multiple_regex_matches
+    assert_equal "the numbers #{color.blue}89#{color.reset} and #{color.blue}22#{color.reset} are in this line",
+      process(/\d\d/, :blue, 'the numbers 89 and 22 are in this line')
+  end
+
+  def test_can_use_multiple_colors_to_match_groups
+    assert_equal "this has some color: #{color.red}this#{color.reset}",
+      process(/color: (\w+)/, [:red], 'this has some color: this')
+    assert_equal "numbers #{color.green}one#{color.reset} and #{color.yellow}two#{color.reset}",
+      process(/(one)[\s\w]+(two)/, [:green, :yellow], 'numbers one and two')
+    assert_equal "#{color.cyan}1#{color.reset} #{color.magenta}2#{color.reset} #{color.black}3#{color.reset}",
+      process(/(\d) (\d) (\d)/, [:cyan, :magenta, :black], '1 2 3')
+  end
+
+  def test_applies_colors_correctly_with_different_numbers_of_colors_and_match_groups
+    assert_equal "numbers #{color.green}one#{color.reset} and two",
+      process(/(one)[\s\w]+two/, [:green, :yellow], 'numbers one and two')
+    assert_equal "numbers #{color.green}one#{color.reset} and two",
+      process(/(one)[\s\w]+(two)/, [:green], 'numbers one and two')
+    assert_equal "numbers #{color.green}one#{color.reset} and #{color.red}two#{color.reset} and three",
+      process(/(one)[\s\w]+(two)[\s\w]+three/, [:green, :red], 'numbers one and two and three')
+  end
+
+  def test_can_specify_no_color_for_match
+    assert_equal 'no color here', process('color', :none, 'no color here')
+    assert_equal 'no color here', process(/color/, :none, 'no color here')
+  end
+
+  def test_can_specify_no_color_for_match_groups
+    assert_equal 'no color here', process(/(color)/, [:none], 'no color here')
+    assert_equal "the first and #{color.red}second#{color.reset} matches",
+      process(/(first)[\s\w]+(second)/, [:none, :red], 'the first and second matches')
+    assert_equal "the #{color.red}first#{color.reset} and second matches",
+      process(/(first)[\s\w]+(second)/, [:red, :none], 'the first and second matches')
+  end
+
+  private
+
+  def process(selector, value, line)
+    sub_engine = ::Styles::SubEngines::Color.new
+    line = ::Styles::Line.new(line, [::Styles::Properties::MatchColor.new(selector, :match_color, value)])
+    sub_engine.process(line).to_s
+  end
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/properties/match_font_weight_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class MatchFontWeightTest < MiniTest::Unit::TestCase
+  def test_can_embolden_a_match
+    test_line = 'this is a test line'
+
+    assert_equal "this is a #{color.bold}test#{color.reset} line", process('test', :bold, test_line)
+    assert_equal "this is a #{color.bold}test#{color.reset} line", process(/test/, :bold, test_line)
+    assert_equal test_line, process('test', :normal, test_line)
+    assert_equal test_line, process(/test/, :normal, test_line)
+    assert_equal test_line, process('test', :invalid, test_line)
+  end
+
+  def test_can_embolden_multiple_matches
+    test_line = 'this is another test line'
+    assert_equal "this is #{color.bold}another#{color.reset} #{color.bold}test#{color.reset} line",
+      process(/(another) (test)/, [:bold, :bold], test_line)
+    assert_equal "this is #{color.bold}another#{color.reset} test line",
+      process(/(another) (test)/, [:bold, :normal], test_line)
+  end
+
+  private
+
+  def process(selector, value, line)
+    sub_engine = ::Styles::SubEngines::Color.new
+    line = ::Styles::Line.new(line, [::Styles::Properties::MatchFontWeight.new(selector, :match_font_weight, value)])
+    sub_engine.process(line).to_s
+  end
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/properties/match_text_decoration_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class MatchTextDecorationTest < MiniTest::Unit::TestCase
+  def test_decorate_match_text
+    test_line = 'this is a test line'
+
+    assert_equal "this is a #{color.underline}test#{color.reset} line", process('test', :underline, test_line)
+    assert_equal "this is a #{color.strikethrough}test#{color.reset} line", process('test', :strikethrough, test_line)
+    assert_equal "this is a #{color.strikethrough}test#{color.reset} line", process('test', :line_through, test_line)
+    assert_equal "this is a #{color.blink}test#{color.reset} line", process('test', :blink, test_line)
+    assert_equal "this is a #{color.underline}test#{color.reset} line", process(/test/, :underline, test_line)
+    assert_equal "this is a #{color.underline}test#{color.reset} line", process(/(test)/, :underline, test_line)
+    assert_equal test_line, process('test', :none, test_line)
+    assert_equal test_line, process('test', :invalid, test_line)
+  end
+
+  def test_decorate_multiple_matches
+    test_line = 'this is a another test line'
+
+    assert_equal "this is a #{color.underline}another#{color.reset} #{color.strikethrough}test#{color.reset} line",
+      process(/(another) (test)/, [:underline, :strikethrough], test_line)
+    assert_equal "this is a #{color.underline}another#{color.reset} test line",
+      process(/(another) (test)/, [:underline, :none], test_line)
+  end
+
+  private
+
+  def process(selector, value, line)
+    sub_engine = ::Styles::SubEngines::Color.new
+    line = ::Styles::Line.new(line, [::Styles::Properties::MatchTextDecoration.new(selector, :match_text_decoration, value)])
+    sub_engine.process(line).to_s
+  end
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/properties/padding_test.rb

@@ -0,0 +1,87 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class PaddingTest < MiniTest::Unit::TestCase
+  def setup
+    @sub_engine = ::Styles::SubEngines::Layout.new 
+  end
+
+  def test_can_use_all_property_names
+    [:padding, :padding_left, :padding_right, :padding_top, :padding_bottom].each do |prop_name|
+      assert_equal ::Styles::Properties::Padding, ::Styles::Properties.find_class_by_property_name(prop_name)
+    end
+  end
+
+  def test_gives_correct_padding_values
+    p = prop(:padding_left, 2)
+    assert_equal 0, p.top
+    assert_equal 0, p.right
+    assert_equal 0, p.bottom
+    assert_equal 2, p.left
+    assert_equal [0, 0, 0, 2], p.all_padding
+
+    assert_equal [4, 4, 4, 4], prop(:padding, 4).all_padding
+    assert_equal [2, 2, 2, 2], prop(:padding, 2).all_padding
+    assert_equal [5, 0, 0, 0], prop(:padding_top, 5).all_padding
+    assert_equal [0, 3, 0, 0], prop(:padding_right, 3).all_padding
+    assert_equal [0, 0, 10, 0], prop(:padding_bottom, 10).all_padding
+
+    assert_equal [0, 0, 0, 0], prop(:padding, :none).all_padding
+    assert_equal [0, 0, 0, 0], prop(:padding_right, :none).all_padding
+  end
+
+  def test_can_combine_padding_properties
+    assert_equal [0, 3, 0, 2], combine([prop(:padding_left, 2), prop(:padding_right, 3)]).all_padding
+    assert_equal [0, 0, 0, 2], combine([prop(:padding_left, 2)]).all_padding
+    assert_equal [5, 2, 2, 2], combine([prop(:padding, 2), prop(:padding_top, 5)]).all_padding
+    assert_equal [5, 4, 2, 2], combine([prop(:padding, 2), prop(:padding_top, 5), prop(:padding_right, 4)]).all_padding
+    assert_equal [2, 2, 2, 2], combine([prop(:padding_top, 5), prop(:padding, 2)]).all_padding
+    assert_equal [0, 2, 2, 2], combine([prop(:padding, 2), prop(:padding_top, 0)]).all_padding
+
+    assert_equal [4, 0, 0, 0], combine([prop(:padding, :none), prop(:padding_top, 4)]).all_padding
+    assert_equal [0, 4, 4, 4], combine([prop(:padding, 4), prop(:padding_top, :none)]).all_padding
+
+    no_top = combine([prop(:padding, 3), prop(:padding_top, 0)])
+    left_and_right = combine([prop(:padding_left, 2), prop(:padding_right, 5)])
+    assert_equal [0, 5, 3, 2], combine([no_top, left_and_right]).all_padding
+  end
+
+  def test_can_configure_with_side_values
+    assert_equal [1, 2, 3, 4], prop(:padding, '1 2 3 4').all_padding
+    assert_equal [1, 2, 3, 0], prop(:padding, '1 2 3').all_padding
+    assert_equal [1, 2, 0, 0], prop(:padding, '1 2').all_padding
+    assert_equal [1, 0, 0, 0], prop(:padding, '1').all_padding
+  end
+
+  def test_padding_left
+    test_line = 'line tests'
+    stub_term_width(80)
+    assert_equal "  #{test_line}", process('line', :padding_left, 2, test_line)
+    assert_equal "          #{test_line}", process('line', :padding_left, 10, test_line)
+  end
+
+  def test_all_padding
+    test_line = 'line tests'
+    stub_term_width(80)
+    assert_equal "#{' ' * 12}\n line tests \n#{' ' * 12}\n", process('line', :padding, 1, test_line)
+  end
+
+  private
+
+  def process(selector, property_name, value, line)
+    line = ::Styles::Line.new(line, [::Styles::Properties::Padding.new(selector, property_name, value)])
+    result = @sub_engine.process(line)
+    result.to_s
+  end
+
+  def prop(name, value, selector='test')
+    ::Styles::Properties::Padding.new(selector, name, value)
+  end
+
+  def combine(*props)
+    ::Styles::Properties::Padding.new(props.flatten)
+  end
+
+  def stub_term_width(width)
+    @sub_engine.stubs(:terminal_width).returns(width)
+  end
+end