Neurogami-roir 1.3.3.1

data/lib/rawr_bundle.rb

@@ -0,0 +1,26 @@
+require 'fileutils'
+
+include FileUtils
+
+namespace :"rawr:bundle" do
+
+  desc "Bundles the jar from rawr:jar into a native Mac OS X application (.app)"
+  task :app => [:"rawr:jar"] do
+    require 'app_bundler'
+    Rawr::AppBundler.new.deploy Rawr::Options.instance
+  end
+
+  desc "Bundles the jar from rawr:jar into a native Windows application (.exe)"
+  task :exe => [:"rawr:jar"] do
+    require 'exe_bundler'
+    Rawr::ExeBundler.new.deploy Rawr::Options.instance
+  end
+  
+  desc "Bundles the jar from rawr:jar into a Java Web Start application (.jnlp)"
+  task :web => [:"rawr:jar"] do
+    require 'web_bundler'
+    Rawr::WebBundler.new.deploy Rawr::Options.instance
+  end
+end
+
+

data/lib/rawr_version.rb

@@ -0,0 +1,3 @@
+module Rawr
+  VERSION = "1.3.3.1"
+end

data/lib/web_bundler.rb

@@ -0,0 +1,114 @@
+require 'bundler'
+
+module Rawr
+  class WebBundler < Bundler
+    def self_sign_pass_phrase(options)
+      return nil unless options[:web_start]
+      return nil unless options[:web_start][:self_sign]
+      options[:web_start][:self_sign_passphrase]
+    end
+
+    def web_path
+      "#{@output_dir}/native_deploy/web"
+    end
+
+    def populate_jnlp_string_template(template_values)
+     <<-JNLP
+<?xml version='1.0' encoding='UTF-8' ?>
+  <jnlp spec='1.0+' codebase='#{template_values[:codebase]}' href='#{template_values[:project_name]}.jnlp'>
+    <information>
+    <title>#{template_values[:project_name]}</title>
+    <vendor>#{template_values[:vendor]}</vendor>
+    <homepage href='#{template_values[:homepage_href]}' />
+    <description>#{template_values[:description]}</description>
+  </information>
+
+  <offline-allowed/>
+
+  <security>
+    <all-permissions/>
+  </security>
+
+  <resources>
+    <j2se version='1.6'/>
+    <j2se version='1.5'/>
+    <jar href='#{template_values[:project_name]}.jar'/>
+      #{template_values[:classpath_jnlp_jars]}
+  </resources>
+
+  <application-desc main-class='#{template_values[:main_java_file]}' />
+</jnlp>
+     JNLP
+    end
+
+
+    def template_values(options)
+      values = {}  
+      values[:project_name]   = @project_name 
+      values[:codebase]  = options[:jnlp][:codebase]
+      values[:vendor] = options[:jnlp][:vendor]
+      values[:homepage_href] = options[:jnlp][:homepage_href] 
+      values[:classpath_jnlp_jars]  = classpath_jnlp_jars
+      values[:main_java_file]  = options[:main_java_file]
+      values[:description]  = options[:jnlp][:description] 
+      values
+    end
+
+    def in_root_dir?(file)
+      file !~ /\//
+    end
+
+    def copy_deployment_to(destination_path)
+      file_utils.mkdir_p destination_path
+      relative_base_dir = @package_dir.sub("#{add_trailing_slash(@base_dir)}", '')
+      (relative_files_without_repo + relative_classpath).flatten.uniq.each do |file|
+        new_dir = "#{add_trailing_slash(destination_path)}#{File.dirname(file).sub(relative_base_dir, '')}"
+        file_utils.mkdir_p(new_dir)
+        file_utils.copy(file, "#{add_trailing_slash(destination_path)}#{file.sub(relative_base_dir, '')}") unless File.directory?(file) || in_root_dir?(file)
+      end
+    end
+
+    def deploy(options)
+      @project_name = options[:project_name]
+      @output_dir = options[:output_dir]
+      @classpath = options[:classpath]
+      @package_dir = options[:package_dir]
+      @base_dir  = add_trailing_slash(options[:base_dir])
+      @main_java_file = options[:main_java_file]
+      @project_jar = 
+
+      file_utils.mkdir_p web_path
+
+      web_start_config_file = "#{@project_name}.jnlp"
+
+      unless File.exists? web_start_config_file
+        File.open(web_start_config_file, 'w') do |file|
+          # WARNING: all-permissions needed for security with JRuby!!!!
+          file << populate_jnlp_string_template(template_values(options))
+        end
+      end
+      
+      copy_deployment_to web_path
+      file_utils.cp web_start_config_file, web_path, :verbose => true
+      storepass = self_sign_pass_phrase(options) ? " -storepass #{self_sign_pass_phrase(options)} " : '' 
+      sh "jarsigner -keystore sample-keys #{storepass} #{web_path}/#{@project_name}.jar myself"
+      puts "done signing project jar"
+      @classpath.each {|jar| sh "jarsigner -keystore sample-keys #{storepass}  #{to_web_path(jar).strip} myself" }
+    end
+
+
+    def classpath_jnlp_jars
+      @classpath.map {|jar| "<jar href='#{jar}'/>"}.join("\n")
+    end
+
+
+    def to_web_path(path)
+      base_dir = add_trailing_slash(@base_dir)
+      package_dir = add_trailing_slash(@package_dir)
+      relative_package_dir = package_dir.sub(base_dir, '')
+      path.sub!(base_dir, '')
+      path.sub!(relative_package_dir , '')
+      "#{web_path}/#{path}"
+    end
+  end
+end

