yay 0.0.1

data/lib/yay/errors.rb

@@ -0,0 +1,109 @@
+
+class Yay
+  class Error < StandardError
+    attr :position
+    
+    def printable_message
+      raise "Unimplemented printable error"
+    end
+    
+    def printable_position
+      array  = @position
+      return "" unless @position
+      length = array.length
+      return " at word #{array[0]}" if length == 1
+      return " on line #{array[1]}, word #{array[0]}" if length == 2
+      return " in file #{array[2]}, line #{array[1]}, word #{array[0]}" if length == 3
+      raise "junk position given to exception"
+    end
+  end
+  
+  class AlreadyAssignedError < Error
+    attr :variable
+    
+    def initialize variable
+      @variable = variable
+    end
+    
+    def printable_message
+      return "The variable #{variable} has already been assigned a value#{printable_position}"
+    end
+  end
+  
+  class CircularReferenceError < Error
+    attr :current
+    attr :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
+  
+  class UnresolvedSubstitutionError < Error
+    attr :variable
+    
+    def initialize variable
+      @variable = variable
+    end
+    
+    def printable_message
+      return "The variable #{variable} is being used but hasn't been set #{printable_position}"
+    end
+  end
+  
+  class CouldntFindFileError < Error
+    attr :filename
+    attr :tried
+    
+    def initialize filename, tried
+      @filename = filename
+      @tried    = tried
+    end
+    
+    def printable_message
+      return "Failed to load file \"#{filename}\"#{printable_position}\nPlaced looked: #{tried.join(', ')}"
+    end
+  end
+  
+  class TooManyColoursError < Error
+    attr :fg
+    attr :bg
+    attr :colour
+    
+    def initialize fg, bg, colour, position
+      @fg       = fg
+      @bg       = bg
+      @colour   = colour
+      @position = position
+    end
+    
+    def printable_message
+      return "There were too many colours in your expression#{printable_position}.\nYou can't use #{colour} as you've already chosen a foreground and background colour"
+    end
+  end
+  
+  class UnexpectedTokenError < Error
+    attr :type
+    attr :value
+    
+    def initialize type, value, position
+      @type     = type
+      @value    = value
+      @position = position
+    end
+
+    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 ""
+    end
+
+    def printable_message
+      return "Unexpected #{type} \"#{value}\"#{printable_position}\n#{extra_message}"
+    end
+  end
+end

data/lib/yay/installer.rb

@@ -0,0 +1,12 @@
+
+class Yay
+  class Installer
+    def initialize(url)
+        @url = url
+    end
+    
+    def install
+      raise "installing files is not yet implemented! :-("
+    end
+  end
+end

data/lib/yay/lexer.rb

@@ -0,0 +1,60 @@
+require 'strscan'
+require 'yay/lexer_regex'
+
+class Yay  
+  class Lexer
+    
+    def initialize(string="")
+      @position = 0
+      @line     = 1
+      
+      # default to an empty string scanner. this provides us an endless number
+      # of eofs
+      use_string(string)
+    end
+    
+    # take a string and begin scanning it
+    def use_string(string)
+      @scanner = StringScanner.new string
+    end
+    
+    def position
+      @position
+    end
+    
+    def line
+      @line
+    end
+    
+    # get the next token in the file
+    def next_token
+      return nil if @scanner.empty?
+
+      unless @scanner.empty?
+        get_patterns.each { |token| 
+          type  = token[0]
+          value = @scanner.scan(token[1])
+          next unless value
+          return next_token if type == :whitespace
+          return next_token if type == :comment
+          @position += 1
+          return normalize_token type, value
+        }
+      end
+      return [:junk, @scanner.scan_until(/$/)]
+    end
+    
+    # perform transformations on the values
+    def normalize_token type, value  
+      case type
+      when nil
+      when :double_quoted
+        value = value[1, value.length - 2]
+        while value.sub!("\\\"", "\"") != nil
+        end
+        type = :literal
+      end
+      return [type, value]
+    end
+  end
+end

