yay 0.0.1

data/bin/yay

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'yay/application'
+Yay::Application.new(STDIN, STDOUT, STDERR, ARGV).run

data/data/defaults/log.yay

@@ -0,0 +1,5 @@
+#!/usr/bin/yay
+# Highlights a lot of different log messages
+
+use syslog
+use log4x

data/data/defaults/log4x.yay

@@ -0,0 +1,18 @@
+#!/usr/bin/yay
+# Highlights log4j style messages
+
+debug and trace are @boring
+"normal" and info are @normal
+warning is @interesting
+error is @serious
+fatal is @serious
+
+# some words that aren't logger levels but are still important
+exception is @serious
+"unhandled exception" is @serious
+important is @serious
+
+@boring are dim lines
+@normal is normal
+@interesting is yellow
+@serious is an inverted red line

data/data/defaults/syslog.yay

@@ -0,0 +1,18 @@
+#!/usr/bin/yay
+# Highlights syslog messages
+
+insensitive
+
+debug is normal
+informational is gray
+notice and warning are yellow
+error and alert are red
+critical and emergency are red lines
+
+# some aliases
+dbg is normal
+info is gray
+notice and warn are yellow
+err and alert
+crit and emerg are red lines
+

data/data/examples/errors.yay

@@ -0,0 +1,6 @@
+#!/usr/bin/yay
+# Will pipe some lines to stderr
+
+warn is an error
+error and fatal are errors
+

data/data/examples/regex.yay

@@ -0,0 +1,24 @@
+#!/usr/bin/yay
+# yay regexes are just like the ones in ruby/perl
+
+# Lets write something really simple
+/simple/ is blue
+
+# Let's match something more complex (like _this _th1s __)
+/_[_\w0-9]*/ is green
+
+# Let's find a regex with a regex!
+/\/\[\_\\w\]\[\_\\w0\-9\]\*\// is yellow
+
+# So how can we make them case insensitive?
+/HELLO/i is blue
+
+# Yay's case commands only affect literals, not regexes
+sensitive /Sensitive/ is blue
+insensitive /Insensitive/ is green
+
+# We can treat a regex like a normal string by using quotes
+"/[match this string]/" is red
+
+# Or we can escape the first character
+\/[andthisonetoo]/ is red

data/data/examples/variables.yay

@@ -0,0 +1,11 @@
+#!/usr/bin/yay
+# Shows off variables
+
+debug is @boring
+warn is @interesting
+error is @serious
+fatal is @serious
+
+all @boring are hidden
+all @interesting are yellow
+all @serious are red lines

data/data/grammar.y

@@ -0,0 +1,56 @@
+# the yay language grammar
+
+class ParserGen
+rule
+
+  body: command_list                      {  }
+      | literal                           { load_file val[0] }
+      | install literal                   { install_file val[1] }
+      | installed                         { print_installed }
+      |
+
+  command_list: command and_opt command_list      {  }
+              | command                           {  }
+
+  command: match
+         | assignment
+         | substitution
+         | equivalence
+         | include_file
+
+  match:  string_list verbs_opt colour_list line_opt { @ruleset.add_match val[0], handle_colours(val[2]), val[3] }
+
+  assignment: string_list verbs_opt variable { @ruleset.add_assignment val[0], val[2] }
+
+  substitution: variable verbs_opt colour_list line_opt { @ruleset.add_substitution val[0], handle_colours(val[2]), val[3] }
+
+  equivalence: variable verbs_opt variable   { @ruleset.add_equivalence val[0], val[2]  }
+
+  include_file: include literal           { load_file val[0] }
+
+  string_list: string and_opt string_list { val[2].unshift(val[0]); result = val[2] }
+             | string                     { result = [val[0]] }
+
+  string: literal                         { result = handle_string(val[0]) }
+        | regex                           { result = handle_regex(val[0]) }
+
+  colour_list: colour colour_list         { val[1].unshift(val[0].to_sym); result = val[1] }
+             | colour                     { result = [val[0].to_sym] }
+
+  and_opt: and                            { result = nil }
+         |                                { }
+
+  line_opt: line                          { result = true }
+          |                               { result = false }
+
+  verbs_opt: verb verbs_opt               { result = nil }
+           |                              { }
+
+end
+
+---- header
+class Yay
+---- inner
+
+---- footer
+end # class Yay

