uv 0.0.7.2 → 0.0.7.3

data/lib/uv/{finding_syntaxes.rb → finding_syntax_nodes.rb}

@@ -1,38 +1,47 @@
 module Uv
 
   def Uv.find_syntaxes_by_ext(ext)
-    syntaxes = []
-    if !@syntaxes.key?(ext)
-      @syntaxes.each do |syntax_name, syntax_node|
-        syntaxes << syntax_node if syntax_node.fileTypes && syntax_node.fileTypes.include?(ext)
-      end
-      filename = File.join(@syntax_path, "#{ext}.syntax")
-      syntaxes << Textpow::SyntaxNode.load(filename) if File.exist?(filename)
-    else
-      syntaxes << @syntaxes[ext]
-    end
-    syntaxes
+    return [load_syntax(ext)] if @syntaxes.key?(ext)
+    puts "No syntax found... loading all syntaxes (including all syntax.fileTypes)" if @debug
+    load_all_syntaxes
+    return [load_syntax(ext)] if @syntaxes.key?(ext)
+    []
   end
 
   def Uv.find_syntaxes_by_first_line(first_line)
-    syntaxes = []
-    @syntaxes.each do |syntax_name, syntax_node|
-      syntaxes << syntax_node if syntax_node.firstLineMatch && syntax_node.firstLineMatch =~ first_line
+    return nil if first_line = ''
+    puts "Searching syntaxes by first line..." if @debug
+    @syntaxes.values.compact.each do |syntax_node|
+      return syntax_node if syntax_node && syntax_node.firstLineMatch && syntax_node.firstLineMatch =~ first_line
     end
-    syntaxes
   end
 
-  def Uv.find_syntaxes(extensions=[], first_line='')
-    init_syntaxes unless @syntaxes
-    syntaxes = []
-    extensions.each do |ext|
-      syntaxes += find_syntaxes_by_ext(ext)
+  def Uv.find_syntaxes(extensions=[], first_line='', slow_search=false)
+    puts "Finding syntaxes for: Extensions: [#{extensions.join(', ')}], First Line: '#{first_line.inspect}'" if @debug
+    init_syntaxes if @syntaxes.empty?
+    syntaxes = []; extensions.delete(''); extensions.compact!
+    case slow_search
+    when false
+       syntaxes << load_syntax(extensions.first) unless extensions.empty?
+    when true
+      syntaxes += extensions.collect {|ext| find_syntaxes_by_ext(ext) }.flatten.compact
+      syntaxes += find_syntaxes_by_first_line(first_line) if syntaxes.empty?
     end
-    syntaxes += find_syntaxes_by_first_line(first_line)
+    syntaxes.compact!
+    puts "Syntaxes found: [#{syntaxes.collect(&:name).join(', ')}]" if @debug and not syntaxes.empty?
+    puts "Uv Error: No syntax match found for '#{extensions.join(', ')}', defaulting to 'plain_text' syntax" if @debug and syntaxes.empty?
     syntaxes
   end
 
 
+
+
+
+
+
+
+
+
   # Returns the Textpow::SyntaxNode for this syntax;
   # @raise ArgumentError if no syntax is found
   # Ex: syntax_node_for('ruby') => Textpow::SyntaxNode.load('ruby.syntax')

data/lib/uv/syntaxes.rb

@@ -0,0 +1,51 @@
+module Uv
+
+  # Loads @syntaxes with all the syntax names.
+  # DOES NOT load the syntax files into TextPow
+  def Uv.init_syntaxes
+    puts "Uv: Finding all syntax names..." if @debug
+    syntax_names.each do |syntax_name|
+      puts "Uv: Setting @syntax[#{syntax_name}]" if @debug and !@syntaxes.key?(syntax_name)
+      @syntaxes[syntax_name] = nil unless @syntaxes.key?(syntax_name)
+    end
+    @syntaxes
+  end
+
+  # Loads @syntaxes with all the syntax names.
+  # Load the syntax files into Textpow instences.
+  # ALSO loads the declared_file_types
+  # @force_reload: boolean. Forces the syntax to be reloaded, overriding any loaded syntax
+  def Uv.load_all_syntaxes(force_reload=false)
+    puts "Uv: Loading all syntaxes..." if @debug
+    syntax_names.each do |syntax_name|
+      load_syntax(syntax_name, force_reload)
+      load_syntax_declared_file_types(@syntaxes[syntax_name])
+    end
+    @syntaxes
+  end
+
+  # Loads @syntaxes[syntax_name] with a Textpow instance
+  # @force_reload: boolean. Forces the syntax to be reloaded, overriding any loaded syntax
+  def Uv.load_syntax(syntax_name, force_reload=false)
+    filename = File.join(@syntax_path, "#{syntax_name}.syntax")
+    begin
+      if force_reload
+        @syntaxes[syntax_name] = Textpow::SyntaxNode.load(filename)
+      else
+        @syntaxes[syntax_name] ||= Textpow::SyntaxNode.load(filename)
+      end
+      puts "#{syntax_name}.syntax loaded" if @debug
+    rescue => e
+      puts "Error in loading syntax: #{syntax_name}.  Returning: #{@syntaxes[syntax_name].class}.  Error: #{e.message}" if @debug
+    end
+    return @syntaxes[syntax_name]
+  end
+
+  def Uv.load_syntax_declared_file_types(syntax_node)
+    syntax_node.fileTypes.each do |file_type|
+      puts "Syntax: #{syntax_node.name} loading FileType: #{file_type}" if @debug
+      @syntaxes[file_type] ||= syntax_node
+    end if syntax_node and syntax_node.fileTypes
+  end
+
+end

