styles 0.0.1

data/lib/styles/core_ext.rb

@@ -0,0 +1,12 @@
+
+[String, Regexp, Symbol].each do |klass|
+  klass.class_eval do
+
+    # Associates the receiver object with a hash of properties and adds the
+    # receiver and properties to the array of rules being parsed, in the global
+    # variable <tt>$current_stylesheet_rules</tt>.
+    def -(properties_hash)
+      $current_stylesheet_rules << [self, properties_hash]
+    end
+  end
+end

data/lib/styles/engine.rb

@@ -0,0 +1,73 @@
+require 'term/ansicolor'
+
+module Styles
+
+  # Takes one or more Stylesheets and applies the rules from them to lines of text.
+  class Engine
+    attr_reader :stylesheets
+
+    def initialize(*stylesheets)
+      @stylesheets = [stylesheets].flatten
+    end
+
+    # Process a line according to the rules that comprise all of the Stylesheets.
+    #
+    # For all the rules that are applicable to this line, find the last defined of each type of
+    # property and apply it.
+    #
+    # Returns nil if the line is hidden or otherwise should not be displayed.
+    def process(line)
+      applicable_rules = rules.find_all { |rule| rule.applicable?(line) }
+
+      simple_properties = {}
+      multiple_names_properties = {}
+      applicable_rules.each do |rule|
+        rule.properties.each do |property|
+          if property.class.multiple_names?
+            (multiple_names_properties[property.class.to_sym] ||= []) << property
+          else
+            simple_properties[property.class.to_sym] = property
+          end
+        end
+      end
+
+      properties = simple_properties.values
+
+      multiple_names_properties.keys.each do |basic_name|
+        props = multiple_names_properties[basic_name]
+        prop_class = props.first.class
+        properties << prop_class.new(props)
+      end
+
+      line_obj = ::Styles::Line.new(line, properties)
+
+      sub_engines.each do |sub_engine|
+        line_obj = sub_engine.process(line_obj)
+        return nil if line_obj.text.nil?
+      end
+
+      line_obj.to_s
+    end
+
+    private
+
+    # Returns instances SubEngines in the order that they should be used in processing.
+    def sub_engines
+      @sub_engines ||= begin
+        [
+          ::Styles::SubEngines::PreProcessor.new,
+          ::Styles::SubEngines::Color.new,
+          ::Styles::SubEngines::Layout.new
+        ]
+      end
+    end
+
+    def rules
+      stylesheets.map(&:rules).flatten
+    end
+
+    def color
+      ::Term::ANSIColor
+    end
+  end
+end

data/lib/styles/line.rb

@@ -0,0 +1,55 @@
+module Styles
+  class Line
+    attr_accessor :applicable_properties, :top, :right, :bottom, :left
+    attr_reader :original
+    attr_writer :text
+
+    def initialize(line, properties=nil)
+      @original = line
+      @original.freeze
+      @applicable_properties = properties
+
+      @text = @original.dup
+      @top = @right = @bottom = @left = ''
+    end
+
+    # The current content of the line, possibly already altered by processing. By content we mean
+    # the line without additional layout characters (margin, padding, border) being applied around
+    # it. This does, however, include color information that may have been added.
+    def text
+      @text.nil? ? nil : @text.dup
+    end
+
+    # The line's main text content surrounded by any extra layout characters that may have been
+    # applied (margin, padding, border). When processing is complete this represents the complete
+    # result to be written to the output stream.
+    def to_s
+      return '' unless text
+      bottom_and_newline = "\n#{bottom}" if bottom && !bottom.empty?
+      "#{top}#{left}#{text}#{right}#{bottom_and_newline}"
+    end
+
+    def total_width
+      colors.uncolor("#{left}#{text}#{right}").size
+    end
+
+    def content_width
+      colors.uncolor(text).size
+    end
+
+    def prop(property_name)
+      prop_name = property_name.to_sym
+      applicable_properties.find { |prop| prop.class.to_sym == prop_name }
+    end
+
+    def prop?(property_name)
+      !!prop(property_name)
+    end
+
+    private
+
+    def colors
+      ::Styles::Colors
+    end
+  end
+end

data/lib/styles/properties.rb

