fuse 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZDNiOTM4NDIyZTA2ZjNkYWQ5MmViMGEwNzZhM2JkZmE1OWYxMGI4MA==
+  data.tar.gz: !binary |-
+    YWY3MmY3YzEyOTY1ZDNhMDIwZTAzMzExN2FlYTMyZDY0NGJjYmYyNA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZmMwNzExMGExNjVmZWEyYjY3ZmM2OTNiYzgwYTcxZGFjY2YzZDdkZTM5MGRj
+    ODI4ZTdmMzBhNDM0OWZkNTQ1M2ZkMDFiZTIzZjkyYTQwNTQwOTdjZmIwYmEz
+    NzlkNGZmMDUwYmM1NDQ3MGY3YmMzNTIyZjExYWQzNWY1Yzc5MDI=
+  data.tar.gz: !binary |-
+    MzJmNDEwOGIzYTBiNGVkMDNjYTk2Y2RlNDIxNWVjNjBhYzZkZjcyNjVkN2M1
+    ODg2YTM1Njc2YjNlNWI4NzkyMTcxNjMzM2E2Y2EzZWYyMmU1NGYxOTQyYjc5
+    YjU4NDE3YjY1NjVkNGI4NTdkMDVkOGYxY2IyMTA0OTk2ZGFkMDQ=

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2013 Neil E. Pearson
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,53 @@
+# Fuse
+
+Portable document authoring. Fuse HTML, JavaScript, CSS, images and fonts into standalone HTML files.
+
+* Drop all your assets in a directory and hit the magic button.
+* Built-in web server based on Thin for authoring your docs.
+* Support for SASS and CoffeeScript.
+* Sprockets-like 'require' syntax for JS and CSS dependency
+* Uses uglify-js to compress JavaScript
+* Simple file naming conventions for font names and CSS media types
+* Transform XML documents on the fly using XSLT
+
+## How to use Fuse
+
+### Authoring
+
+Put some HTML, CSS, JavaScript etc in a directory. `cd` to that directory and run:
+
+```bash
+fuse server
+```
+
+Go to `http://localhost:9460` to view your doc.
+
+### Compiling
+
+When you're happy, from the same directory, run:
+
+```bash
+fuse compile > my_doc.html
+```
+
+Presto.
+
+## Command Line Options
+
+Run `fuse` for a full list of command line options.
+
+Some things you can do from the command line:
+
+* Specify a port for the server
+* Enable/disable asset embedding and/or compression
+* Specify a source document and/or XSL stylesheet
+* Specify the output HTML document's character set
+* Specify an HTML title
+
+## Early days
+
+This gem is truly in its infancy. I'll put in what time I have available. It's also my first gem, so I welcome suggestions, pull requests etc.
+
+## License
+
+Released under [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html). See [LICENSE](LICENSE) for details.

data/bin/fuse

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path '../../lib/fuse', __FILE__
+Fuse.main

data/lib/fuse.rb

@@ -0,0 +1,24 @@
+require 'optparse'
+require 'thin'
+
+module Fuse
+
+  VERSION = '0.1.1'
+
+  def self.root
+    @root ||= File.expand_path File.dirname(__FILE__)
+  end
+
+end
+
+$:.unshift Fuse.root unless $:.include?(Fuse.root)
+
+require 'fuse/main'
+require 'fuse/exceptions'
+require 'fuse/server'
+require 'fuse/document'
+require 'fuse/document/asset'
+require 'fuse/document/asset_types'
+require 'fuse/document/asset_collection'
+
+Fuse.main if $0 == __FILE__

data/lib/fuse/document.rb

