RubyGems - bloggit - Versions diffs - 1.0.3 - Mend

bloggit 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (423) hide show

data/lib/bloggit/client/templates/json.rhtml ADDED Viewed

@@ -0,0 +1,5 @@
+{
+	uri: "<%= req.path_info %>",
+	length:  <%= @count %>,
+	results: <%= @data %>
+}

data/lib/bloggit/client/templates/main.rhtml ADDED Viewed

@@ -0,0 +1,109 @@
+<html>
+	<head>
+		<title><%= site.title %> :: Bloggit</title>
+		<style>
+			HTML, BODY {
+				font: normal 12px Verdana;
+				margin: 0; padding: 0;
+				border: 0 none;
+				overflow: hidden;
+				height: 100%;
+			}
+		</style>
+		<link rel="stylesheet" type="text/css" href="/scripts/resources/css/ext-all.css" />
+	 	<script type="text/javascript" src="/scripts/adapter/jquery/jquery.js"></script>
+	 	<script type="text/javascript" src="/scripts/adapter/jquery/jquery-plugins.js"></script>
+	 	<script type="text/javascript" src="/scripts/adapter/jquery/ext-jquery-adapter.js"></script>
+	 	<script type="text/javascript" src="/scripts/ext-all.js"></script>
+	 	<script type="text/javascript" src="/scripts/app.js"></script>
+		<style>
+			.x-layout-panel-south, x-layout-panel-north {
+				background-color: #c9defa !important;
+			}
+		</style>
+	</head>
+	<body>
+		<div id="container">
+			<div id="tab-pages">
+				<div id="pages-tb">
+					+ New Page,
+					- Delete (selected)
+				</div>
+				<div id="pages-grid">
+					Pages Grid
+				</div>
+				<div>Splitter?</div>
+				<div>Content Editor</div>
+				<div>Extra Info? (tags, title, slug, etc)</div>
+			</div>
+			<div id="tab-posts">
+				<div id="posts-tb"></div>
+				<div id="posts-grid" style="height:500">
+					Posts Grid
+				</div>
+				<div>
+					Splitter?
+				</div>
+				<div>
+					Content Editor (title, slug, publish data, status, etc)
+				</div>
+			</div>
+			<div id="tab-themes">
+				<div id="themes-tb">
+					+ New Theme
+				</div>
+				<div>
+					Theme Tree
+				</div>
+				<div>
+					Theme Editor
+				</div>
+			</div>
+			<div id="tab-plugins">
+				<div id="plugins-tb">
+					+ New Plugin,
+					- Disable (selected)
+				</div>
+				<div>
+					Plugin Tree
+				</div>
+				<div>
+					Plugin Editor
+				</div>
+			</div>
+			<div id="tab-media">
+				<div id="media-tb">
+					+ New Media,
+					- Delete (selected)
+				</div>
+				<div>
+					Media Tree View
+				</div>
+				<div>
+					Media Preview (?)
+				</div>
+			</div>
+			<div id="tab-settings">
+				Settings
+			</div>
+			<div id="tab-preview">
+				<div id="preview-tb">
+					@ Refresh,
+					# Regenerate
+				</div>
+				<div>
+					Preview IFRAME
+				</div>
+			</div>
+			<div id="site-header">
+				Bloggit <%= Bloggit::VERSION %>
+			</div>
+			<div id="home-page">
+				At your service, my dear.
+			</div>
+			<div id="status-bar">
+				Ready.
+			</div>
+		</div>
+	</body>
+</html>

data/lib/bloggit/commandline.rb ADDED Viewed

