osteele-ropenlaszlo 0.5.1

data/CHANGES

@@ -0,0 +1,41 @@
+= Change Log
+
+== Version 0.5.1 (2009/03/22)
+* update for compatibility with OpenLaszlo 4.x
+* move to github
+
+== Version 0.5 (2009/03/22)
+* update for compatibility with OpenLaszlo 4.x
+* move to github
+
+== Version 0.4.1 (2006/01/25)
+* bug fix: don't use popen on Windows
+* bug fix: default LPS_HOME from OPENLASZLO_HOME
+* added note about OpenLaszlo windows bug
+
+== Version 0.4.0 (2006/01/19)
+* new feature: command-line compiler detects compilation warnings
+* bug fix: command-line compilation in qualified directory places object in same directory
+* improve rdoc
+* refactored unit tests
+
+== Version 0.3.0 (2006/01/16)
+* New feature: compilation errors and warnings
+* Bug fix: --output doesn't exist; --dir does
+* refactored test case setup
+* fixed test case directory
+* Rakefile: added rdoc task
+* Updated installation instructions
+* Fixed rdoc formatting errors
+
+== Version 0.2.0 (2006/01/11)
+* Released as gem
+* Moved to rubyforge
+* Added doc directory
+* Added test directory
+* Added examples directory
+
+== Version 0.1.0 (2006/01/04)
+* Initial release
+* Published to osteele.com
+* Announced on weblog.openlaszlo.org

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006-2009 by Oliver Steele
+
+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/README.rdoc

