Neurogami-roir 1.3.3.1

data/lib/exe_bundler.rb

@@ -0,0 +1,106 @@
+require 'fileutils'
+require 'bundler'
+require 'platform'
+
+module Rawr
+  class ExeBundler < Bundler  
+    include FileUtils
+
+    def link_launch4j_bin(prefix, root_path)
+      return if File.exists? "#{root_path}/launch4j/bin"
+      case prefix
+      when 'win'
+        FileUtils.mv "#{root_path}/launch4j/bin-#{prefix}", "#{root_path}/launch4j/bin"
+      else
+        chmod 0755, "#{root_path}/launch4j/bin-#{prefix}/windres"
+        chmod 0755, "#{root_path}/launch4j/bin-#{prefix}/ld"
+        sh "ln -s #{root_path}/launch4j/bin-#{prefix} #{root_path}/launch4j/bin"
+      end
+    end
+
+    def deploy(options)
+      @project_name = options.project_name
+      @classpath = options.classpath
+      @main_java_class = options.main_java_file
+      @built_jar_path = options.jar_output_dir
+
+      @java_app_deploy_path = options.windows_output_dir
+      @target_jvm_version = options.target_jvm_version
+      @minimum_windows_jvm_version = options.minimum_windows_jvm_version
+      @jvm_arguments = options.jvm_arguments
+
+      @startup_error_message     = options.windows_startup_error_message
+      @bundled_jre_error_message = options.windows_bundled_jre_error_message
+      @jre_version_error_message = options.windows_jre_version_error_message
+      @launcher_error_message    = options.windows_launcher_error_message
+      @icon_path                 = options.windows_icon_path
+
+      @launch4j_config_file = "#{@java_app_deploy_path}/configuration.xml"
+
+      copy_deployment_to @java_app_deploy_path
+      puts "Creating Windows application in #{@built_jar_path}/#{@project_name}.exe"
+
+      File.open(@launch4j_config_file, 'w') do |file|
+        file << <<-CONFIG_ENDL
+<launch4jConfig>
+<dontWrapJar>true</dontWrapJar>
+<headerType>0</headerType>
+<jar>#{@project_name}.jar</jar>
+<outfile>#{@java_app_deploy_path}/#{@project_name}.exe</outfile>
+<errTitle></errTitle>
+<jarArgs></jarArgs>
+<chdir></chdir>
+<customProcName>true</customProcName>
+<stayAlive>false</stayAlive>
+<icon>#{@icon_path}</icon>
+<jre>
+  <path></path>
+  <minVersion>#{@minimum_windows_jvm_version}.0</minVersion>
+  <maxVersion></maxVersion>
+  <initialHeapSize>0</initialHeapSize>
+  <maxHeapSize>0</maxHeapSize>
+  #{"<args>" + @jvm_arguments + "</args>" unless @jvm_arguments.nil? || @jvm_arguments.strip.empty?}
+</jre>
+<messages>
+  <startupErr>#{@startup_error_message}</startupErr>
+  <bundledJreErr>#{@bundled_jre_error_message}</bundledJreErr>
+  <jreVersionErr>#{@jre_version_error_message}</jreVersionErr>
+  <launcherErr>#{@launcher_error_message}</launcherErr>
+</messages>
+</launch4jConfig>          
+CONFIG_ENDL
+      end
+
+      file_dir_name = File.dirname(__FILE__)
+
+      # Set ACL permissions to allow launch4j bundler to run on Windows
+      if Platform.instance.using_windows?
+        # Check for FAT32 vs NTFS, the cacls command doesn't work on FAT32 nor is it required
+        output = `fsutil fsinfo volumeinfo #{file_dir_name.split(':')[0]}:\\`
+        # fsutil can only work with admin priviledges
+        raise output if output =~ /requires that you have administrative privileges/
+        # ===== Sample output of 'fsutil fsinfo volumeinfo c:\'
+        # Volume Name :
+        # Volume Serial Number : 0x80a5650a
+        # Max Component Length : 255
+        # File System Name : FAT32
+        # Preserves Case of filenames
+        # Supports Unicode in filenames
+        if 'NTFS' == output.split("\n")[3].split(':')[1].strip
+          sh "echo y | cacls \"#{file_dir_name}/launch4j/bin-win/windres.exe\" /G \"#{ENV['USERNAME']}\":F"
+          sh "echo y | cacls \"#{file_dir_name}/launch4j/bin-win/ld.exe\" /G \"#{ENV['USERNAME']}\":F"
+        end
+        link_launch4j_bin('win', file_dir_name)
+      elsif Platform.instance.using_linux?
+        link_launch4j_bin('linux', file_dir_name)
+      elsif Platform.instance.using_mac?
+        link_launch4j_bin('mac', file_dir_name)
+      end
+
+
+      warn "call: java -jar \"#{file_dir_name}/launch4j/launch4j.jar\" \"#{@launch4j_config_file}\""
+      sh "java -jar \"#{file_dir_name}/launch4j/launch4j.jar\" \"#{@launch4j_config_file}\""
+    end
+
+  end
+end

