styles 0.0.1

data/lib/styles/sub_engines.rb

@@ -0,0 +1,4 @@
+require 'styles/sub_engines/base'
+require 'styles/sub_engines/pre_processor'
+require 'styles/sub_engines/color'
+require 'styles/sub_engines/layout'

data/lib/styles/sub_engines/base.rb

@@ -0,0 +1,16 @@
+module Styles
+  module SubEngines
+    class Base
+
+      private
+
+      def extract_sub_engine_properties(properties)
+        properties.select { |prop| prop.class.sub_engines.include? self.class }
+      end
+
+      def colors
+        ::Styles::Colors
+      end
+    end
+  end
+end

data/lib/styles/sub_engines/color.rb

@@ -0,0 +1,115 @@
+module Styles
+  module SubEngines
+    class Color < Base
+
+      def process(line)
+        color_sub_engine_properties = extract_sub_engine_properties line.applicable_properties
+        line_properties, match_properties = color_sub_engine_properties.partition do |p|
+          property_type(p) == :line
+        end
+
+        line_colors = get_line_colors(line_properties)
+
+        colored_line = line.to_s.chomp
+
+        match_properties.each do |prop|
+          next unless prop.valid_value?
+          if prop.selector.is_a? String
+            colored_line = apply_string_match_property(prop, line_colors, colored_line)
+          elsif prop.selector.is_a? Regexp
+            colored_line = apply_regex_match_property(prop, line_colors, colored_line)
+          end
+        end
+
+        line.text = line_colors.any? ? "#{colors[line_colors]}#{colored_line}#{colors[:reset]}" : colored_line
+        line
+      end
+
+      private
+
+      # Get the property type (:line or :match) of a property instance
+      def property_type(property)
+        klass = property.class
+        if klass.constants.include?(:COLOR_PROPERTY_TYPE) && klass::COLOR_PROPERTY_TYPE == :match
+          :match
+        else
+          :line
+        end
+      end
+
+      def get_line_colors(line_properties)
+        line_properties.map(&:color_to_use).reject { |c| !colors.valid?(c) }.sort
+      end
+
+      # Apply a match property that has a String selector to the given line. Takes into account
+      # line property colors and makes sure the rest of the line has those applied to it.
+      def apply_string_match_property(property, line_colors, line)
+        before_match_colors, after_match_colors = colors.line_substring_color_transitions(
+          line_colors, property.color_to_use
+        )
+        line.gsub(property.selector, "#{before_match_colors}\\0#{after_match_colors}")
+      end
+
+      def apply_regex_match_property(property, line_colors, line)
+        selector, value = property.selector, property.value
+        if value.is_a? Array
+          return line unless selector.is_a?(Regexp)
+          apply_colors_to_multiple_matches(property, line_colors, line)
+        elsif value.is_a? Symbol
+          before_match_colors, after_match_colors = colors.line_substring_color_transitions(
+            line_colors, property.color_to_use
+          )
+          line.gsub(selector) { |match| "#{before_match_colors}#{match}#{after_match_colors}" }
+        else
+          line
+        end
+      end
+
+      # Use the Regexp selector to determine match groups on the given line. Then apply the array
+      # of colors to the each match group, first color to first group and so on. Ignore the last
+      # match groups if they do not have corresponding colors and vice versa.
+      #
+      # If there are color that should be applied to the entire line then make sure to turn them
+      # off before applying match colors and back on after the match.
+      def apply_colors_to_multiple_matches(property, line_colors, line)
+        selector, match_colors = property.selector, [property.color_to_use].flatten
+        match_data = selector.match(line)
+        return line unless match_data && (match_data.size > 1)
+        colored_line = line.dup
+
+        offsets = (1...(match_data.size)).to_a.map { |idx| match_data.offset(idx) }
+
+        # Work backward through the matches because working forward would throw off indicies.
+        # Determine the original index of the match and apply the corresponding color. If we
+        # do not have enough colors for the last match(es) then skip them.
+        # TODO: clean this up, it just feels hacky
+        offsets.reverse.each_with_index do |offset, index|
+          orig_match_index = offsets.size - index - 1
+          match_color = match_colors[orig_match_index]
+          next unless match_color
+
+          before_match_colors, after_match_colors = colors.line_substring_color_transitions(
+            line_colors, match_color
+          )
+
+          beg_idx, end_idx = offset
+          colored_line.insert(end_idx, after_match_colors)
+          colored_line.insert(beg_idx, before_match_colors)
+        end
+
+        colored_line
+      end
+
+      module PropertyMixin
+        # Can be overridden if the color to use should be derived differently
+        def color_to_use
+          value
+        end
+
+        def valid_value?
+          self.class::VALUES.include?(value)
+        end
+      end
+    end
+  end
+end

