RubyGems - html_mockup - Versions diffs - 0.3.2 - Mend

html_mockup 0.3.2

Files changed (14) hide show

data/README.rdoc +81 -0
data/bin/mockup +5 -0
data/examples/config.ru +16 -0
data/examples/html/green.gif +0 -0
data/examples/html/index.html +18 -0
data/examples/partials/test.part.rhtml +3 -0
data/examples/script/server +20 -0
data/lib/html_mockup/cli.rb +178 -0
data/lib/html_mockup/rack/html_mockup.rb +56 -0
data/lib/html_mockup/rack/html_validator.rb +26 -0
data/lib/html_mockup/server.rb +80 -0
data/lib/html_mockup/template.rb +129 -0
data/lib/html_mockup/w3c_validator.rb +120 -0
metadata +86 -0

data/README.rdoc ADDED Viewed

@@ -0,0 +1,81 @@
+== HtmlMockup
+HTML Mockup is a set of tools to create self-containing HTML mockups. HtmlMockup gives you the flexibility
+of a templatinglanguage but at the same time keeps all HTML files viewable. HTML comments are
+used to  determine what partial (sub-template) to render.
+HtmlMockup also provides tools for HTML validation.
+=== Requirements
+HtmlMockup requires the following dependencies
+* Ruby 1.8.x (not tested in 1.9.x)
+* Rubygems
+* Thor (to use mockup binary)
+* Rack > 0.3 (to use mockup serve)
+=== Usage
+Just write regular HTML files and include comment's like this:
+  <!-- [START:partial_name] -->Text<!-- [STOP:partial_name] -->
+The data between the tags will be replaced by the partial contents. Partials are searched in
+"../partials" relative to the directory the script you run resides in. This can be overridden with
+commandline parameters. Partials always must have a .part.r?html ending and are evaluated as ERB during
+insertion.
+=== Syntax for HTML files
+==== Standard partials
+  <!-- [START:partial_name] -->Text<!-- [STOP:partial_name] -->
+==== Pass parameters to partials
+You can pass in parameters to partials in the format of key=value&key2=value2 (it's just a regular CGI
+query string and is parsed by CGI#parse). The partials wich are evaluated as ERB can access the variables
+through standard instance methods. The example below would create the instance variable @key.
+  <!-- [START:partial_name?key=value] -->Text<!-- [STOP:partial_name] -->
+=== Mockup commandline
+==== mockup convert [directory/file]
+Convert can be called with a single html file or a directory. If a directory is specified all .html files
+will be converted.
+*Warning:* Convert will overwrite the file itself!
+Options:
+--partial_path:: the path where the partial files can be found (*.part.html), defaults to director/../partials
+--filter:: The filter to use when finding templates within directory, defaults to *.html
+==== mockup serve [directory/file]
+Serve can be used during development as a simple webserver (Webrick/Mongrel). It also supports
+on-the-fly HTML validation.
+You can also call ./script/server just above the HTML directory.
+Options:
+--port:: The port the server should listen on. Defaults to 9000
+--partial_path:: the path where the partial files can be found (*.part.html), defaults to director/../partials
+--validate:: Flag to set wether or not we should validate all html files (defaults to false)
+==== mockup generate [directory]
+Generate creates a directory structure in directory for use with new HTML mockups.
+==== mockup validate [directory/file]
+Validates all files within directory or just file with the W3C validator webservice.
+Options:
+--show_valid:: Flag to print a line for each valid file too (defaults to false)
+--filter:: What files should be validated, defaults to [^_]*.html
+=== Copyright & license
+Copyright (c) 2009 Flurin Egger, DigitPaint, MIT Style License. (see MIT-LICENSE)

data/bin/mockup ADDED Viewed

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + "/../lib/html_mockup/cli"
+HtmlMockup::Cli.start

data/examples/config.ru ADDED Viewed

@@ -0,0 +1,16 @@
+require 'pathname'
+begin
+  require File.dirname(__FILE__) + "/../vendor/html_mockup/lib/html_mockup/server"
+rescue LoadError => e
+  require 'rubygems'
+  require 'html_mockup/server'
+end
+root_path = Pathname.new(File.dirname(__FILE__)) + "html"
+partial_path = (root_path + "../partials/").realpath
+mockup = HtmlMockup::Server.new(root_path,partial_path)
+run mockup.application

data/examples/html/green.gif ADDED Viewed

Binary file

data/examples/html/index.html ADDED Viewed

@@ -0,0 +1,18 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+	<title>untitled</title>
+</head>
+<body>
+  <!-- [START:test?id=bla] -->
+  <!-- [STOP:test] -->
+  <img src="green.gif" alt="Green" />
+</body>
+</html>

data/examples/partials/test.part.rhtml ADDED Viewed

@@ -0,0 +1,3 @@
+<div id="<%= @id || "fault" %>">
+  Think?
+</div>

data/examples/script/server ADDED Viewed

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'pathname'
+begin
+  require File.dirname(__FILE__) + "/../vendor/html_mockup/lib/html_mockup/server"
+rescue LoadError => e
+  require 'rubygems'
+  require 'html_mockup/server'
+end
+root_path = Pathname.new(File.dirname(__FILE__)) + "../html"
+partial_path = (root_path + "../partials/").realpath
+mockup = HtmlMockup::Server.new(root_path,partial_path)
+# Add some of your own middleware here.
+# mockup.use Rack::CommonLogger
+mockup.run

data/lib/html_mockup/cli.rb ADDED Viewed

@@ -0,0 +1,178 @@
+require 'rubygems'
+require 'thor'
+require 'pathname'
+require 'fileutils'
+include FileUtils
+require File.dirname(__FILE__) + "/template"
+require File.dirname(__FILE__) + "/w3c_validator"
+module HtmlMockup
+  class Cli < Thor
+    desc "serve [directory]","Serve directory as HTML, defaults to current directory"
+    method_options :port => :string, # Defaults to 9000
+                   :partial_path => :string, # Defaults to [directory]/../partials
+                   :validate => :boolean, # Automatically validate all HTML responses @ the w3c
+                   :handler => :string # The handler to use (defaults to mongrel)
+    def serve(path=".")
+      require File.dirname(__FILE__) + '/server'
+      @path,@partial_path = template_paths(path,options["partial_path"])
+      server_options = {}
+      server_options[:Port] = options["port"] || "9000"
+      server = Server.new(@path,@partial_path,options,server_options)
+      puts "Running HtmlMockup with #{server.handler.inspect} on port #{server_options[:Port]}"
+      puts "  Taking partials from #{@partial_path} (#{HtmlMockup::Template.partial_files(@partial_path).size} found)"
+      server.run
+    end
+    desc "validate [directory/file]", "Validates the file or all HTML in directory"
+    method_options :show_valid => :boolean, # Also print a line for each valid file
+                   :filter => :string # What files should be found, defaults to [^_]*.html
+    def validate(path=".")
+      filter = options["filter"] || "[^_]*.html"
+      puts "Filtering on #{options["filter"]}" if options["filter"]
+      if File.directory?(path)
+        any_invalid = false
+        if (files = Dir.glob("#{path}/**/#{filter}")).any?
+        	files.each do |file|
+        		if !self.w3cvalidate(file)
+        		  any_invalid = true
+        	  end
+        	end
+        	if !any_invalid
+        	  puts "All files were considered valid"
+          end
+        else
+          puts "No files matched \"#{filter}\""
+        end
+      elsif File.readable?(path)
+        self.w3cvalidate(path)
+      else
+        puts "No such file/directory #{path}"
+      end
+    end
+    desc "generate [directory]","Create a new HTML mockup directory tree in directory"
+    def generate(path)
+      path = Pathname.new(path)
+      if path.directory?
+        puts "Directory #{path} already exists, please only use this to create new mockups"
+      else
+        example_path = Pathname.new(File.dirname(__FILE__) + "/../../examples")
+        path.mkpath
+        html_path = path + "html"
+        mkdir(html_path)
+        mkdir(html_path + "stylesheets")
+        mkdir(html_path + "images")
+        mkdir(html_path + "javascripts")
+        mkdir(path + "partials")
+        mkdir(path + "script")
+        cp(example_path + "script/server",path + "script/server")
+        cp(example_path + "config.ru",path + "config.ru")
+        (path + "script/server").chmod(0755)
+      end
+    end
+    desc "convert [directory]","Inject all partials, into all HTML files within directory"
+    method_options :partial_path => :string, # Defaults to [directory]/../partials
+                   :filter => :string # What files should be converted defaults to **/*.html
+    def convert(path=".")
+      path,partial_path = template_paths(path,options["partial_path"])
+      filter = options["filter"] || "**/*.html"
+      puts "Converting #{filter} in #{path}"
+      puts "  Taking partials from #{partial_path} (#{HtmlMockup::Template.partial_files(partial_path).size} found)"
+      if path.directory?
+      	Dir.glob("#{path}/#{filter}").each do |file|
+      		puts "  Converting file: " + file
+          HtmlMockup::Template.open(file, :partial_path => partial_path).save
+      	end
+      else
+        HtmlMockup::Template.open(path, :partial_path => partial_path).save
+      end
+    end
+    desc "extract [source_path] [target_path]", "Extract a fully relative html mockup into target_path. It will expand all absolute href's, src's and action's into relative links if they are absolute"
+    method_options :partial_path => :string, # Defaults to [directory]/../partials
+                   :filter => :string # What files should be converted defaults to **/*.html
+    def extract(source_path=".",target_path="../out")
+      require 'hpricot'
+      source_path,target_path = Pathname.new(source_path),Pathname.new(target_path)
+      source_path,partial_path = template_paths(source_path,options["partial_path"])
+      filter = options["filter"] || "**/*.html"
+      raise "Target #{target_path} already exists, please choose a new directory to extract into" if target_path.exist?
+      mkdir_p(target_path)
+      target_path = target_path.realpath
+      # Copy source to target first, we'll overwrite the templates later on.
+      cp_r(source_path.children,target_path)
+      Dir.chdir(source_path) do
+        Dir.glob(filter).each do |file_name|
+          source = HtmlMockup::Template.open(file_name, :partial_path => partial_path).render
+          cur_dir = Pathname.new(file_name).dirname
+          up_to_root = File.join([".."] * (file_name.split("/").size - 1))
+          doc = Hpricot(source)
+          %w{src href action}.each do |attribute|
+            (doc/"*[@#{attribute}]").each do |tag|
+              next unless tag[attribute] =~ /\A\//
+              if true_file = resolve_path(cur_dir + up_to_root + tag[attribute].sub(/\A\//,""))
+                tag[attribute] = true_file.relative_path_from(cur_dir)
+              else
+                puts "Could not resolve link #{tag[attribute]} in #{file_name}"
+              end
+            end
+          end
+          File.open(target_path + file_name,"w"){|f| f.write(doc.to_original_html) }
+        end
+      end
+    end
+    protected
+    def template_paths(path,partial_path=nil)
+      path = Pathname.new(path)
+      partial_path = partial_path && Pathname.new(partial_path) || (path + "../partials/").realpath
+      [path,partial_path]
+    end
+    def w3cvalidate(file)
+      validator = W3CValidator.new(File.read(file))
+      validator.validate!
+      if !options["show_valid"] && !validator.valid || options["show_valid"]
+        print "- #{file} "
+        print "(errors: #{validator.errors}, warnings: #{validator.warnings})\n"
+      end
+      validator.valid
+    end
+    def resolve_path(path)
+      path = Pathname.new(path) unless path.kind_of?(Pathname)
+      # Append index.html/index.htm/index.rhtml if it's a diretory
+      if path.directory?
+        search_files = %w{.html .htm}.map!{|p| path + "index#{p}" }
+      # If it ends with a slash or does not contain a . and it's not a directory
+      # try to add .html/.htm/.rhtml to see if that exists.
+      elsif (path =~ /\/$/) || (path =~ /^[^.]+$/)
+        search_files = [path.to_s + ".html", path.to_s + ".htm"].map!{|p| Pathname.new(p) }
+      else
+        search_files = [path]
+      end
+      search_files.find{|p| p.exist? }
+    end
+  end
+end

data/lib/html_mockup/rack/html_mockup.rb ADDED Viewed

@@ -0,0 +1,56 @@
+require 'rack/request'
+require 'rack/response'
+require 'rack/file'
+module HtmlMockup
+  module Rack
+    class HtmlMockup
+      def initialize(root,partial_path)
+        @docroot = root
+        @partial_path = partial_path
+        @file_server = ::Rack::File.new(@docroot)
+      end
+      def call(env)
+        path = env["PATH_INFO"]
+        # Append index.html/index.htm/index.rhtml if it's a diretory
+        if File.directory?(File.join(@docroot,path))
+          search_files = %w{.html .htm .rhtml}.map!{|p| File.join(@docroot,path,"index#{p}")}
+        # If it's already a .html/.htm/.rhtml file, render that file
+        elsif (path =~ /\.r?html?$/)
+          search_files = [File.join(@docroot,path)]
+        # If it ends with a slash or does not contain a . and it's not a directory
+        # try to add .html/.htm/.rhtml to see if that exists.
+        elsif (path =~ /\/$/) || (path =~ /^[^.]+$/)
+          search_files = [path + ".html", path + ".htm", path + ".rhtml"].map!{|p| File.join(@docroot,p) }
+        # Otherwise don't render anything at all.
+        else
+          search_files = []
+        end
+        if template_path = search_files.find{|p| File.exist?(p)}
+          env["rack.errors"].puts "Rendering template #{template_path.inspect} (#{path.inspect})"
+          begin
+            templ = ::HtmlMockup::Template.open(template_path, :partial_path => @partial_path)
+            resp = ::Rack::Response.new do |res|
+              res.status = 200
+              res.write templ.render
+            end
+            resp.finish
+          rescue StandardError => e
+            env["rack.errors"].puts "  #{e.message}"
+            resp = ::Rack::Response.new do |res|
+              res.status = 500
+              res.write "An error occurred"
+            end
+            resp.finish
+          end
+        else
+          env["rack.errors"].puts "Invoking file handler for #{path.inspect}"
+          @file_server.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/html_mockup/rack/html_validator.rb ADDED Viewed

@@ -0,0 +1,26 @@
+require 'rack/request'
+require 'rack/response'
+module HtmlMockup
+  module Rack
+    class HtmlValidator
+      def initialize(app)
+        @app = app
+      end
+      def call(env)
+        resp = @app.call(env)
+        if resp[1]["Content-Type"].to_s.include?("html")
+          str = ""
+          resp[2].each{|c| str << c}
+          validator = W3CValidator.new(str)
+          validator.validate!
+          if !validator.valid
+            env["rack.errors"].puts "Validation failed on #{env["PATH_INFO"]}: (errors: #{validator.errors}, warnings: #{validator.warnings})"
+          end
+        end
+        resp
+      end
+    end
+  end
+end

data/lib/html_mockup/server.rb ADDED Viewed

@@ -0,0 +1,80 @@
+require 'rack'
+require File.dirname(__FILE__) + "/template"
+require File.dirname(__FILE__) + "/w3c_validator"
+require File.dirname(__FILE__) + "/rack/html_mockup"
+require File.dirname(__FILE__) + "/rack/html_validator"
+module HtmlMockup
+  class Server
+    attr_accessor :options,:server_options, :root, :partial_path
+    def initialize(root,partial_path,options={},server_options={})
+      @stack = ::Rack::Builder.new
+      @middleware = []
+      @root = root
+      @partial_path = partial_path
+      @options,@server_options = options,server_options
+    end
+    # Use the specified Rack middleware
+    def use(middleware, *args, &block)
+      @middleware << [middleware, args, block]
+    end
+    def handler
+      if self.options[:handler]
+        begin
+          @handler = ::Rack::Handler.get(self.options[:handler])
+        rescue LoadError
+        rescue NameError
+        end
+        if @handler.nil?
+          puts "Handler '#{self.options[:handler]}' not found, using fallback."
+        end
+      end
+      @handler ||= detect_rack_handler
+    end
+    def run
+      self.handler.run self.application, @server_options do |server|
+        trap(:INT) do
+          ## Use thins' hard #stop! if available, otherwise just #stop
+          server.respond_to?(:stop!) ? server.stop! : server.stop
+          puts "Bby HtmlMockup"
+        end
+      end
+    end
+    def application
+      return @app if @app
+      @stack.use ::Rack::ShowExceptions
+      @stack.use ::Rack::Lint
+      @stack.use ::Rack::ConditionalGet
+      @middleware.each { |c,a,b| @stack.use(c, *a, &b) }
+      @stack.use Rack::HtmlValidator if self.options["validate"]
+      @stack.run Rack::HtmlMockup.new(self.root, self.partial_path)
+      @app = @stack.to_app
+    end
+    protected
+    # Sinatra's detect_rack_handler
+    def detect_rack_handler
+      servers = %w[mongrel thin webrick]
+      servers.each do |server_name|
+        begin
+          return ::Rack::Handler.get(server_name)
+        rescue LoadError
+        rescue NameError
+        end
+      end
+      raise "Server handler (#{servers.join(',')}) not found."
+    end
+  end
+end

data/lib/html_mockup/template.rb ADDED Viewed

@@ -0,0 +1,129 @@
+require 'pathname'
+require 'strscan'
+require 'erb'
+require 'cgi'
+module HtmlMockup
+  class MissingPartial < StandardError; end
+  class Template
+    class << self
+      def open(filename,options={})
+        raise "Unknown file #{filename}" unless File.exist?(filename)
+        self.new(File.read(filename),options.update(:target_file => filename))
+      end
+      # Returns all available partials in path
+      def partials(path)
+        available_partials = {}
+        path = Pathname.new(path)
+        self.partial_files(path).inject({}) do |mem,f|
+          name = f.to_s.split(".",2)[0]
+          mem[name] = (path + f).read
+          mem
+        end
+      end
+      def partial_files(path)
+        filter = "*.part.{?h,h}tml"
+        files = []
+        Dir.chdir(Pathname.new(path)) do
+          files = Dir.glob(filter)
+        end
+        files
+      end
+    end
+    # Create a new HtmlMockupTemplate
+    #
+    # ==== Parameters
+    # template<String>:: The template to parse
+    # options<Hash>:: See options
+    #
+    # ==== Options (optional)
+    # partial_path<String>:: Path where the partials reside (default: $0/../../partials)
+    #--
+    def initialize(template, options={})
+      defaults = {:partial_path => File.dirname(__FILE__) + "/../../partials/"}
+      @template = template
+      @options = defaults.update(options)
+      @scanner = StringScanner.new(@template)
+      raise "Partial path '#{self.options[:partial_path]}' not found" unless File.exist?(self.options[:partial_path])
+    end
+    attr_reader :template, :options, :scanner
+    # Renders the template and returns it as a string
+    #
+    # ==== Returns
+    # String:: The rendered template
+    #--
+    def render
+      out = ""
+    	while (partial = self.parse_partial_tag!) do
+    	  tag,params,scanned = partial
+    		# add new skipped content to output file
+    		out << scanned
+    		# scan until end of tag
+    		current_content = self.scanner.scan_until(/<!-- \[STOP:#{tag}\] -->/)
+    		out << (render_partial(tag,params) || current_content)
+    	end
+    	out << scanner.rest
+    end
+    def save(filename=self.options[:target_file])
+      File.open(filename,"w"){|f| f.write render}
+    end
+    protected
+    def available_partials(force=false)
+      return @_available_partials if @_available_partials && !force
+      @_available_partials = self.class.partials(self.options[:partial_path])
+    end
+    def parse_partial_tag!
+      params = {}
+      scanned = ""
+      begin_of_tag = self.scanner.scan_until(/<!-- \[START:/)
+      return nil unless begin_of_tag
+      scanned << begin_of_tag
+      scanned << tag = self.scanner.scan(/[a-z0-9_]+/)
+      if scanned_questionmark = self.scanner.scan(/\?/)
+        scanned << scanned_questionmark
+        scanned << raw_params = self.scanner.scan_until(/\] -->/)
+        raw_params.gsub!(/\] -->$/,"")
+        params = CGI.parse(raw_params)
+        params.keys.each{|k| params[k] = params[k].first }
+      else
+        scanned << self.scanner.scan_until(/\] -->/)
+      end
+      [tag,params,scanned]
+    end
+    def render_partial(tag,params)
+      unless self.available_partials[tag]
+        raise MissingPartial.new("Could not find partial '#{tag}' in partial path '#{@options[:partial_path]}'")
+      end
+      template = ERB.new(self.available_partials[tag])
+      context = TemplateContext.new(params)
+      "\n" + template.result(context.get_binding).rstrip + "\n<!-- [STOP:#{tag}] -->"
+    end
+    class TemplateContext
+      def initialize(params)
+        params.each do |k,v|
+          self.instance_variable_set("@#{k}",v)
+        end
+      end
+      def get_binding; binding(); end
+    end
+  end
+end

data/lib/html_mockup/w3c_validator.rb ADDED Viewed

@@ -0,0 +1,120 @@
+require 'cgi'
+require 'net/http'
+require 'uri'
+require 'yaml'
+module HtmlMockup
+  class W3CValidator
+    ValidationUri = "http://validator.w3.org/check"
+    attr_reader :valid,:response,:errors,:warnings,:status
+    class << self
+      def validation_uri
+        @uri ||= URI.parse(ValidationUri)
+      end
+    end
+    def initialize(html)
+      @html = html
+    end
+    def validate!
+      @status = @warnings = @errors = @response = @valid = nil
+      options = {"output" => "json"}
+      query,headers = build_post_query(options)
+      response =  self.request(:post,self.class.validation_uri.path,query,headers)
+      @status,@warnings,@errors = response["x-w3c-validator-status"],response["x-w3c-validator-warnings"].to_i,response["x-w3c-validator-errors"].to_i
+      if @status == "Valid" && @warnings == 0 && @errors == 0
+        return @valid = true
+      else
+        begin
+          @response = YAML.load(response.body)
+        rescue
+        end
+        return (@valid = (@errros == 0))
+      end
+    end
+    protected
+    def build_post_query(options)
+      boundary = "validate-this-content-please"
+      headers = {"Content-type" => "multipart/form-data, boundary=" + boundary + " "}
+      parts = []
+      options.each do |k,v|
+        parts << post_param(k,v)
+      end
+      parts << file_param("uploaded_file","index.html",@html,"text/html")
+      q = parts.map{|p| "--#{boundary}\r\n#{p}"}.join("") + "--#{boundary}--"
+      [q,headers]
+    end
+    def post_param(k,v)
+      "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"\r\n\r\n#{v}\r\n"
+    end
+    def file_param(k,filename,content,mime_type)
+      out = []
+      out << "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"; filename=\"#{filename}\""
+      out << "Content-Transfer-Encoding: binary"
+      out << "Content-Type: #{mime_type}"
+      out.join("\r\n") + "\r\n\r\n" + content + "\r\n"
+    end
+    # Makes request to remote service.
+    def request(method, path, *arguments)
+      result = nil
+      result = http.send(method, path, *arguments)
+      handle_response(result)
+    rescue Timeout::Error => e
+      raise
+    end
+    # Handles response and error codes from remote service.
+    def handle_response(response)
+      case response.code.to_i
+        when 301,302
+          raise "Redirect"
+        when 200...400
+          response
+        when 400
+          raise "Bad Request"
+        when 401
+          raise "Unauthorized Access"
+        when 403
+          raise "Forbidden Access"
+        when 404
+          raise "Rescoure not found"
+        when 405
+          raise "Method not allowed"
+        when 409
+          raise "Rescource conflict"
+        when 422
+          raise "Resource invalid"
+        when 401...500
+          raise "Client error"
+        when 500...600
+          raise "Server error"
+        else
+          raise "Unknown response: #{response.code.to_i}"
+      end
+    end
+    def http
+      site = self.class.validation_uri
+      http = Net::HTTP.new(site.host, site.port)
+  #    http.use_ssl = site.is_a?(URI::HTTPS)
+  #    http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
+      http
+    end
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: html_mockup
+version: !ruby/object:Gem::Version
+  version: 0.3.2
+platform: ruby
+authors:
+- Flurin Egger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2009-11-18 00:00:00 +01:00
+default_executable: mockup
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  type: :runtime
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+    version:
+- !ruby/object:Gem::Dependency
+  name: rack
+  type: :runtime
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    version:
+description:
+email: flurin@digitpaint.nl
+executables:
+- mockup
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- bin/mockup
+- examples/config.ru
+- examples/html/green.gif
+- examples/html/index.html
+- examples/partials/test.part.rhtml
+- examples/script/server
+- lib/html_mockup/cli.rb
+- lib/html_mockup/rack/html_mockup.rb
+- lib/html_mockup/rack/html_validator.rb
+- lib/html_mockup/server.rb
+- lib/html_mockup/template.rb
+- lib/html_mockup/w3c_validator.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/flurin/html_mockup
+licenses: []
+post_install_message:
+rdoc_options:
+- --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:
+rubygems_version: 1.3.5
+signing_key:
+specification_version: 3
+summary: HTML Mockup is a set of tools to create self-containing HTML mockups.
+test_files: []