yay 0.0.5 → 0.0.6

data/lib/yay/application.rb

@@ -3,6 +3,8 @@ require 'yay/colourizer'
 require 'yay/version'
 
 class Yay
+  # this class acts as controller for yay. it interprets user input and
+  # coordinates with the parser
   class Application
 
     # arg that can be used if you don't want the application to do anything
@@ -14,11 +16,12 @@ class Yay
     # arg that can be used to dump the version and exit
     SHOW_VERSION_ARG = '--version'
 
+    # create an application with all the necessary user context
     def initialize(input, output, error, args)
-      raise ArgumentError, "input" unless input.kind_of? IO
+      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
+      raise ArgumentError, "error"  unless error.kind_of? IO
+      raise ArgumentError, "args"   unless args.kind_of? Array
 
       @input   = input
       @output  = output
@@ -27,6 +30,7 @@ class Yay
       @running = false
     end
 
+    # run the application. when this ends, termination is expected
     def run
       raise "already running" if @running
       @running = true
@@ -44,26 +48,40 @@ class Yay
       return if preArg == DO_NOTHING_ARG
       
       begin      
-      
+
         @parser = Yay::Parser.new
 				@parser.allow_all = true
         @parser.parse_array(@args)
         @rules = @parser.get_rules
 
+        # the parser may instruct us to shut down
+        if @parser.shutdown
+          return
+        end
+
         @colourizer = Yay::Colourizer.new @rules, @input, @output
-        
+
         if preArg == DUMP_RULES_ARG
           dump_colours @colourizer.line_rules, @colourizer.part_rules
           return
         end
 
         @colourizer.colourize_pipe
+
+      # provide readable text for internal errors
       rescue Yay::Error => error
-        @error.puts error.printable_message
+        @error.puts "#{ColourWheel::fail}#{error.printable_message}#{ColourWheel::end_colour}"
+
+      # catch ctrl+c and similar events
       rescue Interrupt
       end
+      
+      # emit the end colour just in case we were interrupted
+      print ColourWheel.end_colour
     end
     
+    # with the --dump command we can see the resulting rules created by the
+    # rule definitions (from all files included too)
     def dump_colours line_rules, word_rules
      
       puts "line rules:" if line_rules

data/lib/yay/colour_wheel.rb

@@ -1,58 +1,72 @@
-# 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
+	# the colour wheel contains all the constants needed to create coloured text
+	# there are also a few static helper methods to make rendering text easier
+	class ColourWheel
+
+		# commands. 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
+		}
+
+		# foreground colours
+		FG = {
+			:black   => 30,
+			:red     => 31,
+			:green   => 32,
+			:yellow  => 33,
+			:blue    => 34,
+			:magenta => 35,
+			:cyan    => 36,
+			:white   => 37,
+		};
+
+		# background colours
+		BG = {
+			:black   => 40,
+			:red     => 41,
+			:green   => 42,
+			:yellow  => 43,
+			:blue    => 44,
+			:magenta => 45,
+			:cyan    => 46,
+			:white   => 47
+		};
+
+		# return all the possible colour names
+		# the keys are used as string representations by the parser
+		def self.all_names
+			# assume BG and FG have the same keys
+			MISC.keys | FG.keys
+		end
+
+		# ge the string that begins the current colour code
+		def self.begin_colours(colour_numbers)
+			"\033[#{colour_numbers.join(';')}m"
+		end
+
+		# the command necessary to stop printing with colour
+		def self.end_colour
+			"\033[0m"
+		end
+
+		# ge the string that begins the current colour code
+		def self.success
+			self.begin_colours([FG[:green]])
+		end
+
+		def self.fail()
+			self.begin_colours([FG[:red]])
+		end
+	end
+end

data/lib/yay/colourizer.rb

@@ -1,21 +1,32 @@
 require 'yay/colour_wheel'
 
 class Yay
+  # this class adds colour to a stream based on rules that have been generated
+  # by a parser
   class Colourizer
+    # create a colourizer using specified parser rules and input and output
+    # streams (usually stdin/stdout)
     def initialize rules, input, output
       colourize_rules rules
       @input   = input
       @output  = output
     end
     
+    # get the rules that are applied to a whole line if it contains matching text
+    # of the form [[regex, colour_string],..]
     def line_rules
       @line_rules
     end
     
+    # get the rules that are applied to matching text
+    # of the form [[regex, colour_string],..]
     def part_rules
       @part_rules
     end
 