data/data/lexer_tests.rb

@@ -0,0 +1,171 @@
+class Yay
+LEXER_TESTS = {
+
+  # empty files
+  ""  => [],
+  " " => [],
+
+  # isolated colour
+  "red" => [
+    [:colour, "red"]
+  ],
+  
+  # non-interference with literals
+  "splodge red" => [
+    [:literal, "splodge"],
+    [:colour, "red"]
+  ],
+  
+  # multiple colours
+  "green red" => [
+    [:colour, "green"],
+    [:colour, "red"]
+  ],
+
+  # quoted
+  "\"red\" green" => [
+    [:literal, "red"],
+    [:colour, "green"]
+  ],
+  
+  # word boundaries
+  "hatred of greenspan red" => [
+    [:literal, "hatred"],
+    [:literal, "of"],
+    [:literal, "greenspan"],
+    [:colour, "red"]
+  ],  
+  
+  # literal
+  "abc" => [
+    [:literal, "abc"]
+  ],
+
+  # multiple literals
+  " abc d_e_f h1i2j " => [
+    [:literal, "abc"],
+    [:literal, "d_e_f"],
+    [:literal, "h1i2j"]
+  ],
+
+  # double quoted literals
+  "\"abc\"" => [
+    [:literal, "abc"]
+  ],
+
+  "\"a b c\"" => [
+    [:literal, "a b c"]
+  ],
+
+  # double quoted - non-interference
+  "123 \"abc\" def" => [
+    [:literal, "123"],
+    [:literal, "abc"],
+    [:literal, "def"]
+  ],
+
+  # double quoted and escaped
+  " \"abc\\\"def\\\"hij\"" => [
+    [:literal, "abc\"def\"hij"]
+  ],
+
+  # multiple double quoted and escaped
+  " \"abc\\\"def\\\"hij\" \"123\\\"456\\\"789\"" => [
+    [:literal, "abc\"def\"hij"],
+    [:literal, "123\"456\"789"]
+  ],
+
+  # regular expressions
+  "/abc/" => [
+    [:regex, "/abc/"]
+  ],
+  
+  # unclosed regex
+  "/abc" => [
+    [:junk, "/abc"]
+  ],
+  
+  # regex with modifier
+  "/abc/i" => [
+    [:regex, "/abc/i"]
+  ],
+  
+  # regex with whitespace
+  "/abc def/" => [
+    [:regex, "/abc def/"]
+  ],
+  
+  # FIXME
+  # regex with escaping
+  #"/abc\/def/" => [
+  #  [:regex, "/abc\/def/"]
+  #],
+  
+  # FIXME
+  # regex withescaping and modifier
+  #"/abc\/def/i" => [
+  #  [:regex, "/abc\/def/i"]
+  #],
+
+  # regex noninterference
+  "/abc/ 123" => [
+    [:regex, "/abc/"],
+    [:literal, "123"],
+  ],
+  
+  # refex noninterference
+  "/abc/ 123 /def/" => [
+    [:regex, "/abc/"],
+    [:literal, "123"],
+    [:regex, "/def/"],
+  ],
+  
+  # regex with modifier noninterference
+  "/abc/i 123 /def/" => [
+    [:regex, "/abc/i"],
+    [:literal, "123"],
+    [:regex, "/def/"],
+  ],
+  
+  # FIXME
+  # regex with modifier, regex with escaping noninterference
+  #"/abc/i 123 /def/ /abc\/def/ efg" => [
+  #  [:regex,   "/abc/i"],
+  #  [:literal, "123"],
+  #  [:regex,   "/def/"],
+  #  [:regex,   "/abc\/def/"],
+  #  [:literal, "efg"],
+  #], 
+  
+  # quoted regex
+  "\"/abc/i\"" => [
+    [:literal, "/abc/i"]
+  ],
+
+  # multiple quoted regexes with whitespace
+  "\"/abc/ /def\"" => [
+    [:literal, "/abc/ /def"]
+  ],
+  
+  # and
+  "and cheese and" => [
+    [:and, "and"],
+    [:literal, "cheese"],
+    [:and, "and"]
+  ],    
+  
+  # quoted and
+  "\"and\"" => [
+    [:literal, "and"]
+  ],
+  
+  # commas
+  "mushroom, chicken and pasta" => [
+    [:literal, "mushroom"],
+    [:and, ","],
+    [:literal, "chicken"],
+    [:and, "and"],
+    [:literal, "pasta"]
+  ],
+}
+end