data/lib/yay/lexer_regex.rb

@@ -0,0 +1,38 @@
+require 'yay/colour_wheel'
+
+class Yay
+  class Lexer
+    
+    # The expressions to match to find tokens
+    # Ensure the labels match up to tokens in grammar.y
+    BASE_PATTERNS = [
+      [:whitespace     , /\s+/],
+      [:comment        , /#.*$/],
+
+      # strings
+      [:double_quoted  , /"[^"\\]*(?:\\.[^"\\]*)*"/],
+      [:single_quoted  , /'[^'\\]*(?:\\.[^'\\]*)*'/],
+      [:regex          , /\/[^\/\\\r\n]*(?:x.[^\/x\r\n]*)*\/[a-z]*/],  
+      [:variable       , /@\w+/],
+
+      # keywords
+      [:line           , /\bline[s]?\b/i],
+      [:install        , /\binstall\b/i],
+      [:installed      , /\binstalled\b/i],
+      [:include        , /\b(include|use|load)\b/i],
+      [:and            , /(\b(and|but)\b)|,/i],
+      [:verb           , /\b(is|are|a|an)\b/],
+
+      # everything else matched must be a plain old term
+      [:literal        , /\b\S+\b/],
+    ]
+    
+    def get_patterns
+      patterns = BASE_PATTERNS
+      # add the colour keywords. generate these from the colour wheel's constants
+      colours = Yay::ColourWheel::all_names.join('|')
+      patterns.unshift [:colour, Regexp.new("\\b(#{colours})\\b", Regexp::IGNORECASE)]
+      return patterns
+    end
+  end
+end

data/lib/yay/loader.rb

@@ -0,0 +1,57 @@
+
+class Yay
+  class Loader
+    def initialize filename
+      @filename = filename
+    end
+    
+    # invoking a new parser and process a string of yay commands
+    # any variables inside the parser context will not affect our own
+    # this is particularly useful when loading files
+    def load_string string
+      # invoke a new parser and return the rules it finds
+      parser = Yay::Parser.new
+      return parser.parse string
+    end
+    
+    # 
+    def load_file full_path
+      file = File.open(full_path, "rb")
+      contents = file.read
+      return load_string(contents)
+    end
+    
+    def resolve_targets filename
+      return [
+        "./#{filename}.yay",
+        "~/.yay/#{filename}.yay",
+#        "#{$GEM_HOME}/yay/#{filename}.yay"
+      ]      
+    end
+    
+    # stat for the file locally and globally
+    def resolve_file filename
+      paths = resolve_targets filename
+      paths.each { |file_name| 
+        begin
+          stat = File.stat(file_name)
+          return file_name if stat
+        rescue Errno::ENOENT 
+        end
+      }
+      return nil
+    end
+
+    # load a file
+    def load
+      resolved = resolve_file @filename
+      raise Yay::CouldntFindFileError.new @filename, resolve_targets(@filename) unless resolved
+      @rules = load_file resolved
+      return @rules
+    end
+
+    def get_rules
+      return @rules
+    end
+  end
+end

data/lib/yay/parser.rb

@@ -0,0 +1,89 @@
+require 'yay/parser_gen'
+require 'yay/lexer'
+require 'yay/colour_wheel'
+require 'yay/rule_set'
+require 'yay/loader'
+require 'yay/installer'
+require 'yay/errors'
+
+class Yay
+  class Parser < Yay::ParserGen   
+    def load_file filename
+      loader = Yay::Loader.new filename
+      loader.load
+      @ruleset.merge loader.get_rules
+    end
+
+    def install_file url
+      installer = Yay::Installer.new url
+      installer.install
+    end
+    
+    def print_installed
+      # TODO
+    end
+    
+    def handle_string string
+      string = Regexp::escape(string)
+      Regexp.new(string, Regexp::IGNORECASE)
+    end
+
+    def handle_regex string
+      string
+    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, [@lexer.position, @lexer.line]
+        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 = Yay::Lexer.new unless @lexer
+      @lexer.use_string(str)
+      @ruleset = Yay::RuleSet.new
+
+      do_parse
+      get_rules
+    end
+
+    # get the next token
+    def next_token
+      @lexer.next_token
+    end
+
+    def on_error error_token_id, error_value, value_stack
+      type = token_to_str error_token_id
+      raise Yay::UnexpectedTokenError.new type, error_value, [@lexer.position, @lexer.line]
+    end
+  end
+end

data/lib/yay/parser_gen.rb

@@ -0,0 +1,319 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by racc 1.4.5
+# from racc grammer file "scripts/../data/grammar.y".
+#
+
+require 'racc/parser'
+
+
+class Yay
+
+class ParserGen < Racc::Parser
+
+##### racc 1.4.5 generates ###
+
+racc_reduce_table = [
+ 0, 0, :racc_error,
+ 1, 13, :_reduce_none,
+ 1, 13, :_reduce_2,
+ 2, 13, :_reduce_3,
+ 3, 13, :_reduce_4,
+ 0, 13, :_reduce_none,
+ 3, 14, :_reduce_none,
+ 1, 14, :_reduce_none,
+ 1, 15, :_reduce_none,
+ 1, 15, :_reduce_none,
+ 1, 15, :_reduce_none,
+ 1, 15, :_reduce_none,
+ 1, 15, :_reduce_none,
+ 4, 17, :_reduce_13,
+ 3, 18, :_reduce_14,
+ 4, 19, :_reduce_15,
+ 3, 20, :_reduce_16,
+ 2, 21, :_reduce_17,
+ 3, 22, :_reduce_18,
+ 1, 22, :_reduce_19,
+ 1, 26, :_reduce_20,
+ 1, 26, :_reduce_21,
+ 2, 24, :_reduce_22,
+ 1, 24, :_reduce_23,
+ 1, 16, :_reduce_24,
+ 0, 16, :_reduce_none,
+ 1, 25, :_reduce_26,
+ 0, 25, :_reduce_27,
+ 2, 23, :_reduce_28,
+ 0, 23, :_reduce_none ]
+
+racc_reduce_n = 30
+
+racc_shift_n = 41
+
+racc_action_table = [
+    -7,   -25,    33,    19,    16,    20,   -25,    11,    22,    22,
+    33,    25,    16,     8,     9,    11,     2,     4,    30,     8,
+     9,    11,    36,    28,    31,    29,    29,    18,    -2,    16,
+    38,    29,    38 ]
+
+racc_action_check = [
+     7,     6,    21,     4,    16,     4,     6,    21,     6,     7,
+    23,     9,     8,    23,    23,    23,     0,     0,    18,     0,
+     0,     0,    24,    17,    20,    24,    17,     3,     2,     1,
+    27,    29,    35 ]
+
+racc_action_pointer = [
+    14,    18,    28,    27,     1,   nil,    -1,     0,     1,     9,
+   nil,   nil,   nil,   nil,   nil,   nil,    -7,    18,    18,   nil,
+    22,     0,   nil,     8,    17,   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,   -29,   -30,
+    -8,   -21,    -9,   -10,   -11,   -12,   -29,   -30,   -30,    -3,
+   -30,   -30,   -24,   -30,   -30,   -17,   -28,   -27,   -14,   -23,
+    41,    -4,   -18,   -20,    -6,   -27,   -16,   -13,   -26,   -22,
+   -15 ]
+
+racc_goto_table = [
+     5,    17,    27,    37,    21,    23,    32,     3,    24,    35,
+   nil,    40,   nil,   nil,    39,   nil,    26,   nil,   nil,   nil,
+   nil,   nil,   nil,    34 ]
+
+racc_goto_check = [
+     2,    11,    12,    13,     4,     4,    10,     1,    11,    12,
+   nil,    13,   nil,   nil,    12,   nil,    11,   nil,   nil,   nil,
+   nil,   nil,   nil,     2 ]
+
+racc_goto_pointer = [
+   nil,     7,     0,   nil,    -2,   nil,   nil,   nil,   nil,   nil,
+   -15,     0,   -15,   -24,   nil ]
+
+racc_goto_default = [
+   nil,   nil,   nil,     7,   nil,    10,    12,    13,    14,    15,
+     1,   nil,   nil,   nil,     6 ]
+
+racc_token_table = {
+ false => 0,
+ Object.new => 1,
+ :literal => 2,
+ :install => 3,
+ :local => 4,
+ :variable => 5,
+ :include => 6,
+ :regex => 7,
+ :colour => 8,
+ :and => 9,
+ :line => 10,
+ :verb => 11 }
+
+racc_use_result_var = true
+
+racc_nt_base = 12
+
+Racc_arg = [
+ racc_action_table,
+ racc_action_check,
+ racc_action_default,
+ racc_action_pointer,
+ racc_goto_table,
+ racc_goto_check,
+ racc_goto_default,
+ racc_goto_pointer,
+ racc_nt_base,
+ racc_reduce_table,
+ racc_token_table,
+ racc_shift_n,
+ racc_reduce_n,
+ racc_use_result_var ]
+
+Racc_token_to_s_table = [
+'$end',
+'error',
+'literal',
+'install',
+'local',
+'variable',
+'include',
+'regex',
+'colour',
+'and',
+'line',
+'verb',
+'$start',
+'body',
+'command_list',
+'command',
+'and_opt',
+'match',
+'assignment',
+'substitution',
+'equivalence',
+'include_file',
+'string_list',
+'verbs_opt',
+'colour_list',
+'line_opt',
+'string']
+
+Racc_debug_parser = false
+
+##### racc system variables end #####
+
+ # reduce 0 omitted
+
+ # reduce 1 omitted
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 6
+  def _reduce_2( val, _values, result )
+ load_file val[0]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 7
+  def _reduce_3( val, _values, result )
+ install_file val[1], true
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 8
+  def _reduce_4( val, _values, result )
+ install_file val[2], false
+   result
+  end
+.,.,
+
+ # reduce 5 omitted
+
+ # reduce 6 omitted
+
+ # reduce 7 omitted
+
+ # reduce 8 omitted
+
+ # reduce 9 omitted
+
+ # reduce 10 omitted
+
+ # reduce 11 omitted
+
+ # reduce 12 omitted
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 20
+  def _reduce_13( val, _values, result )
+ @ruleset.add_match val[0], handle_colours(val[2]), val[3]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 22
+  def _reduce_14( val, _values, result )
+ @ruleset.add_assignment val[0], val[2]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 24
+  def _reduce_15( val, _values, result )
+ @ruleset.add_substitution val[0], handle_colours(val[2]), val[3]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 26
+  def _reduce_16( val, _values, result )
+ @ruleset.add_equivalence val[0], val[2]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 28
+  def _reduce_17( val, _values, result )
+ load_file val[0]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 30
+  def _reduce_18( val, _values, result )
+ val[2].unshift(val[0]); result = val[2]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 31
+  def _reduce_19( val, _values, result )
+ result = [val[0]]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 33
+  def _reduce_20( val, _values, result )
+ result = handle_string(val[0])
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 34
+  def _reduce_21( val, _values, result )
+ result = handle_regex(val[0])
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 36
+  def _reduce_22( val, _values, result )
+ val[1].unshift(val[0].to_sym); result = val[1]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 37
+  def _reduce_23( val, _values, result )
+ result = [val[0].to_sym]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 39
+  def _reduce_24( val, _values, result )
+ result = nil
+   result
+  end
+.,.,
+
+ # reduce 25 omitted
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 42
+  def _reduce_26( val, _values, result )
+ result = true
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 43
+  def _reduce_27( val, _values, result )
+ result = false
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'scripts/../data/grammar.y', 45
+  def _reduce_28( val, _values, result )
+ result = nil
+   result
+  end
+.,.,
+
+ # reduce 29 omitted
+
+ def _reduce_none( val, _values, result )
+  result
+ end
+
+end   # class ParserGen
+
+end # class Yay