@@ -0,0 +1,52 @@
+require 'fileutils'
+require 'cmdparse'
+module Bloggit
+  module Cmdline
+    class << self
+      def commands
+        @commands ||= []
+      end
+      attr_accessor :verbose
+      def register(&block)
+        commands << block
+      end
+      def build(cmd, site=nil)
+        commands.each do |block|
+          block.call(cmd, site)
+        end
+      end
+      def execute
+        cmd = CmdParse::CommandParser.new( true, true )
+        Bloggit::Cmdline.verbose = false
+        cmd.program_name = "bloggit"
+        cmd.program_version = Bloggit::RELEASE_INFO
+        cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+          opt.separator "Global options:"
+          opt.on("--verbose", "Be verbose when outputting info") {|t| Bloggit::Cmdline.verbose = true }
+        end
+        #puts "Loading commands from #{File.join( File.dirname(__FILE__), 'commands', '*.rb')} (#{Bloggit::Cmdline.verbose})"
+        Dir[ File.join( File.dirname(__FILE__), 'commands', '*.rb') ].each do |command|
+          require command
+        end
+        site = Dir.getwd.ends_with?('.blog') ? Bloggit::Site.from_file(Dir.getwd) : nil
+        Cmdline.build( cmd, site )
+        cmd.add_command( CmdParse::HelpCommand.new )
+        cmd.add_command( CmdParse::VersionCommand.new )
+        cmd.parse
+      end
+    end
+  end
+end

data/lib/bloggit/commands/page_cmd.rb ADDED Viewed

@@ -0,0 +1,17 @@
+Bloggit::Cmdline.register do |cmd, site|
+  unless site.nil?
+    page_cmd = CmdParse::Command.new( 'page', true, true )
+    page_cmd.short_desc = "Page Management"
+    cmd.add_command( page_cmd )
+    add_page = CmdParse::Command.new( 'new', false )
+    add_page.short_desc = "Create a new page"
+    add_page.set_execution_block do |args|
+      page = Bloggit::Page.to_file(args.to_s)
+      puts "#{page.filename} created."
+    end
+    page_cmd.add_command( add_page )
+  end
+end

data/lib/bloggit/commands/plugin_cmd.rb ADDED Viewed

@@ -0,0 +1,89 @@
+Bloggit::Cmdline.register do |cmd, site|
+  unless site.nil?
+    plugin_cmd = CmdParse::Command.new( 'plugin', true, true )
+    plugin_cmd.short_desc = "Plugin Management"
+    cmd.add_command( plugin_cmd )
+    new_plugin = CmdParse::Command.new( 'new', false )
+    new_plugin.short_desc = "Create a new plugin"
+    new_plugin.set_execution_block do |args|
+      #page = Bloggit::Page.to_file(args.to_s)
+    end
+    plugin_cmd.add_command( new_plugin )
+  end
+end
+PLUGIN_BOILERPLATE =<<EOF
+# = Examples for creating your own plugins...
+include Bloggit
+# = Registering the plugin to retrieve settings from settings.yml
+Plugin.register :example do |settings|
+  # this will read from the settings.yml under plugins.example
+  #  $username = settings.fetch('username', '')
+end
+# = Registering custom tags in the template engine
+#
+# This will register the tag `example` for use in any template page
+# (including layouts). Example usage of this tag:
+#
+#   <%= example :version %>
+#
+# Output:
+#
+#  Bloggit 1.0.0
+#
+Template.register_tag :example do |*args|
+  kind, opts = args
+  opts ||= {}
+  case kind
+    when :version
+      "Bloggit "+ Bloggit::RELEASE_INFO
+    else
+      "Unknown tag "+ kind
+  end
+end
+# = Responding to application events...
+Bloggit::on_event(:after_generate) do |site, cache_dir|
+  # puts "I'm called after the rest of the site has been generated..."
+end
+# = Adding a command line tool...
+Cmdline.register do |cmd, site|
+   example_cmd = CmdParse::Command.new( 'example', true, true )
+   example_cmd.short_desc = "Example tool from plugin"
+   cmd.add_command( example_cmd )
+   sub_cmd = CmdParse::Command.new( 'sub', false )
+   sub_cmd.short_desc = "A sub command"
+   sub_cmd.set_execution_block do |args|
+     puts "Sub-command has been called, w00t!"
+   end
+   example_cmd.add_command( sub_cmd )
+end
+# = Registering a custom text format:
+begin
+  require 'rdoc/markup/simple_markup'
+  require 'rdoc/markup/simple_markup/to_html'
+  Bloggit::TextFormatter.register :rdoc do |text|
+    p = SM::SimpleMarkup.new
+    h = SM::ToHtml.new
+    p.convert(text, h)
+  end
+rescue LoadError
+  puts "There was an error registering the :rdoc text format:"+ $!
+end
+EOF

data/lib/bloggit/commands/post_cmd.rb ADDED Viewed