data/lib/styles/sub_engines/layout.rb

@@ -0,0 +1,158 @@
+require 'ostruct'
+
+module Styles
+  module SubEngines
+    class Layout < Base
+
+      def process(line)
+        layout_sub_engine_properties = extract_sub_engine_properties line.applicable_properties
+
+        if should_hide?(line)
+          line.text = nil
+          return line
+        end
+
+        apply_width_and_text_align(line)
+        apply_padding_border_margin(line)
+
+        line
+      end
+
+      private
+
+      def should_hide?(line)
+        display_property = line.applicable_properties.find { |prop| prop.class == ::Styles::Properties::Display }
+        display_property && ::Styles::Properties::Display::HIDE_VALUES.include?(display_property.value)
+      end
+
+      def apply_width_and_text_align(line)
+        width_prop, text_align_prop = line.prop(:width), line.prop(:text_align)
+        size_no_color = colors.uncolor(line.text).size
+        width = width_prop ? width_prop.width : terminal_width
+
+        return if size_no_color >= width
+        diff = width - size_no_color
+
+        bg_color = if bg_color_prop = line.prop(:background_color)
+                     bg_color_prop.color_to_use
+                   else
+                     :none
+                   end
+
+        if text_align_prop
+          case text_align_prop.value
+          when :left
+            # Pad right only if width explicitly set
+            line.text = "#{line.text}#{colors.color(' ' * diff, bg_color)}" if width_prop
+          when :right
+            pad = ' ' * diff
+            pad = colors.color(pad, bg_color) if width_prop
+            line.text = "#{pad}#{line.text}"
+          when :center
+            before, after = (' ' * (diff/2)), (' ' * (diff/2 + diff%2))
+            before, after = [before, after].map { |pad| colors.color(pad, bg_color)} if width_prop
+            line.text = "#{before}#{line.text}#{after}"
+          end
+        else
+          # Assume left align, pad right only if width explicitly set
+          line.text = "#{line.text}#{colors.color(' ' * diff, bg_color)}" if width_prop
+        end
+      end
+
+      def apply_padding_border_margin(line)
+        padding, margin = (line.prop(:padding) || blank_space_property), (line.prop(:margin) || blank_space_property)
+        border = line.prop(:border) || ::Styles::Properties::Border.new(:any, :border, :none)
+
+        return unless padding || margin || border
+
+        bg_color = if bg_color_prop = line.prop(:background_color)
+                     bg_color_prop.valid_value? ? bg_color_prop.color_to_use : :none
+                   else
+                     :none
+                   end
+
+        # First establish the main line padding and border
+        line.left = colors.force_color("#{border.left_char}#{' ' * padding.left}", bg_color)
+        line.right = colors.force_color("#{' ' * padding.right}#{border.right_char}", bg_color)
+
+        # Calculate margins and add to the main line
+        margin_left, margin_right =
+          if margin.left == :auto || margin.right == :auto
+            diff = terminal_width - line.total_width
+            if diff > 0
+              [(' ' * (diff/2)), (' ' * (diff/2 + diff%2))]
+            else
+              ['', '']
+            end
+          else
+            [' ' * margin.left, ' ' * margin.right]
+          end
+
+        line.left = margin_left + line.left
+        line.right = line.right + margin_right
+
+        content_width = line.content_width
+        border_width = padding.left + content_width + padding.right
+
+        margin_line = "#{' ' * line.total_width}\n"
+        padding_line = "#{margin_left}#{colors.color(' ' * border_width, bg_color)}#{margin_right}\n"
+
+        line.top = margin_line * margin.top if margin.top.is_a?(Integer)
+
+        extender_line = margin_left +
+          colors.force_color("#{border.left_char}#{' ' * border_width}#{border.right_char}", bg_color) +
+            margin_right + "\n"
+
+        if border.top == :none
+          line.top << padding_line * padding.top
+        else
+          line.top << margin_left +
+            colors.force_color("#{border.top_line_chars(border_width)}", bg_color) +
+              margin_right + "\n"
+          line.top << (extender_line * padding.top) if padding.top > 0
+        end
+
+        if border.bottom == :none
+          line.bottom = padding_line * padding.bottom
+        else
+          line.bottom = ''
+          line.bottom << (extender_line * padding.bottom) if padding.bottom > 0
+          line.bottom << margin_left +
+            colors.force_color("#{border.bottom_line_chars(border_width)}", bg_color) +
+              margin_right + "\n"
+        end
+
+        line.bottom << margin_line * margin.bottom if margin.bottom.is_a?(Integer)
+      end
+
+      def apply_margin(line)
+        margin = line.prop(:margin)
+        return unless margin
+
+        if margin.left > 0
+          line.left = ' ' * margin.left
+        end
+      end
+
+      # Tries to determine terminal width, returns 80 by default
+      def terminal_width
+        require 'io/console'
+        IO.console.winsize[1]
+      rescue LoadError
+        begin
+          `tput co`.to_i
+        rescue
+          80
+        end
+      end
+
+      def blank_space_property
+        OpenStruct.new(top: 0, right: 0, bottom: 0, left: 0)
+      end
+
+      def blank_border_property
+        OpenStruct.new(top: :none, right: :none, bottom: :none, left: :none)
+      end
+    end
+  end
+end

