RubyGems - wraptext - Versions diffs - 0.1 - Mend

Files changed (11) hide show

data/.gitignore +17 -0
data/.rspec +2 -0
data/Gemfile +5 -0
data/README.md +27 -0
data/Rakefile +4 -0
data/lib/wraptext.rb +2 -0
data/lib/wraptext/parser.rb +121 -0
data/spec/spec_helper.rb +6 -0
data/spec/wraptext/parser_spec.rb +116 -0
data/wraptext.gemspec +17 -0
metadata +89 -0

data/.gitignore ADDED Viewed

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ --color
2	+ --format documentation

data/Gemfile ADDED Viewed

@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+gemspec
+gem 'rspec'

data/README.md ADDED Viewed

@@ -0,0 +1,27 @@
+# Wraptext
+## What is it?
+Wraptext is a small library designed to accept "blog-style" newline-delimited text with markup, and to return a formatted document with bare text wrapped in `<p>` tags, splitting text nodes with double newlines in them into multiple paragraphs.
+## How to use it
+Add it to your gemfile:
+    gem 'wraptext'
+Then parse your text with it:
+    Wraptext::Parser.new(your_html_fragment).to_html
+This'll return your text fragment with bare text wrapped in paragraph tags, and text nodes that include double newlines split into distinct paragraphs. The primary intent was to enable parsing of Wordpress-generated post content into valid HTML documents, but because the parser is designed to work on generic HTML documents, may be used beyond Wordpress content.
+`Wraptext::Parser` accepts a Nokogiri document, as well, if you already have an existing document you are working with. Wraptext will *not* modify the original document object you pass in; it will create its own internal Nokogiri document to build the new document tree from. You may access this new document with `#to_doc`, if desired.
+## Why not simple_format?
+simple_format is not HTML-aware, and may potentially mangle HTML in ways that you don't want. For example, it would mangle `<script>` and `<pre>` sections in text, breaking them.
+## Why not regexes, like Wordpress does it?
+Mostly because parsing HTML with regexes is almost never the right solution. Using Nokogiri ensures a properly-formed document.

data/Rakefile ADDED Viewed

@@ -0,0 +1,4 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')

data/lib/wraptext.rb ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ require 'nokogiri'
2	+ require 'wraptext/parser'

data/lib/wraptext/parser.rb ADDED Viewed