+    # process the rules created by a parser and determine the actual strings we
+    # need to emit when we use this colour. this breaks parser rules up in to
+    # two categories - line rules and part rules
     def colourize_rules rules
       @line_rules = []
       @part_rules = []
@@ -36,25 +47,32 @@ class Yay
       }
     end
 
+    # create a pipe between the input and output streams, applying colour rules
+    # to every line that appears. only an interrupt, end of file or exception 
+    # will end this process
     def colourize_pipe
+      # this is the colour we'll use when we haven't already applied a colour
+      # we remember the previous colour as we can colourize words within a line
+      # that's already been coloured
       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
+        # track the line_rules end colour so we can return to this after each
+        # match
         end_colour = default_end_colour
 
-        #
+        # apply all line rules
         @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
+            # leave loop; only allow one line match per line
             break
           end
         }
 
-        # 
+        # apply all partial rules
         @part_rules.each { |rule|
           line.gsub!(rule[0], "#{rule[1]}\\0#{end_colour}")
         }

data/lib/yay/errors.rb

@@ -1,16 +1,19 @@
 
 class Yay
+  # the base class for errors in yay. this provides error reporting in a
+  # friendly way (who likes stack traces?)
   class Error < StandardError
-    attr :position
+    attr_reader :position
     
+    # override this to provide user feedback
     def printable_message
       raise "Unimplemented printable error"
     end
     
+    # a generic representation of the error's location on the line, file, etc
     def printable_position
       array  = @position
       return "" unless @position
-      length = array.length
       return " in file #{array[2]}, line #{array[1]}, word #{array[0]}" if array[2]
       return " on line #{array[1]}, word #{array[0]}" if array[1]
       return " at word #{array[0]}" if array[0]
@@ -18,8 +21,47 @@ class Yay
     end
   end
   
+  # thrown when an invalid filename was entered
+  class BadFilenameError < Error  
+    attr_reader :value
+    attr_reader :message
+    
+    def initialize value
+      @value   = value
+    end
+    
+    def printable_message
+      return "Invalid filename #{value} entered"
+    end
+  end
+  
+  # this error wraps an underlying error
+  class InstallFailedError < Error
+    MAX_LENGTH = 1028
+    
+    attr_reader :error
+    attr_reader :url
+    attr_reader :content
+    
+    def initialize url, error, content=nil
+      @url     = url
+      @error   = error
+      @content = content
+      @content = 'empty' if (content==nil||content.strip=="")
+      if @content.length >= InstallFailedError::MAX_LENGTH
+        @content = "#{@content.slice(0,InstallFailedError::MAX_LENGTH)}\n.."
+      end
+    end
+    
+    def printable_message
+      return "Failed to download and install file from #{url}\nReason: #{error}\nResponse was:\n#{content}\nCheck your url!"
+    end
+  end
+  
+  # this error is raised when a variable has already been assigned a value
+  # for example @x is red and @x is blue
   class AlreadyAssignedError < Error
-    attr :variable
+    attr_reader :variable
     
     def initialize variable
       @variable = variable
@@ -30,9 +72,12 @@ class Yay
     end
   end
   
+  # this is a generic access control error that's raised when someoen tries to
+  # do something disallowed in their current context. for example, you can
+  # use the install command from the command line but not a yayfile
   class NotAllowedError < Error
-    attr :action
-    attr :path
+    attr_reader :action
+    attr_reader :path
     
     def initialize action, path
       @action = action
@@ -44,22 +89,26 @@ class Yay
     end
   end
 	
+  # raised when there's a circular reference between rules. this happens when
+  # variables point back to themselves in some way. e.g. @x is @y and @y is @x
   class CircularReferenceError < Error
-    attr :current
-    attr :path
+    attr_reader :current
+    attr_reader :path
     
     def initialize current, path
       @current = current
       @path    = path
     end
-    
+
     def printable_message
       return "There is a circular reference between variables: #{path.join(' => ')} => #{current}#{printable_position}"
     end
   end
   
+  # raised when a variable has been referenced but not given a value. for example
+  # cheese is @x without ever defining what @x is
   class UnresolvedSubstitutionError < Error
-    attr :variable
+    attr_reader :variable
     
     def initialize variable
       @variable = variable
@@ -70,9 +119,10 @@ class Yay
     end
   end
   
