scharfie-bones 0.1.0

data/README

@@ -0,0 +1,38 @@
+Bones, the simple HTML mockup framework.
+
+What it does:
+
+  - Provides a simple framework for creating views
+    without worrying about controllers
+  - Allows the building of a complete static website
+    out of views, partials, and layouts which can
+    then be combined into full HTML pages for deployment
+    onto ANY webserver.
+
+Requirements:
+
+  - ActiveSupport
+  - rack
+
+Starting it up:
+
+	- Install
+	  sudo gem install scharfie-bones -s http://gems.github.com
+
+	- Generate:
+	  bones my_bones_app
+	  cd my_bones_app
+ 
+  - Serve
+    rake server
+ 
+  - Browse:
+    http://localhost:3000
+  
+Flatten your views into .html files:
+
+	- Cache with our without versioning
+    rake cache:simple     # without versioning
+    rake cache:versioned  # with versioning
+
+  Then upload the entire public/ directory to your server.

data/bin/bones

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# $:.unshift(File.dirname(__FILE__) + '/../')
+require 'fileutils'
+
+path = ARGV.shift
+
+if path.nil?
+  puts "Please supply a path to create a bones application."
+  exit
+end
+
+# Ensure given path exists
+path = File.expand_path(path)
+FileUtils.mkdir(path) unless File.directory?(path)
+
+# Set the root to the path
+ROOT = path
+
+require 'boot.rb'
+require 'init.rb'
+
+BonesInitializer.run

data/bones.gemspec

@@ -0,0 +1,37 @@
+Gem::Specification.new do |s|
+  s.name        = "bones"
+  s.version     = "0.1.0"
+  s.date        = "2008-08-22"
+
+  s.summary     = "Simple HTML mockup framework for designers using ERB"
+  s.description = "Simple HTML mockup framework for designers using ERB"
+  s.email       = "scharfie@gmail.com"
+  s.homepage    = "http://github.com/scharfie/bones"
+  s.has_rdoc    = false
+  s.authors     = ["Chris Scharf", "Ryan Heath"]
+	
+  s.require_paths      = ['lib']	
+  s.default_executable = 'bones'
+  s.executables        = ['bones']
+  
+  s.files = [ 
+    'README',
+    'bin/bones',
+    'lib/bones.rb',
+    'lib/boot.rb',
+    'lib/cache.rb',
+    'lib/extensions.rb',
+    'lib/helpers',
+    'lib/helpers/core_helper.rb',
+    'lib/init.rb',
+    'lib/pages/directory.html.erb',
+    'lib/pages/intro.html.erb',
+    'lib/Rakefile',
+    'lib/server.rb',
+    'lib/tasks/bones.rb',
+    'bones.gemspec'
+  ]
+
+  s.add_dependency("rack", [">= 0.3.0"])
+  s.add_dependency("activesupport", [">= 2.1.0"])
+end

data/lib/Rakefile

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'bones'
+require 'bones/lib/tasks'

data/lib/bones.rb

