RubyGems - undress - Versions diffs - 0.1 - Mend

undress 0.1

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 (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: []