data/lib/zip/ioextras.rb

@@ -0,0 +1,155 @@
+module IOExtras  #:nodoc:
+
+  CHUNK_SIZE = 32768
+
+  RANGE_ALL = 0..-1
+
+  def self.copy_stream(ostream, istream)
+    s = ''
+    ostream.write(istream.read(CHUNK_SIZE, s)) until istream.eof? 
+  end
+
+
+  # Implements kind_of? in order to pretend to be an IO object
+  module FakeIO
+    def kind_of?(object)
+      object == IO || super
+    end
+  end
+
+  # Implements many of the convenience methods of IO
+  # such as gets, getc, readline and readlines 
+  # depends on: input_finished?, produce_input and read
+  module AbstractInputStream  
+    include Enumerable
+    include FakeIO
+
+    def initialize
+      super
+      @lineno = 0
+      @outputBuffer = ""
+    end
+
+    attr_accessor :lineno
+
+    def read(numberOfBytes = nil, buf = nil)
+      tbuf = nil
+
+      if @outputBuffer.length > 0
+        if numberOfBytes <= @outputBuffer.length
+          tbuf = @outputBuffer.slice!(0, numberOfBytes)
+        else
+          numberOfBytes -= @outputBuffer.length if (numberOfBytes)
+          rbuf = sysread(numberOfBytes, buf)
+          tbuf = @outputBuffer
+          tbuf << rbuf if (rbuf)
+          @outputBuffer = ""
+        end
+      else
+        tbuf = sysread(numberOfBytes, buf)
+      end
+
+      return nil unless (tbuf)
+
+      if buf
+        buf.replace(tbuf)
+      else
+        buf = tbuf
+      end
+
+      buf
+    end
+
+    def readlines(aSepString = $/)
+      retVal = []
+      each_line(aSepString) { |line| retVal << line }
+      return retVal
+    end
+    
+    def gets(aSepString=$/)
+      @lineno = @lineno.next
+      return read if aSepString == nil
+      aSepString="#{$/}#{$/}" if aSepString == ""
+      
+      bufferIndex=0
+      while ((matchIndex = @outputBuffer.index(aSepString, bufferIndex)) == nil)
+	bufferIndex=@outputBuffer.length
+	if input_finished?
+	  return @outputBuffer.empty? ? nil : flush 
+	end
+	@outputBuffer << produce_input
+      end
+      sepIndex=matchIndex + aSepString.length
+      return @outputBuffer.slice!(0...sepIndex)
+    end
+    
+    def flush
+      retVal=@outputBuffer
+      @outputBuffer=""
+      return retVal
+    end
+    
+    def readline(aSepString = $/)
+      retVal = gets(aSepString)
+      raise EOFError if retVal == nil
+      return retVal
+    end
+    
+    def each_line(aSepString = $/)
+      while true
+	yield readline(aSepString)
+      end
+    rescue EOFError
+    end
+    
+    alias_method :each, :each_line
+  end
+
+
+  # Implements many of the output convenience methods of IO.
+  # relies on <<
+  module AbstractOutputStream 
+    include FakeIO
+
+    def write(data)
+      self << data
+      data.to_s.length
+    end
+
+
+    def print(*params)
+      self << params.to_s << $\.to_s
+    end
+
+    def printf(aFormatString, *params)
+      self << sprintf(aFormatString, *params)
+    end
+
+    def putc(anObject)
+      self << case anObject
+	      when Fixnum then anObject.chr
+	      when String then anObject
+	      else raise TypeError, "putc: Only Fixnum and String supported"
+	      end
+      anObject
+    end
+    
+    def puts(*params)
+      params << "\n" if params.empty?
+      params.flatten.each {
+	|element|
+	val = element.to_s
+	self << val
+	self << "\n" unless val[-1,1] == "\n"
+      }
+    end
+
+  end
+
+end # IOExtras namespace module
+
+
+
+# Copyright (C) 2002-2004 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/zip/stdrubyext.rb