data/lib/generator.rb

@@ -0,0 +1,127 @@
+module Rawr
+  class Generator
+    def self.create_run_config_file(options)
+      File.open("#{options.compile_dir}/run_configuration", "w+") do |run_config_file|
+        run_config_file << "main_ruby_file: " + options.main_ruby_file + "\n"
+      end
+    end
+    def self.create_manifest_file(options)
+      FileUtils.mkdir_p "#{options.compile_dir}/META-INF"
+      File.open("#{options.compile_dir}/META-INF/MANIFEST.MF", "w+") do |manifest_file|
+        manifest_file << "Manifest-Version: 1.0\n"
+       cp_string = options.classpath.join(" \n ") << " " << options.jars.keys.map{|key| "#{key}.jar"}.join(" \n ") << " . \n"
+        manifest_file << "Class-Path: " << cp_string 
+        manifest_file << "Main-Class: #{options.main_java_file}\n"
+      end
+    end
+    
+    def self.create_java_main_file(java_file, java_package, java_class)
+      File.open(java_file, "w+") do |java_main_file|
+        java_main_file << <<-ENDL
+package #{java_package};
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+import java.io.IOException;
+import java.net.URL;
+
+
+import java.util.ArrayList;
+import org.jruby.Ruby;
+import org.jruby.RubyInstanceConfig;
+import org.jruby.javasupport.JavaEmbedUtils;
+
+public class #{java_class}
+{
+  public static void main(String[] args) throws Exception
+  {   
+    RubyInstanceConfig config = new RubyInstanceConfig();
+    config.setArgv(args);
+    Ruby runtime = JavaEmbedUtils.initialize(new ArrayList(0), config);
+    String mainRubyFile = "main";
+   
+    ArrayList<String> config_data = new ArrayList<String>();
+    try{
+      java.io.InputStream ins = Main.class.getClassLoader().getResourceAsStream("run_configuration");
+      if (ins == null ) {
+        System.err.println("Did not find configuration file 'run_configuration', using defaults.");
+      } else {
+        config_data = getConfigFileContents(ins);
+      }
+    }
+    catch(IOException ioe)
+    {
+      System.err.println("Error loading run configuration file 'run_configuration', using defaults: " + ioe);
+    }
+    catch(java.lang.NullPointerException npe)
+    {
+      System.err.println("Error loading run configuration file 'run_configuration', using defaults: " + npe );
+    }
+
+    for(String line : config_data) {
+        String[] parts = line.split(":");
+        if("main_ruby_file".equals(parts[0].replaceAll(" ", ""))) {
+            mainRubyFile = parts[1].replaceAll(" ", "");
+        }
+    }
+
+    runtime.evalScriptlet("require '" + mainRubyFile + "'");
+  }
+
+  public static URL getResource(String path) {
+      return Main.class.getClassLoader().getResource(path);
+  }
+
+  private static ArrayList<String> getConfigFileContents(InputStream input) throws IOException, java.lang.NullPointerException {
+    BufferedReader reader = new BufferedReader(new InputStreamReader(input));
+    String line;
+    ArrayList<String> contents = new ArrayList<String>();
+
+    while ((line = reader.readLine()) != null) {
+      contents.add(line);
+    }
+    reader.close();
+    return(contents);
+  }
+}
+ENDL
+      end
+    end
+    
+    def self.create_default_config_file(config_path, java_class)
+      File.open(config_path, "w+") do |config_file|
+        config_file << <<-ENDL
+configuration do |c|
+  c.project_name = 'ChangeMe'
+  c.output_dir = 'package'
+  c.main_ruby_file = 'main'
+  c.main_java_file = 'org.rubyforge.rawr.Main'
+
+  # Compile all Ruby and Java files recursively
+  # Copy all other files taking into account exclusion filter
+  c.source_dirs = ['src', 'lib/ruby']
+  c.source_exclude_filter = []
+
+  # Location of the jruby-complete.jar. Override this if your jar lives elsewhere.
+  # This allows Rawr to make sure it uses a compatible jrubyc when compiling,
+  # so the class files are always compatible, regardless of your system JRuby.
+  #c.jruby_jar = 'lib/java/jruby-complete.jar'
+  c.compile_ruby_files = true
+  #c.java_lib_files = []  
+  c.java_lib_dirs = ['lib/java']
+  #c.files_to_copy = []
+
+  c.target_jvm_version = 1.5
+  #c.jars[:data] = { :directory => 'data/images', :location_in_jar => 'images', :exclude => /bak/}
+  #c.jvm_arguments = ""
+  #c.jvm_properties = {} # e.g., { 'bluecove.jsr82.psm_minimum_off' => 'true', 'java.library.path' => './lib/java/'} 
+
+  # Bundler options
+  # c.do_not_generate_plist = false
+end
+        ENDL
+      end
+    end
+  end
+end