data/lib/uv/version.rb

@@ -1,3 +1,3 @@
 module Uv
-  VERSION = '0.0.7.2'
+  VERSION = '0.0.7.3'
 end

data/lib/uv.rb

@@ -3,14 +3,15 @@ require 'fileutils'
 require 'textpow'
 require 'uv/render_processor'
 require "uv/version"
-require "uv/finding_syntaxes"
+require "uv/finding_syntax_nodes"
+require "uv/syntaxes"
 require 'uv/utility'
 require 'uv/engine' if defined?(Rails)
 
 
 module Uv
   class << self
-    attr_accessor :render_path, :theme_path, :syntax_path, :default_style, :syntaxes
+    attr_accessor :render_path, :theme_path, :syntax_path, :default_style, :syntaxes, :debug
   end
 
   self.syntax_path   = File.join(File.dirname(__FILE__), '..', 'syntax')
@@ -27,6 +28,17 @@ module Uv
   end
 
 
+  # Returns the list of file names in the syntax dir (without '.syntax' extension)
+  def Uv.syntax_names
+    Dir.glob( File.join(@syntax_path, '*.syntax') ).collect do |f|
+      File.basename(f, '.syntax')
+    end
+  end
+
+  def Uv.debug=(value)
+    @debug=value
+  end
+
   # Copies files from the [ruby-uv/render/<arg1>/files/] to the <arg2> output directory
   def Uv.copy_files output, output_dir
     Uv.path.each do |dir|
@@ -35,12 +47,6 @@ module Uv
     end
   end
 
-  # Returns the list of file names[.syntax] in the syntax dir
-  def Uv.syntaxes
-    Dir.glob( File.join(@syntax_path, '*.syntax') ).collect do |f|
-      File.basename(f, '.syntax')
-    end
-  end
 
   # Returns the list of .css files in the theme directory
   def Uv.themes
@@ -52,15 +58,16 @@ module Uv
   # Parses <arg1> text using RenderProcessor.load(Textpow::SyntaxNode.parse(text)), returns the vailid <output>
   def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = nil, headers = false
     syntaxes = find_syntaxes([syntax_name], get_first_line(text))
-    syntax_node = syntaxes.first
+    return text if syntaxes.empty?
     RenderProcessor.load(output, render_style, line_numbers, headers) do |processor|
-      syntax_node.parse(text, processor)
+      syntaxes.first.parse(text, processor)
     end.string
   end
 
   def Uv.get_first_line(text)
-    first_break = text.index(/[\n\r]/) || text.length - 1
-    text[0..first_break].strip
+    stripped_text = text.strip
+    first_break = stripped_text.index(/[\n\r]/) || stripped_text.length - 1
+    stripped_text[0..first_break].strip
   end
 
   # Parses <arg1> text with Textpow::DebugProcessor, using the given syntax

data/syntax/build.syntax

@@ -1,51 +1,51 @@
---- 
+---
 name: NAnt Build File
-fileTypes: 
+fileTypes:
 - build
 scopeName: source.nant-build
 uuid: 1BA72668-707C-11D9-A928-000D93589AF6
 foldingStartMarker: <[^!?/>]+|<!--
-patterns: 
+patterns:
 - name: comment.block.nant
-  captures: 
-    "0": 
+  captures:
+    "0":
       name: punctuation.definition.comment.nant
   begin: <!--
   end: -->
 - name: meta.tag.nant
-  captures: 
-    "1": 
+  captures:
+    "1":
       name: punctuation.definition.tag.nant
-    "2": 
+    "2":
       name: entity.name.tag.nant
   begin: (</?)([-_a-zA-Z0-9:]+)
   end: (/?>)
-  patterns: 
+  patterns:
   - name: entity.other.attribute-name.nant
     match: " ([a-zA-Z-]+)"
   - name: string.quoted.double.nant
-    endCaptures: 
-      "0": 
+    endCaptures:
+      "0":
         name: punctuation.definition.string.end.nant
     begin: "\""
-    beginCaptures: 
-      "0": 
+    beginCaptures:
+      "0":
         name: punctuation.definition.string.begin.nant
     end: "\""
   - name: string.quoted.single.nant
-    endCaptures: 
-      "0": 
+    endCaptures:
+      "0":
         name: punctuation.definition.string.end.nant
     begin: "'"
-    beginCaptures: 
-      "0": 
+    beginCaptures:
+      "0":
         name: punctuation.definition.string.begin.nant
     end: "'"
 - name: constant.character.entity.nant
-  captures: 
-    "1": 
+  captures:
+    "1":
       name: punctuation.definition.constant.nant
-    "3": 
+    "3":
       name: punctuation.definition.constant.nant
   match: (&)([a-zA-Z]+|#[0-9]+|#x[0-9a-fA-F]+)(;)
 - name: invalid.illegal.bad-ampersand.nant