+  # raised when include file resolution has failed
   class CouldntFindFileError < Error
-    attr :filename
-    attr :tried
+    attr_reader :filename
+    attr_reader :tried
     
     def initialize filename, tried
       @filename = filename
@@ -84,10 +134,13 @@ class Yay
     end
   end
   
+  # raised when a colour sequence was malformed. in practice you can use
+  # infinite colour commands but zero to two actual colours, the first one will
+  # be the foreground and the second one will be the background
   class TooManyColoursError < Error
-    attr :fg
-    attr :bg
-    attr :colour
+    attr_reader :fg
+    attr_reader :bg
+    attr_reader :colour
     
     def initialize fg, bg, colour, position
       @fg       = fg
@@ -101,9 +154,12 @@ class Yay
     end
   end
   
+  # raised when an unexpected token was found by the parser. in otherwords,
+  # the rules of the syntax have been broken somehow and the user hasn't written
+  # a valid command
   class UnexpectedTokenError < Error
-    attr :type
-    attr :value
+    attr_reader :type
+    attr_reader :value
     
     def initialize type, value, position
       @type     = type
@@ -111,12 +167,16 @@ class Yay
       @position = position
     end
 
+    # add extra feedback for some tokens. help the user out!
     def extra_message
       return "Since #{value} has a special meaning, try enclosing it in quotes or a regex when searching for it" if type == "colour"
+      return "Have you finished the line off properly?" if type == "$end"
       return ""
     end
 
     def printable_message
+      return "Unexpected text \"#{value}\"#{printable_position}\n#{extra_message}" if type == "error"
+      return "Unexpected end of line#{printable_position}\n#{extra_message}" if type == "$end"
       return "Unexpected #{type} \"#{value}\"#{printable_position}\n#{extra_message}"
     end
   end

data/lib/yay/installer.rb

@@ -1,12 +1,135 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'yay/paths'
+require 'fileutils'
 
 class Yay
+  # installs .yay files from a remote url in to either ~/.yay or /etc/yay
+  # depending on the users permissions
   class Installer
-    def initialize(url)
-        @url = url
+
+    # initialize an installer for the specified url. the .install method will
+    # attempt the actual installation process
+    def initialize file_name, url
+      # directories to iterate. begin with /etc/yay, which should only be
+      # accessible to sudo. then try a local install.
+      paths     = Yay::Paths.new
+      validate_filename file_name
+      @file_name = append_filetype file_name
+      @dirs = [
+        paths.global_yay_path,
+        paths.local_yay_path
+      ]
+      @url = url
+    end
+    
+    # some filenames just aren't a good idea
+    def validate_filename string
+      raise BadFilenameError.new string if /[\?\*\\\/]/.match(string)
+    end
+    
+    # add the .yay part to the filename if it's missing
+    def append_filetype string
+      return "#{string}.yay" unless /\.yay$/.match(string)
+      return string
+    end
+
+    # see if we can write to a directory. will try to create the folder (and 
+    # its parents) unless asked otherwise
+    def can_write_to_dir dir, create
+
+        begin
+          stat = File.stat(dir)
+          return true if stat && stat.writable?
+        rescue Errno::ENOENT
+        end
+
+        # create and try again if it doesn't exist
+        if create
+          begin
+            FileUtils.mkdir_p dir
+            #FileUtils.chmod 0644, dir 
+            result = can_write_to_dir dir, false
+            puts "Created #{dir}" if result
+            return result
+          rescue Errno::EACCES
+          end
+        end
+
+        return false
+    end
+    
+    # try to find the install directory
+    def get_install_directory
+      # search globally and then locally to see if we can write
+      @dirs.each { |dir| 
+        return dir if can_write_to_dir dir, true
+      }
+      return nil
+    end
+        
+    # make a curl-ish request and get the contents
+    def get_remote_string url, limit=5
+      raise  InstallFailedError.new url, 'HTTP redirect too deep' if limit == 0
+
+      begin
+        puts "Requesting #{url}"
+        url = URI.parse(url)
+
+        request = Net::HTTP::Get.new(url.path || '/')
+        
+        http    = Net::HTTP.new url.host, url.port
+        #http.set_debug_output($stderr)
+        http.use_ssl = url.scheme == 'https' 
+
+        response     = http.start { |http2| 
+          http2.request(request)
+        }
+
+      rescue StandardError => error
+        raise InstallFailedError.new url, error.to_s
+      end
+      
+      case response
+        when Net::HTTPSuccess then 
+          return response.body
+        when Net::HTTPRedirection then
+          puts "Redirecting to #{response['location']}"; 
+          return get_remote_string(response['location'], limit - 1)
+      end
+
+      raise InstallFailedError.new url, "#{response.code} \"#{response.message}\"", response.body
+    end
+    
+    # ensure the rules we've downloaded parse correctly
+    def verify_rules url, string
+      begin
+        parser = Yay::Parser.new
+        parser.parse(string)
+      rescue Yay::Error => error
+        raise InstallFailedError.new url, error.printable_message, string
+      end
+      raise InstallFailedError.new url, "No rules in downloaded file", string if parser.get_rules == []
+      return parser
+    end
+    
+    # store a string 
+    def install_string string, dest_folder
+      dest = "#{dest_folder}/#{@file_name}"
+      File.open(dest, 'w') {|file|
+        file.write(string)
+      }
+      puts "#{ColourWheel::success}Installed to #{dest}#{ColourWheel::end_colour}"
     end
     
