devver-ultraviolet 0.10.5

data/bin/uv

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+begin
+   require 'rubygems'
+   require 'uv'
+rescue LoadError
+   $:.unshift File.join( File.dirname(__FILE__), '..', 'lib' )
+   require 'uv'
+end
+
+require 'optparse'
+require 'ostruct'
+
+o = OpenStruct.new
+o.copy_files = false 
+o.output = "xhtml"
+o.headers = false
+o.theme = "espresso_libre"
+o.lines = true
+
+options = OptionParser.new
+
+options.banner =<<END
+
+Usage: uv [options] input_file
+
+Parses input_file (or stdin, if no input_file is given) and 
+outputs the coresponding HTML to stdout. If no syntax is specified, 
+it tries to guess the best one. If no theme is specified, defaults 
+to espresso_libre.
+
+Example:
+
+   uv -t amy -h ~/.bashrc > bashrc.html
+   
+   Renders the contents of ~/.bashrc to file bashrc.html
+   as a standalone web page.
+
+All options are non-mandatory
+
+Options:
+
+END
+
+options.on( "-c DIR", "--copy-files DIR", <<DESCRIPTION ) {|val| o.copy_files = val}
+Copy the required files to the specified output directory (css, images, etc).
+DESCRIPTION
+
+options.on( "-s SYNTAX", "--syntax SYNTAX", <<DESCRIPTION, Uv.syntaxes) {|val| o.syntax = val}
+The file's syntax (e.g. ruby, c++, etc.) 
+DESCRIPTION
+
+options.on( "-o OUTPUT", "--output OUTPUT", <<DESCRIPTION) {|val| o.output = val}
+The output format (xhtml, latex, etc.) default to xhtml
+DESCRIPTION
+
+options.on( "-t THEME", "--theme THEME", <<DESCRIPTION, Uv.themes) {|val| o.theme = val}
+The theme to be used (e.g. amy, espresso_libre, etc.)
+DESCRIPTION
+
+options.on( "-n", "--no-lines", <<DESCRIPTION ) {|val| o.lines = false}
+Produces output without line numbers
+DESCRIPTION
+
+
+options.on( "-h", "--headers", <<DESCRIPTION ) {|val| o.headers = val}
+Include headers, outputs a self-contained web page/document
+DESCRIPTION
+
+options.on( "-d", "--debug", <<DESCRIPTION ) {|val| o.debug = val}
+Outputs debug information instead of normal page rendering
+DESCRIPTION
+   
+options.on( "-l [syntaxes|themes]", "--list [syntaxes|themes]", ['syntaxes', 'themes'], <<DESCRIPTION ) {|val| o.list = val}
+Lists all the available syntaxes/themes
+DESCRIPTION
+   
+   
+options.on( "-?", "--help", <<DESCRIPTION ) {|val| o.help = val}
+Show this message
+DESCRIPTION
+
+rest = options.parse( ARGV )
+
+
+if o.help
+   puts options
+   exit
+elsif o.list
+   if o.list == 'syntaxes'
+      puts "Available syntaxes:\n"
+      Uv.syntaxes.sort.each{ |s| puts "   - #{s}"}
+   elsif o.list == 'themes'
+      puts "Available themes:\n"
+      Uv.themes.sort.each{ |t| puts "   - #{t}"}
+   else
+      STDERR.puts "Option #{o.list} is not valid should be one of [syntaxes, themes]"
+   end
+   exit
+end
+
+if o.copy_files
+   unless File.exists?(o.copy_files)
+      STDERR.puts "The specified output directory: #{o.copy_files} does not exist."
+      exit -1
+   end
+   Uv.copy_files o.output, o.copy_files
+end
+
+o.filename = rest[0]
+
+if o.filename && ! o.syntax
+   candidates = Uv.syntax_for_file o.filename
+  if candidates.size > 1
+      STDERR.puts "Many syntaxes match, please specify"
+      STDERR.puts "\nMatching syntaxes:"
+      candidates.sort.each { |name, syntax| STDERR.puts "\t - " + name}
+      exit -1
+   end
+   o.syntax = candidates.first.first unless candidates.size == 0
+end
+
+unless o.syntax
+   STDERR.puts "No default syntax found, please specify"
+   exit -1
+end
+
+if o.filename
+   o.text = File.read(o.filename) 
+else
+   o.text = STDIN
+end
+
+if o.debug
+   Uv.debug( o.text, o.syntax )
+   exit
+end
+
+puts Uv.parse( o.text, o.output,  o.syntax, o.lines, o.theme, o.headers )
+

data/lib/uv.rb