data/lib/styles/sub_engines/pre_processor.rb

@@ -0,0 +1,19 @@
+module Styles
+  module SubEngines
+    class PreProcessor < Base
+      def process(line)
+        apply_function(line)
+
+        line
+      end
+
+      private
+
+      def apply_function(line)
+        if (fn = line.prop(:function)) && fn.value.respond_to?(:call)
+          line.text = fn.value.call(line.text)
+        end
+      end
+    end
+  end
+end

data/lib/styles/version.rb

@@ -0,0 +1,3 @@
+module Styles
+  VERSION = '0.0.1'
+end

data/styles.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'styles/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'styles'
+  gem.version       = Styles::VERSION
+  gem.authors       = ['Aaron Royer']
+  gem.email         = ['aaronroyer@gmail.com']
+  gem.description   = %q{plain text stylesheets}
+  gem.summary       = %q{A utility for processing text that provides a Ruby DSL leveraging CSS concepts}
+  gem.homepage      = 'http://github.com/aaronroyer/styles'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.required_ruby_version = '>= 1.9.0'
+
+  gem.add_dependency 'term-ansicolor', '>= 1.1.0'
+
+  gem.add_development_dependency 'timecop'
+  gem.add_development_dependency 'mocha'
+end

data/test/application_test.rb

@@ -0,0 +1,92 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'term/ansicolor'
+require 'tmpdir'
+require 'stringio'
+require 'fileutils'
+require 'timecop'
+
+class ApplicationTest < MiniTest::Unit::TestCase
+  def setup
+    ENV['STYLES_DIR'] = @stylesheets_dir = Dir.mktmpdir
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@stylesheets_dir) if File.directory?(@stylesheets_dir)
+    ENV['STYLES_DIR'] = nil
+  end
+
+  def test_run_with_default_stylesheet
+    File.open(File.join(stylesheets_dir, 'default.rb'), 'w') do |f|
+      f.write " 'hide' - { display: none } "
+    end
+
+    input = StringIO.new "hide this\nnot this\n", 'r'
+    output = StringIO.new
+
+    app = ::Styles::Application.new input_stream: input, output_stream: output
+    app.send :read_stylesheets
+    app.send :process
+
+    assert_equal "not this\n", output.string
+  end
+
+  def test_auto_reload_updated_stylesheet
+    default_stylesheet = File.join stylesheets_dir, 'default.rb'
+    File.open(default_stylesheet, 'w') { |f| f.write " 'word' - { color: green } " }
+
+    input = StringIO.new "has a word\nhas a word\n", 'r'
+    output = StringIO.new
+    app = ::Styles::Application.new input_stream: input, output_stream: output
+
+    app.send :read_stylesheets
+    app.send :process_next_line
+    assert_equal "#{color.green}has a word#{color.reset}\n", output.string
+
+    orig_time = Time.now
+
+    output.truncate(output.rewind)
+
+    File.open(default_stylesheet, 'w') { |f| f.write " 'word' - { color: red } " }
+    FileUtils.touch(default_stylesheet, mtime: orig_time + 2)
+
+    Timecop.freeze(orig_time + 4) do
+      app.send :process_next_line
+    end
+    assert_equal "#{color.red}has a word#{color.reset}\n", output.string
+  end
+
+  def test_does_not_auto_reload_updated_stylesheet_inside_check_interval
+    interval = ::Styles::Application::STYLESHEET_CHECK_INTERVAL_SECONDS
+
+    default_stylesheet = File.join stylesheets_dir, 'default.rb'
+    File.open(default_stylesheet, 'w') { |f| f.write " 'word' - { color: green } " }
+
+    input = StringIO.new "has a word\nhas a word\n", 'r'
+    output = StringIO.new
+    app = ::Styles::Application.new input_stream: input, output_stream: output
+
+    app.send :read_stylesheets
+    app.send :process_next_line
+    assert_equal "#{color.green}has a word#{color.reset}\n", output.string
+
+    orig_time = Time.now
+
+    output.truncate(output.rewind)
+
+    File.open(default_stylesheet, 'w') { |f| f.write " 'word' - { color: red } " }
+    FileUtils.touch(default_stylesheet, mtime: orig_time + (interval - 1))
+
+    Timecop.freeze(orig_time + (interval - 1)) do
+      app.send :process_next_line
+    end
+    assert_equal "#{color.green}has a word#{color.reset}\n", output.string
+  end
+
+  private
+
+  attr_reader :stylesheets_dir
+
+  def color
+    ::Term::ANSIColor
+  end
+end

