pangolin 0.3.0

data/lib/pangolin/jar.rb

@@ -0,0 +1,179 @@
+require 'java'
+
+
+module Pangolin
+
+  include_class 'java.io.FileOutputStream'
+  include_class 'java.util.zip.ZipOutputStream'
+  include_class 'java.util.zip.ZipEntry'
+  
+
+  class Jar
+  
+    # The path to the directory which should be considered the root of the archive.
+    #
+    # If you set +base_dir+ to "build" and add the file "build/Main.class", that file
+    # will be put in the archive as "Main.class". 
+    attr_accessor :base_dir
+    
+    # The ZIP compression rate from 0 (no compression) to 9 (maximal compression)
+    attr_accessor :compression
+    
+    # Whether or not to print the equivalent command string to the output (see #execute)
+    attr_accessor :verbose
+    
+    # The path to the JAR file that will be generated
+    attr_reader :output
+     
+    
+    def initialize( output, files = nil, base_dir = nil )
+      @output      = output
+      @base_dir    = base_dir
+      @entries     = { } # archive_path => IO
+      @verbose     = false
+      @compression = 1
+      
+      self.manifest = { }
+      
+      add_files(files) unless files.nil? || files.empty?
+    end
+  
+    # Sets the attributes that will end up in the JAR manifest.
+    #
+    # Attribute names are treated case insensitively, so setting
+    # both Main-Class and main-class will result in only one being used.
+    #
+    # Will raise an error on malformed attribute names (must start with a
+    # letter or digit and contain only letter, digits, dashes and underscores).
+    # 
+    # The manifest you set will be merged with a set of default attributes (but
+    # yours will override).
+    def manifest=( manifest_hash )
+      @manifest = default_manifest
+      
+      manifest_hash.each do |key, value|
+        raise ArgumentError, "Malformed attribute name #{key}" if key !~ /^[\w\d][\w\d\-_]*$/
+        
+        remove_manifest_attribute(key)
+        
+        @manifest[key] = value
+      end
+    end
+    
+    # Removes a manifest attribute, the comparison is case insensitive.
+    def remove_manifest_attribute( name ) # :nodoc:
+      @manifest.delete_if do |key, value|
+        key.downcase == name.downcase
+      end      
+    end
+    
+    # Convenience method for setting the Main-Class manifest attribute
+    def main_class=( class_name )
+      if class_name
+        @manifest['Main-Class'] = class_name
+      else
+        remove_manifest_attribute('Main-Class')
+      end
+    end
+    
+    def default_manifest # :nodoc:
+      {
+        'Built-By' => "Pangolin v#{Pangolin::version}",
+        'Manifest-Version' => '1.0'
+      }
+    end
+    
+    def manifest_string # :nodoc:
+      @manifest.keys.inject("") do |str, key|
+        str + "#{key}: #{@manifest[key]}\n"
+      end
+    end
+    
+    def commit_manifest # :nodoc:
+      add_blob(manifest_string, 'META-INF/MANIFEST.MF')
+    end
+    
+    # Adds the file at +file_path+ to the archive and put it at +archive_path+
+    # (the same as +file_path+ by default) inside the archive.
+    def add_file( file_path, archive_path = nil )
+      archive_path = find_archive_path(file_path, @base_dir) unless archive_path
+      
+      if File.directory?(file_path)
+        raise ArgumentError, "\"#{file_path}\" is a directory"
+      elsif ! File.exists?(file_path)
+        raise ArgumentError, "\"#{file_path}\" does not exist"
+      end
+      
+      @entries[archive_path || file_path] = File.new(file_path)
+    end
+    
+    # Adds a list of files to the archive, at paths relative to +base_dir+
+    # (defaults to #base_dir) inside the archive.
+    def add_files( files, base_dir = nil )
+      files.each do |file|
+        add_file(file, find_archive_path(file, base_dir || @base_dir))
+      end
+    end
+    
+    # Adds a string to the archive at +archive_path+.
+    def add_blob( str, archive_path )
+      @entries[archive_path] = StringIO.new(str)
+    end
+    
+    def remove_entry( archive_path ) # :nodoc:
+      @entries.delete(archive_path)
+    end
+    
+    def entries # :nodoc:
+      @entries.keys
+    end
+    
+    # Creates the archive. If #verbose is true the equivalent command string
+    # for the +jar+ command will be printed to the stream passed as +io+ (or
+    # +$stdout+ by default)
+    def execute( io = $stderr )
+      raise "Output not set" unless @output
+      
+      compression_flag = @compression == 0 ? '0' : ''
+      
+      io.puts 'jar …' if @verbose
+      
+      commit_manifest
+      create_zipfile
+      
+      true
+    end
+    
+    def create_zipfile # :nodoc:
+      buffer_size = 65536
+      
+      zipstream = ZipOutputStream.new(FileOutputStream.new(@output))
+      
+      @entries.each do |path, io|
+        while buffer = io.read(buffer_size)
+          zipstream.put_next_entry(ZipEntry.new(path))
+          zipstream.write(buffer.to_java_bytes, 0, buffer.length)
+          zipstream.close_entry
+        end
+        
+        io.close
+      end
+            
+      zipstream.close
+    end
+    
+    def find_archive_path( path, base_dir ) # :nodoc:
+      if base_dir
+        prefix = base_dir + (base_dir =~ /\/$/ ? '' : '/')
+      
+        if 0 == path.index(prefix)
+          return path.slice(prefix.length, path.length - prefix.length)
+        end
+      end
+      
+      path
+    end
+    
+  end
+  
+end