@@ -0,0 +1,140 @@
+require 'nokogiri'
+
+class Fuse::Document
+
+  attr_reader :source_path, :xsl_path
+
+  def initialize(options)
+    source = (@options = options)[:source]
+    raise Fuse::Exception::SourceUnknown if source.nil?
+    raise Fuse::Exception::SourceUnknown::NotFound.new(source) unless File.exists?(source)
+    @source_path = expect_one(potential_sources, :source, Fuse::Exception::SourceUnknown)
+    @xsl_path = expect_one(potential_xsl, :xsl, Fuse::Exception::XslMissing) if source_xml?
+  end
+
+  def to_s
+    result.to_html encoding: @options[:encoding]
+  end
+
+  def result
+
+    #todo find a way to transform Nokogiri XML to HTML without serializing
+
+    document = if xsl_path
+      Nokogiri::HTML(Nokogiri::XSLT(File.read xsl_path).transform(Nokogiri::XML(File.read source_path)).to_html encoding: @options[:encoding])
+    else
+      Nokogiri::HTML(File.read source_path)
+    end
+
+    html = document.css('> html').first
+    body = html.css('> body').first
+    head = html.css('> head').first || body.add_previous_sibling(Nokogiri::XML::Node.new 'head', document)
+
+    document.title = @options[:title] unless @options[:title].nil?
+
+    #attach stylesheets and scripts
+    [Fuse::Document::Asset::StyleSheet, Fuse::Document::Asset::JavaScript].each do |klass|
+      collection = assets.of_type(klass).sort!
+      next unless collection.length > 0
+      if @options[:embed_assets]
+        tag = Nokogiri::XML::Node.new(klass::EMBED_WITH, document)
+        raw = collection.map do |asset|
+          tag['type'] = asset.type
+          (@options[:compress_assets] ? asset.compress : asset.filtered).strip
+        end.reject{ |x| x.length == 0 }.join(klass::JOIN_WITH)
+        next unless raw.length > 0
+        tag.content = raw
+        head << tag
+      else
+        collection.each do |asset|
+          data = asset.reference_with
+          tag = Nokogiri::XML::Node.new(data[:tag_name], document)
+          data[:attributes].each { |k, v| tag[k] = v unless v.nil? }
+          head << tag
+        end
+      end
+    end
+
+    #create font stylesheet
+    font_css = ''
+    fonts = {}
+    assets.of_type(Fuse::Document::Asset::Font).each do |asset|
+      (fonts[asset.face] ||= {})[asset.extension.to_sym] = asset
+    end
+    if fonts.length > 0
+      fonts.values.each do |formats|
+        first = formats.values.first
+        font_css << '@font-face{'
+        font_css << 'font-family: "%s";' % first.family
+        font_css << 'font-weight: %s;'   % first.weight
+        font_css << 'font-style: %s;'    % first.style
+        font_css << 'src: url("%s");'    % formats[:eot].relative_path if formats[:eot]
+        css_formats = []
+        Fuse::Document::Asset::Font::CSS_FORMATS.each do |css_format|
+          css_formats << 'url("%s") format("%s")' % [
+              formats[css_format[:extension]].relative_path,
+              css_format[:format]
+          ] if formats[css_format[:extension]]
+        end
+        font_css << 'src: %s;' % css_formats.join(', ') if css_formats.any?
+      end
+    end
+    unless font_css.empty?
+      style_node = head.css('style:not([media]), style[media=all]').first || head.add_child(Nokogiri::XML::Node.new 'style', document)
+      style_node.content = font_css + style_node.content
+    end
+
+    #embed images and fonts
+    if @options[:embed_assets]
+      %w|@src @href @style style|.each do |xpath|
+        document.xpath('//' + xpath).each do |node|
+          assets.of_type(Fuse::Document::Asset::Image, Fuse::Document::Asset::Font).each do |asset|
+            node.content = node.content.gsub asset.relative_path, asset.to_datauri
+          end
+        end
+      end
+    end
+
+    document
+  end
+
+  def root
+    @root ||= File.directory?((opt = @options[:source])) ? opt : File.dirname(opt)
+  end
+
+  private
+
+    def source_xml?
+      source_path.match(/\.xml$/i)
+    end
+
+    def potential_xsl
+      @potential_xsl ||= potentials(:xsl, %w(xsl))
+    end
+
+    def potential_sources
+      @potential_docs ||= begin
+        extensions = %w|html htm|
+        extensions << 'xml' if potential_xsl.any?
+        potentials(:source, extensions)
+      end
+    end
+
+    def potentials(option, extensions)
+      if (option_value = @options[option])
+        raise Fuse::Exception::SourceUnknown::NotFound.new(option_value) unless File.exists?(option_value)
+        return [option_value] unless File.directory? option_value
+      end
+      Dir[File.join(option_value || root, "**/*.{#{extensions.join(',')}}")]
+    end
+
+    def expect_one(list, option, missing_exception)
+      raise missing_exception if list.empty?
+      raise Fuse::Exception::SourceUnknown::TooManySources.new(option, list) if list.length > 1
+      list.first
+    end
+
+    def assets
+      @assets ||= Asset[root]
+    end
+end

data/lib/fuse/document/asset.rb