@@ -0,0 +1,193 @@
+# Bones - the _real_ request handler,
+# which BonesProxy loads and calls upon to
+# do the dirty work.
+class Bones
+  # Process incoming request (for real this time!)
+  def call(env)
+    # Grab the request
+    request  = Rack::Request.new(env) 
+    
+    # Create a new template for the given path
+    # and compile it
+    template = Template.new(request.path_info)
+    output   = template.compile
+
+    # Build a rack response
+    Rack::Response.new.finish do |response|
+      response.write output
+    end    
+  end
+  
+  # Returns array of all pages (excluding partials)
+  def self.pages
+    Dir.chdir(PAGES) do
+      Dir.glob('**/*.html.erb').map do |f|
+        f.starts_with?('_') ? nil : f.gsub('.html.erb', '')
+      end.compact
+    end
+  end  
+  
+  # Template - loads template file based on
+  # request path information and compiles
+  # it using ERB
+  class Template
+    attr_accessor :path
+    attr_accessor :layout
+    attr_accessor :options
+    
+    # Load all available helpers
+    def self.include_helpers
+      files = [
+        Dir.glob(SYSTEM / 'helpers/*_helper.rb'),
+        Dir.glob(ROOT / 'helpers/*_helper.rb')
+      ].flatten
+      
+      # Include each helper
+      files.each do |filename|
+        klass = File.basename(filename, '.rb').camelize
+        force_load klass => filename
+        include klass.constantize
+      end
+    end
+    
+    # Load the helpers
+    include_helpers if Object.const_defined?(:SYSTEM)
+    
+    # Initialize template with path and optional layout
+    def initialize(path, layout=-1, options={})
+      @path    = path.gsub(/\.html|\.html\.erb/, '')
+      @layout  = layout == -1 ? 'application' : layout
+      @options = options
+    end
+    
+    # Full path to template file
+    def filename
+      if @path =~ /raw$/
+        layout false
+        path = SYSTEM / 'pages' / 'directory.html.erb'
+      else
+        path = PAGES / @path
+        path /= 'index' if File.directory?(path) or path.ends_with?('/')
+        path += '.html.erb'
+      end
+    end
+    
+    # Returns array of pages
+    def pages
+      Bones.pages
+    end
+    
+    # Full path to layout file
+    def layout_filename
+      path = LAYOUTS / layout.to_s + '.html.erb'
+    end
+    
+    # Gets/sets layout
+    # If no argument is passed, the layout is returned;
+    # otherwise, sets the layout 
+    # (use false or nil to turn off the layout)
+    def layout(arg=-1)
+      @layout = arg unless arg == -1
+      @layout
+    end
+    
+    # Compiles the template (along with the layout
+    # if necessary)
+    def compile
+      src = ERB.new(File.read(filename)).src
+      src = (local_assigns_source || '') + (src || '')
+      @content_for_layout = eval(src) # erb.result(binding)
+      
+      if layout
+        erb = ERB.new(File.read(layout_filename))
+        erb.result(binding)
+      else
+        @content_for_layout
+      end  
+    end
+    
+    # Generates source for local variable assignments
+    def local_assigns_source
+      src = []
+      (options[:locals] || {}).each do |key, value|
+        src << "#{key} = #{value.inspect};\n"
+      end
+      src.join
+    end
+    
+    # Short-hand for compiling a template
+    def self.compile(*args)
+      Template.new(*args).compile
+    end
+    
+    # Renders partial template - an underscore
+    # is automatically added to the passed name,
+    # so <%= partial 'footer' %> will render
+    # the '_footer.html.erb' template.
+    def partial(name, options={})
+      path = name.to_s.split('/')
+      path[-1] = '_' + path.last unless path.last.starts_with?('_')
+      name = path.join('/')
+      Template.compile(name, false, options)
+    end
+  end
+  
+  # Class used to encapsulate the logic needed to
+  # maintain mockup versions
+  class Versioned
+    # Pre-fix used for versioned directories
+    DIR_PREFIX = 'v'
+    
+    # Start with the original destination
+    def initialize(original_destination)
+      @original_destination = original_destination
+      @versioned_destination = nil
+    end
+    
+    # Returns the new destination, which depends on
+    # the existing amount of 'versions'
+    def destination      
+      @versioned_destination ||= get_versioned_destination
+    end
+    
+    # Transfers all public directories to the new 'versioned'
+    # directory, so each version can contain it's own mockup
+    # (note: only copies asset directories - ignores "v1", "v2", etc)
+    def copy_public_directories
+      public_directories.each do |src|
+        FileUtils.copy_entry ROOT / 'public' / src, destination / src
+      end
+    end
+    
+    # Returns the versioned directories within the 'public' folder
+    # $> Bones::Versioned.directories
+    # $> => ["/v1", "/v2", ... "/vN"]
+    def self.directories
+      Dir.glob(ROOT / 'public' / "#{DIR_PREFIX}**").inject([]) do |dirs, dir|
+        dirs << '/' + dir.gsub(/^\/.+\//, '')
+      end
+    end
+    
+    # Public accessor of version
+    def version
+      next_version
+    end
+    
+    # Returns directory name of versioned path
+    # For example, 'v1'
+    def versioned_directory_name
+      DIR_PREFIX + next_version
+    end
+
+  private
+    # increments to the next version based on existing versions
+    def next_version
+      (self.class.directories.size + 1).to_s
+    end
+    
+    # constructs the next version path
+    def get_versioned_destination
+      @original_destination /= versioned_directory_name
+    end
+  end
+end

data/lib/boot.rb

@@ -0,0 +1,34 @@
+SYSTEM  = File.dirname(__FILE__)
+ROOT    = File.expand_path('.') unless Object.const_defined?(:ROOT)
+PAGES   = File.join(ROOT, 'pages')
+LAYOUTS = File.join(ROOT, 'layouts')
+
+$:.unshift(SYSTEM)
+$:.unshift(File.join(ROOT, 'lib'))
+
+require 'rubygems'
+require 'yaml'
+require 'rack'
+require 'rack/request'
+require 'rack/response'
+require 'activesupport'
+require 'extensions'
+require 'erb'
+require 'bones'
+
+def directories(base)
+  Dir.chdir(base) do
+    Dir.entries(base).map do |e|
+      next if e =~ /^\.+$/ 
+      File.directory?(base / e) ? '/' + e : nil
+    end.compact
+  end  
+end
+
+def page_directories
+  directories(ROOT / 'pages')
+end
+
+def public_directories
+  directories(ROOT / 'public') - page_directories - Bones::Versioned.directories
+end

data/lib/cache.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/ruby
+require File.join(File.dirname(__FILE__), 'boot')
+require 'fileutils'
+require 'bones'
+require 'optparse'
+require 'ostruct'
+
+# Argument processor
+class CacheOptions < OpenStruct
+  # Default options
+  def self.default_options
+    returning new do |o|
+      o.destination = ROOT / 'public'  # Set original destination
+      o.versioned   = false            # No versions by default       
+      o.base        = ''               # Base URL is empty
+    end
+  end
+  
+  # Process arguments
+  def self.process(args)
+    options = default_options
+    
+    OptionParser.new do |o|
+      o.on('--versioned', '--versions', "Enable versioning") do
+        options.versioned   = Bones::Versioned.new(options.destination)
+      end
+      
+      o.on('--base PATH', "Change the base URL path") do |path|
+        options.base = path
+      end
+
+      o.on_tail("-h", "--help", "Show this message") do
+        puts o
+        exit
+      end
+    end.parse!(args)
+    
+    options
+  end
+  
+  # Returns true if the versions enabled
+  def versioned?
+    versioned != false
+  end
+  
+  # Returns destination
+  def destination
+    versioned? ?  versioned.destination : super
+  end
+end
+
+# Process arguments
+options = CacheOptions.process(ARGV)
+
+# Fixes the given URL path to begin at given base.
+# In addition, the .html extension will be added if
+# the path is a page.
+# 
+# For example, if the base is /some_folder,
+#   normalize_url('/page_path', '/some_folder')
+#   # => /some_folder/page_path.html
+def normalize_url(path, base='')
+  @known_pairs ||= {}
+  @public_directories_regex ||= Regexp.new(public_directories.join('|'))
+  
+  if v = @known_pairs[path]
+    return v
+  else
+    value = case
+    when path =~ @public_directories_regex
+      path
+    when File.directory?('pages' / path)
+      path
+    else
+      path + '.html'
+    end
+    
+    @known_pairs[path] = base / value
+  end    
+end
+
+version = options.versioned? ? options.versioned.versioned_directory_name : nil
+
+# Process each page
+Dir.chdir(ROOT) do
+  Bones.pages.each do |page|
+    puts  "** Generating #{[version, page].compact.join('/')}.html"
+    result = Bones::Template.compile(page)
+    result.gsub!(/(href|src|action)="([-A-Za-z0-9_\.\/]+)(.*?)"/) do |match|
+      property, url, params = $1, normalize_url(original_url = $2, options.base), $3
+      '%s="%s%s"' % [property, url, params]
+    end
+  
+    path = options.destination / page + '.html'
+    FileUtils.mkdir_p(File.dirname(path))
+    File.open(path, 'w') { |f| f.write(result) }
+  end
+
+  if options.versioned?  
+    puts "** Copying public files"
+    options.versioned.copy_public_directories
+  end  
+end
+
+puts "** Done."

data/lib/extensions.rb

@@ -0,0 +1,26 @@
+class String
+  # Join strings using /
+  # (i.e. "system" / "pages" -> "system/pages")
+  def /(other)
+    File.join(self, other)
+  end
+end
+
+# Loads filename, removing the associated
+# class if defined
+# 
+# Arguments:
+#   hash of 'Class' => 'filename' pairs
+# 
+# Example:
+# 
+#   force_load 'Application' => 'application.rb'
+# 
+# will remove the Application class if found,
+# and then load the application.rb file
+def force_load(map={})
+  map.each do |klass, filename|
+    Class.remove_class(klass) if Object.const_defined?(klass)
+    load filename 
+  end
+end

data/lib/helpers/core_helper.rb

@@ -0,0 +1,140 @@
+module CoreHelper
+  module HTML
+    # Creates a tag with content and properties
+    # Example:
+    #   content_tag(:div, "Hello", :id => 'greeting')
+    #     -- generates --
+    #   <div id="greeting">Hello</div>
+    def content_tag(name, *arguments, &block)
+      name    = name.to_s
+      options = Hash === arguments.last ? arguments.pop : {}
+      properties = html_options_from_hash(options)
+    
+      result = ["<#{name}"]
+      result << ' ' + properties unless properties.empty?
+    
+      if short_tag_names.include?(name)
+        result << ' />'
+      else
+        result << '>'
+        result << arguments.join
+        result << capture(&block) if block_given?
+        result << "</#{name}>"  
+      end
+    
+      result = result.join('')
+      concat(result, block.binding) if block_given?
+      result
+    end
+
+    # Returns array of tag names that can be
+    # closed with /> instead of </tagname>
+    def short_tag_names
+      %w(input br link hr img)
+    end
+
+    # Converts hash of options into a string of HTML
+    # property="value" pairs
+    def html_options_from_hash(options={})
+      options.map do |key, value|
+        %Q{#{key}="#{value}"}
+      end.sort.join(' ')
+    end
+  
+    # Creates link tag to stylesheet(s)
+    # (options are support as the last argument)
+    def stylesheet_link_tag(*sources)
+      return nil if sources.empty?
+      options = Hash === sources.last ? sources.pop : {}
+      result  = sources.map { |e| stylesheet_tag(e, options) }
+      result.join("\n")
+    end
+  
+    # Creates a stylesheet link tag
+    def stylesheet_tag(name, options={})
+      name += '.css' unless name =~ /\./
+      options.reverse_merge! :href => "/stylesheets/#{name}",
+        :rel => 'stylesheet', :type => 'text/css'
+      
+      content_tag :link, options  
+    end
+
+    # Creates script tag to javascript(s)
+    # (options are support as the last argument)
+    def javascript_include_tag(*sources)
+      return nil if sources.empty?
+      options = Hash === sources.last ? sources.pop : {}
+      sources.collect { |e| javascript_tag(e, options) }.join("\n")
+    end
+
+    # Creates a javascript script tag
+    def javascript_tag(name, options={})
+      name += '.js' unless name =~ /\./
+      options.merge! :src => "/javascripts/#{name}",
+        :type => 'text/javascript'
+      
+      content_tag :script, options 
+     end
+  end
+  
+  module Capture
+    def content_for(name, content = nil, &block)
+      existing_content_for = instance_variable_get("@content_for_#{name}").to_s
+      new_content_for      = existing_content_for + (block_given? ? capture(&block) : content)
+      instance_variable_set("@content_for_#{name}", new_content_for)
+    end
+
+    def capture(*args, &block)
+      # execute the block
+      begin
+        buffer = eval('_erbout', block.binding)
+      rescue
+        buffer = nil
+      end
+    
+      if buffer.nil?
+        capture_block(*args, &block).to_s
+      else
+        capture_erb_with_buffer(buffer, *args, &block).to_s
+      end
+    end
+
+    def capture_block(*args, &block)
+      block.call(*args)
+    end
+  
+    def capture_erb(*args, &block)
+      buffer = eval('_erbout', block.binding)
+      capture_erb_with_buffer(buffer, *args, &block)
+    end
+
+    def capture_erb_with_buffer(buffer, *args, &block)
+      pos = buffer.length
+      block.call(*args)
+  
+      # extract the block 
+      data = buffer[pos..-1]
+  
+      # replace it in the original with empty string
+      buffer[pos..-1] = ''
+  
+      data
+    end
+    
+    def concat(string, binding)
+      eval('_erbout', binding) << string
+    end
+  end
+  
+  include HTML
+  include Capture
+  
+  # Simple helper for setting title
+  # Call from a page template with an argument 
+  # to set the title; call from the layout with
+  # no argument to get the title
+  def title(value=-1)
+    return @content_for_title if value == -1
+    @content_for_title = value
+  end
+end

data/lib/init.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), 'boot') if __FILE__ == $0
+require 'fileutils'
+
+class BonesInitializer
+  def self.ensure_file(path, &block)
+    return if File.exist?(path)
+    puts "** Writing #{path}"
+    File.open(path, 'w', &block)
+  end
+
+  def self.ensure_directory(path)
+    return nil if File.directory?(path)
+    puts "** Creating directory #{path}"
+    FileUtils.mkdir_p(path)  
+    return true
+  end
+
+  def self.run
+    puts "** Initializing"
+
+    ensure_directory(ROOT / 'public' / 'javascripts')
+    ensure_directory(ROOT / 'public' / 'stylesheets')
+    pages_new = ensure_directory(ROOT / 'pages')
+    ensure_directory(ROOT / 'layouts')
+    ensure_directory(ROOT / 'helpers')
+
+    if pages_new
+      ensure_file(ROOT / 'pages' / 'index.html.erb') do |f|
+        f.write File.read(SYSTEM / 'pages' / 'intro.html.erb')
+      end
+    end  
+
+    ensure_file(ROOT / 'layouts' / 'application.html.erb') do |f|
+      f.write <<-HTML
+    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+    <html>
+    <head>
+      <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+      <title>Welcome to bones</title>
+      <%= stylesheet_link_tag 'styles' %>
+      <%= javascript_include_tag %>
+    </head>  
+    <body>
+      <h1>Welcome to <strong>bones</strong></h1>
+      <%= @content_for_layout %>
+    </body>
+    </html>  
+      HTML
+    end
+
+    ensure_file(ROOT / 'public' / 'stylesheets' / 'styles.css')
+
+    puts "** Adding Rakefile to parent directory"
+    ensure_file(ROOT / 'Rakefile') do |f|
+      f.write File.read(SYSTEM / 'Rakefile')
+    end
+
+    puts <<-HELP if __FILE__ == $0
+
+     All set! Now just run:
+       ruby bones/server.rb
+ 
+     The app will run on port 3000
+ 
+    HELP
+  end
+end
+
+BonesInitializer.run if __FILE__ == $0