@@ -0,0 +1,61 @@
+= ROpenLaszlo: Interface to the OpenLaszlo compiler
+
+ROpenLaszo is a Ruby interface to the OpenLaszlo[openlaszlo.org] compiler.  It allows you to compile Open<tt></tt>Laszlo programs from within Ruby, in order to integrate Open<tt></tt>Laszlo development into Rake or Rails applications.
+
+If you are using Open<tt></tt>Laszlo with Ruby on Rails, you probably want the {OpenLaszlo Rails plugin}[laszlo-plugin.rubyforge.org] as well.
+
+OpenLaszlo[openlaszlo.org] programs are written in XML with embedded JavaScript, and compiled into Flash (swf) binary files, or DHTML.  (As of this writing, the DHTML target is in pre-beta form.)  The APIs in this library make it easy for Ruby code to invoke the Open<tt></tt>Laszlo compiler.  For example, if hello.lzx contains the following text:
+  <canvas>
+    <window>
+      <button>Hello, World!</button>
+    </window>
+  </canvas>
+then the following Ruby code can be used to create a file 'hello.swf' which can be executed in a browser or placed on a web site:
+  require 'rubygems'
+  require 'ropenlaszlo'
+  OpenLaszlo::compile 'hello.lzx'
+
+You can turn this snippet into a Rake task that will compile any Open<tt></tt>Laszlo source file:
+  rule '.swf' => '.lzx' do |t|
+    puts "Compiling #{t.source} => #{t.name}" if verbose
+    OpenLaszlo::compile t.source, :output => t.name
+  end
+
+== Requirements
+
+* {OpenLaszlo 3.1 or later}[openlaszlo.org]
+* Ruby -v 1.8.2 or later (untested in earlier versions)
+* RubyGems[rubygems.rubyforge.org]
+
+== Installation
+
+0:: Download and install the {OpenLaszlo SDK}[openlaszlo.org]
+
+1: Install this gem
+  $ gem install osteele-ropenlaszlo -s http://gems.github.com
+
+2:: Set your +OPENLASZLO_HOME+ environment variable to the directory that contains the {OpenLaszlo SDK}[openlaszlo.org].  If the following prints something, you've got it right:
+  grep Laszlo "$OPENLASZLO_HOME/README.txt"
+
+3:: (Optional)  Set your +OPENLASZLO_URL+ environment variable to the web location of the Open<tt></tt>Laszlo server; for example, <tt>http</tt><tt>://localhost:8080/lps-3.1</tt>.  If you omit this step, the module will use the command line compiler, which is slower but is not limited to compiling files inside of +OPENLASZLO_HOME+.
+
+<b>Note:</b> The command-line compiler is broken in the Windows version of Open<tt></tt>Laszlo 3.1.1.  If you are running Windows, step (3) is required.  ({OpenLaszlo bug 1428}[http://www.openlaszlo.org/jira/browse/LPP-1428])
+
+== Additional Resources
+
+* The {OpenLaszlo web site}[openlaszlo.org] is a rich source of information about the Open<tt></tt>Laszlo platform.  It includes links to the wiki, mailing lists, and forums.
+
+* The {Laszlo on Rails}[groups.google.com/group/laszlo-on-rails] news group discusses the integration of Open<tt></tt>Laszlo with Ruby on Rails.
+
+* The {OpenLaszlo Rails plugin}[laszlo-plugin.rubyforge.org] provides generators and scaffolding for using Open<tt></tt>Laszlo with Ruby on Rails.
+
+* {This OpenLaszlo Blog entry}[weblog.openlaszlo.org/archives/2006/01/deploying-openlaszlo-applications-with-rake/] has additional information and some examples of using ROpenLaszlo in a Rakefile.
+
+* The RubyForge project page is here[http://rubyforge.org/projects/ropenlaszlo/].
+
+== License
+
+ROpenLaszlo is copyright (c) 2006 - 2009 by Oliver Steele.  It is
+open-source software, and may be redistributed under the terms of the
+MIT license. The text of this licence is included in the ROpenLaszlo
+distribution.

data/TODO

@@ -0,0 +1,21 @@
+= ROpenLaszlo Project -- To Do List
+
+== Features
+* Add rake task file
+* Compile server: allow use of proxy?
+* Compile server: temporarily copy files into webapp directory
+* compile_string
+* Dependency tracking
+* query compiler version
+
+== Unit Tests
+* Compiler parameters
+* Missing source file
+* Unreachable server
+* Invalid OPENLASZLO_HOME
+
+== Corners
+* invalid parameters
+* server isn't running
+* thinks lps-dev/foo is in lps/ directory
+

data/lib/compiler.rb

@@ -0,0 +1,255 @@
+# Author:: Oliver Steele
+# Copyright:: Copyright (c) 2005-2006 Oliver Steele.  All rights reserved.
+# License:: Ruby License.
+ 
+# == module OpenLaszlo
+# 
+# This module contains utility methods for compiling
+# OpenLaszlo[openlaszlo.org] programs.
+#
+# Example:
+#   # Set up the environment to use the compile server.  The OpenLaszlo server
+#   # must be running in order at this location in order for this to work.
+#   ENV['OPENLASZLO_HOME'] = '/Applications/OpenLaszlo Server 3.1'
+#   ENV['OPENLASZLO_URL'] = 'http://localhost:8080/lps-3.1'
+#
+#   require 'openlaszlo'
+#   # Create a file 'hello.swf' in the current directory:
+#   OpenLaszlo::compile 'hello.lzx'
+#
+# See OpenLaszlo.compile for additional documentation.
+# 
+module OpenLaszlo
+  class CompilationError < StandardError; end
+  
+  # This class implements a bridge to the compile server.
+  #
+  # If you don't need multiple compilers, you can use the methods in
+  # the OpenLaszlo module instead.
+  #
+  # CompileServer is faster than CommandLineCompiler, but can only compile
+  # files in the same directory as the Open<tt></tt>Laszlo SDK.
+  class CompileServer
+    # Options:
+    # * <tt>:openlaszlo_home</tt> - filesystem location of the Open<tt></tt>Laszlo SDK.  Defaults to ENV['OPENLASZLO_HOME']
+    # * <tt>:server_uri</tt> - the URI of the server.  Defaults to ENV['OPENLASZLO_URL'] if this is specified, otherwise to 'http://localhost:8080/lps-dev'.
+    def initialize(options={})
+      @home = options[:home] || ENV['OPENLASZLO_HOME']
+      dirs = Dir[File.join(@home, 'Server', 'lps-*', 'WEB-INF')]
+      @home = File.dirname(dirs.first) if dirs.any?
+      @base_url = options[:server_uri] || ENV['OPENLASZLO_URL'] || 'http://localhost:8080/lps-dev'
+    end
+    
+    # Invokes the Open<tt></tt>Laszlo server-based compiler on
+    # +source_file+.  +source_file+ must be inside the home directory
+    # of the server.
+    #
+    # Options:
+    # * <tt>:format</tt> - request type (default 'swf')
+    # See OpenLaszlo.compile for a description of +options+.
+    def compile(source_file, options={})
+      mtime = File.mtime source_file
+      runtime = options[:runtime] || 'swf8'
+      output = options[:output] || "#{File.expand_path(File.join(File.dirname(source_file), File.basename(source_file, '.lzx')))}.lzr=#{runtime}.swf"
+      compile_object(source_file, output, options)
+      results = request_metadata_for(source_file, options)
+      raise "Race condition: #{source_file} was modified during compilation" if mtime != File.mtime(source_file)
+      results[:output] = output
+      raise CompilationError.new(results[:error]) if results[:error]
+      return results
+    end
+    
+    private
+    def compile_object(source_file, object, options={})
+      options = {}.update(options).update(:output => object)
+      request(source_file, options)
+    end
+    
+    def request_metadata_for(source_file, options={})
+      results = {}
+      options = {}.update(options).update(:format => 'canvas-xml', :output => nil)
+      text = request(source_file, options)
+      if text =~ %r{<warnings>(.*?)</warnings>}m
+        results[:warnings] = $1.scan(%r{<error>\s*(.*?)\s*</error>}m).map{|w|w.first}
+      elsif text !~ %r{<canvas>} && text =~ %r{<pre>Error:\s*(.*?)\s*</pre>}m
+        results[:error] = $1
+      end
+      return results
+    end
+    
+    def request(source_file, options={})
+      output = options[:output]
+      require 'net/http'
+      require 'uri'
+      # assert that pathname is relative to LPS home:
+      absolute_path = File.expand_path(source_file)
+      raise "#{absolute_path} isn't inside #{@home}" unless absolute_path.index(@home) == 0
+      server_relative_path = absolute_path[@home.length..-1]
+      # FIXME: this doesn't handle quoting; use recursive File.split instead
+      # FIXME: should encode the url, for filenames that include '/'
+      server_relative_path.gsub(File::Separator, '/')
+      options = {
+        :lzr => options[:runtime],
+        :debug => options[:debug],
+        :lzproxied => options.fetch(:proxied, false),
+        :lzt => options[:format] || 'swf'}
+      query = options.map{|k,v|"#{k}=#{v}" unless v.nil?}.compact.join('&')
+      url = "#{@base_url}#{server_relative_path}"
+      url += "?#{query}" unless query.empty?
+      Net::HTTP.get_response URI.parse(url) do |response|
+        case response
+        when Net::HTTPOK
+          if output
+            File.open(output, 'w') do |f|
+              response.read_body do |segment|
+                f << segment
+              end
+            end
+          else
+            return response.body
+          end
+        else
+          response.value # for effect: raises error
+        end
+      end
+    end
+  end
+  
+  # This class implements a bridge to the command-line compiler.
+  #
+  # If you don't need multiple compilers, you can use the methods in
+  # the OpenLaszlo module instead.
+  #
+  # CommandLineCompiler is slower than CompileServer, but,
+  # unlike the server, it can compile files in any location.
+  class CommandLineCompiler
+    # Creates a new compiler.
+    #
+    # Options are:
+    # * <tt>:compiler_script</tt> - the path to the shell script that
+    # invokes the compiler.  This defaults to a standard location inside
+    # the value specified by :home.
+    # * <tt>:openlaszlo_home</tt> - the home directory of the Open<tt></tt>Laszlo SDK.
+    # This defaults to ENV['OPENLASZLO_HOME'].
+    def initialize(options={})
+      @lzc = options[:compiler_script]
+      unless @lzc
+        home = options[:openlaszlo_home] || ENV['OPENLASZLO_HOME']
+        raise ":compiler_script or :openlaszlo_home must be specified" unless home
+        search = bin_directories.map{|f| File.join(home, f, 'lzc')}
+        found = search.select{|f| File.exists? f}
+        raise "couldn't find bin/lzc in #{bin_directories.join(' or ')}" if found.empty?
+        @lzc = found.first
+        @lzc += '.bat' if windows?
+      end
+    end
+    
+    # Invokes the OpenLaszlo command-line compiler on +source_file+.
+    #
+    # See OpenLaszlo.compile for a description of +options+.
+    def compile(source_file, options={})
+      runtime = options[:runtime] || 'swf8'
+      output_suffix = ".lzr=#{runtime}.swf"
+      default_output = File.join(File.dirname(source_file),
+                                 File.basename(source_file, '.lzx') + output_suffix)
+      output = options[:output] || default_output
+      raise "#{source_file} and #{output} do not have the same basename." unless File.basename(source_file, '.lzx') == File.basename(output, output_suffix)
+      args = []
+      args << '--runtime=#{options[:runtime]}' if options[:runtime]
+      args << '--debug' if options[:debug]
+      args << '--profile' if options[:profile]
+      args << "--dir '#{File.dirname output}'" unless File.dirname(source_file) == File.dirname(output)
+      args << source_file
+      command = "\"#{@lzc}\" #{args.join(' ')}"
+      ENV['LPS_HOME'] ||= ENV['OPENLASZLO_HOME']
+      begin
+        #raise NotImplementedError --- for testing Windows
+        require "open3"
+        # The compiler writes errors to stdout, warnings to stderr
+        stdin, stdout, stderr = Open3.popen3(command)
+        errors = stdout.read
+        warnings = stderr.readlines
+        warnings.shift if warnings.first and warnings.first =~ /^Compiling:/
+      rescue NotImplementedError
+        # Windows doesn't have popen
+        errors = `#{command}`
+        warnings = []
+      end
+      errors.gsub!(/^\d+\s+/, '') # work around a bug in OpenLaszlo 3.1
+      if errors =~ /^Compilation errors occurred:\n/
+        raise CompilationError.new($'.strip)
+      end
+      results = {:output => output, :warnings => warnings}
+      return results
+    end
+    
+    private
+    
+    # Locations in which to look for the lzc script, relative to OPENLASZLO_HOME
+    def bin_directories
+      [# binary distro location
+        'bin',
+        # source distro location
+        'WEB-INF/lps/server/bin'
+      ]
+    end
+    
+    def windows?
+      RUBY_PLATFORM =~ /win/ and not RUBY_PLATFORM =~ /darwin/
+    end
+  end
+  
+  # Returns the default compiler.  Use the server-based compiler if it's
+  # available, since it's so much faster.
+  def self.compiler
+    return @compiler if @compiler
+    return @compiler = CompileServer.new if ENV['OPENLASZLO_URL'] and ENV['OPENLASZLO_HOME']
+    return @compiler = CommandLineCompiler.new if ENV['OPENLASZLO_HOME']
+    raise <<EOF
+Couldn\'t find an OpenLaszlo compiler.
+
+To use the compile server (recommended), set ENV['OPENLASZLO_URL'] and ENV['OPENLASZLO_HOME'].
+
+To use the command-line compiler, set ENV['OPENLASZLO_HOME'].
+EOF
+  end
+  
+  # Sets the default compiler for future invocations of OpenLaszlo.compile.
+  def self.compiler=(compiler)
+    @compiler = compiler
+  end
+  
+  # Compile an OpenLaszlo source file.
+  #
+  # Examples:
+  #   require 'openlaszlo'
+  #   OpenLaszlo::compile 'hello.lzx'
+  #   OpenLaszlo::compile 'hello.lzx', :debug => true
+  #   OpenLaszlo::compile 'hello.lzx', :runtime => 'swf8'
+  #   OpenLaszlo::compile 'hello.lzx', {:runtime => 'swf8', :debug => true}
+  #   OpenLaszlo::compile 'hello.lzx', :output => 'hello-world.swf'
+  #
+  # Options are:
+  # * <tt>:debug</tt> - debug mode (default false)
+  # * <tt>:output</tt> - specify the name and location for the output file (default = <tt>input_file.sub(/\.lzx$/, '.swf')</tt>)
+  # * <tt>:proxied</tt> - is application proxied (default true)
+  # * <tt>:runtime</tt> - runtime (default swf7)
+  #
+  # See CompileServer.compile and CommandLineCompiler.compile for
+  # additional options that are specific to the compilation methods in
+  # those classes.
+  def self.compile(source_file, options={})
+    return compiler.compile source_file, options
+  end
+  
+  def self.make_html(source_file, options={}) #:nodoc:
+    raise 'not really supported, for now'
+    options = {
+      :format => 'html-object',
+      :output => File.basename(source_file, '.lzx')+'.html'}.update(options)
+    compiler.compile(source_file, options)
+    source_file = options[:output]
+    s = open(source_file).read
+    open(source_file, 'w') {|f| f.write s.gsub!(/\.lzx\?lzt=swf&amp;/, '.lzx.swf?')}
+  end
+end

data/lib/ropenlaszlo.rb

@@ -0,0 +1,5 @@
+# Author:: Oliver Steele
+# Copyright:: Copyright (c) 2005-2006 Oliver Steele.  All rights reserved.
+# License:: Ruby License.
+
+require 'compiler'

data/test/compilation-error.lzx

@@ -0,0 +1,2 @@
+<!-- This doesn't have a close tag, so it will fail compilation. -->
+<canvas

data/test/compilation-warning.lzx

@@ -0,0 +1 @@
+<canvas unknown-attribute="value"/>

data/test/compiler_test.rb

@@ -0,0 +1,144 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'test/unit'
+require 'ropenlaszlo'
+require 'fileutils'
+require File.join(File.dirname(__FILE__), 'test_utils.rb')
+
+include FileUtils
+
+REQUIRED_ENV_VALUES = %w{OPENLASZLO_HOME OPENLASZLO_HOME}
+unless REQUIRED_ENV_VALUES.reject {|w| ENV[w]}.empty?
+  raise "These environment variables must be set: #{REQUIRED_ENV_VALUES}.join(', ')"
+end
+
+module CompilerTestHelper
+  def self.included(base)
+    base.send(:include, InstanceMethods)
+  end
+  
+  private
+  def testfile_pathname(file)
+    return File.expand_path(file, File.dirname(__FILE__))
+  end
+  
+  def assert_same_file(a, b)
+    assert_equal File.expand_path(a), File.expand_path(b)
+  end
+  
+  def compile(file, output=nil, options={})
+    file = testfile_pathname(file)
+    output ||= File.join(File.dirname(file), File.basename(file, '.lzx')+'.lzr=swf8.swf')
+    rm_f output
+    raise "Unable to remove output file: #{output}" if File.exists?(output)
+    begin
+      result = OpenLaszlo::compile(file, *options)
+      assert_same_file output, result[:output]
+      assert File.exists?(output), "#{output} does not exist"
+      return result
+    ensure
+      rm_f output
+    end
+  end
+  
+  # Tests that are shared between CompilerServerTest and
+  # CommandLineCompilerTest.
+  module InstanceMethods
+    def test_compilation
+      result = compile 'test.lzx'
+    end
+    
+    def test_compilation_warning
+      result = compile 'compilation-warning.lzx'
+      assert_instance_of Array, result[:warnings]
+      assert_equal 1, result[:warnings].length
+      assert_match /^compilation-warning.lzx:1:36/, result[:warnings].first
+    end
+    
+    def test_compilation_error
+      ex = (compile 'compilation-error.lzx' rescue $!)
+      assert_instance_of OpenLaszlo::CompilationError, ex
+      assert_match /^compilation-error.lzx:3:1: XML document structures must start and end within the same entity\./, ex.message
+    end
+  end
+end
+
+class CompileServerTest < Test::Unit::TestCase
+  include CompilerTestHelper
+  
+  def setup
+    OpenLaszlo::compiler = nil
+    home = ENV['OPENLASZLO_HOME']
+    dirs = Dir[File.join(home, 'Server', 'lps-*', 'WEB-INF')]
+    home = File.dirname(dirs.first) if dirs.any?
+    @test_dir = File.join(home, 'tmp/ropenlaszlo-tests')
+    mkdir_p @test_dir
+  end
+  
+  def teardown
+    OpenLaszlo::compiler = nil
+    rm_rf @test_dir
+  end
+  
+  private
+  alias :saved_compile :compile
+  
+  def compile(file, output=nil, options={})
+    raise "unimplemented" if output
+    file = testfile_pathname file
+    server_local_file = File.join(@test_dir, File.basename(file))
+    cp file, server_local_file
+    begin
+      saved_compile(server_local_file, output, options)
+    ensure
+      rm_f server_local_file
+    end
+  end
+end
+
+class CommandLineCompilerTest < Test::Unit::TestCase
+  include CompilerTestHelper
+  
+  def setup
+    OpenLaszlo::compiler = nil
+    callcc do |exit|
+      resume = nil
+      ENV.with_bindings 'OPENLASZLO_URL' => nil do
+        resume = callcc do |continue|
+          @teardown = continue
+          exit.call
+        end
+      end
+      resume.call
+    end
+  end
+  
+  def teardown
+    OpenLaszlo::compiler = nil
+    callcc do |continue| @teardown.call(continue) end
+  end
+end
+
+class CompilerFacadeTest < Test::Unit::TestCase
+  def setup
+    raise "ENV['OPENLASZLO_URL'] must be set" unless ENV['OPENLASZLO_URL']
+    raise "ENV['OPENLASZLO_HOME'] must be set" unless ENV['OPENLASZLO_HOME']
+    OpenLaszlo::compiler = nil
+  end
+  
+  def test_select_server
+    assert_instance_of OpenLaszlo::CompileServer, OpenLaszlo::compiler
+  end
+  
+  def test_select_commandline
+    ENV.with_bindings 'OPENLASZLO_URL' => nil do
+      assert_instance_of OpenLaszlo::CommandLineCompiler, OpenLaszlo::compiler
+    end
+  end
+  
+  def test_missing_home
+    ENV.with_bindings 'OPENLASZLO_HOME' => nil do
+      assert_raise(RuntimeError) do OpenLaszlo::compiler end
+    end
+  end
+end

data/test/test.lzx

@@ -0,0 +1 @@
+<canvas/>

data/test/test_utils.rb

@@ -0,0 +1,25 @@
+# Author:: Oliver Steele
+# Copyright:: Copyright (c) 2005-2006 Oliver Steele.  All rights reserved.
+# License:: Ruby License.
+
+class << ENV
+  # Execute a block, restoring the bindings for +keys+ at the end.
+  # NOT thread-safe!
+  def with_saved_bindings keys, &block
+    saved_bindings = Hash[*keys.map {|k| [k, ENV[k]]}.flatten]
+    begin
+      block.call
+    ensure
+      ENV.update saved_bindings
+    end
+  end
+  
+  # Execute a block with the temporary bindings in +bindings+.
+  # Doesn't remove keys; simply sets them to nil.
+  def with_bindings bindings, &block
+    with_saved_bindings bindings.keys do
+      ENV.update bindings
+      return block.call
+    end
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: osteele-ropenlaszlo
+version: !ruby/object:Gem::Version 
+  version: 0.5.1
+platform: ruby
+authors: 
+- Oliver Steele
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-22 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: ROpenLaszlo is an interface to the OpenLaszlo compiler.
+email: steele@osteele.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+- CHANGES
+- TODO
+files: 
+- lib/compiler.rb
+- lib/ropenlaszlo.rb
+- test/compilation-error.lzx
+- test/compilation-warning.lzx
+- test/compiler_test.rb
+- test/test.lzx
+- test/test_utils.rb
+- README.rdoc
+- MIT-LICENSE
+- CHANGES
+- TODO
+has_rdoc: true
+homepage: http://github.com/osteele/ropenlaszlo
+post_install_message: 
+rdoc_options: 
+- --title
+- "ROpenLaszlo: Ruby interface to the OpenLaszlo compiler"
+- --exclude
+- test/.*
+- --inline-source
+- --charset=UTF-8
+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: ropenlaszlo
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Ruby interface to the OpenLaszlo compiler.
+test_files: []
+