@@ -0,0 +1,94 @@
+#encoding: ascii-8bit
+require 'fileutils'
+require 'textpow'
+require 'uv/render_processor.rb'
+
+
+module Uv
+  class << self
+    attr_accessor :render_path, :theme_path, :syntax_path, :default_style, :syntaxes
+  end
+
+  self.syntax_path   = File.join(File.dirname(__FILE__), '..', 'syntax')
+  self.render_path   = File.join(File.dirname(__FILE__), '..', 'render')
+  self.theme_path    = File.join(render_path, 'xhtml', 'files', 'css')
+  self.default_style = 'mac_classic'
+  self.syntaxes      = {}
+  
+  def Uv.path
+    result = []
+    result << File.join(File.dirname(__FILE__), ".." )
+  end
+
+  def self.syntax_node_for(syntax)
+    if !@syntaxes.key?(syntax)
+      filename = File.join(@syntax_path, "#{syntax}.syntax")
+      @syntaxes[syntax] = if File.exist?(filename)
+        Textpow::SyntaxNode.load(filename)
+      else
+        false
+      end
+    end
+    if !@syntaxes[syntax]
+      raise ArgumentError, "No #{syntax}.syntax file in #{@syntax_path}"
+    end
+    @syntaxes[syntax]
+  end
+
+  def Uv.copy_files output, output_dir
+    Uv.path.each do |dir|
+      dir_name = File.join( dir, "render", output, "files" )
+      FileUtils.cp_r( Dir.glob(File.join( dir_name, "." )), output_dir ) if File.exists?( dir_name )
+    end
+  end
+
+  def Uv.syntaxes
+    Dir.glob( File.join(@syntax_path, '*.syntax') ).collect do |f| 
+      File.basename(f, '.syntax')
+    end
+  end
+
+  def Uv.themes
+    Dir.glob( File.join(@theme_path, '*.css') ).collect do |f| 
+      File.basename(f, '.css')
+    end
+  end
+
+  def Uv.syntax_for_file file_name
+    init_syntaxes unless @syntaxes
+    first_line = ""
+    File.open( file_name, 'r' ) { |f|
+      while (first_line = f.readline).strip.size == 0; end
+    }
+    result = []
+    @syntaxes.each do |key, value|
+      assigned = false
+      if value.fileTypes
+        value.fileTypes.each do |t|
+          if t == File.basename( file_name ) || t == File.extname( file_name )[1..-1]
+            result << [key, value] 
+            assigned = true
+            break
+          end
+        end
+      end
+      unless assigned
+        if value.firstLineMatch && value.firstLineMatch =~ first_line
+          result << [key, value] 
+        end
+      end
+    end
+    result
+  end
+
+  def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = nil, headers = false
+    RenderProcessor.load(output, render_style, line_numbers, headers) do |processor|
+      syntax_node_for(syntax_name).parse(text, processor)
+    end.string
+  end
+
+  def Uv.debug text, syntax_name
+    syntax_node_for(syntax_name).parse(text, Textpow::DebugProcessor.new)
+  end
+
+end

data/lib/uv/render_processor.rb

@@ -0,0 +1,146 @@
+require 'cgi'
+
+module Uv
+
+  class RenderProcessor
+    @@score_manager = Textpow::ScoreManager.new
+
+    attr_reader :string
+    attr_accessor :escapeHTML
+
+    def self.load(output, style = nil, line_numbers = false, headers = false)
+      style  ||= Uv.default_style
+      renderer = File.join( Uv.render_path, output,"#{style}.render")
+      raise( ArgumentError, "Output for #{output} in #{style} style is not yet implemented" ) unless File.exists?(renderer)
+      options   = YAML.load_file(renderer)
+      processor = RenderProcessor.new(options, line_numbers, headers)
+      yield processor if block_given?
+      processor
+    end
+
+    def initialize render_options, line_numbers = false, headers = true, score_manager = nil
+      @score_manager  = score_manager || @@score_manager
+      @render_options = render_options
+      @options        = {}
+      @headers        = headers
+      @line_numbers   = line_numbers
+      @escapeHTML     = true
+    end
+    
+    def start_parsing name
+      @stack       = [name]
+      @string      = ""
+      @line        = nil
+      @line_number = 0
+      print @render_options["document"]["begin"] if @headers
+      print @render_options["listing"]["begin"]
+      #         opt = options @stack
+      #         print opt["begin"] if opt
+    end
+    
+    def print string
+      @string << string
+    end
+    
+    def escape string
+      if @render_options["filter"]
+        @escaped = string
+        @escaped = self.instance_eval( @render_options["filter"] )
+        @escaped
+      else
+        string
+      end
+    end
+    
+    def open_tag name, position
+      @stack << name
+      print escape(@line[@position...position].gsub(/\n|\r/, '')) if position > @position
+      @position = position
+      opt = options @stack
+      print opt["begin"] if opt
+    end
+    
+    def close_tag name, position
+      print escape(@line[@position...position].gsub(/\n|\r/, '')) if position > @position
+      @position = position
+      opt = options @stack
+      print opt["end"] if opt
+      @stack.pop
+    end
+    
+    def close_line
+      stack = @stack[0..-1]
+      while stack.size > 1
+        opt = options stack
+        print opt["end"] if opt
+        stack.pop
+      end
+      print "</span>" #end code span
+    end
+    
+    def open_line
+      stack = [@stack.first]
+      clone = @stack[1..-1]
+      while stack.size < @stack.size
+        stack << clone.shift
+        opt = options stack
+        print opt["begin"] if opt
+      end
+    end
+    
+    def new_line line
+      if @line
+        print escape(@line[@position..-1].gsub(/\n|\r/, ''))
+        close_line
+        print @render_options["line"]["end"]
+        print "</span>" #end whole line span
+        print "\n" 
+      end
+      @position = 0
+      @line_number += 1
+      @line = line
+      print "<span id='whole-code-line-#{@line_number}'>"
+      print @render_options["line"]["begin"]
+      if @line_numbers
+        print @render_options["line-numbers"]["begin"] 
+        print @line_number.to_s.rjust(4).ljust(5)
+        print @render_options["line-numbers"]["end"] 
+        print " "
+      end
+      print "<span id='only-code-line-#{@line_number}'>"
+      open_line
+    end
+    
+    def end_parsing name
+      if @line
+        print escape(@line[@position..-1].gsub(/\n|\r/, '')) 
+        while @stack.size > 1
+          opt = options @stack
+          print opt["end"] if opt
+          @stack.pop
+        end
+        print @render_options["line"]["end"]
+        print "</span>" #end code span
+        print "</span>" #end whole line span
+        print "\n"
+      end
+      #         opt = options @stack
+      #         print opt["end"] if opt
+      @stack.pop
+      print @render_options["listing"]["end"]
+      print @render_options["document"]["end"] if @headers
+    end
+    
+    def options stack
+      ref = stack.join ' '
+      return @options[ref] if @options.has_key? ref
+    
+      result = @render_options['tags'].max do |a, b| 
+        @score_manager.score( a['selector'], ref ) <=> @score_manager.score( b['selector'], ref )
+      end
+      result = nil if @score_manager.score( result['selector'], ref ) == 0
+      @options[ref] = result
+    end
+  end
+end
+