@@ -0,0 +1,111 @@
+unless Enumerable.method_defined?(:inject)
+  module Enumerable  #:nodoc:all
+    def inject(n = 0)
+      each { |value| n = yield(n, value) }
+      n
+    end
+  end
+end
+
+module Enumerable #:nodoc:all
+  # returns a new array of all the return values not equal to nil
+  # This implementation could be faster
+  def select_map(&aProc)
+    map(&aProc).reject { |e| e.nil? }
+  end
+end
+
+unless Object.method_defined?(:object_id)
+  class Object  #:nodoc:all
+    # Using object_id which is the new thing, so we need
+    # to make that work in versions prior to 1.8.0
+    alias object_id id
+  end
+end
+
+unless File.respond_to?(:read)
+  class File # :nodoc:all
+    # singleton method read does not exist in 1.6.x
+    def self.read(fileName)
+      open(fileName) { |f| f.read }
+    end
+  end
+end
+
+class String  #:nodoc:all
+  def starts_with(aString)
+    rindex(aString, 0) == 0
+  end
+
+  def ends_with(aString)
+    index(aString, -aString.size)
+  end
+
+  def ensure_end(aString)
+    ends_with(aString) ? self : self + aString
+  end
+
+  def lchop
+    slice(1, length)
+  end
+end
+
+class Time  #:nodoc:all
+  
+  #MS-DOS File Date and Time format as used in Interrupt 21H Function 57H:
+  # 
+  # Register CX, the Time:
+  # Bits 0-4  2 second increments (0-29)
+  # Bits 5-10 minutes (0-59)
+  # bits 11-15 hours (0-24)
+  # 
+  # Register DX, the Date:
+  # Bits 0-4 day (1-31)
+  # bits 5-8 month (1-12)
+  # bits 9-15 year (four digit year minus 1980)
+  
+  
+  def to_binary_dos_time
+    (sec/2) +
+      (min  << 5) +
+      (hour << 11)
+  end
+
+  def to_binary_dos_date
+    (day) +
+      (month << 5) +
+      ((year - 1980) << 9)
+  end
+
+  # Dos time is only stored with two seconds accuracy
+  def dos_equals(other)
+    to_i/2 == other.to_i/2
+  end
+
+  def self.parse_binary_dos_format(binaryDosDate, binaryDosTime)
+    second = 2 * (       0b11111 & binaryDosTime)
+    minute = (     0b11111100000 & binaryDosTime) >> 5 
+    hour   = (0b1111100000000000 & binaryDosTime) >> 11
+    day    = (           0b11111 & binaryDosDate) 
+    month  = (       0b111100000 & binaryDosDate) >> 5
+    year   = ((0b1111111000000000 & binaryDosDate) >> 9) + 1980
+    begin
+      return Time.local(year, month, day, hour, minute, second)
+    end
+  end
+end
+
+class Module  #:nodoc:all
+  def forward_message(forwarder, *messagesToForward)
+    methodDefs = messagesToForward.map { 
+      |msg| 
+      "def #{msg}; #{forwarder}(:#{msg}); end"
+    }
+    module_eval(methodDefs.join("\n"))
+  end
+end
+
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/zip/tempfile_bugfixed.rb

