styles 0.0.1

data/lib/styles/properties/function.rb

@@ -0,0 +1,7 @@
+module Styles
+  module Properties
+    class Function < Base
+      sub_engine :pre_processor
+    end
+  end
+end

data/lib/styles/properties/margin.rb

@@ -0,0 +1,83 @@
+module Styles
+  module Properties
+    class Margin < Base
+      sub_engine :layout
+      other_names :margin_left, :margin_right, :margin_top, :margin_bottom
+
+      attr_reader :top, :right, :bottom, :left
+
+      def initialize(*args)
+        if args.size == 1 && args.first.is_a?(Array)
+          @name = :margin
+          @sub_properties = args.first
+        else
+          if (val = args[2]).is_a?(String)
+            @name = :margin
+            @sub_properties = []
+            side_values = args[2].split.map do |side_value|
+              side_value == 'auto' ? :auto : side_value.to_i
+            end
+            %w[top right bottom left].each_with_index do |side, idx|
+              side_value = side_values[idx]
+              if side_value
+                @sub_properties << self.class.new(args[0], "margin_#{side}".to_sym, side_value)
+              end
+            end
+          else
+            super
+            @sub_properties = nil
+          end
+        end
+        compute_all_margins
+      end
+
+      def all_margins
+        [top, right, bottom, left]
+      end
+
+      protected
+
+      attr_reader :sub_properties
+
+      # Hash of margins that have been defined (nil if not defined) for internal tracking and
+      # combination of sub-properties
+      attr_accessor :defined_margins
+
+      # If the value is an integer, returns that. For any other value, including the valid
+      # <tt>:none</tt> value, <tt>0</tt> is returned.
+      def normalized_value
+        (value.is_a?(Integer) || value == :auto) ? value : 0
+      end
+
+      private
+
+      def compute_all_margins
+        @defined_margins = { top: nil, right: nil, bottom: nil, left: nil }
+
+        if @sub_properties
+          @sub_properties.each do |sub_prop|
+            if sub_prop.name == :margin
+              @defined_margins.merge!(sub_prop.defined_margins.dup.delete_if { |k,v| v.nil? })
+            else
+              @defined_margins.merge!(
+                { sub_prop.name.to_s.sub(/^margin_/, '').to_sym => sub_prop.normalized_value }
+              )
+            end
+          end
+        else
+          if name == :margin
+            [:top, :right, :bottom, :left].each { |side| @defined_margins[side] = normalized_value }
+          elsif name.to_s =~ /margin_(\w+)/
+            @defined_margins[$1.to_sym] = normalized_value
+          end
+        end
+
+        @defined_margins.each_pair { |side, val| set_margin(side, val) }
+      end
+
+      def set_margin(which, val)
+        instance_variable_set("@#{which}".to_sym, (val.nil? ? 0 : val))
+      end
+    end
+  end
+end

data/lib/styles/properties/match_background_color.rb

@@ -0,0 +1,28 @@
+module Styles
+  module Properties
+    class MatchBackgroundColor < Base
+      sub_engine :color
+
+      COLOR_PROPERTY_TYPE = :match
+
+      def valid_value?
+        [value].flatten.all? { |color| colors.is_basic_color?(color) || color == :none }
+      end
+
+      def color_to_use
+        if value.is_a? Array
+          value.map { |color| convert_to_background_color color }
+        elsif value.is_a? Symbol
+          convert_to_background_color value
+        end
+      end
+
+      private
+
+      def convert_to_background_color(color)
+        return :no_bg_color if color == :none
+        color =~ /^on_/ ? color : "on_#{color}".to_sym
+      end
+    end
+  end
+end

data/lib/styles/properties/match_color.rb

@@ -0,0 +1,21 @@
+module Styles
+  module Properties
+    class MatchColor < Base
+      sub_engine :color
+
+      COLOR_PROPERTY_TYPE = :match
+
+      def valid_value?
+        [value].flatten.all? { |color| colors.is_basic_color?(color) || color == :none }
+      end
+
+      def color_to_use
+        if value.is_a? Array
+          value.map { |color| color == :none ? :no_fg_color : color }
+        elsif value.is_a? Symbol
+          value == :none ? :no_fg_color : value
+        end
+      end
+    end
+  end
+end

data/lib/styles/properties/match_font_weight.rb

@@ -0,0 +1,23 @@
+module Styles
+  module Properties
+    class MatchFontWeight < Base
+      sub_engine :color
+
+      COLOR_PROPERTY_TYPE = :match
+
+      VALUES = [:normal, :bold].freeze
+
+      def valid_value?
+        [value].flatten.all? { |sub_value| VALUES.include?(sub_value) }
+      end
+
+      def color_to_use
+        if value.is_a? Array
+          value.map { |sub_value| sub_value == :normal ? :no_bold : sub_value }
+        elsif value.is_a? Symbol
+          value == :normal ? :no_bold : value
+        end
+      end
+    end
+  end
+end