@@ -0,0 +1,121 @@
+module Wraptext
+  class Parser
+    BLOCK_TAGS = %w"table thead tfoot caption col colgroup tbody tr td th div dl dd dt
+    ul ol li pre select option form map area blockquote address math style input hr
+    fieldset legend section article aside hgroup header footer nav p
+    figure figcaption details menu summary h1 h2 h3 h4 h5 h6 script"
+    BLOCK_TAGS_LOOKUP = Hash[*BLOCK_TAGS.map {|e| [e, 1]}.flatten]
+    NO_WRAP_TAG = %w"table thead tfoot caption col colgroup tbody tr td th dl dd dt
+    ul ol li pre select option form map area math style input hr
+    fieldset legend section article aside hgroup header footer nav
+    figure figcaption details menu summary h1 h2 h3 h4 h5 h6 script"
+    NO_WRAP_TAG_LOOKUP = Hash[*NO_WRAP_TAG.map {|e| [e, 1]}.flatten]
+    STRAIGHT_COPY_TAGS = %w"script pre textarea"
+    STRAIGHT_COPY_TAGS_LOOKUP = Hash[*STRAIGHT_COPY_TAGS.map {|e| [e, 1]}.flatten]
+    MULTIPLE_NEWLINES_REGEX = /(\r\n|\n){2,}/
+    def self.parse(text)
+      new(text).to_html
+    end
+    def initialize(text_or_nokogiri_doc)
+      @doc = if text_or_nokogiri_doc.is_a? Nokogiri::XML::Document
+        text_or_nokogiri_doc
+      elsif text_or_nokogiri_doc.is_a? String
+        Nokogiri::HTML text_or_nokogiri_doc
+      else
+        raise "#initialize requires a string or Nokogiri document"
+      end
+      @root = Nokogiri::HTML "<body></body>"
+      reparent_nodes @root.xpath("/html/body").first, @doc.xpath("/html/body").first
+      strip_empty_paragraphs!
+    end
+    def to_html
+      @html ||= @root.xpath("/html/body").inner_html
+    end
+    def to_doc
+      @doc_out ||= @root.xpath("/html/body").first
+    end
+    private
+    def strip_empty_paragraphs!
+      @root.xpath("//p").each do |node|
+        if node.text.strip == ''
+          empty = true
+          node.children.each do |child|
+            if child.name != "text"
+              empty = false
+              break
+            end
+          end
+          node.remove if empty
+        end
+      end
+    end
+    # This traverses the entire document, and where it finds double newlines in text,
+    # it replaces them with <p> tags. This is a document-oriented approach to this
+    # problem, rather than a regex-oriented one like Wordpress takes in PHP.
+    # simple_format is not appropriate here, as it does not consider block-level
+    # html element context when performing substitutions.
+    def reparent_nodes(top, parent)
+      for i in (0..parent.children.length - 1) do
+        node = parent.children[i]
+        # Block-level tags like <div> and <blockquote> should be traversed into.
+        if BLOCK_TAGS_LOOKUP.has_key? node.name
+          # If we hit a block-level tag, we need to unwind any <p> tags we've inserted; block level elements are
+          # siblings to <p> tags, not children.
+          top = top.parent while top.name == "p"
+          # Some tags we don't want to traverse into, like <pre> and <script>. Just copy them into the doc.
+          if STRAIGHT_COPY_TAGS_LOOKUP.has_key? node.name
+            top.add_child node.clone
+          else
+            # If this is a block-level element, we'll create a new empty version of it, stick it into the doc,
+            # then recurse over the original node's children to populate it.
+            copy = @root.create_element node.name, node.attributes
+            top.add_child copy
+            reparent_nodes copy, node
+          end
+        # If this is a text node, we need to make sure it gets wrapped in a P, unless it's in an element that
+        # effectively replaces <p>, like <h1>.
+        # Text is split on double newlines, and each element is given its own <p> tag. If the text already exists
+        # in a <p> tag, the existing tag is re-used for the first chunk.
+        elsif node.text?
+          node.content.split(MULTIPLE_NEWLINES_REGEX).each_with_index do |text, index|
+            if (index == 0 and top.name == "p") or NO_WRAP_TAG_LOOKUP.has_key?(top.name)
+              top.add_child @root.create_text_node(text)
+            elsif top.name == "p"
+              p = @root.create_element "p", text
+              top.after p
+              top = p
+            else
+              p = @root.create_element "p", text
+              top.add_child p
+              top = p
+            end
+          end
+        # If this isn't a block or text node, we need to copy it into the new document. If it's a <p> node, then
+        # we just copy it in directly. Else, wrap it in a <p> tag and copy it in.
+        # This allows things like "<em>Foo</em> Bar Baz" to be wrapped in a single tag, as the <em> tag will be
+        # wrapped in a <p> tag, then the text node will reuse the existing <p> tag when it is parsed.
+        else
+          if top.name == "p"
+            top.add_child node.clone
+          else
+            p = @root.create_element "p", text
+            top.add_child p
+            top = p
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb ADDED Viewed

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'wraptext'
+RSpec.configure do |config|
+end

data/spec/wraptext/parser_spec.rb ADDED Viewed