data/test/colors_test.rb

@@ -0,0 +1,162 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'term/ansicolor'
+
+class ColorsTest < MiniTest::Unit::TestCase
+
+  def test_can_access_basic_colors_with_brackets
+    assert_equal ansi.red, c[:red]
+    assert_equal ansi.blue, c[:blue]
+    assert_equal ansi.on_cyan, c[:on_cyan]
+
+    assert_nil c[:bogus]
+  end
+
+  def test_can_access_compound_colors_with_brackets
+    assert_equal ansi.on_white + ansi.red , c[:red_on_white]
+    assert_equal ansi.blue + ansi.on_blue, c[:blue_on_blue]
+
+    assert_nil c[:red_on_bogus]
+    assert_nil c[:bogus_on_bogus]
+    assert_nil c[:bogus_on_red]
+  end
+
+  def test_can_access_multiple_colors_with_brackets
+    assert_equal ansi.red + ansi.white, c[:red, :white]
+    assert_equal ansi.blue + ansi.red + ansi.white, c[:red, :white, :blue]
+    assert_equal ansi.on_blue + ansi.red + ansi.white, c[:red, :white_on_blue]
+  end
+
+  def test_can_use_arrays_of_colors_with_brackets
+    assert_equal ansi.red + ansi.white, c[[:red, :white]]
+    assert_equal ansi.blue + ansi.red + ansi.white, c[[:red, :white, :blue]]
+    assert_equal ansi.on_blue + ansi.red + ansi.white, c[[:red, :white_on_blue]]
+  end
+
+  def test_maps_certain_css_values_to_ansi
+    assert_equal ansi.strikethrough, c[:line_through]
+  end
+
+  def test_basic_colors_are_valid
+    assert c.valid?(:red)
+    assert c.valid?(:on_red)
+    assert c.valid?(:green)
+    assert c.valid?(:on_green)
+    assert c.valid?(:magenta)
+    assert c.valid?(:on_magenta)
+
+    assert !c.valid?(:bogus)
+    assert !c.valid?(:on_bogus)
+  end
+
+  def test_compound_colors_are_valid
+    assert c.valid?(:red_on_white)
+    assert c.valid?(:blue_on_blue)
+    assert c.valid?(:black_on_blue)
+
+    assert !c.valid?(:blue_on_bogus)
+    assert !c.valid?(:bogus_on_blue)
+  end
+
+  def test_various_other_ansi_escape_codes_are_valid
+    assert c.valid?(:bold)
+    assert c.valid?(:line_through), 'Mapped values are also valid'
+  end
+
+  def test_hard_color_transitions
+    assert_equal ansi.red, c.color_transition([:blue], [:red])
+    assert_equal ansi.red, c.color_transition(:blue, :red)
+    assert_equal ansi.reset + ansi.red, c.color_transition(:on_blue, :red)
+    assert_equal ansi.red + ansi.on_white, c.color_transition([:green, :on_blue], [:red, :on_white])
+    assert_equal ansi.reset + ansi.underline, c.color_transition(:blue, :underline)
+    assert_equal ansi.reset + ansi.blue, c.color_transition(:underline, :blue)
+  end
+
+  def test_soft_color_transitions
+    assert_equal ansi.red, c.color_transition([:blue], [:red], false)
+    assert_equal ansi.red, c.color_transition([:on_blue], [:red], false)
+    assert_equal ansi.on_red, c.color_transition([:blue], [:on_red], false)
+    assert_equal ansi.red, c.color_transition([:green, :on_blue], [:red], false)
+    assert_equal ansi.underline, c.color_transition(:blue, :underline, false)
+    assert_equal ansi.blue, c.color_transition(:underline, :blue, false)
+
+    assert_equal ansi.red, c.color_transition([:blue], [:red], false)
+    assert_equal '', c.color_transition([:blue], [:blue], false)
+  end
+
+  def test_color_transitions_blank_when_not_necessary
+    assert_equal '', c.color_transition([:blue], [:blue])
+    assert_equal '', c.color_transition([:on_white], [:on_white])
+    assert_equal '', c.color_transition([:underline], [:underline])
+    assert_equal '', c.color_transition([:blue, :on_white], [:blue, :on_white])
+    assert_equal '', c.color_transition([:blue, :on_white, :underline], [:blue, :on_white, :underline])
+    assert_equal '', c.color_transition([:blue, :on_white], [:on_white, :blue])
+  end
+
+  def test_color_transition_with_negations
+    assert_equal ansi.reset, c.color_transition(:blue, :no_fg_color)
+    assert_equal ansi.reset, c.color_transition(:on_blue, :no_bg_color)
+    assert_equal ansi.reset, c.color_transition(:blue, :no_bg_color)
+
+    assert_equal ansi.reset, c.color_transition([:blue, :on_white], :no_bg_color)
+    assert_equal ansi.reset + ansi.red, c.color_transition([:blue, :on_white], [:red, :no_bg_color])
+    assert_equal ansi.reset + ansi.blue, c.color_transition([:blue, :on_white], [:blue, :no_bg_color])
+
+    assert_equal ansi.reset + ansi.red, c.color_transition([:blue, :on_white], [:red, :no_bg_color])
+    assert_equal ansi.reset + ansi.blue, c.color_transition([:blue, :on_white], [:blue, :no_bg_color])
+
+    assert_equal ansi.blue, c.color_transition(:no_fg_color, :blue)
+    assert_equal ansi.on_red, c.color_transition(:no_bg_color, :on_red)
+    assert_equal '', c.color_transition([:blue, :no_bg_color], :blue)
+    assert_equal ansi.on_blue, c.color_transition(:no_fg_color, :on_blue)
+    assert_equal '', c.color_transition([:no_fg_color, :on_blue], :on_blue)
+
+
+    assert_equal ansi.reset, c.color_transition(:blue, :no_fg_color, false)
+    assert_equal ansi.reset, c.color_transition(:on_blue, :no_bg_color, false)
+    assert_equal '', c.color_transition(:blue, :no_bg_color, false)
+
+    assert_equal ansi.reset + ansi.blue, c.color_transition([:blue, :on_white], :no_bg_color, false)
+    assert_equal ansi.reset + ansi.red, c.color_transition([:blue, :on_white], [:red, :no_bg_color], false)
+    assert_equal ansi.reset + ansi.blue, c.color_transition([:blue, :on_white], [:blue, :no_bg_color], false)
+
+    assert_equal ansi.reset + ansi.red, c.color_transition([:blue, :on_white], [:red, :no_bg_color], false)
+    assert_equal ansi.reset + ansi.blue, c.color_transition([:blue, :on_white], [:blue, :no_bg_color], false)
+
+    assert_equal ansi.blue, c.color_transition(:no_fg_color, :blue, false)
+    assert_equal ansi.on_red, c.color_transition(:no_bg_color, :on_red, false)
+    assert_equal '', c.color_transition([:blue, :no_bg_color], :blue, false)
+    assert_equal ansi.on_blue, c.color_transition(:no_fg_color, :on_blue, false)
+    assert_equal '', c.color_transition([:no_fg_color, :on_blue], :on_blue, false)
+  end
+
+  def test_can_color_strings_with_auto_reset
+    assert_equal ansi.blue + 'hello' + ansi.reset, c.color('hello', :blue)
+    assert_equal ansi.blue + ansi.on_green + 'hello' + ansi.reset, c.color('hello', :blue, :on_green)
+    assert_equal ansi.blue + ansi.on_green + 'hello' + ansi.reset, c.color('hello', [:blue, :on_green])
+    assert_equal ansi.underline + 'hello' + ansi.reset, c.color('hello', :underline)
+    assert_equal 'hello', c.color('hello', :invalid)
+    assert_equal 'hello', c.color('hello', :none)
+    assert_equal ansi.red + 'hello' + ansi.reset, c.color('hello', :none, :red)
+    assert_equal '', c.color('', :red)
+  end
+
+  def test_force_color
+    str = "has #{ansi.red}some#{ansi.reset} red"
+    assert_equal "#{ansi.on_blue}has #{ansi.red}some#{ansi.reset}#{ansi.on_blue} red#{ansi.reset}",
+      c.force_color(str, :on_blue)
+
+    assert_equal ansi.blue + 'hello' + ansi.reset, c.force_color('hello', :blue)
+    assert_equal '', c.force_color('', :red)
+  end
+
+  private
+
+  def c
+    ::Styles::Colors
+  end
+
+  def ansi
+    ::Term::ANSIColor
+  end
+end
+