data/lib/styles/properties/match_text_decoration.rb

@@ -0,0 +1,36 @@
+module Styles
+  module Properties
+    class MatchTextDecoration < Base
+      sub_engine :color
+
+      COLOR_PROPERTY_TYPE = :match
+
+      # CSS value is line-through and not strikethrough, but include strikethrough as well
+      VALUES = [:none, :underline, :line_through, :strikethrough, :blink].freeze
+
+      def valid_value?
+        [value].flatten.all? { |decoration| VALUES.include?(decoration) }
+      end
+
+      def color_to_use
+        if value.is_a? Array
+          value.map { |decoration| normalize_value decoration }
+        elsif value.is_a? Symbol
+          normalize_value value
+        end
+      end
+
+      private
+
+      def normalize_value(value)
+        if value == :line_through
+          :strikethrough
+        elsif value == :none
+          :no_text_decoration
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/styles/properties/padding.rb

@@ -0,0 +1,81 @@
+module Styles
+  module Properties
+    class Padding < Base
+      sub_engine :layout
+      other_names :padding_left, :padding_right, :padding_top, :padding_bottom
+
+      attr_reader :top, :right, :bottom, :left
+
+      def initialize(*args)
+        if args.size == 1 && args.first.is_a?(Array)
+          @name = :padding
+          @sub_properties = args.first
+        else
+          if (val = args[2]).is_a?(String)
+            @name = :padding
+            @sub_properties = []
+            side_values = args[2].split.map(&:to_i)
+            %w[top right bottom left].each_with_index do |side, idx|
+              side_value = side_values[idx]
+              if side_value
+                @sub_properties << self.class.new(args[0], "padding_#{side}".to_sym, side_value)
+              end
+            end
+          else
+            super
+            @sub_properties = nil
+          end
+        end
+        compute_all_padding
+      end
+
+      def all_padding
+        [top, right, bottom, left]
+      end
+
+      protected
+
+      attr_reader :sub_properties
+
+      # Hash of padding values that have been defined (nil if not defined) for internal
+      # tracking and combination of sub-properties
+      attr_accessor :defined_padding
+
+      # If the value is an integer, returns that. For any other value, including the valid
+      # <tt>:none</tt> value, <tt>0</tt> is returned.
+      def normalized_value
+        value.is_a?(Integer) ? value : 0
+      end
+
+      private
+
+      def compute_all_padding
+        @defined_padding = { top: nil, right: nil, bottom: nil, left: nil }
+
+        if @sub_properties
+          @sub_properties.each do |sub_prop|
+            if sub_prop.name == :padding
+              @defined_padding.merge!(sub_prop.defined_padding.dup.delete_if { |k,v| v.nil? })
+            else
+              @defined_padding.merge!(
+                { sub_prop.name.to_s.sub(/^padding_/, '').to_sym => sub_prop.normalized_value }
+              )
+            end
+          end
+        else
+          if name == :padding
+            [:top, :right, :bottom, :left].each { |side| @defined_padding[side] = normalized_value }
+          elsif name.to_s =~ /padding_(\w+)/
+            @defined_padding[$1.to_sym] = normalized_value
+          end
+        end
+
+        @defined_padding.each_pair { |side, val| set_padding(side, val) }
+      end
+
+      def set_padding(which, val)
+        instance_variable_set("@#{which}".to_sym, (val.nil? ? 0 : val))
+      end
+    end
+  end
+end

data/lib/styles/properties/text_align.rb

@@ -0,0 +1,10 @@
+module Styles
+  module Properties
+    class TextAlign < Base
+      sub_engine :layout
+
+      # Not included: justify and inherit
+      VALUES = [:left, :right, :center]
+    end
+  end
+end

data/lib/styles/properties/text_decoration.rb

@@ -0,0 +1,20 @@
+module Styles
+  module Properties
+    class TextDecoration < Base
+      sub_engine :color
+
+      # CSS value is line-through and not strikethrough, but include strikethrough as well
+      VALUES = [:none, :underline, :line_through, :strikethrough, :blink].freeze
+
+      def color_to_use
+        if value == :line_through
+          :strikethrough
+        elsif value == :none
+          :no_text_decoration
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/styles/properties/width.rb

@@ -0,0 +1,11 @@
+module Styles
+  module Properties
+    class Width < Base
+      sub_engine :layout
+
+      def width
+        value.to_i >= 0 ? value : 0
+      end
+    end
+  end
+end

data/lib/styles/rule.rb