@@ -0,0 +1,72 @@
+require 'base64'
+
+class Fuse::Document::Asset
+
+  def self.[](dir)
+    assets = Fuse::Document::AssetCollection.new
+    Dir[File.join dir, '**/*.*'].each do |full_path|
+      asset = self.for(full_path[dir.length..-1], dir)
+      assets << asset if asset
+    end
+    assets
+  end
+
+  def self.for(path, root = Dir.pwd)
+    full_path = File.join root, path
+    return unless File.exists? full_path
+    type = TYPES[(File.extname(path)[1..-1] || '').to_sym]
+    (@cache ||= {})[File.expand_path full_path] ||= type.new(path, root) if type
+  end
+
+  attr_reader :path
+
+  def initialize(path, root)
+    @root = root
+    @path = path
+  end
+
+  def full_path
+    @full_path ||= File.join @root, @path
+  end
+
+  def relative_path
+    @relative_path ||= path.sub(%r`^/`, '')
+  end
+
+  def raw
+    @raw ||= File.open(full_path, 'rb') { |f| f.read }
+  end
+
+  def filtered
+    @filtered ||= filter? ? filter : raw
+  end
+
+  def filter?
+    respond_to? :filter
+  end
+
+  def call(env)
+    if filter?
+      body = filter
+      [200, {'Content-Type' => type, 'Content-Length' => body.length.to_s}, [body]]
+    else
+      Rack::File.new(@root).call(env)
+    end
+  end
+
+  def type
+    @type ||= Rack::Mime.mime_type('.' + extension)
+  end
+
+  def to_datauri(compress = false)
+    'data:%s;base64,%s' % [
+        type,
+        Base64.strict_encode64(compress && respond_to?(:compress) ? self.compress : raw)
+    ]
+  end
+
+  def extension
+    @extension ||= File.extname(path).downcase[1..-1]
+  end
+
+end

data/lib/fuse/document/asset_collection.rb

@@ -0,0 +1,33 @@
+class Fuse::Document::AssetCollection < Array
+
+  def of_type(*types)
+    self.class.new select { |a|
+      ret = types.include? a.class
+      types.each { |type| ret ||= a.is_a? type } unless ret
+      ret
+    }
+  end
+
+  def sort!
+    unsorted = Array.new(self)
+    clear
+    unsorted.each { |a| push_with_dependents a }
+    self
+  end
+
+  def sort
+    self.class.new(self).sort!
+  end
+
+  def <<(*args)
+    args.each { |arg| super(arg) unless include? arg }
+    self
+  end
+
+  def push_with_dependents(asset)
+    #todo check for circular references
+    asset.dependents.each { |d| push_with_dependents d }
+    self << asset
+  end
+
+end

data/lib/fuse/document/asset_types.rb

