hoshi 0.0.186

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+
+spec = Gem::Specification.new { |s|
+	s.platform = Gem::Platform::RUBY
+
+	s.author = "Pete Elmore"
+	s.email = "pete.elmore@gmail.com"
+	s.files = Dir["{lib,doc,bin,ext}/**/*"].delete_if {|f| 
+		/\/rdoc(\/|$)/i.match f
+	} + %w(Rakefile)
+	s.require_path = 'lib'
+	s.has_rdoc = true
+	s.extra_rdoc_files = Dir['doc/*'].select(&File.method(:file?))
+	s.extensions << 'ext/extconf.rb' if File.exist? 'ext/extconf.rb'
+	Dir['bin/*'].map(&File.method(:basename)).map(&s.executables.method(:<<))
+
+	s.name = 'hoshi'
+	s.rubyforge_project = 'hoshi-view'
+	s.summary = "Nice, object-oriented, first-class views."
+	s.homepage = "http://debu.gs/#{s.name}"
+	%w(metaid hpricot).each &s.method(:add_dependency)
+	s.version = '0.0.186'
+}
+
+Rake::GemPackageTask.new(spec) { |pkg|
+	pkg.need_tar_bz2 = true
+}
+
+task(:install => :package) { 
+	g = "pkg/#{spec.name}-#{spec.version}.gem"
+	system "gem install -l #{g}"
+}

data/bin/html2hoshi

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+#
+# A script that turns HTML into a Hoshi method.  Useful to turn some HTML
+# (generated or not) into Ruby so that you can add some code to it or just for
+# readability.
+#
+
+require 'rubygems'
+
+%w(
+	html2hoshi
+).each &method(:require)
+
+if ARGV.empty?
+	$stderr.puts "Usage:  #{$0} html_file [output_file]\nFor either input " \
+		"or output, using - as the filename does the usual thing."
+	exit 1
+end
+
+html_filename = ARGV.shift
+html_file = 
+	if html_filename == '-'
+		html_file = $stdin
+	elsif File.exist?(html_filename)
+		File.open html_filename
+	else
+		$stderr.puts "Apparently, #{html_filename} does not exist."
+		exit 1
+	end
+
+x = ARGV.shift
+if x.nil? || x == '-'
+	output = File.basename(html_filename, '.html')
+	output = 'unnamed_view' if output == '-'
+	outfile = $stdout
+else
+	output = File.basename(x, '.rb')
+	outfile = File.open(x, 'w')
+end
+
+class_name = output.capitalize.gsub(/_(\w)/) { $1.upcase }
+indent = "\t" # TODO: Make it a command-line option.
+
+hoshi = Hoshi.from_html html_file.read, indent
+
+outfile.print(<<EOHOSHI)
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'hoshi'
+
+# Generated with html2hoshi.  You will likely want to change the class name,
+# method name, and class that it inherits from.
+class #{class_name} < Hoshi::View :html
+#{indent}permissive!
+#{hoshi}
+end
+
+# This file can also be run stand-alone:
+if __FILE__ == $0
+#{indent}require 'cgi'
+#{indent}puts CGI.pretty(#{class_name}.new.page)
+end
+EOHOSHI
+outfile.close