data/lib/pages/directory.html.erb

@@ -0,0 +1,5 @@
+<ul>
+<% pages.each do |page| %>
+  <li><a href="/<%= page.gsub(/index$/, '') %>"><%= page %></a></li>
+<% end %>
+</ul>

data/lib/pages/intro.html.erb

@@ -0,0 +1,28 @@
+<% layout false %>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Welcome to bones</title>
+  <%= stylesheet_link_tag 'styles' %>
+  <%= javascript_include_tag %>
+</head>
+<h1>Welcome to <strong>bones</strong></h1>
+<pre>
+  Getting started:
+  
+  - Create some files in /pages (i.e. index.html.erb)
+  - Create some directories in /pages if you want as well
+    and drop .html.erb files in them as well  
+  - Check out /raw to see all the pages in the system  
+    
+  Other things you can do:
+    
+  - Create partials in /pages (i.e. _footer.html.erb)
+  - Drop anything you want in /public
+      (/stylesheets and /javascripts are created for you)
+  - Customize the layout (/layouts/application.html.erb)
+  - Create your own layout:
+      - Drop the file in /layouts (i.e. /layouts/custom.html.erb)
+      - Use the layout from a page (i.e. &lt;%= layout 'custom' %&gt;)
+</pre>
+</html>

data/lib/server.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), 'boot')
+require 'init'
+
+# BonesProxy is simply a proxy class handler
+# to the actual Bones class - the reason for 
+# this is to allow live changes to Bones
+# and helpers, etc.  The proxy reloads on every 
+# request
+class BonesProxy
+  # Process incoming request
+  def call(env)
+    reload!
+    Bones.new.call(env)  
+  end
+  
+  # Reloads the application
+  def reload!
+    force_load 'Bones' => 'bones.rb'
+  end
+end
+
+class BonesServer
+  def self.run
+    app = Rack::Builder.new do
+       use Rack::CommonLogger
+       use Rack::ShowExceptions
+       use Rack::Reloader
+       use Rack::Static, :urls => public_directories, :root => ROOT / 'public'
+       run BonesProxy.new
+    end
+
+    port = ARGV.shift || 3000
+    puts "** Starting bones server on http://0.0.0.0:#{port}"
+    puts "** Public directories: #{public_directories.to_sentence}"
+    Rack::Handler::Mongrel.run app, :Port => port do |server|
+      puts "** Use CTRL-C to stop."
+    end
+  end
+end
+
+BonesServer.run if __FILE__ == $0