data/lib/jar_builder.rb

@@ -0,0 +1,57 @@
+module Rawr
+  class JarBuilder
+    require 'zip/zip'
+
+    def initialize(name, settings)
+      @name = name
+      @directory = settings[:directory] || (raise "Missing directory value in configuration for #{name}")
+      @items = settings[:items] || nil
+      raise "Invalid exclusion #{settings[:exclude].inspect} for #{name} configuration: exclusion must be a Regexp" unless (settings[:exclude].nil? || settings[:exclude].kind_of?(Regexp))
+      @exclude = settings[:exclude] || nil
+      @location_in_jar = if settings[:location_in_jar]
+                           if ['/', '\\'].member? settings[:location_in_jar][-1].chr
+                             settings[:location_in_jar]
+                           else
+                             "#{settings[:location_in_jar]}/"
+                           end
+                         else
+                           ''
+                         end
+    end
+
+    def build
+      if @items
+        file_list = @items.map { |item|
+          if File.directory?("#{@directory}/#{item}")
+            Dir.glob("#{@directory}/#{item}/**/*")
+          else
+            "#{@directory}/#{item}" #To maintain consistancy with first branch of if
+          end
+        }.flatten.map! {|f| puts "before sub: #{f}"; f.sub("#{@directory}/", ''); puts "before sub: #{f}"; f}.reject {|f| (f =~ @exclude) || File.directory?(f)}
+      else
+        file_list = Dir.glob("#{@directory}/**/*").
+                              map! {|f| f.sub("#{@directory}/", '')}.
+                              reject {|f| (f =~ @exclude) || File.directory?(f)}
+      end
+                            
+      zip_file_name = "#{Rawr::Options.data.jar_output_dir}/#{@name}"
+      puts "=== Creating jar file: #{zip_file_name}"
+      File.delete(zip_file_name) if File.exists? zip_file_name
+      begin
+        Zip::ZipFile.open(zip_file_name, Zip::ZipFile::CREATE) do |zipfile|
+          file_list.each do |file|
+            begin
+              zipfile.add("#{@location_in_jar}#{file}", "#{@directory}/#{file}")
+            rescue => e
+              param1 = "#{@location_in_jar}#{file}"
+              param2 = "#{@directory}/#{file}"
+              puts "Errors with the following zipfile call: zipfile.add(#{param1.inspect}, #{param2.inspect})"
+            end
+          end
+        end
+      rescue
+        puts "Errors opening the zip file: #{zip_file_name}"
+      end
+    end
+  end
+end

data/lib/jruby_batch_compiler.rb