data/data/parser_tests.rb

@@ -0,0 +1,153 @@
+require 'yay/colour_wheel'
+class Yay
+PARSER_TESTS = {
+
+  # empty files
+  ""  => [],
+  " " => [],
+
+  # simple match
+  "apples are green" => [
+    [/apples/i, [ColourWheel::FG[:green]], false],
+  ],
+  
+  # simple match, lines
+  "apples are green lines" => [
+    [/apples/i, [ColourWheel::FG[:green]], true],
+  ],
+
+  # multiple match without and or are
+  "apples grass green" => [
+    [/apples/i, [ColourWheel::FG[:green]], false],
+    [/grass/i,  [ColourWheel::FG[:green]], false],
+  ],
+
+  # multiple match with and
+  "apples and grass green" => [
+    [/apples/i, [ColourWheel::FG[:green]], false],
+    [/grass/i,  [ColourWheel::FG[:green]], false],
+  ],
+
+  # multiple match with and and are
+  "apples and grass are green" => [
+    [/apples/i, [ColourWheel::FG[:green]], false],
+    [/grass/i,  [ColourWheel::FG[:green]], false],
+  ],
+
+  # more matches
+  "apples olives and grass are green" => [
+    [/apples/i, [ColourWheel::FG[:green]], false],
+    [/olives/i, [ColourWheel::FG[:green]], false],
+    [/grass/i,  [ColourWheel::FG[:green]], false],
+  ],
+
+  # newlines allowed
+  "apples \nolives and \ngrass are\n green" => [
+    [/apples/i, [ColourWheel::FG[:green]], false],
+    [/olives/i, [ColourWheel::FG[:green]], false],
+    [/grass/i,  [ColourWheel::FG[:green]], false],
+  ],
+  
+  # multiple matches
+  "apples and olives are green bananas are yellow" => [
+    [/apples/i,  [ColourWheel::FG[:green]],  false],
+    [/olives/i,  [ColourWheel::FG[:green]],  false],
+    [/bananas/i, [ColourWheel::FG[:yellow]], false],
+  ],
+
+  # multiple matches without any conjugation
+  "apples olives green bananas yellow" => [
+    [/apples/i,  [ColourWheel::FG[:green]],  false],
+    [/olives/i,  [ColourWheel::FG[:green]],  false],
+    [/bananas/i, [ColourWheel::FG[:yellow]], false],
+  ],
+
+  # multiple matches with conjugation
+  "apples and olives are green but bananas are yellow" => [
+    [/apples/i,  [ColourWheel::FG[:green]],  false],
+    [/olives/i,  [ColourWheel::FG[:green]],  false],
+    [/bananas/i, [ColourWheel::FG[:yellow]], false],
+  ],
+
+  # multiple matches with multiple matches and conjugation
+  "apples and olives are green but bananas and cheese are yellow" => [
+    [/apples/i,  [ColourWheel::FG[:green]],  false],
+    [/olives/i,  [ColourWheel::FG[:green]],  false],
+    [/bananas/i, [ColourWheel::FG[:yellow]], false],
+    [/cheese/i,  [ColourWheel::FG[:yellow]], false],
+  ],
+  
+  # multiple matches with multiple matches without any conjugation
+  "apples olives green bananas cheese yellow" => [
+    [/apples/i,  [ColourWheel::FG[:green]],  false],
+    [/olives/i,  [ColourWheel::FG[:green]],  false],
+    [/bananas/i, [ColourWheel::FG[:yellow]], false],
+    [/cheese/i,  [ColourWheel::FG[:yellow]], false],
+  ],
+  
+  # multiple matches with multiple matches across lines
+  "apples and olives are green\n bananas and cheese are yellow" => [
+    [/apples/i,  [ColourWheel::FG[:green]],  false],
+    [/olives/i,  [ColourWheel::FG[:green]],  false],
+    [/bananas/i, [ColourWheel::FG[:yellow]], false],
+    [/cheese/i,  [ColourWheel::FG[:yellow]], false],
+  ],
+  
+  # foreground and background colours
+  "apples are red green" => [
+    [/apples/i,  [ColourWheel::FG[:red], ColourWheel::BG[:green]], false],
+  ],
+  
+  # foreground and background colours with lines
+  "apples are red green lines" => [
+    [/apples/i,  [ColourWheel::FG[:red], ColourWheel::BG[:green]], true],
+  ],
+  
+  # colour precedence - command first, one colour
+  "apples are normal red lines" => [
+    [/apples/i,  [ColourWheel::MISC[:normal], ColourWheel::FG[:red]], true],
+  ],
+  
+  # colour precedence - command first
+  "apples are normal red green lines" => [
+    [/apples/i,  [ColourWheel::MISC[:normal], ColourWheel::FG[:red], ColourWheel::BG[:green]], true],
+  ],
+  
+  # two commands
+  "apples are normal inverted lines" => [
+    [/apples/i,  [ColourWheel::MISC[:normal], ColourWheel::MISC[:invert]], true],
+  ],
+
+  # a basic substitution
+  "apples are @nice and @nice are green lines" => [
+    [/apples/i,  [ColourWheel::FG[:green]], true],
+  ],
+  
+  # a more complicated substitution
+  "apples and strawberries are @nice and @nice are green red lines" => [
+    [/apples/i,       [ColourWheel::FG[:green], ColourWheel::BG[:red]], true],
+    [/strawberries/i, [ColourWheel::FG[:green], ColourWheel::BG[:red]], true],
+  ],
+  
+  # an indirect substitution
+  "apples and strawberries are @nice and @nice are @cool and @cool are green red lines" => [
+    [/apples/i,       [ColourWheel::FG[:green], ColourWheel::BG[:red]], true],
+    [/strawberries/i, [ColourWheel::FG[:green], ColourWheel::BG[:red]], true],
+  ],
+  
+  # even more indirect
+  "apples and strawberries are @nice and @nice are @cool and @cool are @awesome and @awesome are green red lines" => [
+    [/apples/i,       [ColourWheel::FG[:green], ColourWheel::BG[:red]], true],
+    [/strawberries/i, [ColourWheel::FG[:green], ColourWheel::BG[:red]], true],
+  ],
+  
+  # complex rules don't interfere with other rules
+  "cheese is yellow and apples and strawberries are @nice and @nice are @cool and @cool are @awesome and @awesome are green red lines and jon is @awesome" => [
+    [/cheese/i,       [ColourWheel::FG[:yellow]], false],
+    [/apples/i,       [ColourWheel::FG[:green], ColourWheel::BG[:red]], true],
+    [/strawberries/i, [ColourWheel::FG[:green], ColourWheel::BG[:red]], true],
+    [/jon/i,          [ColourWheel::FG[:green], ColourWheel::BG[:red]], true]
+  ],
+}
+
+end

