ocra 1.0.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2009-04-05
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,8 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/ocra.rb
+share/ocra/lzma.exe
+share/ocra/stub.exe
+test/test_ocra.rb

data/README.txt

@@ -0,0 +1,104 @@
+= ocra
+
+* http://github.com/larsch/ocra/
+
+== DESCRIPTION:
+
+OCRA (One-Click Ruby Application) builds Windows executables from Ruby
+source code. The executable is a self-extracting, self-running
+executable that contains the Ruby interpreter, your source code and
+any additionally needed ruby libraries or DLL.
+
+== FEATURES/PROBLEMS:
+
+* LZMA Compression (optional, default on)
+* Windows support only
+* Ruby 1.9 support
+* Both console programs and desktop programs supported (no console will
+  pop up with .rbw files).
+
+== TODO:
+
+* Clean up using manual recursive deletion (not SHop).
+
+== SYNOPSIS:
+
+ocra.rb [option] your/script.rb
+
+* OCRA will load your script (using Kernel#load) and build the
+  executable when it exits.
+
+* Your program should 'require' all necessary files when invoked without
+  arguments, so ocra can detect all dependencies.
+
+* Autoloaded constants (e.g. modules and classes) should work. Ocra
+  attempts to load all autoload definitions.
+
+* Ocra does not set up the include path. Use "$:.unshift
+  File.dirname(__FILE__)" at the start of your script if you need to
+  'require' additional source files in the same directory no matter
+  what the user's current working directory is.
+
+* DLLs needs to be added manually (e.g. sqlite3.dll, gdbm.dll,
+  etc.). Use the --dll option.
+
+== REQUIREMENTS:
+
+* Windows
+* Working Ruby installation
+* MinGW Installation (for building the stub)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== TECHNICAL DETAILS
+
+The Ocra stub extracts the contents into a temporary directory
+(Windows' default temporary directory). The directory will contains
+the same directory layout as your Ruby installlation. The source files
+for your application will be put in the 'src' subdirectory.
+
+Libraries found in non-standard path (for example, if you invoke Ocra
+with "ruby -I some/path") will be placed into the site dir
+(lib/ruby/site_ruby).
+
+The RUBYOPT and RUBYLIB variables are cleared before your program is
+launched by the executable in order not to interfere with any Ruby
+installation on the end user's installation.
+
+Autoloaded constants will be attempted loaded when building the
+executable. Modules that doesn't exist will be ignore (but a warning
+will be logged.)
+
+== CREDITS:
+
+Thanks for Igor Pavlov for the LZMA compressor and decompressor. The
+source code used was place into Public Domain by Igor Pavlov.
+
+Erik Veenstra for rubyscript2exe which provided inspiration.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Lars Christensen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,49 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/ocra.rb'
+
+r = Hoe.new('ocra', Ocra::VERSION) do |p|
+  # p.rubyforge_name = 'ocrax' # if different than lowercase project name
+  p.rubyforge_name = 'ocra'
+  p.developer('Lars Christensen', 'larsch@belunktum.dk')
+end
+require 'pp'
+pp r
+
+task :stub do
+  sh "mingw32-make -C src"
+  cp 'src/stub.exe', 'share/ocra/stub.exe'
+end
+
+task :test => :stub
+
+task :standalone => [ 'bin/ocrasa.rb', 'bin/ocrasa.exe' ]
+
+
+file 'bin/ocrasa.rb' => [ 'bin/ocra.rb', 'share/ocra/stub.exe', 'share/ocra/lzma.exe' ] do
+  cp 'bin/ocra.rb', 'bin/ocrasa.rb'
+  File.open("bin/ocrasa.rb", "a") do |f|
+    f.puts "__END__"
+    stub = File.open("share/ocra/stub.exe", "rb") {|g| g.read}
+    stub64 = [stub].pack("m")
+    f.puts stub64.size
+    f.puts stub64
+    lzma = File.open("share/ocra/lzma.exe", "rb") {|g| g.read}
+    lzma64 = [lzma].pack("m")
+    f.puts lzma64.size
+    f.puts lzma64
+  end
+end
+
+file 'bin/ocrasa.exe' => [ 'bin/ocra.rb', 'bin/ocrasa.rb' ] do
+  sh "ruby bin/ocra.rb bin/ocrasa.rb"
+end
+
+task :clean do
+  rm_rf Dir.glob("bin/*.exe")
+  sh "mingw32-make -C src clean"
+end
+
+# vim: syntax=Ruby

data/bin/ocra.rb

@@ -0,0 +1,303 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+
+module Ocra
+  Signature = [0x41, 0xb6, 0xba, 0x4e]
+  OP_END = 0
+  OP_CREATE_DIRECTORY = 1
+  OP_CREATE_FILE = 2
+  OP_CREATE_PROCESS = 3
+  OP_DECOMPRESS_LZMA = 4
+  OP_SETENV = 5
+
+  class << self
+    attr_accessor :lzma_mode
+    attr_accessor :extra_dlls
+    attr_accessor :files
+    attr_accessor :load_autoload
+    attr_accessor :force_windows
+    attr_accessor :force_console
+    attr_accessor :quiet
+    attr_reader :lzmapath
+    attr_reader :stubimage
+    
+    def get_next_embedded_image
+      DATA.read(DATA.readline.to_i).unpack("m")[0]
+    end
+  end
+
+  def Ocra.initialize_ocra
+    if defined?(DATA)
+      @stubimage = get_next_embedded_image
+      lzmaimage = get_next_embedded_image
+      @lzmapath = File.join(ENV['TEMP'], 'lzma.exe').tr('/','\\')
+      File.open(@lzmapath, "wb") { |file| file << lzmaimage }
+    else
+      ocrapath = File.dirname(__FILE__)
+      @stubimage = File.open(File.join(ocrapath, '../share/ocra/stub.exe'), "rb") { |file| file.read }
+      @lzmapath = File.expand_path('../share/ocra/lzma.exe', ocrapath).tr('/','\\')
+      raise "lzma.exe not found" unless File.exist?(@lzmapath)
+    end
+  end
+
+  def Ocra.parseargs(argv)
+    lzma_mode = true
+    extra_dlls = []
+    files = []
+    load_autoload = true
+    force_windows = false
+    force_console = false
+    quiet = false
+    
+    usage = <<EOF
+ocra [options] script.rb
+
+--dll dllname    Include additional DLLs from the Ruby bindir.
+--no-lzma        Disable LZMA compression of the executable.
+--quiet          Suppress output.
+--help           Display this information.
+--windows        Force Windows application (rubyw.exe)
+--console        Force console application (ruby.exe)
+--no-autoload    Don't load/include script.rb's autoloads
+EOF
+
+    while arg = argv.shift
+      case arg
+      when /\A--(no-)?lzma\z/
+        lzma_mode = !$1
+      when /\A--dll\z/
+        extra_dlls << argv.shift
+      when /\A--quiet\z/
+        quiet = true
+      when /\A--windows\z/
+        force_windows = true
+      when /\A--console\z/
+        force_console = true
+      when /\A--no-autoload\z/
+        load_autoload = false
+      when /\A--help\z/, /\A--/
+        puts usage
+        exit
+      else
+        files << arg
+      end
+    end
+
+    if files.empty?
+      puts usage
+      exit
+    end
+
+    @lzma_mode = lzma_mode
+    @extra_dlls = extra_dlls
+    @quiet = quiet
+    @force_windows = force_windows
+    @force_console = force_console
+    @load_autoload = load_autoload
+    @files = files
+  end
+
+  def Ocra.init(argv)
+    parseargs(argv)
+    initialize_ocra
+  end
+
+  # Force loading autoloaded constants. Searches through all modules
+  # (and hence classes), and checks their constants for autoloaded
+  # ones, then attempts to load them.
+  def Ocra.attempt_load_autoload
+    modules_checked = []
+    loop do
+      modules_to_check = []
+      ObjectSpace.each_object(Module) do |mod|
+        modules_to_check << mod unless modules_checked.include?(mod)
+      end
+      break if modules_to_check.empty?
+      modules_to_check.each do |mod|
+        modules_checked << mod
+        mod.constants.each do |const|
+          if mod.autoload?(const)
+            begin
+              mod.const_get(const)
+            rescue LoadError
+              puts "=== WARNING: #{mod}::#{const} was not loadable"
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  def Ocra.build_exe
+    # Attempt to autoload libraries before doing anything else.
+    attempt_load_autoload if Ocra.load_autoload
+
+    # Store the currently loaded files (before we require rbconfig for
+    # our own use).
+    features = $LOADED_FEATURES.dup
+
+    # Find gemspecs to include
+    if defined?(Gem)
+      gemspecs = Gem.loaded_specs.map { |name,info| info.loaded_from }
+    else
+      gemspecs = []
+    end
+
+    require 'rbconfig'
+    exec_prefix = RbConfig::CONFIG['exec_prefix']
+    src_prefix = File.expand_path(File.dirname(Ocra.files[0]))
+    sitelibdir = RbConfig::CONFIG['sitelibdir']
+    bindir = RbConfig::CONFIG['bindir']
+    libruby_so = RbConfig::CONFIG['LIBRUBY_SO']
+
+    instsitelibdir = sitelibdir[exec_prefix.size+1..-1]
+    
+    # Find loaded files
+    libs = []
+    features.each do |filename|
+      path = $:.find { |path| File.exist?(File.expand_path(filename, path)) }
+      if path
+        fullpath = File.expand_path(filename, path)
+        if fullpath.index(exec_prefix) == 0
+          libs << [ fullpath, fullpath[exec_prefix.size+1..-1] ]
+        elsif fullpath.index(src_prefix) == 0
+          libs << [ fullpath, "src/" + fullpath[src_prefix.size+1..-1]]
+        else
+          libs << [ fullpath, File.join(instsitelibdir, filename) ]
+        end
+      else
+        puts "=== WARNING: Couldn't find #{filename}"
+      end
+    end
+
+    executable = Ocra.files[0].sub(/(\.rbw?)?$/, '.exe')
+
+    puts "=== Building #{executable}" unless Ocra.quiet
+    OcraBuilder.new(executable) do |sb|
+      # Add explicitly mentioned files
+      Ocra.files.each do |file|
+        path = File.join('src', file).tr('/','\\')
+        sb.createfile(file, path)
+      end
+
+      # Add the ruby executable and DLL
+      if (Ocra.files[0] =~ /\.rbw$/ && !Ocra.force_windows) || Ocra.force_console
+        rubyexe = "ruby.exe"
+      else
+        rubyexe = "ruby.exe"
+      end
+      sb.createfile(File.join(bindir, rubyexe), "bin\\" + rubyexe)
+      if libruby_so
+        sb.createfile(File.join(bindir, libruby_so), "bin\\#{libruby_so}")
+      end
+
+      # Add extra DLLs
+      Ocra.extra_dlls.each do |dll|
+        sb.createfile(File.join(bindir, dll), File.join("bin", dll).tr('/','\\'))
+      end
+
+      # Add gemspecs
+      gemspecs.each { |gemspec|
+        pref = gemspec[0,exec_prefix.size]
+        path = gemspec[exec_prefix.size+1..-1]
+        if pref != exec_prefix
+          raise "#{gemspec} does not exist in the Ruby installation. Don't know where to put it."
+        end
+        sb.createfile(gemspec, path.tr('/','\\'))
+      }
+
+      # Add loaded libraries
+      libs.each do |path, target|
+        sb.createfile(path, target.tr('/', '\\'))
+      end
+
+      # Set environment variable
+      sb.setenv('RUBYOPT', '')
+      sb.setenv('RUBYLIB', '')
+
+      # Launch the script
+      sb.createprocess("bin\\" + rubyexe, "#{rubyexe} \xff\\src\\" + Ocra.files[0])
+      
+      puts "=== Compressing" unless Ocra.quiet or not Ocra.lzma_mode
+    end
+    puts "=== Finished (Final size was #{File.size(executable)})" unless Ocra.quiet
+  end
+  
+  class OcraBuilder
+    def initialize(path)
+      @paths = {}
+      File.open(path, "wb") do |ocrafile|
+        ocrafile.write(Ocra.stubimage)
+        if Ocra.lzma_mode
+          @of = ""
+        else
+          @of = ocrafile
+        end
+        yield(self)
+
+        if Ocra.lzma_mode
+          begin
+            File.open("tmpin", "wb") { |tmp| tmp.write(@of) }
+            system("#{Ocra.lzmapath} e tmpin tmpout 2>NUL") or fail
+            compressed_data = File.open("tmpout", "rb") { |tmp| tmp.read }
+            ocrafile.write([OP_DECOMPRESS_LZMA, compressed_data.size, compressed_data].pack("VVA*"))
+            ocrafile.write([OP_END].pack("V"))
+          ensure
+            File.unlink("tmpin") if File.exist?("tmpin")
+            File.unlink("tmpout") if File.exist?("tmpout")
+          end
+        else
+          ocrafile.write(@of) if Ocra.lzma_mode
+        end
+
+        ocrafile.write([OP_END].pack("V"))
+        ocrafile.write([Ocra.stubimage.size].pack("V")) # Pointer to start of opcodes
+        ocrafile.write(Signature.pack("C*"))
+      end
+    end
+    def mkdir(path)
+      @paths[path] = true
+      puts "m #{path}" unless Ocra.quiet
+      @of << [OP_CREATE_DIRECTORY, path].pack("VZ*")
+    end
+    def ensuremkdir(tgt)
+      return if tgt == "."
+      if not @paths[tgt]
+        ensuremkdir(File.dirname(tgt))
+        mkdir(tgt)
+      end
+    end
+    def createfile(src, tgt)
+      ensuremkdir(File.dirname(tgt))
+      str = File.open(src, "rb") { |file| file.read }
+      puts "a #{tgt}" unless Ocra.quiet
+      @of << [OP_CREATE_FILE, tgt, str.size, str].pack("VZ*VA*")
+    end
+    def createprocess(image, cmdline)
+      puts "l #{image} #{cmdline}" unless Ocra.quiet
+      @of << [OP_CREATE_PROCESS, image, cmdline].pack("VZ*Z*")
+    end
+    def setenv(name, value)
+      puts "e #{name} #{value}" unless Ocra.quiet
+      @of << [OP_SETENV, name, value].pack("VZ*Z*")
+    end
+    def close
+      @of.close
+    end
+  end # class OcraBuilder
+  
+end # module Ocra
+
+if File.basename(__FILE__) == File.basename($0)
+  Ocra.init(ARGV)
+  ARGV.clear
+  
+  at_exit do
+    Ocra.build_exe
+    exit(0)
+  end
+  
+  puts "=== Loading script to check dependencies" unless Ocra.quiet
+  $0 = Ocra.files[0]
+  load Ocra.files[0]
+end

data/test/test_ocra.rb

@@ -0,0 +1,197 @@
+require "test/unit"
+require "ocra"
+require "tmpdir"
+require "fileutils"
+require "rbconfig"
+
+class TestOcra < Test::Unit::TestCase
+
+  def initialize(*args)
+    super(*args)
+    @testnum = 0
+    @ocra = File.expand_path(File.join(File.dirname(__FILE__), '../bin/ocra.rb'))
+    ENV['RUBYOPT'] = ""
+  end
+
+  def ocra
+    @ocra
+  end
+  
+  def setup
+    @testnum += 1
+    @tempdirname = ".ocratest-#{$$}-#{@testnum}"
+    Dir.mkdir @tempdirname
+    Dir.chdir @tempdirname
+  end
+
+  def teardown
+    Dir.chdir '..'
+    FileUtils.rm_rf @tempdirname
+  end
+  
+  def test_helloworld
+    File.open("helloworld.rb", "w") do |f|
+      f << "hello_world = \"Hello, World!\"\n"
+    end
+    assert system("ruby", ocra, "--quiet", "helloworld.rb")
+    assert File.exist?("helloworld.exe")
+    assert system("helloworld.exe")
+  end
+
+  def test_writefile
+    File.open("writefile.rb", "w") do |f|
+      f << "File.open(\"output.txt\", \"w\") do |f| f.write \"output\"; end"
+    end
+    assert system("ruby", ocra, "--quiet", "writefile.rb")
+    assert File.exist?("writefile.exe")
+    assert system("writefile.exe")
+    assert File.exist?("output.txt")
+    assert "output", File.read("output.txt")
+  end
+
+  def test_exitstatus
+    File.open("exitstatus.rb", "w") do |f|
+      f << "exit 167 if __FILE__ == $0"
+    end
+    assert system("ruby", ocra, "--quiet", "exitstatus.rb")
+    system("exitstatus.exe")
+    assert_equal 167, $?.exitstatus
+  end
+
+  def test_arguments
+    File.open("arguments.rb", "w") do |f|
+      f << "if $0 == __FILE__\n"
+      f << "exit 1 if ARGV.size != 2\n"
+      f << "exit 2 if ARGV[0] != \"foo\"\n"
+      f << "exit 3 if ARGV[1] != \"bar baz\"\n"
+      # f << "exit 4 if ARGV[2] != \"\\\"smile\\\"\"\n"
+      f << "exit(5)\n"
+      f << "end"
+    end
+    assert system("ruby", ocra, "--quiet", "arguments.rb")
+    assert File.exist?("arguments.exe")
+    # system(File.expand_path("arguments.exe"), "foo", "bar baz", "\"smile\"")
+    system("arguments.exe foo \"bar baz\"")
+    assert_equal 5, $?.exitstatus
+  end
+
+  def test_stdout_redir
+    File.open("stdoutredir.rb", "w") do |f|
+      f << "if $0 == __FILE__\n"
+      f << "puts \"Hello, World!\"\n"
+      f << "end\n"
+    end
+    assert system("ruby", ocra, "--quiet", "stdoutredir.rb")
+    assert File.exist?("stdoutredir.exe")
+    system("stdoutredir.exe > output.txt")
+    assert File.exist?("output.txt")
+    assert_equal "Hello, World!\n", File.read("output.txt")
+  end
+
+  def test_stdin_redir
+    File.open("input.txt", "w") do |f|
+      f << "Hello, World!\n"
+    end
+    File.open("stdinredir.rb", "w") do |f|
+      f << "if $0 == __FILE__\n"
+      f << "  exit 104 if gets == \"Hello, World!\\n\""
+      f << "end\n"
+    end
+    assert system("ruby", ocra, "--quiet", "stdinredir.rb")
+    assert File.exist?("stdinredir.exe")
+    system("stdinredir.exe < input.txt")
+    assert 104, $?.exitstatus
+  end
+
+  def test_gdbmdll
+    File.open("gdbmdll.rb", "w") do |f|
+      f << "require 'gdbm'\n"
+      f << "exit 104 if $0 == __FILE__ and defined?(GDBM)\n"
+    end
+    bindir = RbConfig::CONFIG['bindir']
+    
+    gdbmdllpath = Dir[File.join(bindir, 'gdbm*.dll')][0]
+    raise "gdbm dll was not found" unless gdbmdllpath
+    gdbmdll = File.basename(gdbmdllpath)
+    assert system("ruby", ocra, "--quiet", "--dll", gdbmdll, "gdbmdll.rb")
+    path = ENV['PATH']
+    ENV['PATH'] = "."
+    begin
+      system("gdbmdll.exe")
+    ensure
+      ENV['PATH'] = path
+    end
+    assert_equal 104, $?.exitstatus
+  end
+
+  def test_relative_require
+    File.open("relativerequire.rb", "w") do |f|
+      f << "require 'somedir/somefile.rb'\n"
+      f << "exit 160 if __FILE__ == $0 and defined?(SomeConst)"
+    end
+    Dir.mkdir('somedir')
+    File.open("somedir/somefile.rb", "w") do |f|
+      f << "SomeConst = 12312\n"
+    end
+    assert system("ruby", ocra, "--quiet", "relativerequire.rb")
+    assert File.exist?("relativerequire.exe")
+    system("relativerequire.exe")
+    assert_equal 160, $?.exitstatus
+  end
+
+  def test_exiting
+    File.open("exiting.rb", "w") do |f|
+      f << "exit 214\n"
+    end
+    assert system("ruby", ocra, "--quiet", "exiting.rb")
+    assert File.exist?("exiting.exe")
+    system("exiting.exe")
+    assert_equal 214, $?.exitstatus
+  end
+
+  def test_autoload
+    File.open("autoload.rb", "w") do |f|
+      f << "$:.unshift File.dirname(__FILE__)\n"
+      f << "autoload :Foo, 'foo'\n"
+      f << "Foo if __FILE__ == $0\n"
+    end
+    File.open("foo.rb", "w") do |f|
+      f << "class Foo; end\n"
+    end
+    assert system("ruby", ocra, "--quiet", "autoload.rb")
+    assert File.exist?("autoload.exe")
+    File.unlink('foo.rb')
+    assert system("autoload.exe")
+    # assert_equal 214, $?.exitstatus
+  end
+
+  def test_autoload_missing
+    File.open("autoloadmissing.rb", "w") do |f|
+      f << "$:.unshift File.dirname(__FILE__)\n"
+      f << "autoload :Foo, 'foo'\n"
+    end
+    assert system("ruby", ocra, "--quiet", "autoloadmissing.rb")
+    assert File.exist?("autoloadmissing.exe")
+    assert system("autoloadmissing.exe")
+  end
+  
+  def test_autoload_nested
+    File.open("autoloadnested.rb", "w") do |f|
+      f << "$:.unshift File.dirname(__FILE__)\n"
+      f << "module Bar\n"
+      f << "  autoload :Foo, 'foo'\n"
+      f << "end\n"
+      f << "Bar::Foo if __FILE__ == $0\n"
+    end
+    File.open("foo.rb", "w") do |f|
+      f << "module Bar\n"
+      f << "class Foo; end\n"
+      f << "end\n"
+    end
+    assert system("ruby", ocra, "--quiet", "autoloadnested.rb")
+    assert File.exist?("autoloadnested.exe")
+    File.unlink('foo.rb')
+    assert system("autoloadnested.exe")
+    # assert_equal 214, $?.exitstatus
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: ocra
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Lars Christensen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-19 22:00:00 Z
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.10.0
+    version: 
+description: |-
+  OCRA (One-Click Ruby Application) builds Windows executables from Ruby
+  source code. The executable is a self-extracting, self-running
+  executable that contains the Ruby interpreter, your source code and
+  any additionally needed ruby libraries or DLL.
+email: 
+- larsch@belunktum.dk
+executables: 
+- ocra.rb
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/ocra.rb
+- share/ocra/lzma.exe
+- share/ocra/stub.exe
+- test/test_ocra.rb
+has_rdoc: true
+homepage: http://github.com/larsch/ocra/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ocra
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: OCRA (One-Click Ruby Application) builds Windows executables from Ruby source code
+test_files: 
+- test/test_ocra.rb