@@ -0,0 +1,17 @@
+Bloggit::Cmdline.register do |cmd, site|
+  unless site.nil?
+    post_cmd = CmdParse::Command.new( 'post', true, true )
+    post_cmd.short_desc = "Post Management"
+    cmd.add_command( post_cmd )
+    add_post = CmdParse::Command.new( 'new', false )
+    add_post.short_desc = "Create a new blog post"
+    add_post.set_execution_block do |args|
+      post = Bloggit::Post.to_file(args.to_s)
+      puts "#{post.filename} created."
+    end
+    post_cmd.add_command( add_post )
+  end
+end

data/lib/bloggit/commands/site_cmd.rb ADDED Viewed

@@ -0,0 +1,82 @@
+Bloggit::Cmdline.register do |cmd, site|
+  site_cmd = CmdParse::Command.new( 'site', true, true )
+  site_cmd.short_desc = "Site Management"
+  cmd.add_command( site_cmd )
+  if site.nil?
+    new_site = CmdParse::Command.new( 'new', false )
+    new_site.short_desc = "Create a site bundle"
+    new_site.set_execution_block do |args|
+      raise "Site name required!" if args.to_s.empty?
+      name = args.to_s
+      bundle_name = "#{name}.blog"
+      current_dir = Dir.getwd
+      bundle_path = File.join(current_dir, bundle_name)
+      boiler_path = File.expand_path File.join( File.dirname(__FILE__), '..', 'boilerplate')
+      FileUtils.mkdir_p( bundle_path, :verbose=>false)
+      FileUtils.cp_r( Dir.glob(File.join(boiler_path, '*')), bundle_path, :verbose=>false)
+      # After the boilerplate copy... Make sure all the folders are there
+      dirs = [
+        File.join(current_dir, bundle_name, 'cache'),
+        File.join(current_dir, bundle_name, 'media'),
+        File.join(current_dir, bundle_name, 'pages'),
+        File.join(current_dir, bundle_name, 'posts'),
+        File.join(current_dir, bundle_name, 'plugins'),
+        File.join(current_dir, bundle_name, 'themes', 'default', 'images'),
+        File.join(current_dir, bundle_name, 'themes', 'default', 'styles'),
+        File.join(current_dir, bundle_name, 'themes', 'default', 'scripts'),
+        File.join(current_dir, bundle_name, 'themes', 'default', 'templates', 'layouts'),
+        File.join(current_dir, bundle_name, 'themes', 'default', 'templates', 'snippets')
+      ]
+      dirs.each do |path|
+        FileUtils.mkdir_p( path, :verbose=>false)
+      end
+      puts "#{bundle_name} created."
+    end
+    site_cmd.add_command( new_site )
+  else
+    gen_site = CmdParse::Command.new( 'generate', false )
+    gen_site.short_desc = "Generates site HTML in cache/ directory"
+    gen_site.set_execution_block do |args|
+      pub = Bloggit::Generator.new(site, Bloggit::Cmdline.verbose)
+      pub.generate_cache
+    end
+    site_cmd.add_command( gen_site )
+    # publish too?
+    pub_site = CmdParse::Command.new( 'publish', false )
+    pub_site.short_desc = "Uploads the HTML from cache/ to target server"
+    pub_site.set_execution_block do |args|
+      pub = Bloggit::Publisher.new(site, Bloggit::Cmdline.verbose)
+      pub.upload
+    end
+    site_cmd.add_command( pub_site )
+    # cleanup
+    cleanup_cache = CmdParse::Command.new( 'cleanup', false )
+    cleanup_cache.short_desc = "Removes files from cache/ directory"
+    cleanup_cache.set_execution_block do |args|
+      pub = Bloggit::Generator.new(site, Bloggit::Cmdline.verbose)
+      pub.cleanup_cache
+    end
+    site_cmd.add_command( cleanup_cache )
+  end
+end

data/lib/bloggit/commands/theme_cmd.rb ADDED Viewed

@@ -0,0 +1,16 @@
+Bloggit::Cmdline.register do |cmd, site|
+  unless site.nil?
+    theme_cmd = CmdParse::Command.new( 'theme', true, true )
+    theme_cmd.short_desc = "Theme Management"
+    cmd.add_command( theme_cmd )
+    new_theme = CmdParse::Command.new( 'new', false )
+    new_theme.short_desc = "Create a new theme"
+    new_theme.set_execution_block do |args|
+      #page = Bloggit::Page.to_file(args.to_s)
+    end
+    theme_cmd.add_command( new_theme )
+  end
+end