@@ -0,0 +1,127 @@
+require 'jruby/jrubyc'
+require 'ostruct'
+
+module Rawr
+  class JRubyBatchCompiler
+    include JRubyCompiler
+
+    def self.compile_argv
+      dest_dir = ARGV.pop
+      # TODO: add ability to carry options through
+      new.compile_dirs(ARGV, dest_dir)
+    end
+
+    def compile_dirs(src_dirs, dest_dir, options={})
+      #options[:jruby_jar]  ||= 'lib/java/jruby-complete.jar'
+      options[:exclude]    ||= []
+      options[:target_jvm] ||= '1.5'
+      copy_only = options[:copy_only]  ||= false
+
+      #TODO: Allow for copy-only and some other options
+      ruby_globs = glob_ruby_files(src_dirs, options[:exclude])
+
+      ruby_globs.each do |glob_data|
+        files     = glob_data.files
+        directory = glob_data.directory
+        if copy_only
+          copy_files(files, directory, dest_dir)
+        else
+          compile_files(files.map {|file| "#{directory}/#{file}"}, directory, '', dest_dir)
+        end
+      end
+    end
+
+    def copy_files(files, src_dir, dest_dir)
+      files.each do |file|
+        #target_file = "#{dest_dir}/#{file}"
+        FileUtils.mkdir_p(File.dirname("#{dest_dir}/#{file}"))
+        File.copy("#{src_dir}/#{file}", "#{dest_dir}/#{file}")
+      end
+    end
+#      if copy_only
+#        processed_file = file
+#        target_file = "#{dest_dir}/#{file}"
+#      else
+#        relative_dir, name = File.split(file)
+#        processed_file = Java::org::jruby::util::JavaNameMangler.mangle_filename_for_classpath(file, Dir.pwd, "", true) + '.class'
+#        target_file = "#{dest_dir}/#{processed_file}"
+#      end
+#
+#      if file_is_newer?("#{directory}/#{file}", target_file)
+#        FileUtils.mkdir_p(File.dirname("#{dest_dir}/#{processed_file}"))
+#
+#        if copy_only
+#          File.copy("#{directory}/#{processed_file}", "#{dest_dir}/#{processed_file}")
+#        else
+#          # There's no jrubyc.bat/com/etc for Windows. jruby -S works universally here
+#          # TODO: Speed up compiling by not invoking java for each file...
+#          sh "java -jar #{jruby_jar} -S jrubyc #{directory}/#{file}"
+#          File.move("#{directory}/#{processed_file}", "#{dest_dir}/#{processed_file}")
+#        end
+#      end
+
+    def glob_ruby_files(src_dirs, excludes)
+      src_dirs.inject([]) do |file_globs, directory|
+        glob = Dir.glob("#{directory}/**/*.rb")
+        reject_directories!(glob)
+        strip_directory!(glob, directory)
+        reject_excluded_matches!(glob, excludes)
+        puts "files for #{directory}: #{glob.size}"
+        file_globs << OpenStruct.new(:files => glob, :directory => directory)
+        file_globs
+      end
+    end
+
+    def strip_directory!(dir_globs, directory)
+      dir_globs.map! {|file| file.sub("#{directory}/", '')}
+    end
+
+    def reject_directories!(glob)
+      glob.reject! {|file| File.directory?(file)}
+    end
+
+    def reject_excluded_matches!(dir_globs, excludes)
+      dir_globs.reject! do |file|
+        excludes.any? {|exclude| file =~ exclude}
+      end
+    end
+
+    def self.compile_ruby_dirs(src_dirs, dest_dir, jruby_jar='lib/java/jruby-complete.jar', exclude=[], target_jvm='1.5', copy_only=false)
+      ruby_source_file_list = src_dirs.inject([]) do |list, directory|
+        list << Dir.glob("#{directory}/**/*.rb").
+          #reject{|file| File.directory?(file)}.
+          map!{|file| directory ? file.sub("#{directory}/", '') : file}.
+          #reject{|file| exclude.inject(false) {|rejected, filter| (file =~ filter) || rejected} }.
+          map!{|file| OpenStruct.new(:file => file, :directory => directory)}
+      end.flatten!
+
+      ruby_source_file_list.each do |data|
+        file = data.file
+        directory = data.directory
+
+        if copy_only
+          processed_file = file
+          target_file = "#{dest_dir}/#{file}"
+        else
+          relative_dir, name = File.split(file)
+          processed_file = Java::org::jruby::util::JavaNameMangler.mangle_filename_for_classpath(file, Dir.pwd, "", true) + '.class'
+          target_file = "#{dest_dir}/#{processed_file}"
+        end
+
+        if file_is_newer?("#{directory}/#{file}", target_file)
+          FileUtils.mkdir_p(File.dirname("#{dest_dir}/#{processed_file}"))
+
+          if copy_only
+            File.copy("#{directory}/#{processed_file}", "#{dest_dir}/#{processed_file}")
+          else
+            # There's no jrubyc.bat/com/etc for Windows. jruby -S works universally here
+            # TODO: Speed up compiling by not invoking java for each file...
+            sh "java -jar #{jruby_jar} -S jrubyc #{directory}/#{file}"
+            File.move("#{directory}/#{processed_file}", "#{dest_dir}/#{processed_file}")
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/jruby_release.rb

