RubyGems - undress - Versions diffs - 0.1 - Mend

undress 0.1

Files changed (13) hide show

data/.gitignore ADDED

@@ -0,0 +1,3 @@
+doc
+dist
+tmp

data/LICENSE ADDED

@@ -0,0 +1,22 @@
+(The MIT License)
+Copyright (c) 2009 Nicolas Sanguinetti, entp.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/README.rdoc ADDED

@@ -0,0 +1,39 @@
+= Undress
+Easily convert back HTML to Textile, Markdown, RDoc or whatever other
+markup language you like.
+    require "undress"
+    code =<<html
+      <h1>Hello world!</h1>
+      <p><strong>Hey!</strong> How is it going?</p>
+      <h2>Supported Markup Languages so far:</h2>
+      <ul>
+        <li>Textile</li>
+        <li>And more to come :P</li>
+      </ul>
+    html
+    Undress(code).to_textile
+Will produce
+    h1. Hello world!
+    *Hey!* How is it going?
+    h2. Supported Markup Languages so far:
+    * Textile
+    * And more to come :P
+== Supported Markup Languages
+For now the only language supported is Textile. But I'll be happy to accept
+patches to add more languages :)
+== License
+Authors:: Nicolas Sanguinetti (foca[http://github.com/foca])
+License:: MIT (Check LICENSE for details)

data/Rakefile ADDED

@@ -0,0 +1,32 @@
+require "rake/testtask"
+begin
+  require "hanna/rdoctask"
+rescue LoadError
+  require "rake/rdoctask"
+end
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.title = "API Documentation for Undress"
+  rd.rdoc_files.include("README.rdoc", "LICENSE", "lib/**/*.rb")
+  rd.rdoc_dir = "doc"
+end
+begin
+  require "metric_fu"
+rescue LoadError
+end
+begin
+  require "mg"
+  MG.new("undress.gemspec")
+rescue LoadError
+end
+desc "Default: run tests"
+task :default => :test
+Rake::TestTask.new do |t|
+  t.test_files = FileList["test/test_*.rb"]
+end

data/lib/core_ext/object.rb ADDED

@@ -0,0 +1,6 @@
+class Object #:nodoc:
+  def tap
+    yield self
+    self
+  end
+end

data/lib/undress.rb ADDED

@@ -0,0 +1,46 @@
+require "hpricot"
+require File.expand_path(File.dirname(__FILE__) + "/core_ext/object")
+require File.expand_path(File.dirname(__FILE__) + "/undress/grammar")
+# Load an HTML document so you can undress it. Pass it either a string or an IO
+# object. You can pass an optional hash of options, which will be forwarded
+# straight to Hpricot. Check it's
+# documentation[http://code.whytheluckystiff.net/doc/hpricot] for details.
+def Undress(html, options={})
+  Undress::Document.new(html, options)
+end
+module Undress
+  # Register a markup language. The name will become the method used to convert
+  # HTML to this markup language: for example registering the name +:textile+
+  # gives you <tt>Undress(code).to_textile</tt>, registering +:markdown+ would
+  # give you <tt>Undress(code).to_markdown</tt>, etc.
+  def self.add_markup(name, grammar)
+    Document.add_markup(name, grammar)
+  end
+  class Document #:nodoc:
+    def initialize(html, options)
+      @doc = Hpricot(html, options)
+    end
+    def self.add_markup(name, grammar)
+      define_method "to_#{name}" do
+        grammar.process!(@doc)
+      end
+    end
+  end
+  module ::Hpricot #:nodoc:
+    class Elem #:nodoc:
+      def ancestors
+        node, ancestors = parent, Elements[]
+        while node.respond_to?(:parent) && node.parent
+          ancestors << node
+          node = node.parent
+        end
+        ancestors
+      end
+    end
+  end
+end

data/lib/undress/grammar.rb ADDED

@@ -0,0 +1,127 @@
+module Undress
+  # Grammars give you a DSL to declare how to convert an HTML document into a
+  # different markup language.
+  class Grammar
+    def self.inherited(base) # :nodoc:
+      base.instance_variable_set(:@post_processing_rules, post_processing_rules)
+      base.instance_variable_set(:@pre_processing_rules, pre_processing_rules)
+    end
+    # Add a parsing rule for a group of html tags.
+    #
+    #     rule_for :p do |element|
+    #       "<this was a paragraph>#{content_of(element)}</this was a paragraph>"
+    #     end
+    #
+    # will replace your <tt><p></tt> tags for <tt><this was a paragraph></tt>
+    # tags, without altering the contents.
+    #
+    # The element yielded to the block is an Hpricot element for the given tag.
+    def self.rule_for(*tags, &handler) # :yields: element
+      tags.each do |tag|
+        define_method tag.to_sym, &handler
+      end
+    end
+    # Set a default rule for unrecognized tags.
+    #
+    # Unless you define a special case, it will ignore the tags and just output
+    # the contents of unrecognized tags.
+    def self.default(&handler) # :yields: element
+      define_method :method_missing do |tag, node, *args|
+        handler.call(node)
+      end
+    end
+    # Add a post-processing rule to your parser.
+    #
+    # This takes a regular expression that will be applied to the output after
+    # processing any nodes. It can take a string as a replacement, or a block
+    # that will be passed to String#gsub.
+    #
+    #     post_processing(/\n\n+/, "\n\n") # compress more than two newlines
+    #     post_processing(/whatever/) { ... }
+    def self.post_processing(regexp, replacement = nil, &handler) #:yields: matched_string
+      post_processing_rules[regexp] = replacement || handler
+    end
+    # Add a pre-processing rule to your parser.
+    #
+    # This lets you mutate the DOM before applying any rule defined with
+    # +rule_for+. You need to pass a CSS/XPath selector, and a block that
+    # takes an Hpricot element to parse it.
+    #
+    #     pre_processing "ul.toc" do |element|
+    #       element.swap("<p>[[toc]]</p>")
+    #     end
+    #
+    # Would replace any unordered lists with the class +toc+ for a
+    # paragraph containing the code <tt>[[toc]]</tt>.
+    def self.pre_processing(selector, &handler) # :yields: element
+      pre_processing_rules[selector] = handler
+    end
+    def self.post_processing_rules #:nodoc:
+      @post_processing_rules ||= {}
+    end
+    def self.pre_processing_rules #:nodoc:
+      @pre_processing_rules ||= {}
+    end
+    def self.process!(node) #:nodoc:
+      new.process!(node)
+    end
+    attr_reader :pre_processing_rules #:nodoc:
+    attr_reader :post_processing_rules #:nodoc:
+    def initialize #:nodoc:
+      @pre_processing_rules = self.class.pre_processing_rules.dup
+      @post_processing_rules = self.class.post_processing_rules.dup
+    end
+    # Process a DOM node, converting it to your markup language according to
+    # your defined rules. If the node is a Text node, it will return it's
+    # string representation. Otherwise it will call the rule defined for it.
+    def process(nodes)
+      Array(nodes).map do |node|
+        if node.text?
+          node.to_html
+        elsif node.elem?
+          send node.name.to_sym, node
+        else
+          ""
+        end
+      end.join("")
+    end
+    def process!(node) #:nodoc:
+      pre_processing_rules.each do |selector, handler|
+        node.search(selector).each(&handler)
+      end
+      process(node.children).tap do |text|
+        post_processing_rules.each do |rule, handler|
+          handler.is_a?(String) ?  text.gsub!(rule, handler) : text.gsub!(rule, &handler)
+        end
+      end
+    end
+    # Get the result of parsing the contents of a node.
+    def content_of(node)
+      process(node.respond_to?(:children) ? node.children : node)
+    end
+    # Helper method that tells you if the given DOM node is immediately
+    # surrounded by whitespace.
+    def surrounded_by_whitespace?(node)
+      (node.previous.text? && node.previous.to_s =~ /\s+$/) ||
+        (node.next.text? && node.next.to_s =~ /^\s+/)
+    end
+    def method_missing(tag, node, *args) #:nodoc:
+      process(node.children)
+    end
+  end
+end

data/lib/undress/textile.rb ADDED

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + "/../undress")
+module Undress
+  class Textile < Grammar
+    # whitespace handling
+    post_processing(/\n\n+/, "\n\n")
+    post_processing(/\A\s+/, "")
+    post_processing(/\s+\z/, "\n")
+    # special characters introduced by textile
+    post_processing(/&#8230;/, "...")
+    post_processing(/&#8217;/, "'")
+    post_processing(/&#822[01];/, '"')
+    post_processing(/&#8212;/, "--")
+    post_processing(/&#8211;/, "-")
+    post_processing(/(\d+\s*)&#215;(\s*\d+)/, '\1x\2')
+    post_processing(/&#174;/, "(r)")
+    post_processing(/&#169;/, "(c)")
+    post_processing(/&#8482;/, "(tm)")
+    # inline elements
+    rule_for(:a) {|e|
+      title = e.has_attribute?("title") ? " (#{e["title"]})" : ""
+      "[#{content_of(e)}#{title}:#{e["href"]}]"
+    }
+    rule_for(:img) {|e|
+      alt = e.has_attribute?("alt") ? "(#{e["alt"]})" : ""
+      "!#{e["src"]}#{alt}!"
+    }
+    rule_for(:strong)  {|e| "*#{content_of(e)}*" }
+    rule_for(:em)      {|e| "_#{content_of(e)}_" }
+    rule_for(:code)    {|e| "@#{content_of(e)}@" }
+    rule_for(:cite)    {|e| "??#{content_of(e)}??" }
+    rule_for(:sup)     {|e| surrounded_by_whitespace?(e) ? "^#{content_of(e)}^" : "[^#{content_of(e)}^]" }
+    rule_for(:sub)     {|e| surrounded_by_whitespace?(e) ? "~#{content_of(e)}~" : "[~#{content_of(e)}~]" }
+    rule_for(:ins)     {|e| "+#{content_of(e)}+" }
+    rule_for(:del)     {|e| "-#{content_of(e)}-" }
+    rule_for(:acronym) {|e| e.has_attribute?("title") ? "#{content_of(e)}(#{e["title"]})" : content_of(e) }
+    # text formatting and layout
+    rule_for(:p)          {|e| "\n\n#{content_of(e)}\n\n" }
+    rule_for(:br)         {|e| "\n" }
+    rule_for(:blockquote) {|e| "\n\nbq. #{content_of(e)}\n\n" }
+    rule_for(:pre)        {|e|
+      if e.children.all? {|n| n.text? && n.content =~ /^\s+$/ || n.elem? && n.name == "code" }
+        "\n\npc. #{content_of(e % "code")}\n\n"
+      else
+        "<pre>#{content_of(e)}</pre>"
+      end
+    }
+    # headings
+    rule_for(:h1) {|e| "\n\nh1. #{content_of(e)}\n\n" }
+    rule_for(:h2) {|e| "\n\nh2. #{content_of(e)}\n\n" }
+    rule_for(:h3) {|e| "\n\nh3. #{content_of(e)}\n\n" }
+    rule_for(:h4) {|e| "\n\nh4. #{content_of(e)}\n\n" }
+    rule_for(:h5) {|e| "\n\nh5. #{content_of(e)}\n\n" }
+    rule_for(:h6) {|e| "\n\nh6. #{content_of(e)}\n\n" }
+    # lists
+    rule_for(:li) {|e|
+      token = e.parent.name == "ul" ? "*" : "#"
+      nesting = e.ancestors.inject(1) {|total,node| total + (%(ul ol).include?(node.name) ? 0 : 1) }
+      "\n#{token * nesting} #{content_of(e)}"
+    }
+    rule_for(:ul, :ol) {|e|
+      if e.ancestors.detect {|node| %(ul ol).include?(node.name) }
+        content_of(e)
+      else
+        "\n#{content_of(e)}\n\n"
+      end
+    }
+    # definition lists
+    rule_for(:dl) {|e| "\n\n#{content_of(e)}\n" }
+    rule_for(:dt) {|e| "- #{content_of(e)} " }
+    rule_for(:dd) {|e| ":= #{content_of(e)} =:\n" }
+    # tables
+    rule_for(:table) {|e| "\n\n#{content_of(e)}\n" }
+    rule_for(:tr) {|e| "#{content_of(e)}|\n" }
+    rule_for(:td, :th) {|e|
+      prefix = if e.name == "th"
+        "_. "
+      elsif e.has_attribute?("colspan")
+        "\\#{e["colspan"]}. "
+      elsif e.has_attribute?("rowspan")
+        "/#{e["rowspan"]}. "
+      end
+      "|#{prefix}#{content_of(e)}"
+    }
+  end
+  add_markup :textile, Textile
+end

data/test/test_grammar.rb ADDED

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+module Undress
+  class TestGrammar < Test::Unit::TestCase
+    class Parent < Grammar
+      rule_for(:p) {|e| "<this is a paragraph>#{content_of(e)}</this is a paragraph>" }
+    end
+    class WithPreProcessingRules < Parent
+      pre_processing("p.foo") {|e| e.swap("<div>Cuack</div>") }
+      rule_for(:div) {|e| "<this was a div>#{content_of(e)}</this was a div>" }
+    end
+    class Child < Parent; end
+    class OverWriter < WithPreProcessingRules
+      rule_for(:div) {|e| content_of(e) }
+    end
+    class TextileExtension < Textile
+      rule_for(:a) {|e| "" }
+    end
+    def parse_with(grammar, html)
+      grammar.process!(Hpricot(html))
+    end
+    context "extending a grammar" do
+      test "the extended grammar should inherit the rules of the parent" do
+        output = parse_with Child, "<p>Foo Bar</p>"
+        assert_equal "<this is a paragraph>Foo Bar</this is a paragraph>", output
+      end
+      test "extending a grammar doesn't overwrite the parent's rules" do
+        output = parse_with OverWriter, "<div>Foo</div>"
+        assert_equal "Foo", output
+        output = parse_with WithPreProcessingRules, "<div>Foo</div>"
+        assert_equal "<this was a div>Foo</this was a div>", output
+      end
+      test "extending textile doesn't blow up" do
+        output = parse_with TextileExtension, "<p><a href='/'>Cuack</a></p><p>Foo Bar</p><p>I <a href='/'>work</a></p>"
+        assert_equal "Foo Bar\n\nI\n", output
+      end
+    end
+    context "pre processing rules" do
+      test "mutate the DOM before parsing the tags" do
+        output = parse_with WithPreProcessingRules, "<p class='foo'>Blah</p><p>O hai</p>"
+        assert_equal "<this was a div>Cuack</this was a div><this is a paragraph>O hai</this is a paragraph>", output
+      end
+    end
+  end
+end

data/test/test_helper.rb ADDED

@@ -0,0 +1,10 @@
+require "test/unit"
+require "contest"
+Dir[File.expand_path(File.dirname(__FILE__) + "/../lib/**/*.rb")].each do |file|
+  require file
+end
+begin
+  require "redgreen"
+rescue LoadError
+end

data/test/test_textile.rb ADDED

@@ -0,0 +1,198 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+module Undress
+  class TextileTest < Test::Unit::TestCase
+    def assert_renders_textile(textile, html)
+      assert_equal textile, Undress(html).to_textile
+    end
+    context "Converting HTML to textile" do
+      test "converts nested tags" do
+        assert_renders_textile "h2. _this is *very* important_\n", "<h2><em>this is <strong>very</strong> important</em></h2>"
+      end
+      context "inline elements" do
+        test "converts <strong> tags" do
+          assert_renders_textile "*foo bar*", "<strong>foo bar</strong>"
+        end
+        test "converts <em> tags" do
+          assert_renders_textile "_foo bar_", "<em>foo bar</em>"
+        end
+        test "converts <code> tags" do
+          assert_renders_textile "@foo bar@", "<code>foo bar</code>"
+        end
+        test "converts <cite> tags" do
+          assert_renders_textile "??foo bar??", "<cite>foo bar</cite>"
+        end
+        test "converts <sup> tags" do
+          assert_renders_textile "foo ^sup^ bar", "foo <sup>sup</sup> bar"
+          assert_renders_textile "foo[^sup^]bar", "foo<sup>sup</sup>bar"
+        end
+        test "converts <sub> tags" do
+          assert_renders_textile "foo ~sub~ bar", "foo <sub>sub</sub> bar"
+          assert_renders_textile "foo[~sub~]bar", "foo<sub>sub</sub>bar"
+        end
+        test "converts <ins> tags" do
+          assert_renders_textile "+foo bar+", "<ins>foo bar</ins>"
+        end
+        test "converts <del> tags" do
+          assert_renders_textile "-foo bar-", "<del>foo bar</del>"
+        end
+        test "converts <acronym> tags" do
+          assert_renders_textile "EPA(Environmental Protection Agency)", "<acronym title='Environmental Protection Agency'>EPA</acronym>"
+          assert_renders_textile "EPA", "<acronym>EPA</acronym>"
+        end
+      end
+      context "links" do
+        test "converts simple links (without title)" do
+          assert_renders_textile "[Foo Bar:/cuack]", "<a href='/cuack'>Foo Bar</a>"
+        end
+        test "converts links with titles" do
+          assert_renders_textile "[Foo Bar (You should see this):/cuack]", "<a href='/cuack' title='You should see this'>Foo Bar</a>"
+        end
+      end
+      context "images" do
+        test "converts images without alt attributes" do
+          assert_renders_textile "!http://example.com/image.png!", "<img src='http://example.com/image.png'/>"
+        end
+        test "converts images with alt attributes" do
+          assert_renders_textile "!http://example.com/image.png(Awesome Pic)!", "<img src='http://example.com/image.png' alt='Awesome Pic'/>"
+        end
+      end
+      context "text formatting" do
+        test "converts paragraphs" do
+          assert_renders_textile "foo\n\nbar\n", "<p>foo</p><p>bar</p>"
+        end
+        test "converts <pre> tags which only contain a <code> child" do
+          assert_renders_textile "pc. var foo = 1;\n", "<pre><code>var foo = 1;</code></pre>"
+          assert_renders_textile "pc. var foo = 1;\n", "<pre>   <code>var foo = 1;</code>   </pre>"
+        end
+        test "leaves <pre> tags which contain mixed content as HTML" do
+          assert_renders_textile "<pre>  foo bar</pre>", "<pre>  foo bar</pre>"
+        end
+        test "converts <br> into a new line" do
+          assert_renders_textile "Foo\nBar", "Foo<br/>Bar"
+        end
+        test "converts blockquotes" do
+          assert_renders_textile "bq. foo bar\n", "<blockquote><div>foo bar</div></blockquote>"
+        end
+      end
+      context "headers" do
+        test "converts <h1> tags" do
+          assert_renders_textile "h1. foo bar\n", "<h1>foo bar</h1>"
+        end
+        test "converts <h2> tags" do
+          assert_renders_textile "h2. foo bar\n", "<h2>foo bar</h2>"
+        end
+        test "converts <h3> tags" do
+          assert_renders_textile "h3. foo bar\n", "<h3>foo bar</h3>"
+        end
+        test "converts <h4> tags" do
+          assert_renders_textile "h4. foo bar\n", "<h4>foo bar</h4>"
+        end
+        test "converts <h5> tags" do
+          assert_renders_textile "h5. foo bar\n", "<h5>foo bar</h5>"
+        end
+        test "converts <h6> tags" do
+          assert_renders_textile "h6. foo bar\n", "<h6>foo bar</h6>"
+        end
+      end
+      context "lists" do
+        test "converts bullet lists" do
+          assert_renders_textile "* foo\n* bar\n", "<ul><li>foo</li><li>bar</li></ul>"
+        end
+        test "converts numbered lists" do
+          assert_renders_textile "# foo\n# bar\n", "<ol><li>foo</li><li>bar</li></ol>"
+        end
+        test "converts nested bullet lists" do
+          assert_renders_textile "* foo\n** bar\n* baz\n", "<ul><li>foo<ul><li>bar</li></ul></li><li>baz</li></ul>"
+        end
+        test "converts nested numbered lists" do
+          assert_renders_textile "# foo\n## bar\n# baz\n", "<ol><li>foo<ol><li>bar</li></ol></li><li>baz</li></ol>"
+        end
+        test "converts nested mixed lists" do
+          assert_renders_textile "* foo\n## bar\n## baz\n*** quux\n* cuack\n",
+                                 "<ul><li>foo<ol><li>bar</li><li>baz<ul><li>quux</li></ul></li></ol></li><li>cuack</li></ul>"
+        end
+        test "converts a definition list" do
+          assert_renders_textile "- foo := defining foo =:\n- bar := defining bar =:\n",
+                                 "<dl><dt>foo</dt><dd>defining foo</dd><dt>bar</dt><dd>defining bar</dd></dl>"
+        end
+      end
+      context "tables" do
+        test "converts a simple table" do
+          assert_renders_textile "|foo|bar|baz|\n|1|2|3|\n",
+                                 "<table><tr><td>foo</td><td>bar</td><td>baz</td></tr><tr><td>1</td><td>2</td><td>3</td></tr></table>"
+        end
+        test "converts a table with headers" do
+          assert_renders_textile "|_. foo|_. bar|_. baz|\n|1|2|3|\n",
+                                 "<table><tr><th>foo</th><th>bar</th><th>baz</th></tr><tr><td>1</td><td>2</td><td>3</td></tr></table>"
+        end
+        test "converts a table with cells that span multiple columns" do
+          assert_renders_textile "|foo|bar|baz|\n|\\2. 1|2|\n",
+                                 "<table><tr><td>foo</td><td>bar</td><td>baz</td></tr><tr><td colspan='2'>1</td><td>2</td></tr></table>"
+        end
+        test "converts a table with cells that span multiple rows" do
+          assert_renders_textile "|/2. foo|bar|baz|\n|1|2|\n",
+                                 "<table><tr><td rowspan='2'>foo</td><td>bar</td><td>baz</td></tr><tr><td>1</td><td>2</td></tr></table>"
+        end
+      end
+      context "applying post processing rules" do
+        test "compresses newlines to a maximum of two consecutive newlines" do
+          assert_renders_textile "Foo\n\nBar\n\nBaz\n\n* Quux 1\n* Quux 2\n", "<p>Foo</p><p>Bar</p><p>Baz</p><ul><li>Quux 1</li><li>Quux 2</li></p>"
+        end
+        test "strips trailing newlines from the start and end of the output string" do
+          assert_renders_textile "Foo\n", "<p>Foo</p>"
+        end
+        test "converts all fancy characters introduced by textile back into their 'source code'" do
+          assert_renders_textile "What the ... hell?", "What the &#8230; hell?"
+          assert_renders_textile "It's mine", "It&#8217;s mine"
+          assert_renders_textile "\"Fancy quoting\"", "&#8220;Fancy quoting&#8221;"
+          assert_renders_textile "How dashing--right?", "How dashing&#8212;right?"
+          assert_renders_textile "How dashing - right?", "How dashing &#8211; right?"
+          assert_renders_textile "2 x 2 = 4", "2 &#215; 2 = 4"
+          assert_renders_textile "2x2 = 4", "2&#215;2 = 4"
+          assert_renders_textile "Registered(r)", "Registered&#174;"
+          assert_renders_textile "Copyrighted(c)", "Copyrighted&#169;"
+          assert_renders_textile "Trademarked(tm)", "Trademarked&#8482;"
+        end
+      end
+    end
+  end
+end

data/undress.gemspec ADDED

@@ -0,0 +1,40 @@
+Gem::Specification.new do |s|
+  s.name    = "undress"
+  s.version = "0.1"
+  s.date    = "2009-07-13"
+  s.description = "Simply translate HTML to Textile, Markdown, or whatever other markup format you need"
+  s.summary     = "Convert HTML into other markup languages"
+  s.homepage    = "http://undress.rubyforge.org"
+  s.authors = "Nicolás Sanguinetti"
+  s.email   = "contacto@nicolassanguinetti.info"
+  s.require_paths     = ["lib"]
+  s.rubyforge_project = "undress"
+  s.has_rdoc          = true
+  s.rubygems_version  = "1.3.1"
+  s.add_dependency "hpricot"
+  if s.respond_to?(:add_development_dependency)
+    s.add_development_dependency "sr-mg"
+    s.add_development_dependency "contest"
+    s.add_development_dependency "redgreen"
+  end
+  s.files = %w[
+.gitignore
+LICENSE
+README.rdoc
+Rakefile
+undress.gemspec
+lib/undress.rb
+lib/undress/grammar.rb
+lib/undress/textile.rb
+lib/core_ext/object.rb
+test/test_helper.rb
+test/test_grammar.rb
+test/test_textile.rb
+]
+end

metadata ADDED

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: undress
+version: !ruby/object:Gem::Version
+  version: "0.1"
+platform: ruby
+authors:
+- "Nicol\xC3\xA1s Sanguinetti"
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2009-07-13 00:00:00 -03:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hpricot
+  type: :runtime
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
+    version:
+- !ruby/object:Gem::Dependency
+  name: sr-mg
+  type: :development
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
+    version:
+- !ruby/object:Gem::Dependency
+  name: contest
+  type: :development
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
+    version:
+- !ruby/object:Gem::Dependency
+  name: redgreen
+  type: :development
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
+    version:
+description: Simply translate HTML to Textile, Markdown, or whatever other markup format you need
+email: contacto@nicolassanguinetti.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- undress.gemspec
+- lib/undress.rb
+- lib/undress/grammar.rb
+- lib/undress/textile.rb
+- lib/core_ext/object.rb
+- test/test_helper.rb
+- test/test_grammar.rb
+- test/test_textile.rb
+has_rdoc: true
+homepage: http://undress.rubyforge.org
+licenses: []
+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: undress
+rubygems_version: 1.3.4
+signing_key:
+specification_version: 3
+summary: Convert HTML into other markup languages
+test_files: []