data/lib/bloggit/etc/hash.rb ADDED Viewed

@@ -0,0 +1,24 @@
+class Hash
+  # Extends a hash so that it can be used like an object in a template context (e.g. +hash.key+)
+  def method_missing(name, *args)
+    if name.to_s.ends_with? '='
+      name = name.to_s[0..-2]
+      self[name] = args[0]
+    else
+      if self.has_key? name.to_s
+        self[name.to_s]
+      elsif self.has_key? name.to_sym
+        self[name.to_sym]
+      else
+        super(name,*args)
+      end
+    end
+  end
+  # Returns the binding so you can retrieve values from it...
+  def get_binding
+    binding
+  end
+end

data/lib/bloggit/etc/string.rb ADDED Viewed

@@ -0,0 +1,5 @@
+class String
+  def to_slug
+    self.downcase.gsub( /[^-a-z0-9~\s\.:;+=_]/, '').gsub(/[\s\.:;=_+]+/, '-').gsub(/[\-]{2,}/, '-').to_s
+  end
+end

data/lib/bloggit/generator.rb ADDED Viewed

@@ -0,0 +1,331 @@
+# See Bloggit::Generator
+module Bloggit
+  # = Generator
+  class Generator
+    attr_reader :site, :cache_dir, :template_dir, :errors
+    def initialize(site, verbose=false)
+      @v = verbose
+      @site = site
+      @cache_dir = File.join(site.base_path, 'cache')
+      @blog_root = site.blog_path # settings.fetch('blog_root', '')
+      @site_home = site.home_page # settings.fetch('homepage', 'blog')
+      Template.config { |t| t.site = @site }
+    end
+    def cleanup_cache(opts={})
+      Bloggit::fire_event(:before_cleanup)
+      puts_if_verbose "Cleaning up files from cache folder..."
+      FileUtils.rm_rf Dir.glob( File.join(@cache_dir, '*') )
+      puts_if_verbose "Done."
+    rescue
+      puts "Done with errors:\n\n#{$!}"
+    ensure
+      Bloggit::fire_event(:after_cleanup)
+    end
+    def generate_cache(opts={})
+      @errors = {}
+      errs = Bloggit::fire_event(:before_generate, @site, @cache_dir)
+      @errors.merge!(errs) if errs.is_a?( Hash )
+      puts_if_verbose "Blog generation..."
+      gen_homepage(site.latest_posts)
+      if @site.blog_path != ''
+        create_folder site.blog_path
+        gen_inline_archive(site.latest_posts, :path=>@site.build_post_path('index.html'))
+      end
+      post_yrs = site.posts.group_by &:post_year
+      post_yrs.each do |year, posts_in_year|
+        create_folder @site.blog_path, year.to_s
+        gen_year_archive year, posts_in_year
+        post_mths = posts_in_year.group_by &:post_month
+        post_mths.each do |month, posts_in_month|
+          create_folder @site.blog_path,  year.to_s, month.to_s
+          gen_month_archive year, month, posts_in_month
+          posts_in_month.each do |post|
+            gen_post(post)
+          end
+        end
+      end
+      if site.has_tags?
+        create_folder 'tags'
+        gen_tags_archive(site.tags)
+        site.tags.each do |tag|
+          gen_tag_archive(tag)
+        end
+      end
+      puts_if_verbose "News feed..."
+      gen_news_feed(site.posts)
+      puts_if_verbose "Static page generation..."
+      site.pages.each do |page|
+        gen_page(page)
+      end
+      puts_if_verbose "Copying media files..."
+      media_root = File.join(site.base_path, 'media')
+      FileUtils.cp_r media_root, cache_dir, :verbose=>false
+      puts_if_verbose "Copying '#{site.theme}' theme files..."
+      create_folder 'theme'
+      theme_root = File.join(site.base_path, 'themes', site.theme)
+      theme_dirs = []
+      %w(images scripts styles).each {|dir| theme_dirs << File.join(theme_root, dir) }
+      FileUtils.cp_r theme_dirs, File.join(cache_dir, 'theme'), :verbose=>false
+      errs = Bloggit::fire_event(:after_generate, @site, @cache_dir)
+      @errors.merge!(errs) if errs.is_a?( Hash )
+      errs = Bloggit::fire_event(:before_finish, @site, @cache_dir)
+      @errors.merge!(errs) if errs.is_a?( Hash )
+      puts_if_verbose "Generating cache checksum..."
+      generate_checksums
+      puts_if_verbose ''
+      if @errors.keys.length == 0
+        puts "Done."
+        true
+      else
+        puts "Done with errors:"
+        @errors.each do |err, items|
+          puts ">>> #{err}:"
+          items.each do |item|
+            puts "    - #{item}"
+          end
+        end
+        false
+      end
+    end
+    def generate_checksums
+      checksum_data = Bloggit::Checksum.generate_from(cache_dir)
+      File.open( File.join(cache_dir, 'checksum.yml'), 'w' ) do |f|
+        f.write checksum_data.to_yaml
+      end
+    rescue
+      report_error('checksum.yml')
+    end
+    # Individual object generators...
+    def gen_post(post)
+      ctx = {
+        'post' => post,
+        'site' => @site
+      }
+      render_template :post, post.permalink, ctx
+      puts_if_verbose "  - #{post.permalink}"
+    rescue
+      report_error(post.permalink || '??')
+    end
+    def gen_page(page)
+      ctx = {
+        'page' => page,
+        'site' => @site
+      }
+      render_template :page, "#{page.slug}.html", ctx
+      puts_if_verbose "  - #{page.permalink}"
+    rescue
+      report_error(page.permalink || '??')
+    end
+    def gen_homepage(posts, opts={})
+      opts.posts = posts
+      opts.grouped_posts = opts.posts.group_by(&:publish_date)
+      opts.site = @site
+      path = opts.fetch(:path, 'index.html')
+      render_template :home, path, opts
+      puts_if_verbose "  - #{path}"
+    rescue
+      report_error(path)
+    end
+    def gen_inline_archive(posts, opts={})
+      opts.posts = posts
+      opts.grouped_posts = opts.posts.group_by(&:publish_date)
+      opts.site = @site
+      opts.mode = :inline
+      path = opts.fetch(:path, 'index.html')
+      render_template :archive, path, opts
+      puts_if_verbose "  - #{path}"
+    rescue
+      report_error(path)
+    end
+    def gen_year_archive(year, posts, opts={})
+      opts[:type] = :posts
+      opts[:mode] = :list
+      opts[:year] = year
+      opts[:posts] = posts
+      opts[:grouped_posts] = posts.group_by(&:post_month)
+      opts[:path] = @site.build_post_path( "#{year}/index.html" )
+      gen_archives(opts)
+      puts_if_verbose "  - #{opts[:path]}"
+    rescue
+      report_error( opts[:path] )
+    end
+    def gen_month_archive(year, month, posts, opts={})
+      opts[:type] = :posts
+      opts[:mode] = :inline
+      opts[:year] = year
+      opts[:month] = month
+      opts[:posts] = posts
+      opts[:path] = @site.build_post_path( "#{year}/#{month}/index.html" )
+      gen_archives(opts)
+      puts_if_verbose "  - #{opts[:path]}"
+    rescue
+      report_error(opts[:path])
+    end
+    def gen_tags_archive(tags, opts={})
+      opts.mode = :all_tags
+      opts.tags = tags
+      opts.site = @site
+      render_template :tag_archive, 'tags/index.html', opts
+      puts_if_verbose "  - tags/index.html"
+    rescue
+      report_error("tags/index.html")
+    end
+    def gen_tag_archive(tag, opts={})
+      opts.mode = :single_tags
+      opts.tag = tag
+      opts.site = @site
+      render_template :tag_archive, "tags/#{tag.slug}.html", opts
+      puts_if_verbose "  - tags/#{tag.slug}.html"
+    rescue
+      report_error("tags/#{tag.slug}.html")
+    end
+    def gen_archives(opts={})
+      opts.reverse_merge! :type=>:posts, :mode=>:inline, :path=>'index.html', :site=>@site
+      render_template :archive, opts[:path], opts
+    end
+    def gen_news_feed(posts)
+      feed_type = @site.settings.syndication.fetch('type', 'rss')
+      limit = @site.settings.syndication.fetch('number_of_entries', 10)
+      target_posts = posts[0..limit]
+      File.open(  File.join(cache_dir, @site.settings.syndication.filename), 'w') do |f|
+        case feed_type
+        when 'rss': gen_rss_feed(target_posts, f)
+        when 'atom': gen_atom_feed(target_posts, f)
+        end
+      end
+      puts_if_verbose "  - #{site.settings.syndication.filename} (#{feed_type})"
+    rescue
+      report_error("#{site.settings.syndication.filename} (#{feed_type})")
+    end
+    def gen_atom_feed(posts, io_obj)
+      tmpl = Template.from_text('')
+      Template.folder_depth = 0
+      xml = Builder::XmlMarkup.new( :target=>io_obj, :indent=>2 )
+      #xml.instruct! 'xml-stylesheet', :href=>'/stylesheets/atom.css', :type=>'text/css'
+      xml.feed :xmlns=>'http://www.w3.org/2005/Atom' do
+        xml.div :xmlns=>'http://www.w3.org/1999/xhtml', :class=>'info' do
+         xml << <<-EOF
+           This is an Atom formatted XML site feed.
+           It is intended to be viewed in a Newsreader or syndicated to another site.
+           Please visit <a href="http://www.atomenabled.org/">atomenabled.org</a> for more info.
+         EOF
+        end
+        xml.title   @site.title
+        xml.link    :rel=>'self', :href=>@site.absolute_path_to(:feed)
+        xml.link    :href=>@site.absolute_path_to(:home)
+        xml.id      :href=>@site.absolute_path_to(:home)
+        xml.updated posts.first.publish_date.strftime("%a, %d %b %Y %H:%M:%S %z")
+        xml.author  { xml.name @site.author }
+        posts.each do |post|
+          xml.entry do
+            xml.title   post.title
+            xml.link    :href=>@site.absolute_path_to(post)
+            xml.id      atom_id_for(post)
+            xml.updated post.publish_date.strftime("%a, %d %b %Y %H:%M:%S %z")
+            xml.author  { xml.name @site.author }
+            # xml.summary entry.summary
+            xml.content post.render_content(tmpl.render_binding), :type=>'html'
+          end
+        end
+      end
+    end
+    def gen_rss_feed(posts, io_obj)
+      tmpl = Template.from_text('')
+      Template.folder_depth = 0
+      xml = Builder::XmlMarkup.new( :target=>io_obj, :indent=>2 )
+      xml.instruct! :xml, :version=>"1.0"
+      xml.rss(:version=>"2.0"){
+        xml.channel{
+          xml.title( @site.title() )
+          xml.link( @site.absolute_path_to(:home) )
+          xml.description(site.subtitle)
+          xml.language('en-us')
+            for post in posts
+              xml.item do
+                xml.title(post.title)
+                xml.category(post.tags.join(', '))
+                xml.description(post.render_content(tmpl.render_binding))
+                xml.pubDate(post.publish_date.strftime("%a, %d %b %Y %H:%M:%S %z"))
+                xml.link(site.absolute_path_to(post))
+                xml.guid(site.absolute_path_to(post))
+              end
+            end
+        }
+      }
+    end
+  private
+    def puts_if_verbose(msg='')
+      puts(msg) if @v
+    end
+    def report_error(affected_item)
+      err_msg = $!.to_s
+      @errors[err_msg] ||= []
+      @errors[err_msg] << affected_item
+      puts_if_verbose "  x #{affected_item}"
+    end
+    def create_folder(*folder_names)
+      folder_names.delete_if {|p| p=="" }
+      full_path = [cache_dir, folder_names].flatten
+      FileUtils.mkdir_p File.join(*full_path), :verbose=>false
+    end
+    def atom_id_for(post)
+      base_url = @site.settings.syndication.fetch('base_url', 'no-name.com').gsub('http://', '')
+      "tag:#{base_url},#{post.publish_date.strftime('%Y-%m-%d')}:#{post.permalink}"
+    end
+    def render_template(template, path, ctx={})
+      output = Template.render(template, File.dirname(path), ctx)
+      File.open(  File.join(cache_dir, path), 'w') do |f|
+        f.write output
+      end
+    end
+  end
+end