+    # attempt the installation process
     def install
-      raise "installing files is not yet implemented! :-("
+      dest_folder = get_install_directory
+      raise "Couldn't write to or create directories #{@dirs.join(' or ')} something is up with your system!" unless dest_folder
+      string = get_remote_string @url
+      verify_rules @url, string
+      install_string string, dest_folder
     end
   end
 end

data/lib/yay/lexer.rb

@@ -2,11 +2,12 @@ require 'strscan'
 require 'yay/lexer_regex'
 
 class Yay  
+  # tokenises yay rules
   class Lexer
 		attr :context_name
     
     def initialize(string="", context_name=nil)
-      @position     = 0
+      @position     = 1
       @line         = 1
 			@context_name = context_name
       
@@ -15,19 +16,23 @@ class Yay
       use_string(string)
     end
    
-	def context_name= value
-		@context_name = value
-	end
+    # the context name describes the source yay rules. this is free-form
+    # text but is best set to the filename
+    def context_name= value
+      @context_name = value
+    end
 
     # take a string and begin scanning it
     def use_string(string)
       @scanner = StringScanner.new string
     end
     
+    # return the current word
     def position
       @position
     end
     
+    # return the current line
     def line
       @line
     end

data/lib/yay/lexer_regex.rb

@@ -27,6 +27,9 @@ class Yay
       [:literal        , /\b\S+\b/],
     ]
     
+    # get the regular expressions we need. always use this instead of
+    # referencing the base patterns directly as we augment that array with
+    # the colour names that are available
     def get_patterns
       patterns = BASE_PATTERNS
       # add the colour keywords. generate these from the colour wheel's constants

data/lib/yay/lister.rb

@@ -0,0 +1,59 @@
+require 'yay/paths'
+
+class Yay
+  # Lists installed .yay files
+  # See also: Rimmer, Cat
+  class Lister
+
+    # returns [[name, path],..]
+    def get_files_in_dir dir
+      results = []
+      Dir.glob("#{dir}/*.yay").each { |path| 
+        matches = /\/(\w*)?\.yay$/.match(path)
+        if matches[1]
+          results.unshift [matches[1], path]
+        else
+          puts "Eh.. #{path} isn't quite right"
+        end
+      }
+      return results
+    end
+    
+    # returns {dir=>[file,..]
+    def get_all_files
+      paths  = Yay::Paths.new
+      result = {}
+      paths.yay_paths.each { |path| 
+        result[path] = get_files_in_dir path
+      }
+      return result
+    end
+    
+    # print the search paths we'll use when looking for yay files
+    def print_paths
+      puts "Search paths: (in order of precedence)"
+      paths = Yay::Paths.new
+      paths.yay_paths.each { |dir| 
+        puts dir
+      }
+    end
+    
+    # print the files we can use and the command that can be typed to use it
+    def print_files
+      puts "Installed styles:"
+      get_all_files.each_pair { |dir, files| 
+        #puts "#{dir}:"
+        files.each { |file| 
+          puts "#{file[0]}#{' '*(20-file[0].length)}#{file[1]}"
+        }
+      }      
+    end
+    
+    # print all paths and files we find in them
+    def print
+      print_paths
+      puts
+      print_files
+    end
+  end
+end

data/lib/yay/loader.rb