@@ -0,0 +1,67 @@
+require 'term/ansicolor'
+
+module Styles
+  class Rule
+
+    # Special Selectors are Symbols that describe common special cases.
+    SPECIAL_SELECTORS = {
+      blank: /^\s*$/,
+      empty: /^$/,
+      any: /^/,
+      all: /^/ # Synonym of :any
+    }
+
+    attr_accessor :selector, :properties, :unrecognized_properties
+
+    def initialize(selector, properties_hash)
+      @selector = selector
+      @unrecognized_properties = {}
+
+      @properties = properties_hash.keys.map do |name|
+        property_class = ::Styles::Properties.find_class_by_property_name(name)
+        if property_class
+          property_class.new(selector, name, properties_hash[name])
+        else
+          unrecognized_properties[name] = properties_hash[name]
+          nil
+        end
+      end.compact
+    end
+
+    # Indicates whether this Rule is applicable to the given line, according to the selector. You
+    # could say the selector 'matches' the line for an applicable rule.
+    #
+    # A String selector matches if it appears anywhere in the line.
+    # A Regexp selector matches if it matches the line.
+    #
+    # ANSI color codes are ignored when matching to avoid false positives or negatives.
+    def applicable?(line)
+      uncolored_line = color.uncolor(line.chomp)
+      case selector
+        when String
+          uncolored_line.include?(selector)
+        when Regexp
+          selector.match(uncolored_line)
+        when Symbol
+          SPECIAL_SELECTORS[selector].match(uncolored_line)
+        else
+          false
+      end
+    end
+
+    # Apply the rule to the given line
+    #
+    # If the line is nil then it has been hidden before this rule has been applied. Just return
+    # nil and leave it as hidden.
+    def apply(line)
+      return nil if line.nil?
+      properties.inject(line.dup) {|result, property| property.apply(result) }
+    end
+
+    private
+
+    def color
+      ::Term::ANSIColor
+    end
+  end
+end

data/lib/styles/stylesheet.rb

@@ -0,0 +1,103 @@
+module Styles
+  class Stylesheet
+
+    attr_accessor :file_path, :rules
+    attr_reader :last_updated
+
+    # For creating a one off, temporary Stylesheet without an associated file. Mostly useful
+    # for testing.
+    def self.from_string(string)
+      stylesheet = new
+      stylesheet.rules = eval_rules string
+      stylesheet
+    end
+
+    def initialize(stylesheet_file_path=nil)
+      @file_path = stylesheet_file_path
+      @rules = []
+      @last_updated = nil
+      load_rules_from_file if @file_path
+    end
+
+    def unrecognized_property_names
+      rules.map { |rule| rule.unrecognized_properties.keys }.flatten
+    end
+
+    def reload
+      load_rules_from_file
+    end
+
+    def outdated?
+      !last_updated || file_mtime > last_updated
+    end
+
+    def reload_if_outdated
+      reload if outdated?
+    end
+
+    private
+
+    attr_writer :last_updated
+
+    def file_mtime
+      File.mtime file_path
+    end
+
+    def load_rules_from_file
+      begin
+        self.rules = self.class.eval_rules(IO.read(file_path), file_path)
+      rescue Errno::ENOENT => e
+        msg = "Stylesheet '#{File.basename file_path}' does not exist in #{File.dirname file_path}"
+        raise ::Styles::StylesheetLoadError, msg
+      end
+      self.last_updated = Time.now
+    end
+
+    # Evaluates rules specified in the DSL format and returns an array of Rule objects.
+    #
+    # This evaluates the stylesheet text in a throwaway execution context. A reference to an array
+    # to contain the parsed rules is place in the global variable <tt>$current_stylesheet_rules</tt>
+    # while this is happening. This is for DSL support and allows the use of the <tt>-</tt> method
+    # on core types to add rules to Stylesheets. See core_ext.rb for more details.
+    def self.eval_rules(string, file_path=nil)
+      $current_stylesheet_rules = []
+      context = EvalContext.new
+
+      begin
+        context.instance_eval(string)
+      rescue SyntaxError => se
+        msg = "Could not parse stylesheet: #{file_path || '(no file)'}\n#{se.message.sub(/^\(eval\):/, 'line ')}"
+        raise ::Styles::StylesheetLoadError, msg
+      end
+
+      # After eval the global variable will contain an array of selector and
+      # properties pairs. See core_ext.rb for how these are collected.
+      rules = $current_stylesheet_rules.map { |selector_and_properties| Rule.new *selector_and_properties }
+
+      $current_stylesheet_rules = nil
+      rules
+    end
+
+    # Instances serve as throwaway execution contexts for user-produced stylesheet text. This is
+    # useful so that methods that only serve to support the DSL do not pollute the resulting
+    # Stylesheet object. Also, method definitions or overrides in the stylesheet will not affect
+    # the Stylesheet (probably). Since we are executing Ruby code there is no guarantee that
+    # that something won't get messed up, but this makes inadvertently doing so much less likely.
+    class EvalContext
+
+      # Supports the DSL for stylesheets, making them more attractive and CSS-y by allowing
+      # property values to be specified like this
+      #
+      #   color: red
+      #
+      # instead of like this
+      #
+      #   color: :red
+      #
+      def method_missing(name)
+        name
+      end
+
+    end
+  end
+end