commaparty 0.0.2 → 0.0.3pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6e73d560a55fc00b3b576893d73e44430a59ed6
-  data.tar.gz: 9e48ba511096e3ea56f0fd04ed90e2663c70db9b
+  metadata.gz: 0ccf4025df7a717391079619f63559d9018095a7
+  data.tar.gz: 1245299fe3cca38daa9748b5e4db70ba8fdd15c2
 SHA512:
-  metadata.gz: 058f7d1a5fb6df420d9287fca8db5643b4a3dfcee1f4be03a882441643ed95e812f0e5763967cb08de2bb434c3ce385eb70ab4af75d5db51659fc63015c004bd
-  data.tar.gz: e05832615dfff1cebff80dd2ec1a207032ccfe627d4315de6cf11a86b96afb32c3314db71d2208eee9f396fd945d0cc349f217ff706d56061272338458fc98c5
+  metadata.gz: 374c05013a8e124e6a993192866604231007c6f9c8cdaccbb0ae711afebe49a832aa4c773444763f208f04db9a1699fc0eff8c509c022e817e451bcb14dda2f2
+  data.tar.gz: b646a876669d879644a3aef76d10aa7cd7ecb788cc4ee548f78f7786efda463d2421ed903ee74f10b913ee0156d943c28301ecee6808a5193376c1340dc45905

data/README.md

@@ -1,7 +1,5 @@
 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

data/Rakefile

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

data/lib/commaparty/markup.rb

@@ -9,36 +9,29 @@ module CommaParty
     end
 
     def call
-      build(@hiccup).doc.to_html
-    end
-
-    def builder
       build(@hiccup)
     end
 
-    def hiccup
-      @hiccup.flatten(1)
-    end
-
     private
 
     def build(elements)
-      Nokogiri::XML::Builder.new do |doc|
-        elements.each do |element|
-          create_child(doc, element)
+      doc = Nokogiri::XML::Builder.new do |doc|
+        doc.root do |root|
+          elements.each do |element|
+            create_child(root, element)
+          end
         end
-      end
+      end.doc.root.children.to_html
     end
 
     def create_child(node, element)
-      return if element == []
       tag, attributes, children = CommaParty::DestructureElement.new(element).call
       node.send(tag, attributes) {|n| make_nodes(n, children) }
     end
 
     def make_nodes(parent, children)
       children.each do |child|
-        if terminal?(child)
+        if child.is_a?(String) || child.is_a?(Fixnum) || child.nil?
           parent << child.to_s
         else
           create_child(parent, child)
@@ -46,11 +39,5 @@ module CommaParty
       end
     end
 
-    def terminal?(child)
-      child.is_a?(String) ||
-      child.is_a?(Fixnum) ||
-      child.nil?
-    end
-
   end
 end

data/lib/commaparty/version.rb

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

data/lib/commaparty/xml.rb

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

data/lib/commaparty.rb

@@ -17,9 +17,5 @@ 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

@@ -46,7 +46,7 @@ describe CommaParty::DestructureElement do
       expect(body).to eq([[:li, "one"], [:li, "two"], [:li, "three"]])
     end
 
-    it 'destructures an element with a tag in the body' do
+    it 'wat' do
       tag, attributes, body = described_class.new([:p, [:em, "hello"]]).call
       expect(tag).to eq(:p_)
       expect(attributes).to eq({})

data/spec/commaparty/markup_spec.rb

@@ -7,180 +7,47 @@ describe CommaParty::Markup do
 
     it 'generates a single tag' do
       html = described_class.new([:tag]).call
-      expect(html).to eq("<tag></tag>\n")
+      expect(html).to eq("<tag></tag>")
     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>\n")
+      expect(html).to eq("<tag attribute=\"something\"></tag>")
     end
 
     it 'generates a single tag with a value' do
       html = described_class.new([:tag, 'value']).call
-      expect(html).to eq("<tag>value</tag>\n")
+      expect(html).to eq("<tag>value</tag>")
     end
 
     it 'generates two sibling tags' do
       html = described_class.new([:div, [:tag1], [:tag2]]).call
-      expect(html).to eq("<div>\n<tag1></tag1><tag2></tag2>\n</div>\n")
+      expect(html).to eq("<div>\n<tag1></tag1><tag2></tag2>\n</div>")
     end
 
     it 'generates nested tags' do
-      nested = [:parent, [:tag1, [:tag2, [:tag3, [:tag4, 'deep', [:tag5, 'nesting']]]]]]
-      html = described_class.new(nested).call
-      expect(html).to eq("<parent><tag1><tag2><tag3><tag4>deep<tag5>nesting</tag5></tag4></tag3></tag2></tag1></parent>\n")
+      html = described_class.new([:theparent, [:tag1], [:tag2]]).call
+      expect(html).to eq("<theparent><tag1></tag1><tag2></tag2></theparent>")
     end
 
     it 'handles tags with the same names as ruby methods' do
       html = described_class.new([:parent]).call