@@ -1,11 +1,13 @@
 require 'yay/paths'
 
 class Yay
+  # resolves the location of an include file
   class Loader
     def initialize filename
       @filename = filename
     end
 		
+    # get the default loader. this, um, loads the default.yay file!
 		def self.default_file_loader
 			return Yay::Loader.new Yay::Paths::DEFAULT_YAYFILE
 		end

data/lib/yay/parser.rb

@@ -6,150 +6,175 @@ require 'yay/loader'
 require 'yay/installer'
 require 'yay/errors'
 require 'yay/paths'
+require 'yay/lister'
 
 class Yay
-  class Parser < Yay::ParserGen   
-		attr :allow_default
-		attr :allow_install
-		attr :allow_include
-		attr :allow_print
+	# extends the parser that was automatically generated by racc and adds the
+	# behaviour necessary. this separation is done only because it's difficult to
+	# use .y files for anything other than grammar rules, even if they do allow
+	# ruby code
+	class Parser < Yay::ParserGen   
+
+		# allow this parser to load the default rule file if the rule body is empty
+		attr_accessor :allow_default
+
+		# allow this parser to install new rule files from remote sources. beware
+		# the consequences. this should be allowed from the command line only!
+		attr_accessor :allow_install
+
+		# allow this parser to include rule files that are installed. including
+		# ones in the gem folders, globally and locally
+		attr_accessor :allow_include
+
+		# allow this parser to search for and print out all the rules that are
+		# installed
+		attr_accessor :allow_list
+
+		# set to true to signal to the application or parent parser that it's time
+		# to shut down
+		attr_reader :shutdown
 
 		def initialize context_name=nil
-      @lexer = Yay::Lexer.new
+			@lexer = Yay::Lexer.new
 			@lexer.context_name = context_name
 		end
 
-		def allow_include= value
-			@allow_include = value
-		end
-		
 		# load a file from a url
-    def include_file filename
+		def include_file filename
 			raise NotAllowedError.new "include #{filename}", current_position unless @allow_include
-      loader = Yay::Loader.new filename
-      loader.load
-      @ruleset.merge loader.get_rules
-    end
+			loader = Yay::Loader.new filename
+			loader.load
+			@ruleset.merge loader.get_rules
+		end
 
 		# install a file from a url
-    def install_file url
+		def install_file file_name, url
 			raise NotAllowedError.new "install #{url}", current_position unless @allow_install
-      installer = Yay::Installer.new url
-      installer.install
-    end
-    
+			installer = Yay::Installer.new file_name, url
+			installer.install
+			@shutdown = true
+		end
+
 		# print the full list of yay files
-    def list_installed
-			raise NotAllowedError.new "list installed yay files", current_position unless @allow_print
-      # TODO
-    end
-		
+		def list_installed
+			raise NotAllowedError.new "list installed yay files", current_position unless @allow_list
+			lister = Yay::Lister.new 
+      lister.print
+      @shutdown = true
+		end
+
 		# allow all parser actions
 		def allow_all= value
-			@allow_default = @allow_install = @allow_include = @allow_print = value
+			@allow_default = @allow_install = @allow_include = @allow_list = value
 		end
 
 		# load the default file. used when the commandline is empty
 		def use_default_file
 			# don't throw an error in this case. it's legitimate for a file to be empty
 			return unless @allow_default