data/doc/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Peter Elmore (pete.elmore at gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the 
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software. 
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+DEALINGS IN THE SOFTWARE.

data/doc/README

@@ -0,0 +1,180 @@
+= Hoshi
+
+== Summary
+
+Hoshi is a library for creating real first-class HTML/XML views.  So,
+unlike template libraries, you can take advantage of mixins,
+inheritance, and all the other wonderful features of Ruby's object
+system.  There is also support for easy RSS feeds and CGI.
+
+Hoshi is designed to:
+	* Generate clean HTML/XHTML/XML with minimal effort
+	* Be easy for a coder to use and understand
+	* Take full advantage of Ruby's object sytem
+	* Be more readable and easier to write than bare HTML
+
+It is semi-modeled after Markaby, but with a much more straightforward
+implementation and different semantics (e.g., no instance_eval, so scope
+inside a tag is as expected).  Hoshi also allows a tag to follow another
+tag without requiring any <<, +, or +=.
+
+== Installation
+
+You can install via rubygems,
+
+  gem install hoshi
+
+or by downloading from github (http://github.com/pete/hoshi).
+
+== Usage
+
+These examples and more featured in the fabulous doc/examples directory.
+Also, there is a program included called html2hoshi (and associated
+lib/html2hoshi.rb; see Hoshi.from_html) that takes HTML as input and
+converts it to Ruby code using Hoshi.
+
+=== Class-based
+
+These should be fairly straightforward:
+
+  require 'hoshi'
+
+  class Trivial < Hoshi::View :html4
+    def show
+      doctype
+      html {
+        head {
+          title "Hello, world!"
+          link :rel => 'stylesheet', :href => '/css/hoshi.css'
+        }
+
+        body {
+          h1 "Hello, world!"
+          p "This is a greeting to the world."
+        }
+      }
+      render
+    end
+  end
+
+  puts Trivial.new.show
+
+You can get a little more complicated:
+
+  require 'hoshi'
+  require 'cgi'
+
+  module Layout
+    def main_page(t)
+      doctype
+      html {
+        head {
+          title t
+          script(:type => 'text/javascript') {
+            raw "alert(\"Hi, I'm some javascript, I suppose.\");"
+          }
+        }
+        
+        body {
+          h1 t, :class => 'page_title'
+
+          yield
+        }
+      }
+    end
+
+    def list_page(t)
+      main_page(t) {
+        ul {
+          yield
+        }
+      }
+    end
+  end
+
+
+  class Fibonacci < Hoshi::View :xhtml1
+    include Layout
+
+    def list_page(n)
+      super("Fibonacci: f(0)..f(#{n})") {
+        fib_upto(n).map { |i| li i.to_s }
+      }
+      CGI.pretty(render)
+    end
+
+    private
+
+    def fib_upto n
+      a = Array.new(n) 
+      
+      0.upto(n) { |i|
+        a[i] = 
+          if i < 2
+            1
+          else
+            a[i - 1] + a[i - 2]
+          end
+      }
+
+      a
+    end
+  end
+
+  puts Fibonacci.new.list_page(n)
+
+=== Block-based
+
+For simpler cases where you only intend to produce markup, perhaps for use as a templating engine.
+
+  require 'hoshi'
+
+  str = Hoshi::View::HTML4.build {
+    doctype
+    html {
+      head {
+        title "Hello, world!"
+        link :rel => 'stylesheet', :href => '/css/hoshi.css'
+      }
+
+      body {
+        h1 "Hello, world!"
+        p "This is a greeting to the world."
+      }
+    }
+  }
+
+  puts str
+
+== Bugs
+
+There needs to be some work done on correcting the tags.
+
+== Credits
+
+Author:
+Pete Elmore -- (pete.elmore(a)gmail.com)
+
+Initial Design:
+Dan Yoder -- (danyoder(a)mac.com)
+
+Simple block version:
+Nolan Darilek -- (nolan(a)thewordnerd.info)
+
+Homie that be lookin' out for my broken deps:
+Lars Lethonen
+
+The guys that paid me to do this:
+AT&T Interactive.  (By the way, email me if you want to come work here.)
+
+Also, I guess I should credit Attractive Eighties Women
+(http://attractiveeightieswomen.com/), since I was blasting them the
+whole time I was developing this.  Like, over and over.  I couldn't stop
+listening.  My friends and family are becoming concerned.  I don't feel
+that I am yet ready to take the first step by admitting there is a
+problem.  Intervention may be required.  This paragraph should probably
+be considered a cry for help.
+
+== Home page
+
+http://debu.gs/hoshi

data/doc/TODO

@@ -0,0 +1,10 @@
+TODO for 1.0:
+* Separate the tags by close type in the various View sub-classes.  (The most
+  tedious thing on the list, but required for compliance.)
+* Still not too happy about the way RSS feeds are done, going to rework.
+
+TODO for later:
+* Have html2hoshi do a smarter job of deciding doctypes, not using permissive!
+  so much.
+* View logic helpers.
+* Ooh, ooh, SVG!

data/doc/examples/blocks.rb

@@ -0,0 +1,18 @@
+require 'hoshi'
+
+str = Hoshi::View::HTML4.build {
+	doctype
+	html {
+		head {
+			title "Hello, world!"
+			link :rel => 'stylesheet', :href => '/css/hoshi.css'
+		}
+
+		body {
+			h1 "Hello, world!"
+			p "This is a greeting to the world."
+		}
+	}
+}
+
+puts str

data/doc/examples/env.cgi

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+# Perl, eat your heart out.
+
+require 'rubygems'
+require 'hoshi'
+
+qstring = ENV.delete 'QUERY_STRING'
+query = CGI.parse qstring if qstring
+
+Hoshi::View(:html4) {
+	doc {
+		head { title "env.cgi, just like Mom used to make" }
+		body {
+			h1 "CGI Environment:"
+			ul { 
+				ENV.to_a.sort.map { |k,v|
+					li CGI.escapeHTML("#{k} => #{v}")
+				}
+			}
+
+			if query
+				h1 "Arguments:"
+				ul {
+					query.sort.map { |k,v| 
+						li {
+							safe "#{k} = "
+							if v.size == 1
+								safe v
+							else
+								ul { v.map { |sv| li { safe sv } } }
+							end
+						}
+					}
+				}
+			else
+				h1 "No Arguments"
+			end
+		}
+	}
+	render_cgi
+}

data/doc/examples/feed.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'hoshi'
+
+class Feed < Hoshi::View :html
+	permissive!
+	def show
+		raw "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+		raw "<?xml-stylesheet href=\"http://feeds.feedburner.com/~d/styles/rss2full.xsl\" type=\"text/xsl\" media=\"screen\"?>"
+		raw "<?xml-stylesheet href=\"http://feeds.feedburner.com/~d/styles/itemcontent.css\" type=\"text/css\" media=\"screen\"?>"
+		rss("xmlns:wfw"=>"http://wellformedweb.org/CommentAPI/", "xmlns:atom"=>"http://www.w3.org/2005/Atom", "version"=>"2.0", "xmlns:content"=>"http://purl.org/rss/1.0/modules/content/", "xmlns:dc"=>"http://purl.org/dc/elements/1.1/") {
+			channel {
+				title "Debugs"
+				link "http://debu.gs/blog/debugs.rss"
+				description
+				language "en"
+				tag "atom10:link", nil, "href"=>"http://feeds.feedburner.com/debugs", "rel"=>"self", "xmlns:atom10"=>"http://www.w3.org/2005/Atom", "type"=>"application/rss+xml"
+				item {
+					title "Hoshi 0.1.0 Released...Soon"
+					link "http://debu.gs/hoshi-010-released"
+					pubDate "Thu, 06 Nov 2008 00:00:00 +0000"
+					description "Bringing first-class views to Ruby."
+				}
+				item {
+					title "LiveConsole 0.2.0 Released"
+					link "http://debu.gs/liveconsole-020-released"
+					pubDate "Thu, 16 Oct 2008 00:00:00 +0000"
+					description "LiveConsole 0.2.0 released with support for Unix Domain Sockets and arbitrary bindings."
+				}
+			}
+		}
+		render
+	end
+end
+
+if __FILE__ == $0
+	require 'cgi'
+	puts CGI.pretty(Feed.new.show)
+end

data/doc/examples/layouts.rb

@@ -0,0 +1,60 @@
+require 'hoshi'
+require 'cgi'
+
+module Layout
+	def main_page(t)
+		doctype
+		html {
+			head {
+				title t
+				script(:type => 'text/javascript') {
+					raw "alert(\"Hi, I'm some javascript, I suppose.\");"
+				}
+			}
+
+			body {
+				h1 t, :class => 'page_title'
+				yield
+			}
+		}
+	end
+
+	def list_page(t)
+		main_page(t) {
+			ul {
+				yield
+			}
+		}
+	end
+end
+
+
+class Fibonacci < Hoshi::View :xhtml1
+	include Layout
+
+	def list_page(n)
+		super("Fibonacci: f(0)..f(#{n})") {
+			fib_upto(n).map { |i| li i.to_s }
+		}
+		CGI.pretty(render)
+	end
+
+	private
+
+	def fib_upto n
+		a = Array.new(n) 
+
+		0.upto(n) { |i|
+			a[i] = 
+				if i < 2
+					1
+				else
+					a[i - 1] + a[i - 2]
+				end
+		}
+
+		a
+	end
+end
+
+puts Fibonacci.new.list_page(10)

data/doc/examples/rss2.rb

@@ -0,0 +1,52 @@
+require 'hoshi'
+require 'ostruct'
+
+class BlogFeed < Hoshi::View :rss2
+	def initialize(blog)
+		super()
+
+		# This will generate the inside of the channel tag.
+		def_channel { 
+			title blog.title
+			link blog.url
+			description blog.description
+		}
+
+		# This block gets called once per item.
+		def_item { |i|
+			title i.title
+			link i.url
+			description i.summary
+			# pub_date is a helper for pubDate:
+			pub_date i.time
+			author i.author.email if i.author
+		}
+
+		# You need items to have a feed.
+		self.items = blog.entries
+	end
+end
+
+# We're going to stub out a fake blog object full of fake entries before we get
+# to the good part.
+blog = OpenStruct.new(:title => 'Hello, world of syndication!',
+					  :url => 'http://www.example.com/blog',
+					  :description => 'Nope, no, not at all.')
+
+author = Struct.new(:email)
+blog.entries = [
+	{ :title => "first ps0t!!!1!", 
+	  :url => 'http://www.example.com/blog/first_psot',
+	  :description => 'This is the first post.',
+	  :time => (Time.now - 60 * 60 * 24),
+	  :author => author.new('biff@example.com'),
+	},
+	{ :title => "What is with Biff?",
+	  :url => 'http://www.example.com/blog/biff_sux',
+	  :description => 'Jerk stole the first post from me.',
+	  :time => Time.now,
+	  :author => author.new('emily_postnews@example.com'),
+	},
+].map &OpenStruct.method(:new)
+
+puts BlogFeed.new(blog).render

data/doc/examples/trivial.rb

@@ -0,0 +1,21 @@
+require 'hoshi'
+
+class Trivial < Hoshi::View :html4
+	def show
+		doctype
+		html {
+			head {
+				title "Hello, world!"
+				link :rel => 'stylesheet', :href => '/css/hoshi.css'
+			}
+
+			body {
+				h1 "Hello, world!"
+				p "This is a greeting to the world."
+			}
+		}
+		render
+	end
+end
+
+puts Trivial.new.show

data/lib/hoshi/monkey_patches.rb

@@ -0,0 +1,8 @@
+class Hash
+	# Makes this hash fit to be put into a tag.
+	# { :a => 1, :b => "two" }.to_html_options # => 'a="one" b="two"'
+	def to_html_options double_quotes = true
+		qchar = double_quotes ? '"' : "'"
+		map { |k,v| "#{k}=#{qchar}#{v}#{qchar}" }.join(' ')
+	end
+end

data/lib/hoshi/tag.rb

@@ -0,0 +1,42 @@
+module Hoshi
+	# Represents an HTML tag.  You usually won't be using this class directly.
+	class Tag
+		attr_accessor :name, :close_type
+
+		# A tag currently has only two attributes:  a name and a method for
+		# closing it, which both decide how it is rendered as a string. 
+		# A self-closing tag:
+		#   Tag.new('test', :self).render # => "<test />"
+		# A tag that does not need to close:
+		#   Tag.new('test', :none).render('test this') # => "<test>test this\n"
+		# And a regular tag:
+		#   Tag.new('test').render # => "<test></test>"
+		def initialize(name, close_type = nil)
+			@name, @close_type = name, close_type
+		end
+
+		# Generates a string from this tag.  inside should be the contents to
+		# put between the opening and closing tags (if any), and opts are the
+		# HTML options to put in the tag.  For example,
+		#   Tag.new('div').render('Click for an alert.', 
+		#                         :onclick => "alert('Hi.');")
+		# gets you this:
+		#   <div onclick="alert('Hi.');">Click for an alert.</div>
+		def render(inside = nil, opts = {})
+			inside = inside.to_s
+
+			s = "<#{name} #{opts.to_html_options}".strip
+			if inside.empty? && close_type == :self
+				return s << " />"
+			end
+
+			s << ">" << inside
+
+			if close_type == :none
+				s << "\n"
+			else
+				s << "</#{name}>"
+			end
+		end
+	end
+end

data/lib/hoshi/view/html.rb

@@ -0,0 +1,16 @@
+class Hoshi::View
+	class HTML < self
+		# So, 'p' may look a little out of place here, but if you sub-class
+		# View(:html) directly and use permissive!, you'll end up with Kernel#p
+		# rather than a <p> tag.  Almost never what you want.
+		tags *%w(html head body p)
+
+		def self.content_type
+			'text/html'
+		end
+
+		def cdata str
+			append! "<![CDATA[\n" + str + "\n]]>"
+		end
+	end
+end

data/lib/hoshi/view/html3.rb

@@ -0,0 +1,7 @@
+require 'hoshi/view/html'
+
+class Hoshi::View
+	class HTML3 < HTML
+		dtd! "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2//EN\">"
+	end
+end

data/lib/hoshi/view/html4.rb

@@ -0,0 +1,17 @@
+require 'hoshi/view/html'
+
+class Hoshi::View
+	class HTML4 < HTML
+		dtd! "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" " \
+			"\"http://www.w3.org/TR/html4/strict.dtd\">"
+
+
+		tags *%w(a address applet area base basefont bdo blockquote body br
+				 button caption center col colgroup dd div dl dt fieldset font
+				 form frame frameset h1 h2 h3 h4 h5 h6 head hr html iframe img
+				 input isindex label legend li link map meta noframes noscript
+				 object ol optgroup option p param pre q script select span
+				 style table tbody textarea tfoot thead title tr ul)
+	end
+end
+

data/lib/hoshi/view/html4_frameset.rb

@@ -0,0 +1,8 @@
+require 'hoshi/view/html4'
+
+class Hoshi::View
+	class HTML4Frameset < HTML4
+		dtd! "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 " \
+			"Frameset//EN\" \"http://www.w3.org/TR/html4/frameset.dtd\">"
+	end
+end

data/lib/hoshi/view/html4_transitional.rb

@@ -0,0 +1,8 @@
+require 'hoshi/view/html4'
+
+class Hoshi::View
+	class HTML4Transitional < HTML
+		dtd! "<DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 " \
+			"Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">"
+	end
+end

data/lib/hoshi/view/rss2.rb

@@ -0,0 +1,56 @@
+require 'time' # Doesn't everything?
+
+class Hoshi::View
+	class RSS2 < self
+		class InvalidItemError < ValidationError; end
+		class InvalidChannelError < ValidationError; end
+
+		tags *%w(author category channel cloud comments copyright description
+				 docs enclosure generator guid item language lastBuildDate link
+				 managingEditor pubDate rating skipDays skipHours source title
+				 ttl webMaster rss image url )
+
+		attr_accessor :channel_block, :item_block, :items
+
+		dtd! "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+
+		def self.content_type
+			'application/rss+xml'
+		end
+
+		def def_channel &b
+			self.channel_block = b
+		end
+
+		def def_item &b
+			self.item_block = b
+		end
+
+		# A small helper so you can just pass a date, time, or string rather
+		# than worrying about format.
+		def pub_date dt
+			dt =
+				case dt
+				when Time, Date, DateTime
+					dt.rfc822
+				else
+					dt
+				end
+			pubDate dt
+		end
+
+		def render
+			clear!
+			doctype
+			rss(:version => '2.0') {
+				channel {
+					channel_block.call
+					items.each { |i| 
+						item { item_block.call i }
+					}
+				}
+			}
+			super()
+		end
+	end
+end

data/lib/hoshi/view/xhtml.rb

@@ -0,0 +1,9 @@
+require 'hoshi/view/html'
+
+class Hoshi::View
+	class XHTML < HTML
+		def self.content_type
+			'application/xhtml+xml'
+		end
+	end
+end

data/lib/hoshi/view/xhtml1.rb

@@ -0,0 +1,17 @@
+require 'hoshi/view/xhtml'
+
+class Hoshi::View
+	class XHTML1 < XHTML
+		dtd! "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 " \
+			"Strict//EN\" " \
+			"\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"
+		tags *%w(a abbr acronym address applet area b base basefont bdo big
+				 blockquote body br button caption center cite code col
+				 colgroup dd del dfn dir div dl dt em fieldset font form h1 h2
+				 h3 h4 h5 h6 head hr html i iframe img input ins isindex kbd
+				 label legend li link map menu meta noframes noscript object ol
+				 optgroup option p param pre q s samp script select small span
+				 strike strong style sub sup table tbody td textarea tfoot th
+				 thead title tr tt u ul var)
+		end
+end

data/lib/hoshi/view/xhtml1_frameset.rb

@@ -0,0 +1,16 @@
+require 'hoshi/view/xhtml1'
+
+class Hoshi::View
+	class XHTML1Frameset < XHTML1
+		dtd! "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 " \
+			"Frameset//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\">"
+		tags *%w(a abbr acronym address applet area b base basefont bdo big
+				 blockquote body br button caption center cite code col
+				 colgroup dd del dfn dir div dl dt em fieldset font form frame
+				 frameset h1 h2 h3 h4 h5 h6 head hr html i iframe img input ins
+				 isindex kbd label legend li link map menu meta noframes
+				 noscript object ol optgroup option p param pre q s samp script
+				 select small span strike strong style sub sup table tbody td
+				 textarea tfoot th thead title tr tt u ul var)
+	end
+end

data/lib/hoshi/view/xhtml1_strict.rb

@@ -0,0 +1,8 @@
+require 'hoshi/view/xhtml'
+
+class Hoshi::View
+	class XHTML1 < XHTML
+		dtd! "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" " \
+			"\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"
+	end
+end

data/lib/hoshi/view/xhtml1_transitional.rb

@@ -0,0 +1,9 @@
+require 'hoshi/view/xhtml'
+
+class Hoshi::View
+	class XHTML1Transitional < XHTML
+		dtd! "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 " \
+			"Transitional//EN\" " \
+			"\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">"
+	end
+end

data/lib/hoshi/view/xhtml2.rb

@@ -0,0 +1,7 @@
+require 'hoshi/view/xhtml'
+
+class Hoshi::View
+	class XHTML2 < XHTML
+		dtd! "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">"
+	end
+end

data/lib/hoshi/view.rb

@@ -0,0 +1,205 @@
+require 'metaid'
+require 'cgi'
+
+module Hoshi
+	# The View class is the super-class for views you create with Hoshi.  More
+	# likely, though, you'll be using one of View's many sub-classes as the
+	# super-class for your view, like this:
+	#   class MyView < Hoshi::View :html4
+	# or
+	#   class MyView < Hoshi::View::XHTML1Frameset
+	# Of course, using View[] is the preferred method for the sake of brevity.
+	# When you create a view class, you'll want to define one or more methods
+	# that eventually call View#render, which turns your view into HTML.
+	# (Private methods and methods that build up state do not need to do so.)
+	class View
+		class ValidationError < StandardError; end
+
+		# This creates an instance method for this view which appends a tag.
+		# Most of these are handled for you.  The arguments to this method
+		# match those to Tag.new.  See also View#permissive!.
+		# 	tag('h1')
+		# 	def show_an_h1
+		# 		h1 "I have been shown"
+		# 	end
+		def self.tag(name, close_type = nil)
+			class_eval <<-EOHACK
+				def #{name}(*opts, &b)
+					if b
+						tag #{name.inspect}, #{close_type.inspect}, *opts, &b
+					else
+						tag #{name.inspect}, #{close_type.inspect}, *opts, &b
+					end
+				end
+			EOHACK
+		end
+
+		# A short-hand for creating multiple tags via View.tag.  For tags that
+		# do not require closing, see View.open_tags.
+		def self.tags *names
+			names.map &method(:tag)
+		end
+
+		# A short-hand for creating multiple tags that are left open.
+		def self.open_tags *names
+			names.map { |n| tag n, :none }
+		end
+
+		# This method choses, based on the provided doctype, the proper
+		# sub-class of View.  Generally, you'll be using this rather than
+		# sub-classing View directly.  The doctype argument is case- and
+		# underscore-insensitive, and valid arguments are names of View
+		# subclasses that are inside the View namespace.
+		def self.[] doctype
+			doctype = doctype.to_s.downcase.gsub('_', '')
+			const_get(constants.find { |c| 
+				cl = const_get c
+				(cl.ancestors.include?(self) && 
+				 c.to_s.downcase == doctype) rescue false
+			}) rescue nil
+		end
+
+		# Sets the doctype declaration for this class.
+		def self.dtd! dtd
+			dtd += "\n"
+			define_method(:doctype) { append! dtd }
+		end
+		def doctype
+			comment "No doctype defined; are you sub-classing View directly " \
+				"and not calling dtd!()?"
+		end
+
+		# Free-form tags.  Basically, dynamic tag creation by method_missing.
+		def self.permissive!
+			@permissive = true
+		end
+
+		# Returns true if we add tags to this class on the fly.
+		def self.permissive?
+			@permissive
+		end
+
+		# Only the tags already specified are allowed.  No dynamic tag
+		# creation.  This is the default.
+		def self.strict!
+			@permissive = false
+		end
+
+		# Returns true if we do not add tags to the class on the fly.
+		def self.strict?
+			!permissive?
+		end
+
+		# Create and render a view via a block.
+		def self.build(&block)
+			c = new
+			c.instance_eval(&block)
+			c.render
+		end
+
+		# This is overridden in HTML/XHTML, and you'll definitely want to
+		# override it if you subclass View directly.
+		def self.content_type
+			'application/octet-stream'
+		end
+
+		# Most of these files depend on the above method definitions.
+		Dir["#{File.dirname(__FILE__)}/view/*.rb"].each &method(:require)
+
+		def initialize
+			clear!
+		end
+
+		# Clears the current state of this view.
+		def clear!
+			self.tree = []
+			self.current = tree
+		end
+
+		# Adds a comment.
+		def comment(*a)
+			if a.include?('--')
+				raise ValidationError, "Comments can't include '--'."
+			else
+				append! "<!-- #{a} -->"
+			end
+		end
+
+		# Appends a tag to the current document, for when a tag is only needed
+		# once or has a name that is not a valid method name.
+		def tag(tname, close_type = nil, *opts, &b)
+			t = Tag.new(tname, close_type)
+
+			if b
+				old, self.current = current, []
+				b.call
+				inside, self.current = current.map { |i| i.to_s }.join, old
+			else
+				inside = opts.shift if opts.first.kind_of?(String)
+			end
+
+			append! t.render(inside, opts.first || {})
+		end
+
+		# Appends something to the document.  The comment, decl, and various
+		# tag methods call this.
+		def append! x
+			current << x
+			x
+		end
+
+		# If you're tired of typing "doctype\nhtml" every single time.
+		def doc &b
+			doctype
+			html &b
+		end
+
+		# Turns things in to strings, properly escapes them, and appends them
+		# to the document.
+		def safe *things
+			append! CGI.escapeHTML(things.map { |i| i.to_s }.join("\n"))
+		end
+
+		# Appends one or more non-escaped strings to the document.
+		def raw *things
+			append! things.join
+		end
+
+		# Returns the string representation of the document.  This is what you
+		# want to eventually call.
+		def render
+			tree.flatten.map { |i| i.to_s }.join
+		end
+
+		# Prints the string representation of the docutment, with HTTP headers.
+		# Useful for one-off CGI scripts.  Takes an optional hash argument for
+		# headers (Content-Type and Status are set by default).  See CGI#header
+		# for information on how the header hash should look.
+		def render_cgi(extra_headers = {})
+			h = { 
+				'type' => self.class.content_type,
+				'status' => 'OK',
+			}.merge(extra_headers)
+
+			CGI.new.out(h) { render }
+		end
+
+		# Dynamically add tags if the view class for this object is permissive.
+		def method_missing(mname, *args, &b)
+			if self.class.permissive?
+				self.class.tag mname
+				if b
+					send mname, *args, &b
+				else
+					send mname, *args
+				end
+			else
+				super
+			end
+		end
+
+		private
+
+		attr_accessor :tree, :current
+	end
+end

data/lib/hoshi.rb

@@ -0,0 +1,20 @@
+require 'hoshi/monkey_patches'
+
+require 'hoshi/tag'
+require 'hoshi/view'
+
+# This is the namespace for all of Hoshi, which currently only includes
+# Hoshi::View and Hoshi::Tag .  For an overview, see doc/README .  For
+# specifics, check out Hoshi::View .
+module Hoshi
+	# This is a cosmetic method; you may do Hoshi::View[:type],
+	# Hoshi::View(:type), or Hoshi::View :type
+	def self.View(*a, &b)
+		klass = View[*a]
+		if b
+			klass.build &b
+		else
+			klass
+		end
+	end
+end

data/lib/html2hoshi.rb

@@ -0,0 +1,85 @@
+require 'hpricot'
+
+module Hoshi
+	# A semi-hacky method for converting HTML text to a Hoshi method.  It takes
+	# an HTML document as a string, and optionally the string to use for each
+	# level of indentation.
+	def self.from_html(html, indent = "\t")
+		"#{indent}def page" << tree_to_hoshi(parse(html), indent, 2) <<
+			"\n#{indent * 2}render\n#{indent}end"
+	end
+
+	private
+
+	def self.parse(doc)
+		Hpricot.method(
+			if doc.include?('<?xml') # Seems like a safe assumption.
+				:XML
+			else
+				:parse
+			end).call(doc)
+	end
+
+	def self.tree_to_hoshi(tree, indent = "\t", indentlevel = 0)
+		idt = indent * indentlevel
+		str = ''
+		tree.each_child { |i|
+			str << ("\n#{idt}" <<
+			case i
+			when Hpricot::Elem
+				# Something simple that resembles rules for ruby method naming.
+				# I know that both XML and Ruby allow most valid unicode 
+				# characters in tags/method names, but this is Good Enough.
+				using_tag = !/^[a-z][a-zA-Z0-9_]*[!?]?$/.match(i.name)
+
+				args, block = [], nil
+				s = if using_tag
+						args << i.name.inspect << 'nil'
+						'tag'
+					else
+						i.name
+					end
+
+				if i.children.size == 1 && 
+				   i.children.first.kind_of?(Hpricot::Text)
+					fc = i.children.first.to_s.strip
+					args << fc.inspect unless fc.empty?
+				elsif !i.children.empty?
+					block = ' {' << 
+						tree_to_hoshi(i, indent, indentlevel + 1) <<
+						"\n#{idt}}"
+				end
+
+				unless i.attributes.empty?
+					args << i.attributes.inspect.sub(/^\{/, '').sub(/\}$/, '')
+				end
+
+				unless args.empty?
+					arg_s = args.join(', ')
+					if block
+						s << "(#{arg_s})"
+					else
+						s << " #{arg_s}"
+					end
+				end
+
+				s << block if block
+
+				s
+			when Hpricot::Comment
+				"comment #{i.content.inspect}"
+			when Hpricot::BogusETag
+				"raw #{i.to_s.inspect} # Dangling end tag."
+			when Hpricot::DocType, Hpricot::ProcIns, Hpricot::XMLDecl, 
+			     Hpricot::Text, Object
+				x = i.to_s
+				if /\A\s*\Z/.match(x)
+					next
+				else
+					"raw #{i.to_s.strip.inspect}"
+				end
+			end)
+		}
+		str
+	end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: hoshi
+version: !ruby/object:Gem::Version 
+  version: 0.0.186
+platform: ruby
+authors: 
+- Pete Elmore
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-10 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: metaid
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: pete.elmore@gmail.com
+executables: 
+- html2hoshi
+extensions: []
+
+extra_rdoc_files: 
+- doc/README
+- doc/TODO
+- doc/LICENSE
+files: 
+- lib/html2hoshi.rb
+- lib/hoshi.rb
+- lib/hoshi
+- lib/hoshi/monkey_patches.rb
+- lib/hoshi/view
+- lib/hoshi/view/html.rb
+- lib/hoshi/view/xhtml1_strict.rb
+- lib/hoshi/view/xhtml1_frameset.rb
+- lib/hoshi/view/html4_transitional.rb
+- lib/hoshi/view/xhtml.rb
+- lib/hoshi/view/html3.rb
+- lib/hoshi/view/html4_frameset.rb
+- lib/hoshi/view/xhtml1.rb
+- lib/hoshi/view/html4.rb
+- lib/hoshi/view/xhtml2.rb
+- lib/hoshi/view/xhtml1_transitional.rb
+- lib/hoshi/view/rss2.rb
+- lib/hoshi/tag.rb
+- lib/hoshi/view.rb
+- doc/README
+- doc/examples
+- doc/examples/layouts.rb
+- doc/examples/trivial.rb
+- doc/examples/blocks.rb
+- doc/examples/env.cgi
+- doc/examples/feed.rb
+- doc/examples/rss2.rb
+- doc/TODO
+- doc/LICENSE
+- bin/html2hoshi
+- Rakefile
+has_rdoc: true
+homepage: http://debu.gs/hoshi
+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: hoshi-view
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Nice, object-oriented, first-class views.
+test_files: []
+