data/lib/yay/application.rb

@@ -0,0 +1,44 @@
+require 'yay/parser'
+require 'yay/colourizer'
+
+class Yay
+  class Application
+
+    # args that can be used if you don't want the application to do anything
+    DO_NOTHING_ARGS = ['--do-nothing']
+
+    def initialize(input, output, error, args)
+      raise ArgumentError, "input" unless input.kind_of? IO
+      raise ArgumentError, "output" unless output.kind_of? IO
+      raise ArgumentError, "error" unless error.kind_of? IO
+      raise ArgumentError, "args" unless args.kind_of? Array
+
+      @input   = input
+      @output  = output
+      @error   = error
+      @args    = args
+      @running = false
+    end
+
+    def run
+      raise "already running" if @running
+      @running = true
+      
+      return if @args == DO_NOTHING_ARGS
+      
+      begin      
+      
+        @parser = Yay::Parser.new
+        @parser.parse_array(@args)
+        @rules = @parser.get_rules
+
+        @colourizer = Yay::Colourizer.new @rules, @input, @output
+        @colourizer.colourize_pipe
+      rescue Yay::Error => error
+        @error.puts error.printable_message
+      rescue Interrupt
+      end
+    end
+
+  end
+end

data/lib/yay/colour_wheel.rb

@@ -0,0 +1,58 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+class Yay
+  class ColourWheel
+    
+    # not colours as such. commandline support varies
+    MISC = {
+      :reset       => 0,
+      :bright      => 1,
+      :dim         => 2,
+      :underscore  => 4,
+      :blink       => 5,
+      :reverse     => 7,
+      :hidden      => 8,	
+      
+      :normal      => 0, #alias
+      :invert      => 7, #alias
+      :inverted    => 7, #alias
+      :underscored => 4, #alias
+    }
+    
+    FG = {
+      :black   => 30,
+      :red     => 31,
+      :green   => 32,
+      :yellow  => 33,
+      :blue    => 34,
+      :magenta => 35,
+      :cyan    => 36,
+      :white   => 37,
+    };
+
+    BG = {
+      :black   => 40,
+      :red     => 41,
+      :green   => 42,
+      :yellow  => 43,
+      :blue    => 44,
+      :magenta => 45,
+      :cyan    => 46,
+      :white   => 47
+    };
+
+    def self.all_names
+      # assume BG and FG have the same keys
+      MISC.keys | FG.keys
+    end
+
+    def self.begin_colours(colours)
+      "\033[#{colours.join(';')}m"
+    end
+
+    def self.end_colour()
+      "\033[0m"
+    end
+  end
+end