-      loader = Yay::Loader.default_file_loader
-      loader.load
-      @ruleset.merge loader.get_rules
-		end
-    
-    def handle_string string
-      string = Regexp::escape(string)
-      return Regexp.new(string, Regexp::IGNORECASE)
-    end
-
-    def handle_regex string
-      return string_to_regex string, false
-    end
-
-    # for lack of a better function, this will take the ending sequence from
-    # a regular expression and convert it in to a bytewise options variable
-    def extract_regexp_options args
-      return 0 if args.nil?
-      raise ArgumentError unless args.kind_of? String
-      options_map = {
-        'i' => Regexp::IGNORECASE,
-        'm' => Regexp::MULTILINE,
-        'x' => Regexp::EXTENDED,
-      }
-      options = 0
-      args.each { |char|
-        options |= options_map[char] || 0
-      }
-      return options
-    end
-    
-    # for lack of a better function, this will take a string like "/abc/" and
-    # transform it in to a regex object
-    def string_to_regex string, escape=true
-      matches = /\/([^\/\\\r\n]*(?:\\.[^\/\\\r\n]*)*)\/([a-z]\b)*/.match string
-      return nil if matches[1].nil?
-      content = matches[1]
-	  content = Regexp::escape(content) if escape
-      options = extract_regexp_options matches[2]
-      return Regexp.new(content, options)
-    end
-    
-    # given an array of colour strings, create an array with the VT100 colour
-    # sequences inside
-    def handle_colours colours
-      fg = bg = nil
-      result = []
-      # iterate the colour list and try to find up to two colours (foreground,
-      # background) and unlimited miscellaneous colours (reset, invert, etc)
-      colours.each { |colour| 
-        misc_val = ColourWheel::MISC[colour]
-        if !misc_val.nil?
-          result.push misc_val
-        elsif !fg
-          fg = ColourWheel::FG[colour]
-          result.push fg
-        elsif !bg
-          bg = ColourWheel::BG[colour]
-          result.push bg
-        else
-          raise Yay::TooManyColoursError.new fg, bg, colour, current_position
-        end
-      }
-      result
-    end
-
-    def get_rules
-      @ruleset.get_rules
-    end
-
-    # process commandline arguments as if they were from a yay file
-    def parse_array args
-      raise ArgumentError, "args" unless args.kind_of? Array
-      parse args.join(' ')
-    end
-    
-    # parse a string
-    def parse(str)
-      @lexer.use_string(str)
-      @ruleset = Yay::RuleSet.new
-
-      do_parse
-      get_rules
-    end
-
-    # get the next token
-    def next_token
-      @lexer.next_token
-    end
+			loader = Yay::Loader.default_file_loader
+			loader.load
+			@ruleset.merge loader.get_rules
+		end
+
+		# process a string token in to something we can use
+		def handle_string string
+			string = Regexp::escape(string)
+			return Regexp.new(string, Regexp::IGNORECASE)
+		end
+
+		# process a regex token in to something we can use
+		def handle_regex string
+			return string_to_regex string, false
+		end
 
+		# for lack of a better function, this will take the ending sequence from
+		# a regular expression and convert it in to a bytewise options variable
+		def extract_regexp_options args
+			return 0 if args.nil?
+			raise ArgumentError unless args.kind_of? String
+			options_map = {
+				'i' => Regexp::IGNORECASE,
+				'm' => Regexp::MULTILINE,
+				'x' => Regexp::EXTENDED,
+			}
+			options = 0
+			args.each { |char|
+				options |= options_map[char] || 0
+			}
+			return options
+		end
+
+		# for lack of a better function, this will take a string like "/abc/" and
+		# transform it in to a regex object
+		def string_to_regex string, escape=true
+			matches = /\/([^\/\\\r\n]*(?:\\.[^\/\\\r\n]*)*)\/([a-z]\b)*/.match string
+			return nil if matches[1].nil?
+			content = matches[1]
+			content = Regexp::escape(content) if escape
+			options = extract_regexp_options matches[2]
+			return Regexp.new(content, options)
+		end
+
+		# given an array of colour strings, create an array with the VT100 colour
+		# sequences inside
+		def handle_colours colours
+			fg = bg = nil
+			result = []
+			# iterate the colour list and try to find up to two colours (foreground,
+			# background) and unlimited miscellaneous colours (reset, invert, etc)
+			colours.each { |colour| 
+				misc_val = ColourWheel::MISC[colour]
+				if !misc_val.nil?
+					result.push misc_val
+				elsif !fg
+					fg = ColourWheel::FG[colour]
+					result.push fg
+				elsif !bg
+					bg = ColourWheel::BG[colour]
+					result.push bg
+				else
+					raise Yay::TooManyColoursError.new fg, bg, colour, current_position
+				end
+			}
+			result
+		end
+
+		# get the end result of the parse
+		def get_rules
+			@ruleset.get_rules
+		end
+
+		# process commandline arguments as if they were from a yay file
+		def parse_array args
+			raise ArgumentError, "args" unless args.kind_of? Array
+			parse args.join(' ')
+		end
+
+		# parse a string. returns the results
+		def parse(str)
+			@lexer.use_string(str)
+			@ruleset = Yay::RuleSet.new
+
+			do_parse
+			return get_rules
+		end
+
+		# get the next token
+		def next_token
+			@lexer.next_token
+		end
+
+		# get location information from the lexer in a nice little array we can
+		# pass to an exception constructor
 		def current_position
 			return [@lexer.position, @lexer.line, @lexer.context_name]
 		end