@@ -0,0 +1,34 @@
+%w[
+  base
+  display
+  color
+  background_color
+  font_weight
+  text_decoration
+  match_color
+  match_background_color
+  match_font_weight
+  match_text_decoration
+  text_align
+  padding
+  margin
+  border
+  width
+  function
+].each { |property| require "styles/properties/#{property}" }
+
+module Styles
+  module Properties
+
+    def self.all_property_classes
+      constants = ::Styles::Properties.constants - [:Base]
+      constants.map { |con| ::Styles::Properties.const_get(con) }
+    end
+
+    def self.find_class_by_property_name(name)
+      name = name.to_sym
+      all_property_classes.find { |klass| klass.names.include? name }
+    end
+
+  end
+end

data/lib/styles/properties/background_color.rb

@@ -0,0 +1,15 @@
+module Styles
+  module Properties
+    class BackgroundColor < Base
+      sub_engine :color
+
+      VALUES = (Styles::Colors::COLOR_VALUES + [:none]).freeze
+
+      # Convert foreground colors to background
+      def color_to_use
+        return :no_bg_color if value == :none
+        value =~ /^on_/ ? value : "on_#{value}".to_sym
+      end
+    end
+  end
+end

data/lib/styles/properties/base.rb

@@ -0,0 +1,68 @@
+require 'term/ansicolor'
+
+module Styles
+  module Properties
+    class Base
+      attr_accessor :selector, :name, :value
+
+      def self.sub_engines
+        @sub_engines ||= []
+      end
+
+      # Macro to specify a sub-engine that this property is processed by
+      def self.sub_engine(name)
+        sub_engine_class = ::Styles::SubEngines.const_get(camelize(name.to_s))
+        sub_engines << sub_engine_class
+
+        begin
+          include sub_engine_class::PropertyMixin
+        rescue NameError
+          # do nothing if PropertyMixin does not exist for SubEngine
+        end
+      end
+
+      # The name of this property, for use in stylesheets, as a Symbol
+      def self.to_sym
+        underscore(name).split('/').last.to_sym
+      end
+
+      # Macro to specify other names that a property class uses, besides the main +to_sym+ version
+      def self.other_names(*names)
+        @other_names = names
+        @names = self.names
+      end
+
+      def self.names
+        @names ||= [to_sym, instance_variable_get('@other_names')].flatten.compact
+      end
+
+      def self.multiple_names?
+        names.size > 1
+      end
+
+      def initialize(selector, name, value)
+        @selector, @name, @value = selector, name, value
+      end
+
+      def colors
+        ::Styles::Colors
+      end
+
+      private
+
+      def self.underscore(word)
+        word = word.dup
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      def self.camelize(word)
+        word.capitalize.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }
+      end
+    end
+  end
+end

data/lib/styles/properties/border.rb