@@ -0,0 +1,195 @@
+#
+# tempfile - manipulates temporary files
+#
+# $Id: tempfile_bugfixed.rb,v 1.2 2005/02/19 20:30:33 thomas Exp $
+#
+
+require 'delegate'
+require 'tmpdir'
+
+module BugFix  #:nodoc:all
+
+# A class for managing temporary files.  This library is written to be
+# thread safe.
+class Tempfile < DelegateClass(File)
+  MAX_TRY = 10
+  @@cleanlist = []
+
+  # Creates a temporary file of mode 0600 in the temporary directory
+  # whose name is basename.pid.n and opens with mode "w+".  A Tempfile
+  # object works just like a File object.
+  #
+  # If tmpdir is omitted, the temporary directory is determined by
+  # Dir::tmpdir provided by 'tmpdir.rb'.
+  # When $SAFE > 0 and the given tmpdir is tainted, it uses
+  # /tmp. (Note that ENV values are tainted by default)
+  def initialize(basename, tmpdir=Dir::tmpdir)
+    if $SAFE > 0 and tmpdir.tainted?
+      tmpdir = '/tmp'
+    end
+
+    lock = nil
+    n = failure = 0
+    
+    begin
+      Thread.critical = true
+
+      begin
+	tmpname = sprintf('%s/%s%d.%d', tmpdir, basename, $$, n)
+	lock = tmpname + '.lock'
+	n += 1
+      end while @@cleanlist.include?(tmpname) or
+	File.exist?(lock) or File.exist?(tmpname)
+
+      Dir.mkdir(lock)
+    rescue
+      failure += 1
+      retry if failure < MAX_TRY
+      raise "cannot generate tempfile `%s'" % tmpname
+    ensure
+      Thread.critical = false
+    end
+
+    @data = [tmpname]
+    @clean_proc = Tempfile.callback(@data)
+    ObjectSpace.define_finalizer(self, @clean_proc)
+
+    @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
+    @tmpname = tmpname
+    @@cleanlist << @tmpname
+    @data[1] = @tmpfile
+    @data[2] = @@cleanlist
+
+    super(@tmpfile)
+
+    # Now we have all the File/IO methods defined, you must not
+    # carelessly put bare puts(), etc. after this.
+
+    Dir.rmdir(lock)
+  end
+
+  # Opens or reopens the file with mode "r+".
+  def open
+    @tmpfile.close if @tmpfile
+    @tmpfile = File.open(@tmpname, 'r+')
+    @data[1] = @tmpfile
+    __setobj__(@tmpfile)
+  end
+
+  def _close	# :nodoc:
+    @tmpfile.close if @tmpfile
+    @data[1] = @tmpfile = nil
+  end    
+  protected :_close
+
+  # Closes the file.  If the optional flag is true, unlinks the file
+  # after closing.
+  #
+  # If you don't explicitly unlink the temporary file, the removal
+  # will be delayed until the object is finalized.
+  def close(unlink_now=false)
+    if unlink_now
+      close!
+    else
+      _close
+    end
+  end
+
+  # Closes and unlinks the file.
+  def close!
+    _close
+    @clean_proc.call
+    ObjectSpace.undefine_finalizer(self)
+  end
+
+  # Unlinks the file.  On UNIX-like systems, it is often a good idea
+  # to unlink a temporary file immediately after creating and opening
+  # it, because it leaves other programs zero chance to access the
+  # file.
+  def unlink
+    # keep this order for thread safeness
+    File.unlink(@tmpname) if File.exist?(@tmpname)
+    @@cleanlist.delete(@tmpname) if @@cleanlist
+  end
+  alias delete unlink
+
+  if RUBY_VERSION > '1.8.0'
+    def __setobj__(obj)
+      @_dc_obj = obj
+    end
+  else
+    def __setobj__(obj)
+      @obj = obj
+    end
+  end
+
+  # Returns the full path name of the temporary file.
+  def path
+    @tmpname
+  end
+
+  # Returns the size of the temporary file.  As a side effect, the IO
+  # buffer is flushed before determining the size.
+  def size
+    if @tmpfile
+      @tmpfile.flush
+      @tmpfile.stat.size
+    else
+      0
+    end
+  end
+  alias length size
+
+  class << self
+    def callback(data)	# :nodoc:
+      pid = $$
+      lambda{
+	if pid == $$ 
+	  path, tmpfile, cleanlist = *data
+
+	  print "removing ", path, "..." if $DEBUG
+
+	  tmpfile.close if tmpfile
+
+	  # keep this order for thread safeness
+	  File.unlink(path) if File.exist?(path)
+	  cleanlist.delete(path) if cleanlist
+
+	  print "done\n" if $DEBUG
+	end
+      }
+    end
+
+    # If no block is given, this is a synonym for new().
+    #
+    # If a block is given, it will be passed tempfile as an argument,
+    # and the tempfile will automatically be closed when the block
+    # terminates.  In this case, open() returns nil.
+    def open(*args)
+      tempfile = new(*args)
+
+      if block_given?
+	begin
+	  yield(tempfile)
+	ensure
+	  tempfile.close
+	end
+
+	nil
+      else
+	tempfile
+      end
+    end
+  end
+end
+
+end # module BugFix
+if __FILE__ == $0
+#  $DEBUG = true
+  f = Tempfile.new("foo")
+  f.print("foo\n")
+  f.close
+  f.open
+  p f.gets # => "foo\n"
+  f.close!
+end