data/lib/pangolin/javac.rb

@@ -0,0 +1,128 @@
+require 'java'
+
+
+module Pangolin
+
+  # must use include_class instead of import because import interferes with Rake's import
+  include_class 'java.io.PrintWriter'
+  include_class 'java.io.StringWriter'
+
+
+  class Javac
+
+    # The files to compile.
+    attr_accessor :source_files
+    
+    # Additional directories where source files can be found.
+    attr_accessor :source_path
+                  
+    # The directory where the generated class files should be written, defaults to "build"
+    attr_accessor :destination
+  
+    # The compilation class path
+    attr_accessor :class_path
+    
+    # Show deprecation warnings, true by default
+    attr_accessor :deprecation_warnings
+    
+    # Generate warnings, true by default
+    attr_accessor :warnings
+    
+    # The encoding of the source files
+    attr_accessor :encoding
+    
+    # Whether or not to print the equivalent command string to the output (see #execute)
+    attr_accessor :verbose
+    
+    # Enable or diable specific warnings by adding their names to this list.
+    # The possible values are:
+    # * all
+    # * cast
+    # * deprecation
+    # * divzero
+    # * empty
+    # * unchecked
+    # * fallthrough
+    # * path
+    # * serial
+    # * finally
+    # * overrides
+    # * none
+    # Prefix with '-' to disable.
+    attr_accessor :lint
+
+    # Determines the maximum number of errors to print, default (nil) is to print all
+    attr_accessor :max_errors
+    
+    # Determines the maximum number of warnings to print, default (nil) is to print all
+    attr_accessor :max_warnings
+
+
+    def initialize( *source_files )
+      @source_files = source_files || [ ]
+  
+      @source_path          = [ ]
+      @destination          = 'build'
+      @class_path           = [ ]
+      @deprecation_warnings = true
+      @warnings             = true
+      @encoding             = nil
+      @verbose              = false
+      @lint                 = [ ]
+    end
+  
+    # Run javac. If #verbose is true the equivalent command string for
+    # the +javac+ command will be printed to the stream passed as +io+ (or
+    # +$stdout+ by default)
+    def execute( io = $stderr )
+      output_writer = StringWriter.new
+  
+      io.puts 'javac …' if @verbose
+  
+      result = execute_compiler(output_writer)
+      
+      output_str = output_writer.to_s
+      
+      io.puts output_str if output_str !~ /^\s*$/
+  
+      if 0 == result
+        true
+      else
+        false
+      end
+    end
+    
+    def command_args # :nodoc:
+      args = [ ]
+      args << '-sourcepath' << formatted_path(@source_path) unless @source_path.empty?
+      args << '-d' << @destination unless (@destination.nil? || @destination =~ /^\s*$/)
+      args << '-classpath' << formatted_path(@class_path) unless @class_path.empty?
+      args << '-deprecation' if @deprecation_warnings
+      args << '-nowarn' unless @warnings
+      args << '-encoding' << @encoding if @encoding
+      args << '-Xmaxerrs' << @max_errors if @max_errors
+      args << '-Xmaxwarns' << @max_warnings if @max_warnings 
+      args + lint_flags + @source_files
+    end
+    
+  private
+  
+    def lint_flags
+      @lint.map { |lint| '-Xlint:' + lint }
+    end
+  
+    def execute_compiler(output_writer)
+      com.sun.tools.javac.Main.compile(command_args.to_java(java.lang.String), PrintWriter.new(output_writer))
+    end
+        
+    def formatted_path(items)
+      if items.respond_to? :join
+        items.join(':')
+      else
+        items.to_s
+      end
+    end
+
+  end
+  
+end

data/lib/pangolin/junit.rb

