silhouette 1.0.0 → 2.0.0

data/lib/silhouette/default.css

@@ -0,0 +1,68 @@
+TABLE {
+    FONT-SIZE: 11px
+}
+
+TABLE.code {
+    border:black 1px solid;
+}
+
+BODY {
+    FONT-FAMILY: sans-serif;
+}
+.coverageHit { 
+    border-right:#dcdcdc 1px solid;
+    background-color:#c8c8f0;
+}
+.coverageCount, .lineCount { border-right:#dcdcdc 1px solid; }
+.coverageMissing, .coverageMissed { 
+    border-right:#dcdcdc 1px solid;
+    background-color:#300;
+}
+.coverageMissed { border-right:#dcdcdc 1px solid; }
+.lineNonCode { 
+    border-right:#dcdcdc 1px solid;
+    background-color:#f0f0f0;
+}
+.lineCount { 
+    border-right:#dcdcdc 1px solid; 
+    background-color:#c8c8f0;
+}
+.sourceLineHighlight {
+    background-color:#200;
+}
+
+.sourceLineGoodHighlight {
+    background-color:#023103;
+}
+
+.coverageMethod {
+    background-color:#1a4400;
+}
+
+.sourceLinePartialHighlight {
+    background-color:#202020;
+}
+
+.sourceLine {
+    color:#ffffff;
+    background-color:#171717;
+}
+
+.normal { color: #ffffff; }
+.comment { color: #99462e; }
+.keyword { color: #79a8df; }
+.method { color: #b3b3b3; }
+.class { color: #6486c7; }
+.module { color: #6486c7; }
+.punct { color: #cdcdcd; }
+.symbol { color: #2368ff; }
+.string { color: #b6ac99; }
+.char { color: #F07; }
+.ident { color: #ffffff; }
+.constant { color: #fffa00; }
+.regex { color: #dd585d; }
+.number { color: #2368ff; }
+.attribute { color: #3d93a9; }
+.global { color: #7FB; }
+.expr { color: #e2e2e2; }
+.escape { color: #277; }

data/lib/silhouette/emitters.rb

@@ -0,0 +1,176 @@
+module Silhouette
+  class InvalidFormat < Exception; end
+  
+  def self.emitters
+      out = []
+      constants.each do |name|
+          con = const_get(name)
+          if Class === con and con.superclass == Emitter
+              out << con
+          end
+      end
+      out
+  end
+  
+  def self.find_emitter(file)
+    
+    if !File.exists? file
+      bz = "#{file}.bz2"
+      file = bz if File.exists?(bz)
+    end
+    
+    if !File.exists? file
+      gz = "#{file}.gz"
+      file = gz if File.exists?(gz)
+    end
+
+    if file == "-"
+      io = STDIN
+    
+    elsif /.bz2$/.match(file)
+      io = IO.popen("bzip2 -dc '#{file}'")
+    elsif /.gz$/.match(file)
+      io = IO.popen("gzip -dc '#{file}'")
+    else
+      raise "Unknown file" unless File.exists?(io)
+      io = File.open(file)
+    end
+
+    emitters.each do |em|
+      begin
+        return em.new(io)
+      rescue InvalidFormat
+      end
+    end
+
+    raise InvalidFormat, "Unable to find valid emitter"
+  end
+  
+  class Emitter
+      def initialize(processor=nil)
+          @processor = processor
+      end
+      
+      attr_accessor :processor
+  end 
+  
+  class BinaryEmitter < Emitter
+      MAGIC = "<>"
+      
+      def initialize(file, processor=nil)
+          if file.kind_of? String
+              raise "Unknown file" unless File.exists?(file)
+              @io = File.open(file)
+          else
+              @io = file
+          end
+          
+          magic = @io.read(2)
+          raise InvalidFormat unless magic == MAGIC
+          
+          @method_size = "S"
+          @file_size = "S"
+          @ret_call_fmt = "i#{@method_size}#{@file_size}ii"
+          @ret_call_size = 16
+          super(processor)
+      end
+  
+      class DoneParsing < Exception; end
+  
+      def parse
+          begin
+              loop { emit }
+          rescue DoneParsing
+          end
+      end
+      
+      FIXED_SIZE = {
+          ?c => 20,
+          ?r => 20,
+          ?@ => 8
+      }
+  
+      def next_cmd
+          str = @io.read(1)
+          raise DoneParsing unless str
+      
+          cmd = str[0]
+          if [?!, ?*, ?&].include? cmd
+              size = @io.read(4).unpack("i").first
+          else
+              size = FIXED_SIZE[cmd]
+          end
+              
+          [cmd, size, @io.read(size)]
+      end
+      
+      def parse
+          begin
+          # Use "while true" instead of "loop" because loop is
+          # really a method call.
+          while true
+              data = @io.read(1)
+              raise DoneParsing unless data
+      
+              cmd = data[0]
+          
+              # These are hardcoded in here for speed.
+              if cmd == ?r or cmd == ?c or cmd == ?l
+                  size = @ret_call_size
+              elsif cmd == ?@
+                  size = 8
+              else
+                  size = @io.read(4).unpack("i").first
+              end
+          
+              proc = @processor
+              data = @io.read(size)
+          
+              case cmd
+              when ?r
+                  parts = data.unpack(@ret_call_fmt)
+                  @processor.process_return(*parts)
+                  # return [:return, *parts]
+              when ?c
+                  parts = data.unpack(@ret_call_fmt)
+                  @processor.process_call(*parts)
+              when ?l
+                  parts = data.unpack(@ret_call_fmt)
+                  @processor.process_line(*parts)
+                  # return [:call, *parts]
+              when ?!
+                  parts = data.unpack("Z#{size - 8}ii")
+                  @processor.process_start(*parts)
+                  # return [:start, *parts]
+              when ?@
+                  parts = data.unpack("ii")
+                  @processor.process_end(*parts)
+                  # return [:end, *parts]
+              when ?&
+                  parts = data.unpack("ia#{size - 4}")
+                  parts += parts.pop.split("\0")
+                  @processor.process_method(*parts)
+                  # return [:method, *parts]
+              when ?*
+                  parts = data.unpack("iZ#{size - 4}")
+                  @processor.process_file(*parts)
+                  # return [:file, *parts]
+              when ?(
+                  @method_size = "I"
+                  @ret_call_size += 2
+                  @ret_call_fmt = "i#{@method_size}#{@file_size}ii"
+              when ?)
+                  @file_size = "I"
+                  @ret_call_size += 2
+                  @ret_call_fmt = "i#{@method_size}#{@file_size}ii"
+              else
+                  raise "Unknown type '#{cmd.chr}'"
+              end
+          end
+          
+          # This means we're done.
+          rescue DoneParsing
+          end
+      end
+  end
+end

data/lib/silhouette/finder.rb

@@ -0,0 +1,138 @@
+require 'syntax/convertors/html'
+
+module Silhouette
+  class MethodFinder < Syntax::Convertors::HTML
+    class MethodPosition
+      def initialize(name, klass)
+        @name = name
+        @klass = klass
+        @misses = 0
+        @loc = 0
+      end
+      
+      def total
+        @last_line - @first_line
+      end
+    
+      attr_accessor :first_line, :last_line, :name, :klass, :misses, :loc
+      
+      def coverage
+        loc_hit = @loc - @misses
+        ((loc_hit / @loc.to_f) * 100).to_i
+      end
+    end
+  
+    class ClassPosition
+      def initialize(name)
+        @name = name
+        @misses = 0
+      end
+      
+      def total
+        @last_line - @first_line
+      end
+    
+      attr_accessor :first_line, :last_line, :name, :misses
+    end
+  
+    def initialize(tok)
+      super
+      @line_no = 1
+      @inner_ends = 0
+      @class_path = []
+      @class_stack = []
+      @modules = []
+      @methods = []
+      @method_stack = []
+      @current_method = nil
+      @html = ""
+      @line_start = true
+    end
+    
+    attr_reader :methods, :modules
+  
+    HAS_END = %w!if begin while for until case unless!
+
+    def process_token(tok)
+      # p [tok, tok.group]
+      case tok.group
+      when :normal, :string, :constant
+        nls = tok.count("\n")
+        @line_no += nls
+        @line_start = true if nls > 0
+      when :class, :module
+        # How to handle classes inside conditions? Don't count them.
+        return unless @inner_ends == 0
+        @class_path << tok.to_s
+        klass = ClassPosition.new(@class_path.join("::"))
+        klass.first_line = @line_no
+        @modules << klass
+        @class_stack << klass
+        # puts "start class: #{@class_path.inspect}"
+      when :method
+        return unless @inner_ends == 0
+        # Handle nested methods by just ignoring the nested ones.
+        if @class_path.last == :def
+          @inner_ends += 1
+        else
+          meth = MethodPosition.new(tok, @class_path.join("::"))
+          meth.first_line = @line_no
+          @methods << meth
+          @method_stack << meth
+          @class_path << :def
+          # puts "start meth: #{@class_path.inspect}, #{tok}"
+        end
+      when :keyword
+        if HAS_END.include?(tok.to_s) and @line_start
+          @inner_ends += 1
+          return
+        elsif tok == "do"
+          @inner_ends += 1
+          return
+        end
+      
+        if tok == "end"
+          if @inner_ends == 0
+            was_in = @class_path.pop
+            if was_in == :def
+              # puts "Done with method: #{@class_path.inspect}"
+              @method_stack.last.last_line = @line_no
+              @method_stack.pop
+            else
+              fin = @class_stack.pop
+              if fin
+                fin.last_line = @line_no
+              end
+            end
+          else
+            @inner_ends -= 1
+            # puts "pending ends: #{@inner_ends}"
+          end
+        end
+      end
+      
+      if tok.group != :normal
+        @line_start = false
+      end
+    end
+  
+    def find(text)
+      @tokenizer.tokenize(text) do |tok|
+        process_token tok       
+      end
+    end
+  
+    private
+  
+    def html_escape(tok)
+      process_token(tok)
+      super
+    end
+  end
+end
+require 'pp'
+if $0 == __FILE__
+  con = Silhouette::MethodFinder.for_syntax "ruby"
+  con.convert ARGF.read
+  pp con
+end

data/lib/silhouette/light.css

@@ -0,0 +1,63 @@
+TABLE {
+    FONT-SIZE: 11px
+}
+
+TABLE.code {
+    border:black 1px solid;
+}
+
+BODY {
+    FONT-FAMILY: sans-serif;
+}
+.coverageHit { 
+    border-right:#dcdcdc 1px solid;
+    background-color:#c8c8f0;
+}
+.coverageCount, .lineCount { border-right:#dcdcdc 1px solid; }
+.coverageMissing, .coverageMissed { 
+    border-right:#dcdcdc 1px solid;
+    background-color:#F0C8C8;
+}
+.coverageMissed { border-right:#dcdcdc 1px solid; }
+.lineNonCode { 
+    border-right:#dcdcdc 1px solid;
+    background-color:#f0f0f0;
+}
+.lineCount { 
+    border-right:#dcdcdc 1px solid; 
+    background-color:#c8c8f0;
+}
+.sourceLineHighlight {
+    background-color:#F0C8C8;
+}
+
+.sourceLineGoodHighlight {
+    background-color:#c1ffd1;
+}
+
+.coverageMethod {
+    background-color:#c1ffd1;
+}
+
+.sourceLinePartialHighlight {
+    background-color:#f1f1f1;
+}
+
+.normal {}
+.comment { color: #005; font-style: italic; }
+.keyword { color: #0000dd; }
+.method { color: #077; }
+.class { color: #074; }
+.module { color: #050; }
+.punct { color: #447; font-weight: bold; }
+.symbol { color: #099; }
+.string { color: #b58401; }
+.char { color: #F07; }
+.ident { color: #004; }
+.constant { color: #07F; }
+.regex { color: #B66; background: #FEF; }
+.number { color: #e15858;; }
+.attribute { color: #3d93a9; }
+.global { color: #7FB; }
+.expr { color: #227; }
+.escape { color: #277; }

data/lib/silhouette/process.rb

@@ -0,0 +1,3 @@
+require 'silhouette/processor'
+require 'silhouette/converter'
+require 'silhouette/emitters'