commaparty 0.0.1pre → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03a8339495655f770639b4379f0efd00ed002bc4
-  data.tar.gz: 3e7f1c68a4075921dfc9499db7be3d74d4689456
+  metadata.gz: fb1260fe51a78f3ddb15ecaf6dde6b7bf4454153
+  data.tar.gz: 20b13794581d73bc1c5320e13823db4f9110785e
 SHA512:
-  metadata.gz: 63980a3c5b5cf2b9849443cdb99a9f1937f8bbc6e8d24cdd9b060c7ca11e4f3b7cb6ba9bc14befe22eec5988489f40ac0cf18a3e3819e8521c211684f3745ce4
-  data.tar.gz: fa24ef4475c3e4e55cb46b6405a1ccd826bb5d568abdd12858c7156a2e8b6f4766a68ab7e30dba1bf1a8a2860f6d86d2c85c54aad4c4e8eb54b37c0fb3f90575
+  metadata.gz: d740c51a965cb0432cf7115707abedcb8865f855460aa527eab4688e9678b553be9143898919799e17f889fd30d22f8db462c939a4ae43675ec6768d64b84e06
+  data.tar.gz: 79977c9adcd41ff2140d07156ad2f9874d54e1b4c8edffc062027765292c2388335ba63f8c5aad710582b9a7e7290d16f4efb2dc29fe3659f897fa422bdd8ef1

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3

data/README.md

@@ -1,9 +1,12 @@
 CommaParty
 ======