@@ -0,0 +1,120 @@
+JUNIT_JAR_PATH = File.dirname(__FILE__) + '/ext/junit.jar'
+
+
+require JUNIT_JAR_PATH
+
+
+include_class 'java.lang.ClassLoader'
+include_class 'java.lang.ClassNotFoundException'
+include_class 'java.net.URLClassLoader'
+include_class 'java.net.URL'
+
+
+module Pangolin
+
+  class Junit
+    
+    include Output::Formatting
+    
+    
+    attr_accessor :class_path
+    attr_accessor :colorize
+    attr_accessor :verbose
+    
+
+    def initialize(*classes)
+      @class_names = classes || [ ]
+      @class_path  = [ ]
+      @colorize    = false
+      @verbose     = false
+    end
+  
+    def classes
+      @class_names
+    end
+  
+    def execute(io=$stderr)
+      io.puts 'junit …' if @verbose
+      
+      junit  = load_class('org.junit.runner.JUnitCore').new_instance
+      result = junit.run(class_instances)
+      
+      print_result(result)
+      
+      0 == result.failure_count
+    end
+      
+  private
+  
+    def print_result(result)
+      if result.was_successful
+        puts format_header('%d tests run in %.1f seconds, no failures' % [result.run_count, result.run_time/1000])
+      else
+        args = [
+          result.run_count, 
+          result.run_time/1000, 
+          result.failure_count, 
+          result.failure_count == 1 ? '' : 's'
+        ]
+    
+        puts format_header('%d tests run in %.1f seconds with %d failure%s' % args)
+        puts ''
+      
+        result.failures.each do |failure|
+          puts format_error_header('- ' + failure.test_header)
+          puts format_error('  ' + failure.message) unless failure.message.nil? || failure.message =~ /^\s*$/
+          
+          filtered_stack_trace_array(failure.trace).each do |trace_frame|
+            puts format_stack_trace('  ' + trace_frame.strip)
+          end
+          
+          puts '' #unless failure == result.failures.to_a.last
+        end
+      end
+    end
+    
+    def filtered_stack_trace_array(trace)
+      trace.split("\n").reject do |line|
+        case line
+        when /java.lang.AssertionError/, /at org.junit/, /at sun.reflect/, /at java.lang.reflect/, /at org.jruby/, /jrake/
+          true
+        else
+          false
+        end
+      end
+    end  
+  
+    def full_class_path
+      @class_path + [JUNIT_JAR_PATH]
+    end
+  
+    def pretty_class_path
+      full_class_path.join(':')
+    end
+
+    def class_path_urls      
+      full_class_path.map do |e|
+        full_path  = File.expand_path(e)
+        full_path += '/' if File.directory?(full_path) && full_path[-1] != '/'
+        
+        URL.new('file', 'localhost', full_path)
+      end
+    end
+
+    def class_loader
+      @class_loader ||= URLClassLoader.new(class_path_urls.to_java(URL), ClassLoader.system_class_loader)
+    end
+
+    def class_instances
+      @class_names.map { |class_name| load_class(class_name) }.to_java(java.lang.Class)
+    end
+    
+    def load_class(class_name)
+      class_loader.load_class(class_name)
+    rescue ClassNotFoundException => e
+      raise LoadError, "Class not found: #{class_name} (looking in #{pretty_class_path})"
+    end
+  
+  end
+  
+end

data/lib/pangolin/output/formatting.rb

@@ -0,0 +1,65 @@
+module Pangolin
+	module Output
+	  module Formatting
+
+      FORMATTING = {
+        # colors
+        :black      => "\e[30m",
+        :red        => "\e[31m",
+        :green      => "\e[32m",
+        :yellow     => "\e[33m",
+        :blue       => "\e[34m",
+        :magenta    => "\e[35m",
+        :cyan       => "\e[36m",
+        :white      => "\e[37m",
+              
+        # text styles
+        :bold       => "\e[1m",
+        :underline  => "\e[4m",
+        :blink      => "\e[5m",
+        :reverse    => "\e[7m",
+        :concealed  => "\e[8m",
+        
+        # backgrounds
+        :black_bg   => "\e[40m",
+        :red_bg     => "\e[41m",
+        :green_bg   => "\e[42m",
+        :yellow_bg  => "\e[43m",
+        :blue_bg    => "\e[44m",
+        :magenta_bg => "\e[45m",
+        :cyan_bg    => "\e[46m",
+        :white_bg   => "\e[47m"
+      }
+      
+      FORMATTING_OFF = "\e[0m"
+      
+	    def format_text(text, formatting)
+	      if @colorize
+	        format_codes = [formatting].flatten
+	        format_codes.reject! { |f| FORMATTING[f].nil? }
+	        format_codes.map! { |f| FORMATTING[f] }
+	        format_codes.join + text + FORMATTING_OFF
+        else
+          text
+        end
+      end
+      
+      def format_header(text)
+        format_text(text, :bold)
+      end
+      
+      def format_error_header(text)
+        format_text(text, [:red, :bold])
+      end
+      
+      def format_error(text)
+        format_text(text, :red)
+      end
+      
+      def format_stack_trace(text)
+        text
+      end
+	    
+	  end
+	end
+end