data/lib/yay/colourizer.rb

@@ -0,0 +1,58 @@
+require 'yay/colour_wheel'
+
+class Yay
+  class Colourizer
+    def initialize rules, input, output
+      colourize_rules rules
+      @input   = input
+      @output  = output
+    end
+
+    def colourize_rules rules
+      @line_rules = []
+      @part_rules = []
+
+      rules.each { |rule|
+
+        regex   = rule[0]
+        colours = rule[1]
+        is_line = rule[2]
+
+        colour_string = ColourWheel::begin_colours(colours)
+
+        if is_line
+          @line_rules.unshift [regex, colour_string]
+        else
+          @part_rules.unshift [regex, colour_string]
+        end
+      }
+    end
+
+    def colourize_pipe
+      default_end_colour = ColourWheel::end_colour
+      
+      @input.each_line { |line|
+
+        # track the line_rules end colour so we can return to this after each match
+        end_colour = default_end_colour
+
+        #
+        @line_rules.each { |rule| 
+          if line.match(rule[0])
+            line = "#{rule[1]}#{line.rstrip}#{default_end_colour}"
+            end_colour = rule[1]
+            # only allow one line
+            break
+          end
+        }
+
+        # 
+        @part_rules.each { |rule|
+          line.gsub!(rule[0], "#{rule[1]}\\0#{end_colour}")
+        }
+
+        @output.puts line
+      }
+    end
+  end
+end