ulbrich-jruby-enginize 0.1

data/README

@@ -0,0 +1,114 @@
+= JRuby-Enginize
+
+== About
+
+JRuby-Enginize is a generator for Google AppEngine compliant JRuby
+applications. The generator will support several frameworks but only has
+Sinatra on board for the moment being. If you want to learn more about Google
+AppEngine, go to http://code.google.com/appengine and have a look at the
+tutorials.
+
+== Prerequisites
+
+JRuby-Enginize needs a proper JRuby installation including rake and the
+Google AppEngine SDK for Java. More dependencies depend on the framework
+template to generate an application for: For Sinatra
+(http://www.sinatrarb.com), you will need the "sinatra" gem. Be sure to
+install such gems with <tt>jgem</tt> or <tt>jruby -S gem</tt> as you need
+them for JRuby and not for Ruby.
+
+You also need an Google AppEngine account to actually publish your code.
+Without account you can still play around with the tool and run applications
+locally.
+
+== Installation
+
+Install JRuby-Enginize as a gem with
+
+  jgem sources -a http://gems.github.com  # Only needed once!
+  sudo jgem install ulbrich-jruby-enginize
+
+and be sure to really install with <tt>jgem</tt> as JRuby-Enginize will
+refuse to work in normal Ruby environment. It is for creating application
+running on Google AppEngine and it makes no sense outside JRuby!
+  
+== Using jruby-enginize
+
+The gem includes is a single executable named <tt>jruby-enginize</tt> which is
+inspired by the <tt>rails</tt> tool for generating Rails applications. So just
+call
+
+  jruby -S jruby-enginize
+
+and have a look at the options.
+
+Here are the steps for creating and deploying a new Sinatra application:
+
+* Register with Google AppEngine and look for a name for your application
+  which is not already taken. If you don't care about this, you will get in
+  trouble upon deploying your application and have to manually reconfigure
+  all files!
+
+* Generate your application. Sample:
+
+  <tt>jruby -S jruby-enginize --email foo@bar.com foobar</tt>
+
+* Go to the new directory, learn about the available rake tasks and try out
+  your application: 
+
+  <tt>cd foobar</tt>
+  <tt>jruby rake --tasks</tt>
+
+  <tt>jruby -S rake sinatra:run</tt>
+
+* Deploy the application with the application name and e-mail address you 
+  generated with:
+
+  <tt>jruby -S rake appengine:deploy</tt>
+
+You can repeat the deployment whenever you want. Be sure to set the version
+number in "appengine-web.xml" to a new value, when you are experimenting with
+an unstable version and don't want to risk your users getting exceptions.
+
+You can try the new version by opening e.g.
+
+  http://3.latest.foobar.appspot.com
+
+and replacing "3" with the version number you want to run.
+
+Switch the application to the new version as default (stable version) by
+opening
+
+  http://appengine.google.com/deployment?&app_id=foobar
+
+and setting a new default available at
+
+  http://foobar.appspot.com
+
+A small README with these and a few more application specific hints is
+generated along with the source code. Have fun.
+
+== Copyright & License
+
+Copyright (c) 2009 Holtzbrinck Digital GmbH, Jan Ulbrich
+
+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/bin/jruby-enginize

@@ -0,0 +1,6 @@
+#!//usr/bin/env jruby -S
+# JRuby-Enginize, a generator for Google AppEngine compliant JRuby apps.
+
+require 'lib/script'
+
+JRubyEnginize::Script.enginize

data/lib/generator.rb

@@ -0,0 +1,165 @@
+# JRuby-Enginize, a generator for Google AppEngine compliant JRuby apps.
+#
+# This file contains the JRubyEnginize::Generator class creating a new
+# directory tree of files drawn from a set of shared and specific templates.
+
+require 'ftools'
+require 'find'
+
+module JRubyEnginize # :nodoc:
+
+  # Code for generating a directory tree created from a shared and a template
+  # specific set of template files.
+
+  class Generator
+    attr_reader :email, :template, :name, :path, :dryrun
+
+    # Constructor of the generator needing at least email, path and template
+    # to run.
+    #
+    # Parameters:
+    #
+    # [email] Mail address of the Google AppEngine account to publish with
+    # [path] Path of the directory to create
+    # [template] Name of the set of templates to generate from
+    # [options] Additional options
+    #
+    # Options:
+    # 
+    # [:name] Optional app name defaulting to name of directory
+    # [:dryrun] Flag to enable 
+
+    def initialize(email, path, template, options = {})
+      @email = email
+      @path = path
+      @template = template
+
+      options = options.dup
+
+      @name = options.delete(:name)
+      @name = File.basename(path) if @name.nil? or @name.empty?
+
+      @dryrun = options.delete(:dryrun)
+
+      raise ArgumentError, "Unknown option(s) #{options.keys.join(', ')}" unless options.empty?
+    end
+
+    # Runs the generator. Starts with setting up a map of files to create
+    # and overriding shared ones with template specific stuff. Runs through
+    # the collected files and calls process_file to render new files in the
+    # target path.
+
+    def run
+      templatesdir = Generator::templates_directory
+
+      shareddir = File.join(templatesdir, 'shared')
+      templatedir = File.join(templatesdir, template)
+
+      raise ArgumentError, 'Missing shared templates' unless File.stat(shareddir).directory?
+      raise ArgumentError, "Template \"#{template}\" missing" unless File.stat(templatedir).directory?
+
+      
+      puts "!!no changes written as this is only a dry run...\n" if dryrun
+      puts "Generating files for template \"#{template}\":\n\n"
+
+      template_files(shareddir, templatedir).each do |key, path|
+        target = File.join(self.path, key)
+        puts "  Creating \"#{target}\" from template\n    file \"#{path}\""
+
+        process_file(path, target) unless dryrun
+      end
+      
+      puts "\nYour next steps:\n\n  cd #{self.path}\n\n  jruby -S rake"
+      puts "  jruby -S rake --tasks\n\n  jruby -S rake appengine:deploy\n\n"
+    end
+
+    # Returns an Array with the available template names.
+
+    def self.templates
+      return Dir[File.join(Generator::templates_directory, '*')].collect { |path|
+               (name = File.basename(path)) == 'shared' ? nil : name }.compact
+    end      
+
+    protected
+
+      # Returns a Hash with relative paths of files as keys and the whole
+      # paths as values. Runs through all paths in the order as provided and
+      # overrides keys with files found in later paths.
+      #
+      # Sample:
+      #
+      #   + templates
+      #      + shared
+      #      |  + foo
+      #      |  + lib
+      #      |     + bar # Will be overridden with file found in specific
+      #      |
+      #      + specific
+      #         + lib
+      #         |  + bar
+      #         |
+      #         + other
+      #
+      #   => { 'foo' => '/path/templates/shared/foo',
+      #      'lib/bar' => '/path/templates/specific/bar',
+      #      'other' => '/path/templates/specific/other' }
+      #
+      # Parameters:
+      #
+      # [*paths] Paths to directories to gather files from
+
+      def template_files(*paths)
+        files = {}
+
+        Find.find(*paths) do |path|
+          Find.prune if path[-1].chr == '.'
+
+          next if File.stat(path).directory?
+          next if (key = path.gsub(/.*\/templates\/[^\/]+\//, '')) == ''
+
+          files[key] = path
+        end
+
+        return files
+      end      
+
+      # Creates the target file from the source including some substitution
+      # of variables. The target path needs not to exist, as directories are
+      # added on the fly. If the source is an executable, the target file will
+      # be set executable, too.
+      #
+      # Parameters:
+      #
+      # [source] Source file
+      # [target] Target file
+
+      def process_file(source, target)
+        content = File.read(source).gsub(/\{\{[^}]*\}\}/) do |match|
+          case match
+          when '{{email}}'
+            email
+          when '{{name}}'
+            name
+          else
+            match
+          end
+        end
+
+        File.makedirs(File.dirname(target))
+
+        File.open(target, 'wb') do |file|
+          stat = File.stat(source)
+
+          file.write(content)
+          file.chmod(stat.mode | 0x111) if stat.executable?
+        end
+      end
+
+      # Returns the directory where the template files reside (located
+      # relative to the source file of class JRubyEnginize::Generator).
+
+      def self.templates_directory
+        return File.join(File.dirname(File.dirname(__FILE__)), 'templates')
+      end
+  end
+end

data/lib/script.rb

@@ -0,0 +1,85 @@
+# JRuby-Enginize, a generator for Google AppEngine compliant JRuby apps.
+#
+# This file contains the JRubyEnginize::Script class refactored to keep the
+# executables lean.
+
+require 'optparse'
+require 'rubygems'
+
+require 'lib/generator'
+
+module JRubyEnginize # :nodoc:
+
+  # Commandline code refactored to keep the executables lean.
+
+  module Script
+    
+    # Command line code for the <tt>"jruby-enginize"</tt> executable. Call
+    # with <tt>"--help"</tt> to learn more. Checks for running on JRuby and
+    # having the Google AppEngine SDK around and forwards work to
+    # JRubyEnginize::Generator.
+
+    def self.enginize
+      email = nil
+      template = 'sinatra'
+      path = nil
+
+      prog = File.basename($0)
+
+      # Check for running with JRuby: The whole generator makes no sense if not 
+      # running with or at least for JRuby...
+
+      begin
+        java.lang.String
+      rescue
+        $stderr.puts "!!#{prog} makes only sense on JRuby systems. Please try again." 
+        exit(1)
+      end
+
+      # The AppEngine SDK has to be around, too.
+
+      begin
+        raise ArgumentError if not File.stat(`which appcfg.sh`.chop).executable?
+      rescue Exception
+        $stderr.puts "!!AppEngine SDK missing. Please retry after installing." 
+        exit(2)
+      end
+
+      options = { :name => nil, :dryrun => false }
+
+      OptionParser.new do |opt|
+        opt.banner = "Usage: #{prog} [options] --email address dirname"
+
+        opt.on('-e', '--email address', 'E-Mail address to publish app with') { |email| }
+        opt.on('-t', '--template name', "Name of the template (defaults to #{template})") { |template| }
+        opt.on('-n', '--name appname', 'Name of the app (defaults to dir basename)') { |name|
+          options[:name] = name }
+        opt.on('-d', '--dry', 'Test run not really creating files') {
+          options[:dryrun] = true }
+        opt.on('-T', '--templates', 'List available templates') {
+          puts 'Supported templates:'
+          JRubyEnginize::Generator.templates.each { |name| puts "  #{name}" }
+          exit(0) }
+
+        begin
+          opt.parse!(ARGV)
+
+          raise "missing directory name" if (path = ARGV.first).nil? or path.empty?
+          raise "directory already exists" if FileTest.exists? path
+
+          raise "missing e-mail address" if email.nil? or email.empty?
+        rescue SystemExit
+          exit(1)
+        rescue Exception => exception
+          $stderr.puts "!!#{exception}\n\n"
+
+          opt.parse!(['--help'])
+
+          exit(3)
+        end
+      end
+      
+      JRubyEnginize::Generator.new(email, path, template, options).run
+    end
+  end
+end

data/templates/shared/README

@@ -0,0 +1,39 @@
+README
+
+This is a generic README generated by jruby-enginize. Please replace with
+something more meaningful... ;-)
+
+GOOGLE APPENGINE DEPLOYMENT
+
+As a basic requirement, copy and split the JRuby-JAR calling
+
+  jrake jruby:splitjars
+
+once and after each upgrade to a new version of JRuby.
+
+Deploy the application with
+
+  jrake appengine:deploy
+
+and open
+
+  http://{{name}}.appspot.com
+
+to have a first test.
+
+Be sure to set the version number in "appengine-web.xml" to a new value, when
+you are experimenting with an unstable version and don't want to risk your
+users getting exceptions.
+
+You can try the new version by opening e.g.
+
+  http://3.latest.{{name}}.appspot.com
+
+and replacing "3" with the version number you want to run.
+
+Switch the application to the new version as default (stable version) by
+opening
+
+  http://appengine.google.com/deployment?&app_id={{name}}
+
+and setting a new default.

data/templates/shared/Rakefile

@@ -0,0 +1,68 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+Dir[File.join(File.dirname(__FILE__), 'lib', 'tasks', '*.rake')].each do |ext|
+  load ext
+end
+
+desc 'Display some help and the README'
+task :help do
+  puts 'Call "jruby -S rake --tasks" to learn what tasks are available...'
+  puts
+  puts File.read('README')
+end
+
+task :default => [:help]
+
+namespace :jruby do
+  desc 'Split the way too large JRuby JAR into two smaller files'
+  task :splitjars do  
+    puts 'Split the way too large JRuby JAR into two smaller files.'
+    libdir = File.join(File.dirname(__FILE__), 'lib')
+    puts `#{libdir}/split-jruby.sh`
+  end
+
+  desc 'Runs the splitjars task if splitted files not already exist'
+  task :check4jars do
+    file1 = File.join(File.dirname(__FILE__), 'lib', 'jruby-core.jar')
+    file2 = File.join(File.dirname(__FILE__), 'lib', 'ruby-stdlib.jar')
+
+    begin
+      File.stat(file1)
+      File.stat(file2)
+    rescue Errno::ENOENT
+      puts 'Need to copy and split JAR files. Generating them on the fly now...'
+      Rake::Task['jruby:splitjars'].invoke
+    end
+  end
+end
+
+namespace :appengine do
+  desc 'Create the WAR file for deployment'
+  task :war do
+    puts 'Create the WAR file for deployment.'
+    puts `jruby -S warble`
+  end
+
+  desc 'Upload the new application code'
+  task :upload do
+    puts 'Upload the new application code (this may take a while).'
+    puts `appcfg.sh --enable_jar_splitting --email={{email}} update tmp/war`
+  end
+
+  desc 'Roll back a blocked and halfway broken deploy'
+  task :rollback do
+    puts 'Roll back a blocked and halfway broken deploy.'
+    puts `appcfg.sh --enable_jar_splitting rollback tmp/war`
+  end
+
+  desc 'Remove temp stuff'
+  task :clean do
+    puts 'Remove temp stuff.'
+    puts `rm -rf tmp slingyard.war`
+  end
+
+  desc 'Deploy the application (generating WAR plus uploading files)'
+  task :deploy => ['jruby:check4jars', :war, :upload]
+end

data/templates/shared/appengine-web.xml

@@ -0,0 +1,21 @@
+<appengine-web-app xmlns="http://appengine.google.com/ns/1.0">
+    <application>{{name}}</application>
+    <version>1</version>
+    <static-files />
+    <resource-files />
+    <sessions-enabled>false</sessions-enabled>
+    <system-properties>
+      <property name="jruby.management.enabled" value="false" />
+      <property name="os.arch" value="" />
+      <property name="jruby.compile.mode" value="JIT"/> <!-- JIT|FORCE|OFF -->
+      <property name="jruby.compile.fastest" value="true"/>
+      <property name="jruby.compile.frameless" value="true"/>
+      <property name="jruby.compile.positionless" value="true"/>
+      <property name="jruby.compile.threadless" value="false"/>
+      <property name="jruby.compile.fastops" value="false"/>
+      <property name="jruby.compile.fastcase" value="false"/>
+      <property name="jruby.compile.chainsize" value="500"/>
+      <property name="jruby.compile.lazyHandles" value="false"/>
+      <property name="jruby.compile.peephole" value="true"/>
+   </system-properties>
+</appengine-web-app>

data/templates/shared/lib/split-jruby.sh

@@ -0,0 +1,67 @@
+#!/bin/sh
+# Utility script for splitting the JRuby JAR into two smaller JAR files. This
+# is a workaround for a limitation of the JAR size in Google AppEngine.
+#
+# The code for this script has been taken from hints and links found at
+# http://jruby-rack.appspot.com.
+
+SCRIPTHOME=`dirname $0`
+JRUBY=`which jruby`
+
+if [ ! -x "$JRUBY" ]; then
+  echo "!!Missing jruby executable. Please check installation." > /dev/stderr
+  exit 1
+fi
+
+# See where the jruby binary is installed and find the JRuby JAR from there.
+
+PREFIX=`dirname \`dirname $JRUBY\``
+JARFILE="$PREFIX/share/java/jruby/lib/jruby-complete.jar"
+
+if [ ! -f "$JARFILE" ]; then
+  PREFIX=`dirname \`dirname $JRUBY\``
+  JARFILE="$PREFIX/lib/jruby-complete.jar"
+fi
+
+if [ ! -f "$JARFILE" ]; then
+  echo "!!Missing JRuby JAR. Please check installation." > /dev/stderr
+  exit 1
+fi
+
+echo "Using $JARFILE for splitting"
+echo "and assembling a AppEngine savvy version of the JRuby JAR in the lib "
+echo "directory."
+
+cd $SCRIPTHOME
+
+rm -rf jruby-core.jar
+rm -rf ruby-stdlib.jar
+rm -rf tmp_unpack
+
+mkdir -p tmp_unpack
+cd tmp_unpack
+
+jar xf $JARFILE
+
+cd ..
+
+mkdir -p jruby-core
+
+mv tmp_unpack/org jruby-core
+mv tmp_unpack/com jruby-core
+mv tmp_unpack/jline jruby-core
+mv tmp_unpack/jay jruby-core
+mv tmp_unpack/jruby jruby-core
+
+cd jruby-core
+
+jar cf ../jruby-core.jar .
+
+cd ../tmp_unpack
+
+jar cf ../ruby-stdlib.jar .
+
+cd ..
+
+rm -rf jruby-core
+rm -rf tmp_unpack

data/templates/sinatra/app.rb

@@ -0,0 +1,26 @@
+# This application files as generated by jruby-enginize.
+
+require 'rubygems'
+
+begin
+  require 'haml'
+  require 'sass'
+  require 'sinatra'
+rescue LoadError => exception
+  $stderr.puts '!!missing sinatra. Install sinatra gem and try again.'
+  exit(1)
+end
+
+# GET /
+ 
+get '/' do
+  haml :index
+end
+
+# GET /stylesheet.css
+
+get '/stylesheet.css' do
+  content_type 'text/css', :charset => 'utf-8'
+
+  sass :stylesheet
+end

data/templates/sinatra/config/warble.rb

@@ -0,0 +1,95 @@
+# Disable automatic framework detection by uncommenting/setting to false
+# Warbler.framework_detection = false
+ 
+# Warbler web application assembly configuration file
+Warbler::Config.new do |config|
+  # Temporary directory where the application is staged
+  # config.staging_dir = "tmp/war"
+ 
+  # Application directories to be included in the webapp.
+  config.dirs = %w(lib public views)
+ 
+  # Additional files/directories to include, above those in config.dirs
+  # config.includes = FileList["db"]
+  config.includes = FileList["appengine-web.xml", "app.rb", "config.ru"]
+  # Additional files/directories to exclude
+  # config.excludes = FileList["lib/tasks/*"]
+ 
+  # Additional Java .jar files to include.  Note that if .jar files are placed
+  # in lib (and not otherwise excluded) then they need not be mentioned here.
+  # JRuby and JRuby-Rack are pre-loaded in this list.  Be sure to include your
+  # own versions if you directly set the value
+  # config.java_libs += FileList["lib/java/*.jar"]
+ 
+  # Loose Java classes and miscellaneous files to be placed in WEB-INF/classes.
+  # config.java_classes = FileList["target/classes/**.*"]
+ 
+  # One or more pathmaps defining how the java classes should be copied into
+  # WEB-INF/classes. The example pathmap below accompanies the java_classes
+  # configuration above. See http://rake.rubyforge.org/classes/String.html#M000017
+  # for details of how to specify a pathmap.
+  # config.pathmaps.java_classes << "%{target/classes/,}p"
+ 
+  # Gems to be included. You need to tell Warbler which gems your application needs
+  # so that they can be packaged in the war file.
+  # The Rails gems are included by default unless the vendor/rails directory is present.
+  # config.gems += ["activerecord-jdbcmysql-adapter", "jruby-openssl"]
+  # config.gems << "tzinfo"
+  config.gems = ['sinatra', 'haml']
+ 
+  # Uncomment this if you don't want to package rails gem.
+  # config.gems -= ["rails"]
+ 
+  # The most recent versions of gems are used.
+  # You can specify versions of gems by using a hash assignment:
+  # config.gems["rails"] = "2.0.2"
+ 
+  # You can also use regexps or Gem::Dependency objects for flexibility or
+  # fine-grained control.
+  # config.gems << /^merb-/
+  # config.gems << Gem::Dependency.new("merb-core", "= 0.9.3")
+ 
+  # Include gem dependencies not mentioned specifically
+  config.gem_dependencies = true
+ 
+  # Files to be included in the root of the webapp.  Note that files in public
+  # will have the leading 'public/' part of the path stripped during staging.
+  # config.public_html = FileList["public/**/*", "doc/**/*"]
+ 
+  # Pathmaps for controlling how public HTML files are copied into the .war
+  # config.pathmaps.public_html = ["%{public/,}p"]
+ 
+  # Name of the war file (without the .war) -- defaults to the basename
+  # of RAILS_ROOT
+  config.war_name = "{{name}}"
+ 
+  # Name of the MANIFEST.MF template for the war file. Defaults to the
+  # MANIFEST.MF normally generated by `jar cf`.
+  # config.manifest_file = "config/MANIFEST.MF"
+ 
+  # Value of RAILS_ENV for the webapp -- default as shown below
+  # config.webxml.rails.env = ENV['RAILS_ENV'] || 'production'
+ 
+  # Application booter to use, one of :rack, :rails, or :merb. (Default :rails)
+  # config.webxml.booter = :rack
+  config.webxml.booter = :rack
+ 
+  # When using the :rack booter, "Rackup" script to use.
+  # The script is evaluated in a Rack::Builder to load the application.
+  # Examples:
+  # config.webxml.rackup = %{require './lib/demo'; run Rack::Adapter::Camping.new(Demo)}
+  # config.webxml.rackup = require 'cgi' && CGI::escapeHTML(File.read("config.ru"))
+ 
+  # Control the pool of Rails runtimes. Leaving unspecified means
+  # the pool will grow as needed to service requests. It is recommended
+  # that you fix these values when running a production server!
+  # config.webxml.jruby.min.runtimes = 2
+  # config.webxml.jruby.max.runtimes = 4
+  config.webxml.jruby.min.runtimes = 1
+  config.webxml.jruby.max.runtimes = 1
+  config.webxml.jruby.init.serial = true
+ 
+  # JNDI data source name
+  # config.webxml.jndi = 'jdbc/rails'
+  config.java_libs = []
+end

data/templates/sinatra/config.ru

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'sinatra'
+ 
+root_dir = File.dirname(__FILE__)
+ 
+set :environment, :production
+set :root, root_dir
+set :app_file, File.join(root_dir, 'app.rb')
+disable :run
+ 
+require 'app'
+ 
+run Sinatra::Application

data/templates/sinatra/lib/tasks/sinatra.rake

@@ -0,0 +1,7 @@
+namespace :sinatra do
+  desc 'Start a local test server on part 4567'
+  task :run do
+    puts 'Start a local test server on part 4567'
+    puts `jruby -S app.rb`
+  end
+end

data/templates/sinatra/views/index.haml

@@ -0,0 +1,17 @@
+%center
+  %div{ :id => 'main' }
+    %center
+      %p
+        %img{ :src => '/images/appengine_logo.png' }
+      %h1
+        Hi folks! Nice to meet you here!
+      %p
+        This is
+        %a{ :href => 'http://code.google.com/appengine' } Google AppEngine
+        running the
+        %a{ :href => 'http://www.sinatrarb.com' } Sinatra
+        framework.
+      %p
+        %img{ :src => '/images/sinatra_logo.png' }
+  %div{ :id => 'footer' }
+    This small application was generated by JRuby-Enginize.

data/templates/sinatra/views/layout.haml

@@ -0,0 +1,6 @@
+!!!
+%html
+  %head
+    %link{ :rel => 'stylesheet', :href => '/stylesheet.css', :type => 'text/css' }
+  %body
+    = yield

data/templates/sinatra/views/stylesheet.sass

@@ -0,0 +1,44 @@
+body
+  :background #bbbbbb
+  :color #000000
+  :font-family helvetica
+  :font-size 12pt
+
+h1, h2, h3, h4, h5, h6
+  :font-family helvetica
+
+h1
+  :font-size 18pt
+
+h2
+  :font-size 16pt
+
+h3
+  :font-size 14pt
+
+h4, h5, h6
+  :font-size 12pt
+
+a
+  :color #000000
+  :text-decoration none
+  :border-bottom 1px dotted
+
+a:hover
+  :border-bottom 1px solid
+
+div
+  :width 580px
+  :padding 3px 5px
+  :text-align left
+
+#main
+  :background #ffffff
+  :margin-top 50px
+  :height auto
+  :border 1px solid #808080
+
+#footer
+  :padding-left 0px
+  :font-size 9pt
+  :color #404040

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: ulbrich-jruby-enginize
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Jan Ulbrich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: jan.ulbrich @nospam@ holtzbrinck.com
+executables: 
+- jruby-enginize
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- bin/jruby-enginize
+- lib/generator.rb
+- lib/script.rb
+- templates/sinatra/views/stylesheet.sass
+- templates/sinatra/views/layout.haml
+- templates/sinatra/views/index.haml
+- templates/sinatra/public/images/sinatra_logo.png
+- templates/sinatra/lib/tasks/sinatra.rake
+- templates/sinatra/config.ru
+- templates/sinatra/config/warble.rb
+- templates/sinatra/app.rb
+- templates/shared/README
+- templates/shared/Rakefile
+- templates/shared/public/images/appengine_logo.png
+- templates/shared/lib/split-jruby.sh
+- templates/shared/lib/jruby-rack-0.9.4.jar
+- templates/shared/appengine-web.xml
+- README
+has_rdoc: true
+homepage: http://github.com/ulbrich/jruby-enginize
+post_install_message: 
+rdoc_options: 
+- --exclude
+- pkg
+- --exclude
+- templates
+- --all
+- --title
+- JRuby-Enginize
+- --main
+- README
+require_paths: 
+- .
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A package for generating Google AppEngine compliant JRuby projects.
+test_files: []
+