+[![Build Status](https://travis-ci.org/ecmendenhall/commaparty.png?branch=master)](https://travis-ci.org/ecmendenhall/commaparty)
+
 CommaParty is a Ruby implementation of Clojure's
 [Hiccup](https://github.com/weavejester/hiccup/) HTML generation library.
 It uses arrays to represent elements, and hashes to represent an element's
-attributes. Unlike in Clojure, you have to use a lot of commas everywhere.
+attributes. Unlike in Clojure, you have to use a lot of commas everywhere all
+the time.
 
 Install
 -------
@@ -25,42 +28,31 @@ Syntax
 Here is a basic example of commaparty syntax:
 
 ```ruby
-user=> (use 'hiccup.core)
-nil
-user=> (html [:span {:class "foo"} "bar"])
-"<span class=\"foo\">bar</span>"
+[1] pry(main)> require 'commaparty'
+=> true
+[2] pry(main)> CommaParty.markup([:span, {class: "foo"}, "bar"])
+=> "<span class=\"foo\">bar</span>"
 ```
 
-The first element of the vector is used as the element name. The second
-attribute can optionally be a map, in which case it is used to supply
+The first element of the array is used as the element name. The second
+attribute can optionally be a hash, in which case it is used to supply
 the element's attributes. Every other element is considered part of the
 tag's body.
 
-Hiccup is intelligent enough to render different HTML elements in
-different ways, in order to accommodate browser quirks:
-
-  ```clojure
-user=> (html [:script])
-  "<script></script>"
-user=> (html [:p])
-  "<p />"
-  ```
+It provides a CSS-like shortcut for denoting `id` and `class`
+attributes:
 
-  And provides a CSS-like shortcut for denoting `id` and `class`
-  attributes:
+```ruby
+[1] pry(main)> CommaParty.markup([:'div#foo.bar.baz', "bang"])
+=> "<div class=\"bar baz\" id=\"foo\">bang</div>"
+```
 
-  ```clojure
-  user=> (html [:div#foo.bar.baz "bang"])
-  "<div id=\"foo\" class=\"bar baz\">bang</div>"
-  ```
+If the body of the element is an array, its contents will be expanded out
+into the element body. This makes working with methods like `map` more
+convenient:
 
-  If the body of the element is a seq, its contents will be expanded out
-  into the element body. This makes working with forms like `map` and
-  `for` more convenient:
 
-  ```clojure
-  user=> (html [:ul
-      (for [x (range 1 4)]
-       [:li x])])
-  "<ul><li>1</li><li>2</li><li>3</li></ul>"
-  ```
+```ruby
+[2] pry(main)> CommaParty.markup([:ul, (1..4).map {|n| [:li, n]}])
+=> "<ul>\n<li>1</li>\n<li>2</li>\n<li>3</li>\n<li>4</li>\n</ul>"
+```

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/commaparty.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry-nav"
 end

data/lib/commaparty/destructure_element.rb

@@ -1,3 +1,5 @@
+require 'commaparty/parse_attributes'
+require 'commaparty/parse_body'
 require 'commaparty/parse_tag'
 
 module CommaParty
@@ -14,22 +16,12 @@ module CommaParty
     private
 
     def normalize_element(element)
-      tag, tag_attributes = CommaParty::ParseTag.new(element.shift).call
-      tag = safe_tagname(tag)
-      attributes = attribute(element) || {}
+      tag, tag_attributes = CommaParty::ParseTag.new(element).call
+      attributes = CommaParty::ParseAttributes.new(element).call
+      body = CommaParty::ParseBody.new(element).call
       [tag,
        attributes.merge(tag_attributes),
-       element]
-    end
-
-    def safe_tagname(tag)
-      "#{tag.to_s}_".to_sym
-    end
-
-    def attribute(element)
-      if element.first && element.first.is_a?(Hash)
-        element.shift
-      end
+       body]
     end
 
   end

data/lib/commaparty/markup.rb

@@ -4,32 +4,44 @@ require 'commaparty/destructure_element'
 module CommaParty
   class Markup
 
-    def initialize(*hiccup)
-      @hiccup = hiccup
+    def initialize(hiccup)
+      @hiccup = [hiccup]
     end
 
     def call
-      build(*@hiccup)
+      build(@hiccup).doc.to_html
+    end
+
+    def builder
+      build(@hiccup)
+    end
+
+    def hiccup
+      @hiccup.flatten(1)
     end
 
     private
 
-    def build(*elements)
-      doc = Nokogiri::XML::Builder.new do |doc|
-        doc.root do |root|
-          elements.each do |element|
-            create_child(root, element)
-          end
+    def build(elements)
+      Nokogiri::XML::Builder.new do |doc|
+        elements.each do |element|
+          create_child(doc, element)
         end
-      end.doc.root.children.to_html
+      end
     end
 
     def create_child(node, element)
       tag, attributes, children = CommaParty::DestructureElement.new(element).call
-      if children.empty? || children.first.is_a?(String)
-        node.send(tag, attributes) {|n| n << children.first }
-      else
-        node.send(tag, attributes) {|n| n << build(*children) }
+      node.send(tag, attributes) {|n| make_nodes(n, children) }
+    end
+
+    def make_nodes(parent, children)
+      children.each do |child|
+        if child.is_a?(String) || child.is_a?(Fixnum) || child.nil?
+          parent << child.to_s
+        else
+          create_child(parent, child)
+        end
       end
     end
 

data/lib/commaparty/parse_attributes.rb

@@ -0,0 +1,17 @@
+module CommaParty
+  class ParseAttributes
+
+    def initialize(element)
+      @attributes = element[1]
+    end
+
+    def call
+      if @attributes.is_a?(Hash)
+        @attributes
+      else
+        {}
+      end
+    end
+
+  end
+end

data/lib/commaparty/parse_body.rb

@@ -0,0 +1,30 @@
+module CommaParty
+  class ParseBody
+
+    def initialize(element)
+      @element = element
+    end
+
+    def call
+      if nested?
+        body.flatten(1)
+      else
+        body
+      end
+    end
+
+    def body
+      @body ||=
+      if @element[1].is_a?(Hash)
+        @element[2..-1]
+      else
+        @element[1..-1]
+      end
+    end
+
+    def nested?
+      body[0].is_a?(Array) && !body[0][0].is_a?(Symbol)
+    end
+
+  end
+end

data/lib/commaparty/parse_tag.rb

@@ -2,11 +2,11 @@ module CommaParty
   class ParseTag
 
     def initialize(tag)
-      @tag = tag
+      @tag = tag[0]
     end
 
     def call
-      [tag_name, attributes]
+      [safe_tag_name, attributes]
     end
 
     private
@@ -32,5 +32,9 @@ module CommaParty
       @tag.to_s.match(/([^\.,#,\b]+)/).captures.first.to_sym
     end
 
+    def safe_tag_name
+      "#{tag_name.to_s}_".to_sym
+    end
+
   end
 end

data/lib/commaparty/version.rb

@@ -1,3 +1,3 @@
 module CommaParty
-  VERSION = "0.0.1pre"
+  VERSION = "0.0.1"
 end

data/lib/commaparty/xml.rb

@@ -9,20 +9,13 @@ module CommaParty
     end
 
     def initialize(markup)
-      @markup = CommaParty::Markup.new(markup).call
+      @markup = CommaParty::Markup.new(markup)
     end
 
     def call
-      build(@markup)
+      @markup.builder.to_xml
     end
 
-    private
-
-    def build(markup)
-      Nokogiri::XML::Builder.new do |doc|
-        doc << markup
-      end.to_xml
-    end
   end
 
 end

data/lib/commaparty.rb

@@ -17,5 +17,9 @@ module CommaParty
     CommaParty::Markup.new(hiccup).call
   end
 
+  def self.builder(hiccup)
+    CommaParty::Markup.new(hiccup).builder
+  end
+
 end
 

data/spec/commaparty/destructure_element_spec.rb

@@ -5,38 +5,52 @@ describe CommaParty::DestructureElement do
 
   describe 'Normalizing elements' do
     it 'destructures an element with tag only' do
-      tag, attributes, values = described_class.new([:lol]).call
+      tag, attributes, body = described_class.new([:lol]).call
       expect(tag).to eq(:lol_)
       expect(attributes).to eq({})
-      expect(values).to eq([])
+      expect(body).to eq([])
     end
 
-    it 'destructures an element with tag, attributes, and values' do
-      tag, attributes, values = described_class.new([:lol, {id: "the-id"}, "lol"]).call
+    it 'destructures an element with tag, attributes, and body' do
+      tag, attributes, body = described_class.new([:lol, {id: "the-id"}, "lol"]).call
       expect(tag).to eq(:lol_)
       expect(attributes).to eq({id: "the-id"})
-      expect(values).to eq(["lol"])
+      expect(body).to eq(["lol"])
     end
 
     it 'destructures an element with tag and attributes only' do
-      tag, attributes, values = described_class.new([:lol, {id: "the-id"}]).call
+      tag, attributes, body = described_class.new([:lol, {id: "the-id"}]).call
       expect(tag).to eq(:lol_)
       expect(attributes).to eq({id: "the-id"})
-      expect(values).to eq([])
+      expect(body).to eq([])
     end
 
-    it 'destructures an element with tag and values only' do
-      tag, attributes, values = described_class.new([:lol, 'wut']).call
+    it 'destructures an element with tag and body only' do
+      tag, attributes, body = described_class.new([:lol, 'wut']).call
       expect(tag).to eq(:lol_)
       expect(attributes).to eq({})
-      expect(values).to eq(['wut'])
+      expect(body).to eq(['wut'])
     end
 
     it 'destructures an element with sibling children' do
-      tag, attributes, values = described_class.new([:lol, {}, [:div], [:ul], [:other]]).call
+      tag, attributes, body = described_class.new([:lol, {}, [:div, {lol: 'wut'}], [:ul], [:other]]).call
       expect(tag).to eq(:lol_)
       expect(attributes).to eq({})
-      expect(values).to eq([[:div], [:ul], [:other]])
+      expect(body).to eq([[:div, {lol: 'wut'}], [:ul], [:other]])
+    end
+
+    it 'destructures an element with an array of children' do
+      tag, attributes, body = described_class.new([:ul, ["one", "two", "three"].map {|n| [:li, n]}]).call
+      expect(tag).to eq(:ul_)
+      expect(attributes).to eq({})
+      expect(body).to eq([[:li, "one"], [:li, "two"], [:li, "three"]])
+    end
+
+    it 'destructures an element with a tag in the body' do
+      tag, attributes, body = described_class.new([:p, [:em, "hello"]]).call
+      expect(tag).to eq(:p_)
+      expect(attributes).to eq({})
+      expect(body).to eq([[:em, "hello"]])
     end
   end
 end

data/spec/commaparty/markup_spec.rb

@@ -7,37 +7,69 @@ describe CommaParty::Markup do
 
     it 'generates a single tag' do
       html = described_class.new([:tag]).call
-      expect(html).to eq("<tag></tag>")
+      expect(html).to eq("<tag></tag>\n")
     end
 
     it 'generates a single tag with an attribute' do
       html = described_class.new([:tag, {attribute: 'something'}]).call
-      expect(html).to eq("<tag attribute=\"something\"></tag>")
+      expect(html).to eq("<tag attribute=\"something\"></tag>\n")
     end
 
     it 'generates a single tag with a value' do
       html = described_class.new([:tag, 'value']).call
-      expect(html).to eq("<tag>value</tag>")
+      expect(html).to eq("<tag>value</tag>\n")
     end
 
     it 'generates two sibling tags' do
-      html = described_class.new([:tag1], [:tag2]).call
-      expect(html).to eq("<tag1></tag1><tag2></tag2>")
+      html = described_class.new([:div, [:tag1], [:tag2]]).call
+      expect(html).to eq("<div>\n<tag1></tag1><tag2></tag2>\n</div>\n")
     end
 
     it 'generates nested tags' do
       html = described_class.new([:theparent, [:tag1], [:tag2]]).call
-      expect(html).to eq("<theparent><tag1></tag1><tag2></tag2></theparent>")
+      expect(html).to eq("<theparent><tag1></tag1><tag2></tag2></theparent>\n")
     end
 
     it 'handles tags with the same names as ruby methods' do
       html = described_class.new([:parent]).call
-      expect(html).to eq("<parent></parent>")
+      expect(html).to eq("<parent></parent>\n")
     end
 
     it 'handles tags with shortcut syntax' do
       html = described_class.new([:'tag.one.two.three#id']).call
-      expect(html).to eq("<tag class=\"one two three\" id=\"id\"></tag>")
+      expect(html).to eq("<tag class=\"one two three\" id=\"id\"></tag>\n")
+    end
+
+    it 'handles seqs in the tag body' do
+      html = described_class.new([:ul, ["one", "two", "three"].map {|n| [:li, n]}]).call
+      expect(html).to eq("<ul>\n<li>one</li>\n<li>two</li>\n<li>three</li>\n</ul>\n")
+    end
+
+    it 'handles nils in the tag body' do
+      html = described_class.new([:div, nil]).call
+      expect(html).to eq("<div></div>\n")
+    end
+  end
+
+  describe 'Generating builders' do
+
+    it 'returns a Nokogiri builder' do
+      builder = described_class.new([:div]).builder
+      expect(builder.class).to eq(Nokogiri::XML::Builder)
+    end
+
+    it 'produces the same XML' do
+      markup = described_class.new([:div, [:span, 'lol']])
+      expect(markup.builder.doc.to_html).to eq(markup.call)
+    end
+
+  end
+
+  describe 'Retrieving hiccup' do
+
+    it 'returns its hiccup' do
+      hiccup = described_class.new([:div, [:ul, (1..3).map {|n| [:li, n]}]]).hiccup
+      expect(hiccup).to eq([:div, [:ul, [[:li, 1], [:li, 2], [:li, 3]]]])
     end
 
   end

data/spec/commaparty/parse_attributes_spec.rb

@@ -0,0 +1,21 @@
+require 'rspec'
+require 'commaparty/parse_attributes'
+
+describe CommaParty::ParseAttributes do
+
+  it 'extracts attributes when explicitly included' do
+    attributes = described_class.new([:tag, {attribute: 'value'}]).call
+    expect(attributes).to eq({attribute: 'value'})
+  end
+
+  it 'extracts attributes when not explicitly included' do
+    attributes = described_class.new([:tag]).call
+    expect(attributes).to eq({})
+  end
+
+  it 'extracts default attributes when the tag has a body' do
+    attributes = described_class.new([:tag, 'body']).call
+    expect(attributes).to eq({})
+  end
+
+end

data/spec/commaparty/parse_body_spec.rb

@@ -0,0 +1,36 @@
+require 'rspec'
+require 'commaparty/parse_body'
+
+describe CommaParty::ParseBody do
+
+  it 'returns [] for tags with no body' do
+    body = described_class.new([:tag]).call
+    expect(body).to eq([])
+  end
+
+  it 'returns the body for tags with a body' do
+    body = described_class.new([:tag, 'body']).call
+    expect(body).to eq(['body'])
+  end
+
+  it 'returns [] for tags with attributes and no body' do
+    body = described_class.new([:tag, {}]).call
+    expect(body).to eq([])
+  end
+
+  it 'returns the body for tags with attributes and a body' do
+    body = described_class.new([:tag, {}, 'body']).call
+    expect(body).to eq(['body'])
+  end
+
+  it 'returns the body for tags with attributes and a body' do
+    body = described_class.new([:p, [:em, "hello"]]).call
+    expect(body).to eq([[:em, 'hello']])
+  end
+
+  it 'returns the body for tags with attributes and a body' do
+    body = described_class.new([:p, "Hello ", [:em, "World!"]]).call
+    expect(body).to eq(["Hello ", [:em, "World!"]])
+  end
+
+end

data/spec/commaparty/parse_tag_spec.rb

@@ -6,40 +6,52 @@ describe CommaParty::ParseTag do
   describe 'Tag shortcuts' do
 
     it 'parses tags without shortcut syntax' do
-      tag, attributes = described_class.new(:boring).call
-      expect(tag).to eq(:boring)
+      tag, attributes = described_class.new([:boring]).call
+      expect(tag).to eq(:boring_)
       expect(attributes).to eq({})
     end
 
     it 'parses tags with a class shortcut' do
-      tag, attributes = described_class.new(:'exciting.class').call
-      expect(tag).to eq(:exciting)
+      tag, attributes = described_class.new([:'exciting.class']).call
+      expect(tag).to eq(:exciting_)
       expect(attributes).to eq({class: 'class'})
     end
 
     it 'parses tags with an id shortcut' do
-      tag, attributes = described_class.new(:'exciting#id').call
-      expect(tag).to eq(:exciting)
+      tag, attributes = described_class.new([:'exciting#id']).call
+      expect(tag).to eq(:exciting_)
       expect(attributes).to eq({id: 'id'})
     end
 
     it 'parses tags with a class shortcut and id shortcut' do
-      tag, attributes = described_class.new(:'exciting.class#id').call
-      expect(tag).to eq(:exciting)
+      tag, attributes = described_class.new([:'exciting.class#id']).call
+      expect(tag).to eq(:exciting_)
       expect(attributes).to eq({class: 'class', id: 'id'})
     end
 
     it 'handles different orders' do
-      tag, attributes = described_class.new(:'exciting#id.class').call
-      expect(tag).to eq(:exciting)
+      tag, attributes = described_class.new([:'exciting#id.class']).call
+      expect(tag).to eq(:exciting_)
       expect(attributes).to eq({class: 'class', id: 'id'})
     end
 
     it 'handles multiple classes' do
-      tag, attributes = described_class.new(:'exciting.one.two').call
-      expect(tag).to eq(:exciting)
+      tag, attributes = described_class.new([:'exciting.one.two']).call
+      expect(tag).to eq(:exciting_)
       expect(attributes).to eq({class: 'one two'})
     end
+
+    it 'handles tags with attributes' do
+      tag, attributes = described_class.new([:tag, {}]).call
+      expect(tag).to eq(:tag_)
+      expect(attributes).to eq({})
+    end
+
+    it 'handles tags with attributes and values' do
+      tag, attributes = described_class.new([:tag, {}, 'value']).call
+      expect(tag).to eq(:tag_)
+      expect(attributes).to eq({})
+    end
   end
 
 end

data/spec/commaparty_spec.rb

@@ -0,0 +1,48 @@
+require 'commaparty'
+
+describe CommaParty do
+
+  it 'has a helpful html method' do
+    expect(CommaParty.html([:tag])).to match("<html><tag></tag></html>\n")
+  end
+
+  it 'has a helpful xml method' do
+    expect(CommaParty.xml([:tag])).to match("<tag/>\n")
+  end
+
+  it 'has a helpful markup method' do
+    expect(CommaParty.markup([:tag])).to match("<tag></tag>\n")
+  end
+
+  it 'has a helpful builder method' do
+    builder = CommaParty.builder([:tag])
+    expect(builder.class).to eq(Nokogiri::XML::Builder)
+    expect(builder.doc.to_html).to eq(CommaParty.markup([:tag]))
+  end
+
+  context 'converts ruby syntax to html string' do
+    it { expect(CommaParty.markup [:script]).to eq "<script></script>\n" }
+    it { expect(CommaParty.markup [:p, "hello"]).to eq "<p>hello</p>\n" }
+    it { expect(CommaParty.markup [:p, [:em, "hello"]]).to eq "<p><em>hello</em></p>\n" }
+    it { expect(CommaParty.markup [:span, {:class => "foo"}, "bar"]).to eq "<span class=\"foo\">bar</span>\n" }
+    it { expect(CommaParty.markup [:div, {id: "email", class: "selected starred"}, "..."]).to eq "<div id=\"email\" class=\"selected starred\">...</div>\n" }
+    it { expect(CommaParty.markup [:a, {:href => "http://github.com"}, "GitHub"]).to eq "<a href=\"http://github.com\">GitHub</a>\n"}
+
+    context 'collections' do
+      it { expect(CommaParty.markup [:ul, ['a','b'].map { |x| [:li, x]}]).to eq "<ul>\n<li>a</li>\n<li>b</li>\n</ul>\n"}
+      it { expect(CommaParty.markup [:ul, (11...13).map { |n| [:li, n]}]).to eq "<ul>\n<li>11</li>\n<li>12</li>\n</ul>\n"}
+    end
+
+    context 'css shorthand' do
+      it { expect(CommaParty.markup [:'p.hi', "hello"]).to eq "<p class=\"hi\">hello</p>\n" }
+      it { expect(CommaParty.markup [:'p#hi', "hello"]).to eq "<p id=\"hi\">hello</p>\n" }
+      it { expect(CommaParty.markup [:'p.hi.greet.left', "hello"]).to eq "<p class=\"hi greet left\">hello</p>\n" }
+      it { expect(CommaParty.markup [:'p#hi.greet.left', "hello"]).to eq "<p class=\"greet left\" id=\"hi\">hello</p>\n" }
+    end
+
+    context 'different shaped trees' do
+      it { expect(CommaParty.markup [:p, "Hello ", [:em, "World!"]]).to eq "<p>Hello <em>World!</em></p>\n" }
+      it { expect(CommaParty.markup [:div, [:p, "Hello"], [:em, "World!"]]).to eq "<div>\n<p>Hello</p>\n<em>World!</em>\n</div>\n" }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: commaparty
 version: !ruby/object:Gem::Version
-  version: 0.0.1pre
+  version: 0.0.1
 platform: ruby
 authors:
 - Connor Mendenhall
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-22 00:00:00.000000000 Z
+date: 2014-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -66,6 +66,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A ruby implementation of Clojure's Hiccup markup generation library.
 email:
 - ecmendenhall@gmail.com
@@ -74,6 +88,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -83,14 +98,19 @@ files:
 - lib/commaparty/destructure_element.rb
 - lib/commaparty/html.rb
 - lib/commaparty/markup.rb
+- lib/commaparty/parse_attributes.rb
+- lib/commaparty/parse_body.rb
 - lib/commaparty/parse_tag.rb
 - lib/commaparty/version.rb
 - lib/commaparty/xml.rb
 - spec/commaparty/destructure_element_spec.rb
 - spec/commaparty/html_spec.rb
 - spec/commaparty/markup_spec.rb
+- spec/commaparty/parse_attributes_spec.rb
+- spec/commaparty/parse_body_spec.rb
 - spec/commaparty/parse_tag_spec.rb
 - spec/commaparty/xml_spec.rb
+- spec/commaparty_spec.rb
 homepage: https://github.com/ecmendenhall/commaparty
 licenses:
 - MIT
@@ -106,9 +126,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.3
@@ -119,5 +139,8 @@ test_files:
 - spec/commaparty/destructure_element_spec.rb
 - spec/commaparty/html_spec.rb
 - spec/commaparty/markup_spec.rb
+- spec/commaparty/parse_attributes_spec.rb
+- spec/commaparty/parse_body_spec.rb
 - spec/commaparty/parse_tag_spec.rb
 - spec/commaparty/xml_spec.rb
+- spec/commaparty_spec.rb