-      expect(html).to eq("<parent></parent>\n")
+      expect(html).to eq("<parent></parent>")
     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>\n")
+      expect(html).to eq("<tag class=\"one two three\" id=\"id\"></tag>")
     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")
+      expect(html).to eq("<ul>\n<li>one</li>\n<li>two</li>\n<li>three</li>\n</ul>")
     end
 
     it 'handles nils in the tag body' do
       html = described_class.new([:div, nil]).call
-      expect(html).to eq("<div></div>\n")
-    end
-
-    it 'handles empty arrays in the tag body' do
-      html = described_class.new([:div, [], 'he', [[]], 'llo']).call
-      expect(html).to eq("<div>hello</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
-
-  describe 'Hiccup specs' do
-
-    describe 'basic tags' do
-      specify { expect(described_class.new([:div]).call).to eq("<div></div>\n") }
-      specify { expect(described_class.new(["div"]).call).to eq("<div></div>\n") }
-    end
-
-    describe 'tag syntax sugar' do
-      specify { expect(described_class.new([:'div#foo']).call).to eq("<div id=\"foo\"></div>\n") }
-      specify { expect(described_class.new([:'div.foo']).call).to eq("<div class=\"foo\"></div>\n") }
-      specify { expect(described_class.new([:'div.foo', ["bar", "baz"].join]).call).
-                to eq("<div class=\"foo\">barbaz</div>\n") }
-      specify { expect(described_class.new([:'div.a.b']).call).to eq("<div class=\"a b\"></div>\n") }
-      specify { expect(described_class.new([:'div.a.b.c']).call).to eq("<div class=\"a b c\"></div>\n") }
-      specify { expect(described_class.new([:'div#foo.bar.baz']).call).
-                to eq("<div class=\"bar baz\" id=\"foo\"></div>\n") }
-    end
-
-    describe 'tag contents' do
-      specify { expect(described_class.new([:div]).call).to eq("<div></div>\n") }
-      specify { expect(described_class.new([:h1]).call).to eq("<h1></h1>\n") }
-      specify { expect(described_class.new([:script]).call).to eq("<script></script>\n") }
-      specify { expect(described_class.new([:text]).call).to eq("<text></text>\n") }
-      specify { expect(described_class.new([:a]).call).to eq("<a></a>\n") }
-      specify { expect(described_class.new([:iframe]).call).to eq("<iframe></iframe>\n") }
-      specify { expect(described_class.new([:title]).call).to eq("<title></title>\n") }
-      specify { expect(described_class.new([:section]).call).to eq("<section></section>\n") }
-      specify { expect(described_class.new([:select]).call).to eq("<select></select>\n") }
-      specify { expect(described_class.new([:object]).call).to eq("<object></object>\n") }
-      specify { expect(described_class.new([:video]).call).to eq("<video></video>\n") }
-    end
-
-    describe 'tags containing text' do
-      specify { expect(described_class.new([:text, "Lorem Ipsum"]).call).
-                to eq("<text>Lorem Ipsum</text>\n") }
-    end
-
-    describe 'contents are concatenated' do
-      specify { expect(described_class.new([:body, "foo", "bar"]).call).
-                to eq("<body>foobar</body>\n") }
-      specify { expect(described_class.new([:body, [:p], [:br]]).call).
-                to eq("<body>\n<p></p>\n<br>\n</body>\n") }
-    end
-
-    describe 'seqs are expanded' do
-      specify { expect(described_class.new([:body, ["foo", "bar"]]).call).
-                to eq("<body>foobar</body>\n") }
-    end
-
-    describe 'tags can contain tags' do
-      specify { expect(described_class.new([:div, [:p]]).call).
-                to eq("<div><p></p></div>\n") }
-      specify { expect(described_class.new([:div, [:b]]).call).
-                to eq("<div><b></b></div>\n") }
-      specify { expect(described_class.new([:p, [:span, [:a, "foo"]]]).call).
-                to eq("<p><span><a>foo</a></span></p>\n") }
-    end
-
-    describe 'tag with blank attribute map' do
-      specify { expect(described_class.new([:xml, {}]).call).
-                to eq("<xml></xml>\n") }
-    end
-
-    describe 'tag with populated attribute map' do
-      specify { expect(described_class.new([:xml, {a: "1", b: "2"}]).call).
-                to eq("<xml a=\"1\" b=\"2\"></xml>\n") }
-      specify { expect(described_class.new([:img, {id: "foo"}]).call).
-                to eq("<img id=\"foo\">\n") }
-    end
-
-    describe 'tag content can be vars' do
-      var = "foo"
-      specify { expect(described_class.new([:span, var]).call).
-                to eq("<span>foo</span>\n") }
-    end
-
-    describe 'tag content can be function calls' do
-      specify { expect(described_class.new([:span, [1, 1].inject(:+)]).call).
-                to eq("<span>2</span>\n") }
-      specify { expect(described_class.new([:span, {foo: "bar"}.fetch(:foo)]).call).
-                to eq("<span>bar</span>\n") }
-    end
-
-    describe 'attributes can contain vars' do
-      var = "foo"
-      specify { expect(described_class.new([:xml, {x: var}]).call).
-                to eq("<xml x=\"foo\"></xml>\n") }
-      specify { expect(described_class.new([:xml, {x: var}, "bar"]).call).
-                to eq("<xml x=\"foo\">bar</xml>\n") }
-    end
-
-    describe 'attributes can contain function calls' do
-
-      def foo
-        "foo"
-      end
-
-      specify { expect(described_class.new([:img, {src: ["/foo", "/bar"].join}]).call).
-                to eq("<img src=\"/foo/bar\">\n") }
-      specify { expect(described_class.new([:div, {id: ["a", "b"].join}, foo]).call).
-                to eq("<div id=\"ab\">foo</div>\n") }
+      expect(html).to eq("<div></div>")
     end
 
   end

data/spec/commaparty/parse_body_spec.rb

@@ -3,7 +3,7 @@ require 'commaparty/parse_body'
 
 describe CommaParty::ParseBody do
 
-  it 'returns [] for tags with no body' do
+  it 'returns nil for tags with no body' do
     body = described_class.new([:tag]).call
     expect(body).to eq([])
   end

data/spec/commaparty_spec.rb

@@ -3,46 +3,40 @@ require 'commaparty'
 describe CommaParty do
 
   it 'has a helpful html method' do
-    expect(CommaParty.html([:tag])).to match("<html><tag></tag></html>\n")
+    expect(CommaParty.html([:tag])).to match('<html><tag></tag></html>')
   end
 
   it 'has a helpful xml method' do
-    expect(CommaParty.xml([:tag])).to match("<tag/>\n")
+    expect(CommaParty.xml([:tag])).to match('<tag/>')
   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]))