@@ -0,0 +1,145 @@
+require 'sass'
+require 'coffee-script'
+require 'uglifier'
+
+class Fuse::Document::Asset
+
+  module HasDependents
+    COMMENT_PATTERN = %r`^\s*(/\*[\s\S]*?\*/|(\s*//.*\s+)+)`
+    REQUIRE_PATTERN = %r`^\s*(?:\*|//)=\s+(require|require_glob)\s+(.+?)\s*$`
+
+    def dependents
+      ret = Fuse::Document::AssetCollection.new
+      local_root = File.dirname(full_path)
+      if (comments = raw[COMMENT_PATTERN])
+        comments.lines.each do |line|
+          if (match = REQUIRE_PATTERN.match(line))
+            case match[1]
+              when 'require'
+                [File.join(local_root, match[2])]
+              when 'require_glob'
+                Dir[File.join(local_root, match[2])]
+              else
+                []
+            end.map do |p|
+              Fuse::Document::Asset.for(p[@root.length..-1], @root)
+            end.reject do |p|
+              p.nil?
+            end.each do |p|
+              ret << p
+            end
+          end
+        end
+      end
+      ret
+    end
+  end
+
+  class StyleSheet < self
+    EMBED_WITH = 'style'
+    JOIN_WITH = ''
+    MEDIA_PATTERN = /\(([a-z]+(?:,\s*[a-z]+)*)\)\.[a-z]+$/i
+    include HasDependents
+    def reference_with
+      {
+          tag_name: 'link',
+          attributes: {
+              rel: 'stylesheet',
+              href: relative_path,
+              media: media
+          }
+      }
+    end
+    def media
+      @media ||= (match = MEDIA_PATTERN.match(path)) && match[1].split(/,\s*/).sort.join(', ')
+    end
+    def compress; ::Sass.compile raw, style: :compressed end
+    def type; 'text/css' end
+    class Sass < self
+      def filter; ::Sass.compile raw, style: :expanded end
+    end
+  end
+
+  class JavaScript < self
+    EMBED_WITH = 'script'
+    JOIN_WITH = ';'
+    include HasDependents
+    def reference_with
+      {
+          tag_name: 'script',
+          attributes: {
+              type: type,
+              src: relative_path
+          }
+      }
+    end
+    def compress; Uglifier.compile filtered end
+    def type; 'text/javascript' end
+    class Coffee < self
+      def filter; CoffeeScript.compile raw end
+    end
+  end
+
+  class Image < self
+  end
+
+  class Font < self
+    CSS_FORMATS = [
+        { extension: :woff, format: 'woff' },
+        { extension: :ttf,  format: 'truetype' },
+        { extension: :otf,  format: 'opentype' }
+    ]
+    MIME_TYPES = {
+        otf: 'application/x-font-opentype',
+        ttf: 'application/x-font-truetype',
+    }
+    VARIANT_PATTERN = %r`([^/]+?)(?:[-_ ](normal|bold|bolder|lighter|[1-9]00))?(?:[-_ ](normal|italic|oblique))?\.[a-z]+$`
+    def family; @family ||= variant[:family] end
+    def weight; @weight ||= variant[:weight] end
+    def style;  @style  ||= variant[:style]  end
+    def variant
+      @variant ||= begin
+        match = VARIANT_PATTERN.match(path)
+        {
+            family: match[1],
+            weight: match[2] || 'normal',
+            style:  match[3] || 'normal'
+        }
+      end
+    end
+    def face; @face ||= [family, weight, style].join('-') end
+    def type
+      MIME_TYPES[extension.to_sym] || super
+    end
+  end
+
+  class Xml < self
+  end
+
+  class Xsl < self
+  end
+
+  class Html < self
+  end
+
+  TYPES = {
+      css:    StyleSheet,
+      scss:   StyleSheet::Sass,
+      sass:   StyleSheet::Sass,
+      js:     JavaScript,
+      coffee: JavaScript::Coffee,
+      jpg:    Image,
+      jpeg:   Image,
+      png:    Image,
+      gif:    Image,
+      svg:    Image,
+      ttf:    Font,
+      woff:   Font,
+      eot:    Font,
+      otf:    Font,
+      xml:    Xml,
+      xsl:    Xsl,
+      htm:    Html,
+      html:   Html
+  }
+end

data/lib/fuse/exceptions.rb

@@ -0,0 +1,25 @@
+class Fuse::Exception < ::RuntimeError
+  class SourceUnknown < self
+    class TooManySources < self
+      attr_reader :option_name, :options
+      def initialize(option_name, options)
+        @option_name = option_name
+        @options = options
+      end
+    end
+    class NotFound < self
+      attr_reader :path
+      def initialize(path)
+        @path = path
+      end
+      def message; "Couldn't find '#{path}'." end
+    end
+    def message; 'Couldn\'t determine source document. Please specify one with --source.' end
+  end
+  class XslMissing
+    def message
+      'Couldn\'t locate an XSL stylesheet to transform the source document. Please specify one with --xsl.'
+    end
+  end
+  def message; end
+end

data/lib/fuse/main.rb