-		
-    def on_error error_token_id, error_value, cant_touch_this
-      type = token_to_str error_token_id
-      raise Yay::UnexpectedTokenError.new type, error_value, current_position
-    end
-  end
+
+		# the racc on_error function
+		def on_error error_token_id, error_value, cant_touch_this
+			type = token_to_str error_token_id
+			raise Yay::UnexpectedTokenError.new type, error_value, current_position
+		end
+	end
 end

data/lib/yay/parser_gen.rb

@@ -15,37 +15,39 @@ module_eval(<<'...end grammar.y/module_eval...', 'grammar.y', 54)
 ##### State transition tables begin ###
 
 racc_action_table = [
-    -7,   -25,    32,    17,    25,    17,   -25,    12,    22,    22,
-    32,    20,    30,     9,    10,    12,     2,     4,     8,     9,
-    10,    12,    28,    35,    19,    29,    29,    -2,    17,    37,
-    29,    37 ]
+    -7,   -25,    33,    17,    25,    17,   -25,    12,    22,    22,
+    33,    20,    30,     9,    10,    12,     2,     4,     8,     9,
+    10,    12,    28,    36,    31,    29,    29,    19,    -2,    17,
+    38,    29,    38 ]
 
 racc_action_check = [
      7,     6,    21,    17,    10,     9,     6,    21,     6,     7,
     23,     4,    19,    23,    23,    23,     0,     0,     0,     0,
-     0,     0,    18,    24,     3,    18,    24,     2,     1,    27,
-    29,    34 ]
+     0,     0,    18,    24,    20,    18,    24,     3,     2,     1,
+    27,    29,    35 ]
 
 racc_action_pointer = [
-    14,    17,    27,    24,     9,   nil,    -1,     0,   nil,    -6,
+    14,    18,    28,    27,     9,   nil,    -1,     0,   nil,    -6,
      2,   nil,   nil,   nil,   nil,   nil,   nil,    -8,    17,    12,
-   nil,     0,   nil,     8,    18,   nil,   nil,    19,   nil,    22,
-   nil,   nil,   nil,   nil,    21,   nil,   nil,   nil,   nil,   nil ]
+    22,     0,   nil,     8,    18,   nil,   nil,    20,   nil,    23,
+   nil,   nil,   nil,   nil,   nil,    22,   nil,   nil,   nil,   nil,
+   nil ]
 
 racc_action_default = [
     -5,   -29,   -20,   -30,   -30,    -1,   -19,   -25,    -4,   -29,
    -30,    -8,   -21,    -9,   -10,   -11,   -12,   -29,   -30,   -30,
-    -3,   -30,   -24,   -30,   -30,   -17,   -28,   -27,   -14,   -23,
-    40,   -18,   -20,    -6,   -27,   -16,   -13,   -26,   -22,   -15 ]
+   -30,   -30,   -24,   -30,   -30,   -17,   -28,   -27,   -14,   -23,
+    41,    -3,   -18,   -20,    -6,   -27,   -16,   -13,   -26,   -22,
+   -15 ]
 
 racc_goto_table = [
-     5,    18,    27,    36,    21,    23,    31,     3,    34,    24,
-    39,   nil,   nil,    38,   nil,   nil,   nil,    26,   nil,   nil,
-   nil,   nil,   nil,    33 ]
+     5,    18,    27,    37,    21,    23,    32,     3,    35,    24,
+   nil,    40,   nil,    39,   nil,   nil,   nil,    26,   nil,   nil,
+   nil,   nil,   nil,    34 ]
 
 racc_goto_check = [
      2,    11,    12,    13,     4,     4,    10,     1,    12,    11,
-    13,   nil,   nil,    12,   nil,   nil,   nil,    11,   nil,   nil,
+   nil,    13,   nil,    12,   nil,   nil,   nil,    11,   nil,   nil,
    nil,   nil,   nil,     2 ]
 
 racc_goto_pointer = [
@@ -60,7 +62,7 @@ racc_reduce_table = [
   0, 0, :racc_error,
   1, 13, :_reduce_1,
   1, 13, :_reduce_2,
-  2, 13, :_reduce_3,
+  3, 13, :_reduce_3,
   1, 13, :_reduce_4,
   0, 13, :_reduce_5,
   3, 14, :_reduce_6,
@@ -90,7 +92,7 @@ racc_reduce_table = [
 
 racc_reduce_n = 30
 
-racc_shift_n = 40
+racc_shift_n = 41
 
 racc_token_table = {
   false => 0,
@@ -177,7 +179,7 @@ module_eval(<<'.,.,', 'grammar.y', 6)
 
 module_eval(<<'.,.,', 'grammar.y', 7)
   def _reduce_3(val, _values, result)
-     install_file val[1] 
+     install_file val[1], val[2] 
     result
   end
 .,.,

data/lib/yay/paths.rb

@@ -2,10 +2,10 @@ require 'rubygems'
 require 'yay/version'
 
 class Yay
-	
+
 	# some utility functions for finding the current install and .yay paths
 	class Paths
-		
+
 		DEFAULT_YAYFILE = 'default'
 
 		# get the paths to installed gems
@@ -20,13 +20,17 @@ class Yay
 
 		# get all the paths where we might be able to find .yay files
 		def yay_paths
-			result = [local_yay_path]
+			result = [local_yay_path,global_yay_path]
 			gempaths.each { |v| 
 				result.push gempath_to_yaypath(v)
 			}
 			return result
 		end
 
+		def global_yay_path
+			return '/etc/yay'
+		end
+
 		# get the path we store local .yay files
 		def local_yay_path
 			raise "ENV[HOME] not found!" unless ENV['HOME']
@@ -34,5 +38,5 @@ class Yay
 		end
 
 	end
-		
-end
+
+end

data/lib/yay/rule_set.rb

@@ -21,7 +21,8 @@ class Yay
     def merge rules
       @rules = @rules | rules
     end
-    
+ 
+    # get the rules, complete with variable substitutions made
     def get_rules
       # ensure we substitute all variables
       substitute_variables if @string_to_var
@@ -79,6 +80,7 @@ class Yay
       return result
     end
     
+    # replace all references to variables with their actual colours
     def substitute_variables
       @string_to_var.each { |ref| 
         string   = ref[0]

data/lib/yay/version.rb

@@ -2,18 +2,21 @@ require 'open3'
 
 class Yay
 
-	VERSION = "0.0.5"
+  # the gem version. increment to make a new release!
+  VERSION = "0.0.6"
 
-	def self.version
-		@rev ||= begin
-			begin
-				rev = Open3.popen3("git rev-parse HEAD") {|stdin, stdout, stderr| stdout.read }.strip
-			rescue Errno::ENOENT
-				rev = ""
-			end
-			rev.empty? ? nil : " (#{rev})"
-		end
-		"#{VERSION}#@rev"
-	end
+  # yoinked from chef. this gives us the git revision number of the current
+  # build if possible. used for --version
+  def self.version
+    @rev ||= begin
+      begin
+        rev = Open3.popen3("git rev-parse HEAD") {|stdin, stdout, stderr| stdout.read }.strip
+      rescue Errno::ENOENT
+        rev = ""
+      end
+      rev.empty? ? nil : " (#{rev})"
+    end
+    "#{VERSION}#@rev"
+  end
 
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: yay
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - jon davey
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-18 00:00:00 +00:00
+date: 2011-11-20 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -30,21 +30,22 @@ extra_rdoc_files: []
 files: 
 - LICENSE
 - data/yay/default.yay
-- data/yay/syslog.yay
 - data/yay/log4x.yay
-- lib/yay/lexer.rb
-- lib/yay/parser.rb
+- data/yay/syslog.yay
+- lib/yay/colourizer.rb
+- lib/yay/application.rb
+- lib/yay/version.rb
 - lib/yay/parser_gen.rb
-- lib/yay/errors.rb
-- lib/yay/colour_wheel.rb
+- lib/yay/lister.rb
 - lib/yay/lexer_regex.rb
-- lib/yay/paths.rb
-- lib/yay/version.rb
-- lib/yay/application.rb
+- lib/yay/errors.rb
+- lib/yay/parser.rb
 - lib/yay/loader.rb
-- lib/yay/rule_set.rb
-- lib/yay/colourizer.rb
+- lib/yay/paths.rb
+- lib/yay/colour_wheel.rb
 - lib/yay/installer.rb
+- lib/yay/rule_set.rb
+- lib/yay/lexer.rb
 - bin/yay
 has_rdoc: true
 homepage: http://github.com/jond3k/yay