commaparty 0.0.2pre → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ff205c728b610398ebae49f09f8b3f7bd76b7aa
-  data.tar.gz: 2fa31a4f7a4267c4a4ddadc1d8288f6b7872f7c2
+  metadata.gz: c6e73d560a55fc00b3b576893d73e44430a59ed6
+  data.tar.gz: 9e48ba511096e3ea56f0fd04ed90e2663c70db9b
 SHA512:
-  metadata.gz: 3b6b55a5955129843ad2c48b2f203c4e46126bc3a3c66fbf87df990d1aaf416a13418165cb60b1aa0e4b5e0f2f7a621ba33c7b2598238a860b62a8abc54921fe
-  data.tar.gz: 49d7511cb62731b6b664d4bb866252e85a492992930ef8c92f8d17db5e8416e80c9488459cfbc9057f811dc2f3939413c88f73896e1cad61c3f06b2994a77386
+  metadata.gz: 058f7d1a5fb6df420d9287fca8db5643b4a3dfcee1f4be03a882441643ed95e812f0e5763967cb08de2bb434c3ce385eb70ab4af75d5db51659fc63015c004bd
+  data.tar.gz: e05832615dfff1cebff80dd2ec1a207032ccfe627d4315de6cf11a86b96afb32c3314db71d2208eee9f396fd945d0cc349f217ff706d56061272338458fc98c5

data/.travis.yml

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

data/README.md

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

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/lib/commaparty/markup.rb

@@ -9,29 +9,36 @@ 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)
-      doc = Nokogiri::XML::Builder.new do |doc|
-        doc.root do |root|
-          elements.each do |element|
-            create_child(root, element)
-          end
+      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)
+      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 child.is_a?(String) || child.is_a?(Fixnum)
+        if terminal?(child)
           parent << child.to_s
         else
           create_child(parent, child)
@@ -39,5 +46,11 @@ 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.2pre"
+  VERSION = "0.0.2"
 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/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 'wat' do
+    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({})

data/spec/commaparty/markup_spec.rb

@@ -7,42 +7,180 @@ 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([:div, [:tag1], [:tag2]]).call
-      expect(html).to eq("<div>\n<tag1></tag1><tag2></tag2>\n</div>")
+      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>")
+      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")
     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>")
+      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
+
+    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") }
     end
 
   end

data/spec/commaparty/parse_body_spec.rb

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

data/spec/commaparty_spec.rb

@@ -3,40 +3,46 @@ require 'commaparty'
 describe CommaParty do
 
   it 'has a helpful html method' do
-    expect(CommaParty.html([:tag])).to match('<html><tag></tag></html>')
+    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/>')
+    expect(CommaParty.xml([:tag])).to match("<tag/>\n")
   end
 
   it 'has a helpful markup method' do
-    expect(CommaParty.markup([:tag])).to match('<tag></tag>')
+    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>" }
-    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>"}
+    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>"}
-      it { expect(CommaParty.markup [:ul, (11...13).map { |n| [:li, n]}]).to eq "<ul>\n<li>11</li>\n<li>12</li>\n</ul>"}
+      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>" }
-      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>" }
+      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>" }
-      it { expect(CommaParty.markup [:div, [:p, "Hello"], [:em, "World!"]]).to eq "<div>\n<p>Hello</p>\n<em>World!</em>\n</div>" }
+      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.2pre
+  version: 0.0.2
 platform: ruby
 authors:
 - Connor Mendenhall
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-07 00:00:00.000000000 Z
+date: 2014-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -88,12 +88,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - commaparty.gemspec
 - lib/commaparty.rb
+- lib/commaparty/.markup.rb.swn
 - lib/commaparty/destructure_element.rb
 - lib/commaparty/html.rb
 - lib/commaparty/markup.rb
@@ -125,9 +127,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