@@ -0,0 +1,116 @@
+require 'spec_helper'
+describe Wraptext::Parser do
+  it "should accept a String document" do
+    Wraptext::Parser.new("This is a string document").should be_a(Wraptext::Parser)
+  end
+  it "should accept a Nokogiri document" do
+    doc = Nokogiri::HTML "<body>foo</body>"
+    Wraptext::Parser.new(doc).should be_a(Wraptext::Parser)
+  end
+  context "given a document" do
+    before :each do
+      doc = <<-EOF
+      This is some text.
+      This is some more text.
+      EOF
+      @doc = Wraptext::Parser.new(doc)
+    end
+    it "should return a string from #to_html" do
+      @doc.to_html.should be_a(String)
+    end
+    it "should return a Nokogiri::XML::Element from #to_doc" do
+      @doc.to_doc.should be_a(Nokogiri::XML::Element)
+    end
+  end
+  context "given a set of plain text" do
+    before :each do
+      doc = <<-EOF
+      This is some text.
+      This is some more text.
+      EOF
+      @doc = Wraptext::Parser.new(doc)
+    end
+    it "should convert plain text to p-wrapped text" do
+      expects = <<-EOF
+<p>This is some text.</p>
+<p>      This is some more text.
+</p>
+EOF
+      @doc.to_html.should == expects.strip
+    end
+  end
+  context "given plain text with a block element in the middle" do
+    it "should respect block-level elements" do
+      doc = <<-EOF
+This is some text
+<div>This is a block level element</div>
+This is some text after the block element
+EOF
+      expects = <<-EOF
+<p>This is some text
+</p>
+<div><p>This is a block level element</p></div>
+<p>
+This is some text after the block element
+</p>
+EOF
+      Wraptext::Parser.new(doc).to_html.should == expects.strip
+    end
+  end
+  context "given plain text with some p-peer tags" do
+    it "should not inject p tags directly inside p-peer tags" do
+      doc = <<-EOF
+This is some text
+<h1>This is a p-peer element</h1>
+This is some text after the block element
+EOF
+      expects = <<-EOF
+<p>This is some text
+</p>
+<h1>This is a p-peer element</h1>
+<p>
+This is some text after the block element
+</p>
+EOF
+      Wraptext::Parser.new(doc).to_html.should == expects.strip
+    end
+  end
+  context "given a <script> tag" do
+    it "should not perform any transformation inside the tag" do
+      doc = <<-EOF
+This is some precursor text
+And another line
+<script>
+  var elem = 'this is some javascript';
+  elem = elem.toUpperCase();
+</script>
+EOF
+      expects = <<-EOF
+<p>This is some precursor text</p>
+<p>And another line
+</p>
+<script>
+  var elem = 'this is some javascript';
+  elem = elem.toUpperCase();
+</script>
+EOF
+      Wraptext::Parser.new(doc).to_html.should == expects.strip
+    end
+  end
+end

data/wraptext.gemspec ADDED Viewed

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |gem|
+  gem.authors       = ["Chris Heald"]
+  gem.email         = ["cheald@gmail.com"]
+  gem.description   = %q{Wraps bare text nodes from an HTML document in <p> tags and splits text nodes on double newlines. Conveniently serves to format Wordpress post content properly as a side effect.}
+  gem.summary       = %q{Wraps bare text nodes from an HTML document in <p> tags and splits text nodes on double newlines.}
+  gem.homepage      = ""
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "wraptext"
+  gem.require_paths = ["lib"]
+  gem.version       = "0.1"
+  gem.add_dependency('nokogiri')
+end

metadata ADDED Viewed

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: wraptext
+version: !ruby/object:Gem::Version
+  hash: 9
+  prerelease:
+  segments:
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors:
+- Chris Heald
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-01-29 00:00:00 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        hash: 3
+        segments:
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Wraps bare text nodes from an HTML document in <p> tags and splits text nodes on double newlines. Conveniently serves to format Wordpress post content properly as a side effect.
+email:
+- cheald@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- lib/wraptext.rb
+- lib/wraptext/parser.rb
+- spec/spec_helper.rb
+- spec/wraptext/parser_spec.rb
+- wraptext.gemspec
+homepage: ""
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      hash: 3
+      segments:
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      hash: 3
+      segments:
+      - 0
+      version: "0"
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.12
+signing_key:
+specification_version: 3
+summary: Wraps bare text nodes from an HTML document in <p> tags and splits text nodes on double newlines.
+test_files:
+- spec/spec_helper.rb
+- spec/wraptext/parser_spec.rb
+has_rdoc:

wraptext 0.1