@@ -0,0 +1,104 @@
+require 'open-uri'
+require 'fileutils'
+
+module Rawr
+  class JRubyRelease
+    @@releases = nil
+
+    BASE_URL='http://repository.codehaus.org/org/jruby/jruby-complete'
+
+    attr_accessor :version, :rc, :version_string
+
+    def self.get(version, destination)
+      release = case version
+                when 'current'
+                  get_most_current_releases(1).first
+                when 'stable'
+                  get_most_current_stable_releases(1).first
+                end
+      release.download
+      release.move_to destination
+    end
+
+    def self.get_most_current_releases(count=5)
+      @@releases ||= get_list
+      if @@releases.size > count
+        return [@@releases.last] if count == 1
+        @@releases[(@@releases.size-(count+1))..(@@releases.size-1)]
+      else
+        @@releases
+      end
+    end
+
+    def self.get_most_current_stable_releases(count=5)
+      @@releases ||= get_list
+      selected = @@releases.select{ |r| r.rc.to_s.strip.empty? }
+      if selected .size > count
+        return [selected.last] if count == 1
+        selected[(selected.size-(count+1))..(selected.size-1)]
+      else
+        selected
+      end
+    end
+
+    def self.get_list
+      # We get HTML 3.2 or something, with lines like this:
+      # <a href="0.9.8/">
+      #
+      # so we want to find all of those and find the latest, but note any RC entries
+      lines = open(BASE_URL).readlines
+      lines.map!{|l| l =~ /(href=")([\.\dRC]+)(\/">)/ ? $2 : nil }
+      lines.compact!
+      lines.map!{|l| new(l) }
+      lines.sort!
+
+      @@releases = lines
+    end
+
+    def initialize(version_string)
+      @version_string = version_string
+      version_string =~ /([\.\d]+)(RC\d)*/
+      @version = $1.to_s
+      @rc = $2.to_s
+      mj,mn,patch = @version.split('.')
+      @version  = "#{mj.to_i}.#{mn.to_i}.#{patch.to_i}"
+    end
+
+    def download
+      open("jruby-complete.jar","wb").write(open(self.jar_url).read)
+    end
+
+    def move_to(destination)
+      FileUtils.mkdir_p destination
+      FileUtils.move("jruby-complete.jar", "#{destination}/jruby-complete.jar")
+    end
+
+    def jar_url
+      # http://repository.codehaus.org/org/jruby/jruby-complete/1.1RC2/jruby-complete-1.1RC2.jar
+      # http://repository.codehaus.org/org/jruby/jruby-complete/1.1.4/jruby-complete-1.1.4.jar
+      # For example.
+      "#{BASE_URL}/#{@version_string}/jruby-complete-#{@version_string}.jar"
+    end
+
+    def <=>(other)
+      raise "#{other} is not a Release." unless other.kind_of?(Rawr::JRubyRelease)
+      if self.version != other.version
+        self.version <=> other.version #? self : other
+      else
+        self.rc <=> other.rc #? self : other
+      end
+    end
+
+    def to_s
+      "<Release @version=#{@version}; @rc='#{@rc}' jar_url='#{jar_url}'/>"
+    end
+
+    def to_nice_string
+      "Release version #{@version} #{@rc} #{jar_url}"
+    end
+
+    def full_version_string
+      "#{@version} #{@rc}"
+    end
+  end
+end

data/lib/launch4j/LICENSE.txt

@@ -0,0 +1,30 @@
+Launch4j (http://launch4j.sourceforge.net/)
+Cross-platform Java application wrapper for creating Windows native executables.
+
+Copyright (c) 2004, 2008 Grzegorz Kowal
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the Launch4j nor the names of its contributors
+      may be used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.