data/lib/tasks/bones.rb

@@ -0,0 +1,28 @@
+desc "Start bones server"
+task :server do
+  ARGV.shift
+  load File.join(File.dirname(__FILE__), '..', 'server.rb')
+  BonesServer.run
+end
+
+namespace :cache do
+  desc "Cache page templates for redistribution (non-versioned)"
+  task :simple do
+    ARGV.shift
+    load File.join(File.dirname(__FILE__), '..', 'cache.rb')
+  end
+  
+  desc "Cache page templatets for redistribution (versioned)"
+  task :versioned do
+    ARGV.shift
+    file = File.join(File.dirname(__FILE__), '..', 'cache.rb')
+    system "ruby #{file} '--versioned'"
+  end
+end
+
+task :clean do
+  # TODO
+  # ARGV.shift
+  # ARGV.unshift '--clean'
+  # load File.join(File.dirname(__FILE__), 'cache.rb')
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: scharfie-bones
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Chris Scharf
+- Ryan Heath
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-22 00:00:00 -07:00
+default_executable: bones
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+    version: 
+description: Simple HTML mockup framework for designers using ERB
+email: scharfie@gmail.com
+executables: 
+- bones
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- bin/bones
+- lib/bones.rb
+- lib/boot.rb
+- lib/cache.rb
+- lib/extensions.rb
+- lib/helpers
+- lib/helpers/core_helper.rb
+- lib/init.rb
+- lib/pages/directory.html.erb
+- lib/pages/intro.html.erb
+- lib/Rakefile
+- lib/server.rb
+- lib/tasks/bones.rb
+- bones.gemspec
+has_rdoc: false
+homepage: http://github.com/scharfie/bones
+post_install_message: 
+rdoc_options: []
+
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple HTML mockup framework for designers using ERB
+test_files: []
+