@@ -0,0 +1,147 @@
+module Styles
+  module Properties
+    class Border < Base
+      # :dashed the same as :dotted
+      STYLES = [:solid, :dashed, :dotted, :double]
+
+      SOLID_CHARS = { top: "\u2500", right: "\u2502", bottom: "\u2500", left: "\u2502",
+        top_left: "\u250C", top_right: "\u2510", bottom_left: "\u2514", bottom_right: "\u2518" }.freeze
+      SOLID_BOLD_CHARS = { top: "\u2501", right: "\u2503", bottom: "\u2501", left: "\u2503",
+        top_left: "\u250F", top_right: "\u2513", bottom_left: "\u2517", bottom_right: "\u251B" }.freeze
+      DOUBLE_CHARS = { top: "\u2550", right: "\u2551", bottom: "\u2550", left: "\u2551",
+        top_left: "\u2554", top_right: "\u2557", bottom_left: "\u255A", bottom_right: "\u255D" }.freeze
+
+      # dotted doesn't have its own corners, reuse solid
+      DOTTED_CHARS = { top: "\u2504", right: "\u2506", bottom: "\u2504", left: "\u2506",
+        top_left: "\u250F", top_right: "\u2513", bottom_left: "\u2517", bottom_right: "\u251B" }.freeze
+      DASHED_CHARS = DOTTED_CHARS
+
+      STYLE_CHARS = {
+        solid: SOLID_CHARS, dotted: DOTTED_CHARS, dashed: DASHED_CHARS, double: DOUBLE_CHARS
+      }.freeze
+
+      sub_engine :layout
+      other_names :border_left, :border_right, :border_top, :border_bottom
+
+      attr_reader :top, :right, :bottom, :left
+
+      def initialize(*args)
+        if args.size == 1 && args.first.is_a?(Array)
+          @sub_properties = args.first
+        else
+          super
+          @sub_properties = nil
+        end
+        compute_all_border_values
+      end
+
+      def all_border_values
+        [top, right, bottom, left]
+      end
+
+      # Generate methods for returning the proper characters to make up this border
+      [
+        :top_char, :right_char, :bottom_char, :left_char,
+        :top_left_char, :top_right_char, :bottom_left_char, :bottom_right_char
+      ].each do |method_name|
+        str = method_name.to_s
+        position = str.sub(/_char$/, '')
+
+        define_method(method_name) do |*args|
+          raise ArgumentError, "Wrong number of arguments to #{method_name}: #{args.size}" if args.size > 1
+
+          return '' if position.split('_').any? { |side| send(side) == :none }
+
+          side_style = send(str.split('_').first)
+          return '' if side_style == :none
+          times = args.size == 1 ? args.first.to_i : 1
+          # TODO: check color validity
+          style, color = side_style
+
+          begin_color, end_color = if color != :default
+            [colors[color], colors[:reset]]
+          else
+            ['', '']
+          end
+
+          "#{begin_color}#{STYLE_CHARS[style][position.to_sym] * times}#{end_color}"
+        end
+      end
+
+      # Draws the top line portion of a border with the specified inner width
+      def top_line_chars(width)
+        return '' if top == :none
+        tl = top_left_char.empty? ? (left == :none ? '' : ' ') : top_left_char
+        tr = top_right_char.empty? ? (right == :none ? '' : ' ') : top_right_char
+        "#{tl}#{top_char(width)}#{tr}"
+      end
+
+      # Draws the bottom line portion of a border with the specified inner width
+      def bottom_line_chars(width)
+        return '' if bottom == :none
+        bl = bottom_left_char.empty? ? (left == :none ? '' : ' ') : bottom_left_char
+        br = bottom_right_char.empty? ? (right == :none ? '' : ' ') : bottom_right_char
+        "#{bl}#{bottom_char(width)}#{br}"
+      end
+
+      private
+
+      def compute_all_border_values
+        if @sub_properties
+          set_all_border_values(:none)
+
+          @sub_properties.each do |sub_prop|
+            if sub_prop.name == :border
+              set_all_border_values(parse_value(sub_prop.value))
+            else
+              set_border_value($1, parse_value(value))
+              set_border_value(sub_prop.name.to_s.sub(/^border_/, ''), parse_value(sub_prop.value))
+            end
+          end
+        else
+          if name == :border
+            set_all_border_values(parse_value(value))
+          elsif name.to_s =~ /border_(\w+)/
+            set_all_border_values(:none)
+            set_border_value($1, parse_value(value))
+          end
+        end
+      end
+
+      # Converts a "raw" value into an array of values specifying a border. Returns an array
+      # of the parsed sub-values, the style first and color second,
+      #
+      # Values can be in the following forms.
+      #
+      # Only a style, with default color assumed
+      #   'solid'
+      # or
+      #   :solid
+      #
+      # A style and a color
+      #   'dotted red'
+      def parse_value(val)
+        return val if val == :none
+        default = [:solid, :default]
+        if val.is_a?(Symbol) && STYLES.include?(val)
+          [val, :default]
+        elsif val.is_a?(String)
+          parts = val.split
+          style = (parts[0] && STYLES.include?(parts[0].to_sym)) ? parts[0].to_sym : :solid
+          color = parts[1] ? parts[1].to_sym : :default
+          [style, color]
+        else
+          default
+        end
+      end
+
+      def set_all_border_values(val)
+        @top = @right = @bottom = @left = val
+      end
+
+      def set_border_value(which, val)
+        instance_variable_set("@#{which}".to_sym, val)
+      end
+    end
+  end
+end

data/lib/styles/properties/color.rb

@@ -0,0 +1,16 @@
+module Styles
+  module Properties
+    class Color < Base
+      sub_engine :color
+
+      def valid_value?
+        return true if value == :none
+        colors[value]
+      end
+
+      def color_to_use
+        value == :none ? :no_fg_color : value
+      end
+    end
+  end
+end

data/lib/styles/properties/display.rb

@@ -0,0 +1,10 @@
+module Styles
+  module Properties
+    class Display < Base
+      sub_engine :layout
+
+      SHOW_VALUES = [:block, :inline, :inline_block, true].freeze
+      HIDE_VALUES = [:none, false].freeze
+    end
+  end
+end

data/lib/styles/properties/font_weight.rb

@@ -0,0 +1,13 @@
+module Styles
+  module Properties
+    class FontWeight < Base
+      sub_engine :color
+
+      VALUES = [:normal, :bold].freeze
+
+      def color_to_use
+        value == :normal ? :no_bold : value
+      end
+    end
+  end
+end