+    expect(CommaParty.markup([:tag])).to match('<tag></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"}
+    it { expect(CommaParty.markup [:script]).to eq "<script></script>" }
+    it { expect(CommaParty.markup [:p, "hello"]).to eq "<p>hello</p>" }
+    it { expect(CommaParty.markup [:p, [:em, "hello"]]).to eq "<p><em>hello</em></p>" }
+    it { expect(CommaParty.markup [:span, {:class => "foo"}, "bar"]).to eq "<span class=\"foo\">bar</span>" }
+    it { expect(CommaParty.markup [:div, {id: "email", class: "selected starred"}, "..."]).to eq "<div id=\"email\" class=\"selected starred\">...</div>" }
+    it { expect(CommaParty.markup [:a, {:href => "http://github.com"}, "GitHub"]).to eq "<a href=\"http://github.com\">GitHub</a>"}
 
     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"}
+      it { expect(CommaParty.markup [:ul, ['a','b'].map { |x| [:li, x]}]).to eq "<ul>\n<li>a</li>\n<li>b</li>\n</ul>"}
+      it { expect(CommaParty.markup [:ul, (11...13).map { |n| [:li, n]}]).to eq "<ul>\n<li>11</li>\n<li>12</li>\n</ul>"}
     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" }
+      it { expect(CommaParty.markup [:'p.hi', "hello"]).to eq "<p class=\"hi\">hello</p>" }
+      it { expect(CommaParty.markup [:'p#hi', "hello"]).to eq "<p id=\"hi\">hello</p>" }
+      it { expect(CommaParty.markup [:'p.hi.greet.left', "hello"]).to eq "<p class=\"hi greet left\">hello</p>" }
+      it { expect(CommaParty.markup [:'p#hi.greet.left', "hello"]).to eq "<p class=\"greet left\" id=\"hi\">hello</p>" }
     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" }
+      it { expect(CommaParty.markup [:p, "Hello ", [:em, "World!"]]).to eq "<p>Hello <em>World!</em></p>" }
+      it { expect(CommaParty.markup [:div, [:p, "Hello"], [:em, "World!"]]).to eq "<div>\n<p>Hello</p>\n<em>World!</em>\n</div>" }
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: commaparty
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3pre
 platform: ruby
 authors:
 - Connor Mendenhall
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-12 00:00:00.000000000 Z
+date: 2014-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -95,7 +95,6 @@ files:
 - Rakefile
 - commaparty.gemspec
 - lib/commaparty.rb
-- lib/commaparty/.markup.rb.swn
 - lib/commaparty/destructure_element.rb
 - lib/commaparty/html.rb
 - lib/commaparty/markup.rb
@@ -127,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: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.3