data/lib/uv/utility.rb

@@ -0,0 +1,67 @@
+module Uv
+  def Uv.foreground bg
+    fg = "#FFFFFF"
+    3.times do |i|
+      fg = "#000000" if bg[i*2+1, 2].hex > 0xFF / 2 
+    end
+    fg
+  end
+
+  def Uv.alpha_blend bg, fg
+    unless bg =~ /^#((\d|[ABCDEF]){3}|(\d|[ABCDEF]){6}|(\d|[ABCDEF]){8})$/i
+      raise(ArgumentError, "Malformed background color '#{bg}'" )
+    end
+    unless fg =~ /^#((\d|[ABCDEF]){3}|(\d|[ABCDEF]){6}|(\d|[ABCDEF]){8})$/i
+      raise(ArgumentError, "Malformed foreground color '#{fg}'" )
+    end
+    
+    if bg.size == 4
+      tbg  =  (fg[1,1].hex * 0xff / 0xf).to_s(16).upcase.rjust(2, '0')
+      tbg +=  (fg[2,1].hex * 0xff / 0xf).to_s(16).upcase.rjust(2, '0')
+      tbg +=  (fg[3,1].hex * 0xff / 0xf).to_s(16).upcase.rjust(2, '0')
+      bg   =  "##{tbg}"
+    end
+    
+    result = ""
+    if fg.size == 4
+      result += (fg[1,1].hex * 0xff / 0xf).to_s(16).upcase.rjust(2, '0')
+      result += (fg[2,1].hex * 0xff / 0xf).to_s(16).upcase.rjust(2, '0')
+      result += (fg[3,1].hex * 0xff / 0xf).to_s(16).upcase.rjust(2, '0')
+    elsif fg.size == 9
+      if bg.size == 7
+        div0 = bg[1..-1].hex
+        div1, alpha = fg[1..-1].hex.divmod( 0x100 )
+        3.times {      
+          div0, mod0 = div0.divmod( 0x100 )
+          div1, mod1 = div1.divmod( 0x100 )
+          result = ((mod0 * alpha + mod1 * ( 0x100 - alpha ) ) / 0x100).to_s(16).upcase.rjust(2, '0') + result
+        } 
+      else
+        div_a, alpha_a = bg[1..-1].hex.divmod( 0x100 )
+        div_b, alpha_b = fg[1..-1].hex.divmod( 0x100 )
+        alpha = alpha_a + alpha_b * (0x100 - alpha_a)
+        3.times {
+          div_b, c_b = div_b.divmod( 0x100 )
+          div_a, c_a = div_a.divmod( 0x100 )
+          result = ((c_a * alpha_a + ( 0x100 - alpha_a ) * alpha_b * c_b ) / alpha).to_s(16).upcase.rjust(2, '0') + result
+        } 
+      end
+      #result = "FF00FF"
+    else
+      result = fg[1..-1]
+    end
+    "##{result}"
+  end
+
+  def Uv.normalize_color settings, color, fg = false
+    if color
+      if fg
+        alpha_blend( settings["foreground"] ? settings["foreground"] : "#000000FF", color )
+      else
+        alpha_blend( settings["background"] ? settings["background"] : "#000000FF", color )
+      end
+    else
+      color
+    end
+  end
+end