@@ -0,0 +1,129 @@
+require 'optparse'
+require 'thin'
+
+module Fuse
+
+  DEFAULTS = {
+    common: {
+      source: '.',
+      encoding: 'UTF-8'
+    },
+    server: {
+        port: 9460,
+        embed_assets: false
+    },
+    compile: {
+        embed_assets: true,
+        compress_assets: true
+    }
+  }
+
+  def self.main
+
+    options = {}
+
+    options_parser = OptionParser.new do |opts|
+
+      opts.banner = 'Usage: fuse [command] [options]'
+      opts.separator ''
+      opts.separator 'Commands:'
+      opts.separator '    server  : Run a local testing server'
+      opts.separator '    compile : Compile the document and send to STDOUT'
+      opts.separator ''
+      opts.separator 'Options:'
+
+      opts.on('-c',
+              '--[no-]compress-assets',
+              'Compress assets.'
+      ) do |compress|
+        options[:compress_assets] = compress
+      end
+
+      opts.on('-e',
+              '--encoding CHARSET',
+              "Output encoding. Default is #{DEFAULTS[:common][:encoding]}."
+      ) do |e|
+        options[:encoding] = e
+      end
+
+      opts.on('-m',
+              '--[no-]embed-assets',
+              'Embed assets.'
+      ) do |embed|
+        options[:embed_assets] = embed
+      end
+
+      opts.on('-p',
+              '--port PORT',
+              Integer,
+              "Port on which to listen (only with 'server' command). Default is #{DEFAULTS[:server][:port]}."
+      ) do |port|
+        options[:port] = port
+      end
+
+      opts.on('-s',
+              '--source [FILE|DIR]',
+              'The source directory, or HTML or XML document. Default is current directory.'
+      ) do |doc|
+        options[:source] = doc
+      end
+
+      opts.on('-t',
+              '--title TITLE',
+              'HTML document title.'
+      ) do |t|
+        options[:title] = t
+      end
+
+      opts.on('-x',
+              '--xsl FILE',
+              'XSL transformation stylesheet. Default is current directory.'
+      ) do |xsl|
+        abort "#{xsl} isn't a valid XSL stylesheet" unless xsl.match(/\.xsl$/i)
+        options[:xsl] = xsl
+      end
+
+      opts.on_tail('-h', '--help', 'Show this message.') { puts opts.to_s }
+
+    end
+
+    options_parser.parse!
+
+    options = merge_defaults(options)
+
+    case ARGV[0]
+
+      when 'server'
+        Thin::Server.start('0.0.0.0', options[:port]) do
+          use Rack::ShowExceptions
+          run Server.new(options)
+        end
+
+      when 'compile'
+        begin
+          print Document.new(options).to_s
+        rescue Exception::SourceUnknown::TooManySources
+          $stderr.puts "Found more than one potential #{$!.option_name} document. Please specify one with --#{$!.option_name}."
+          $stderr.puts $!.options.join "\n"
+        rescue Exception
+          $!.message ? $stderr.puts($!.message) : raise
+        end
+
+      else
+        puts options_parser
+
+    end
+
+  end
+
+  private
+
+    def self.merge_defaults(options)
+      if (defaults = DEFAULTS[(ARGV[0] || '').to_sym])
+        defaults.merge(DEFAULTS[:common]).merge(options)
+      else
+        options
+      end
+    end
+
+end

data/lib/fuse/server.rb

@@ -0,0 +1,71 @@
+require 'nokogiri'
+
+class Fuse::Server
+
+  def initialize(options)
+    @options = options
+  end
+
+  def call(env)
+
+    @env = env
+
+    call_options = @options.merge Hash[request.GET.map{ |k, v| [k.to_sym, v] }]
+
+    if (asset = Fuse::Document::Asset.for(request.path, File.directory?(@options[:source]) ? @options[:source] : File.dirname(@options[:source])))
+      return asset.call(env)
+    end
+
+    begin
+      doc = Fuse::Document.new(call_options)
+    rescue Fuse::Exception::SourceUnknown::TooManySources
+      doc = render_list($!.options, $!.option_name)
+    rescue Fuse::Exception
+      if $!.message
+        doc = render_error($!.message)
+      else
+        raise
+      end
+    end
+
+    [200, {'Content-Type' => 'text/html'}, [doc.to_s]]
+
+  end
+
+  private
+
+    def request
+      Rack::Request.new(@env)
+    end
+
+    def render_error(text)
+      render_body do |h|
+        h.p { h.text text }
+      end
+    end
+
+    def render_list(assets, key)
+      render_body do |h|
+        h.h3 { h.text "Choose #{key}:" }
+        h.ul {
+          assets.each do |asset|
+            h.li {
+              h.a(href: '?' + Rack::Utils.build_query(request.GET.merge(key.to_s => asset))) {
+                h.text asset
+              }
+            }
+          end
+        }
+      end
+    end
+
+    def render_body
+      Nokogiri::HTML::Builder.new do |h|
+        h.html {
+          h.head { h.title { h.text 'Fuse' } }
+          h.body { yield h }
+        }
+      end.to_html
+    end
+
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: fuse
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Neil E. Pearson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: uglifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.6
+- !ruby/object:Gem::Dependency
+  name: coffee-script
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: sass
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.5
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+description: ! 'Portable document authoring. Fuse HTML, JavaScript, CSS, images and
+  fonts into standalone HTML files.
+
+'
+email: neil@helium.net.au
+executables:
+- fuse
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/fuse
+- lib/fuse/document/asset.rb
+- lib/fuse/document/asset_collection.rb
+- lib/fuse/document/asset_types.rb
+- lib/fuse/document.rb
+- lib/fuse/exceptions.rb
+- lib/fuse/main.rb
+- lib/fuse/server.rb
+- lib/fuse.rb
+- README.md
+- LICENSE
+homepage: https://github.com/hx/fuse
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Fuse HTML, CSS, JavaScript, Fonts and Images into a single file.
+test_files: []