hentry_consumer 0.4.0 → 0.5.0

data/Gemfile

@@ -1,9 +1,4 @@
 source 'https://rubygems.org'
 
-group :test, :development do
-  gem "rspec"
-  gem 'guard-rspec'
-  gem 'rb-fsevent', '~> 0.9.1'
-end
-
+# Specify your gem's dependencies in hentry_consumer.gemspec
 gemspec

data/README.md

@@ -22,7 +22,7 @@ serialized h-entry objects. The returned Object structure looks something like t
 
 ## Current Version
 
-0.4.0
+0.5.0
 
 
 ## Requirements
@@ -57,10 +57,12 @@ require "hentry_consumer"
 HentryConsumer.parse(File|URL)
 ```
 [Example Gist of HTML with h-entry posts](https://raw.github.com/gist/3835447/7128a66a3ac7e971a82daac5fa2076d17b88e435/gistfile1.html)
+[Another Example Gist of HTML with h-entry posts](https://gist.github.com/88d6d476483e9528fb3a)
 
 ## Authors
 
 * Bookis Smuin / [@bookis](https://github.com/bookis)
+* Jessica Lynn Suttles / [@jlsuttles](https://github.com/jlsuttles)
 
 ## Contributions
 
@@ -78,13 +80,13 @@ If you find bugs, have feature requests or questions, please
 ### Specs
 
 ```bash
-rake spec
+guard
 ```
 
 ### Releases
 
 ```bash
-TODO how do you do a release?
+rake release
 ```
 
 

data/hentry_consumer.gemspec

@@ -6,8 +6,8 @@ require 'hentry_consumer/version'
 Gem::Specification.new do |gem|
   gem.name          = "hentry_consumer"
   gem.version       = HentryConsumer::VERSION
-  gem.authors       = ["Bookis Smuin"]
-  gem.email         = ["vegan.bookis@gmail.com"]
+  gem.authors       = ["Bookis Smuin", "Jessica Lynn Suttles"]
+  gem.email         = ["vegan.bookis@gmail.com", "jlsuttles@gmail.com"]
   gem.description   = %q{A hATOM feed parser}
   gem.summary       = %q{Takes in HTML containing an h-feed classed element and returns serialized data based on the Microformat 2 hEntry specs}
   gem.homepage      = "https://github.com/G5/hentry_consumer"
@@ -17,7 +17,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
   
-  gem.add_dependency 'nokogiri'
-  gem.add_dependency 'json'
+  gem.add_runtime_dependency 'nokogiri'
+  gem.add_runtime_dependency 'json'
   
+  gem.add_development_dependency "rspec", "~> 2.11.0"
+  gem.add_development_dependency "guard-rspec", "~> 2.1.0"
+  gem.add_development_dependency "rb-fsevent", "~> 0.9.2"
+  gem.add_development_dependency "debugger", "~> 1.2.1"
 end

data/lib/hentry_consumer/element.rb

@@ -2,29 +2,40 @@ module HentryConsumer
   class Element
     attr_accessor :element
     
-    def initialize(microformat)
-      @element = microformat
-      parse_elements
+    def initialize(element)
+      @element = element
+      parse_elements(@element)
     end
-    
-    def to_html
-      @element.to_html
-    end
-    
-    def to_xml
-      @element.to_xml
+
+    def parse_elements(elements)
+      if elements.is_a?(Nokogiri::XML::NodeSet)
+        elements.each do |element|
+          parse_elements(element)
+        end
+      else
+        parse_element(elements)
+      end
     end
 
-    def parse_elements
-      FormatClass.each do |letter|
-        @element.css(">*[class*=#{letter}-]").each do |a|
-          assign_value(symbolize_class(a["class"]), a.text.gsub('\n', " ").strip)
+    def parse_element(element)
+      classes = element["class"]
+      # element may be a microformat element
+      if classes =~ /(p|n|e|i|u|dt)-/
+        classes.split.each do |c|
+          parse_microformat(element, c)
         end
+      # element may contain a microformat element
+      else
+        parse_elements(element.children)
       end
     end
 
-    def symbolize_class(klass)
-      klass.to_s.downcase.split.first.gsub(/\w{1,2}-/, "").to_sym
+    def parse_microformat(element, c)
+      assign_value(symbolize_class(c), element.text)
+    end
+
+    def symbolize_class(c)
+      c.to_s.downcase.gsub(/\w{1,2}-/, "").to_sym
     end
 
     def [](key)
@@ -37,6 +48,7 @@ module HentryConsumer
 
     def assign_value(symbolized_class, value)
       return unless self.respond_to?(symbolized_class)
+      value = value.gsub('\n', " ").strip if value.is_a?(String)
       if FormatRules.can_have_many?(symbolized_class)
         self[symbolized_class] ||= []
         self[symbolized_class] << value
@@ -44,5 +56,13 @@ module HentryConsumer
         self[symbolized_class] = value
       end
     end
+
+    def to_html
+      @element.to_html
+    end
+    
+    def to_xml
+      @element.to_xml
+    end
   end
-end
+end

data/lib/hentry_consumer/format_rules.rb

@@ -1,7 +1,8 @@
 module HentryConsumer
   class FormatRules
-    REQUIRED      = []
-    UNIQUE = [:uid, :bookmark]
+    REQUIRED = []
+    UNIQUE   = [:uid, :bookmark]
+
     class << self
       def required?(format)
         REQUIRED.include? format
@@ -15,4 +16,4 @@ module HentryConsumer
       end
     end
   end
-end
+end

data/lib/hentry_consumer/h_card.rb

@@ -16,6 +16,5 @@ module HentryConsumer
         }]
       }.to_json(a)
     end
-    
   end
-end
+end

data/lib/hentry_consumer/h_entry.rb

@@ -1,59 +1,60 @@
 module HentryConsumer
   class HEntry < Element
-
     attr_accessor :name, :categories, :author, :content, :bookmark, :published_at, :summary
     alias_method :authors, :author
 
-    def parse_elements
-      FormatClass.each do |letter|
-        @element.css(">*[class*=#{letter}-]").each do |attrs|
-          attrs["class"].split.each do |klass|
-            parse_element(attrs, klass)
-          end
-        end
+    # overrides Element#parse_microformat
+    def parse_microformat(element, c)
+      case c
+      when "p-author"     then parse_author(element)
+      when "p-category"   then parse_category(element)
+      when "e-content"    then parse_content(element)
+      when "dt-published" then parse_published(element)
+      when "u-uid"        then parse_uid(element)
+      else                     parse_general(element, c)
       end
     end
 
+    def parse_author(element)
+      assign_value :author, HCard.new(element.children)
+    end
+
+    def parse_category(element)
+      self.categories ||= {}
+      self.categories[element.text.gsub("\n", " ").strip] = element["href"]
+    end
+
+    def parse_content(element)
+      assign_value :content, element.inner_html
+    end
+
+    def parse_published(element)
+      assign_value :published_at, element["datetime"]
+    end
+
+    def parse_uid(element)
+      assign_value :bookmark, element["href"]
+    end
+
+    def parse_general(element, c)
+      assign_value symbolize_class(c), element.text
+    end
+
     def to_json(*a)
       {:items =>
         [{
           :type => ["h-entry"],
           :properties => {
-            :name       => self.name,
-            :categories => self.categories,
-            :author => self.author,
-            :content    => self.content,
-            :bookmark   => self.bookmark,
-            :published_at  => self.published_at,
-            :summary    => self.summary
+            :name         => self.name,
+            :categories   => self.categories,
+            :author       => self.author,
+            :content      => self.content,
+            :bookmark     => self.bookmark,
+            :published_at => self.published_at,
+            :summary      => self.summary
           }
         }]
       }.to_json(a)
     end
-
-    private
-
-    def parse_element(microformat, klass)
-      key, value = case klass
-      when 'p-author'
-        [symbolize_class(klass), HCard.new(microformat)]
-      when 'p-category'
-        self.categories ||= {}
-        self.categories[microformat.text.gsub('\n', " ").strip] = microformat["href"]
-      when 'e-content'
-        [:content, parse_content(microformat)]
-      when'dt-published'
-        [:published_at, microformat["datetime"]]
-      when "u-uid"
-        [:bookmark, microformat['href']]
-      else
-        [symbolize_class(klass), microformat.text.gsub('\n', " ").strip]
-      end
-      assign_value(key, value)
-    end
-
-    def parse_content(microformat)
-      microformat.inner_html
-    end
   end
-end
+end

data/lib/hentry_consumer/h_feed.rb

@@ -1,21 +1,22 @@
 module HentryConsumer
   class HFeed
-    attr_accessor :entries
+    attr_accessor :html, :entries
+
     def initialize(html)
+      @html = Nokogiri::HTML(open(html).read)
       @entries = []
-      parse_html(html)
+      parse_html
     end
 
-    def parse_html(html)
-      doc = Nokogiri::HTML(open(html).read)
-      doc.css(".h-entry").each do |mf_entry|
-        entry = HEntry.new(mf_entry)
+    def parse_html
+      self.html.css(".h-entry").each do |hentry|
+        entry = HEntry.new(hentry.children)
         self.entries << entry
       end
     end
 
     def to_html
-      self.entries.collect(&:to_html).join
+      self.html.css(".h-entry").collect(&:to_html).join
     end
     alias_method :to_s, :to_html
 
@@ -29,4 +30,4 @@ module HentryConsumer
     end
     
   end
-end
+end

data/lib/hentry_consumer/version.rb

@@ -1,3 +1,3 @@
 module HentryConsumer
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/hentry_consumer.rb

@@ -1,13 +1,18 @@
+# I don't think you're supposed to require gems here,
+# they should go in the Gemspec as dependencies
 require 'nokogiri'
 require 'open-uri'
 require 'json'
-require 'hentry_consumer/element'
 Gem.find_files("hentry_consumer/**/*.rb").each { |path| require path }
 
 module HentryConsumer
-  FormatClass = %w(p n e i u dt)
-  def self.parse(html)
-    HFeed.new(html)
+  module ClassMethods
+    def parse(html)
+      HFeed.new(html)
+    end
+  end
+  extend ClassMethods
+  def self.included(other)
+    other.extend(ClassMethods)
   end
-  
 end

data/spec/lib/hentry_consumer/h_card_spec.rb

@@ -1,17 +1,30 @@
 require 'hentry_consumer'
 
-describe HentryConsumer::HEntry do
+describe HentryConsumer::HCard do
   before do
     stub_const("HentryConsumer::FormatRules::REQUIRED", [:url, :email])
     stub_const("HentryConsumer::FormatRules::UNIQUE", [:uid, :bookmark])
   end
 
-  let(:result) { HentryConsumer.parse(File.open("spec/support/example.html")) }
-  let(:entry) { result.entries.first }
-  subject { entry.authors.first }
+  describe "example.html" do
+    let(:result) { HentryConsumer.parse(File.open("spec/support/example.html")) }
+    let(:entry) { result.entries.first }
+    subject { entry.authors.first }
 
-  its(:name)  { should eq ["Jessica Suttles"]}
+    its(:name)  { should eq ["Jessica Suttles"]}
 
-  its(:emails) { should have(1).things }
-  its(:urls) { should have(2).things }
+    its(:emails) { should have(1).things }
+    its(:urls) { should have(2).things }
+  end
+
+  describe "nested_example.html" do
+    let(:result) { HentryConsumer.parse(File.open("spec/support/nested_example.html")) }
+    let(:entry) { result.entries.first }
+    subject { entry.authors.first }
+
+    its(:name)  { should eq ["Jessica"]}
+
+    its(:emails) { should have(1).things }
+    its(:urls) { should have(1).things }
+  end
 end

data/spec/lib/hentry_consumer/h_entry_spec.rb

@@ -1,75 +1,151 @@
 require 'hentry_consumer'
 
 describe HentryConsumer::HEntry do
-  let(:result) { HentryConsumer.parse(File.open("spec/support/example.html")) }
-  let(:entry) { result.entries.first }
+  describe "example.html" do
+    let(:result) { HentryConsumer.parse("spec/support/example.html") }
+    let(:entry) { result.entries.first }
 
-  it "should have an array of entries" do
-    entry.should be_an_instance_of HentryConsumer::HEntry
-  end
-  
-  it "has a name" do
-    entry.name.should eq ["Senior Cat Living"]
-  end
+    it "should have an array of entries" do
+      entry.should be_an_instance_of HentryConsumer::HEntry
+    end
 
-  it "has a summary" do
-    entry.summary.should eq ["Signed up with 3 locations"]
-  end
+    it "has a name" do
+      entry.name.should eq ["Senior Cat Living"]
+    end
 
-  it "has a time" do
-    entry.published_at.should eq ["2012-08-26 20:09-0700"]
-  end
+    it "has a summary" do
+      entry.summary.should eq ["Signed up with 3 locations"]
+    end
 
-  it "has a bookmark" do
-    entry.bookmark.should eq "http://g5.com/feed/entries/2012-08-26-20-09-0700"
-  end
+    it "has a time" do
+      entry.published_at.should eq ["2012-08-26 20:09-0700"]
+    end
 
-  it "should have 2 authors" do
-    entry.authors.should have(2).things HentryConsumer::HCard
-  end
-  it "has an author as an hcard" do
-    entry.authors.first.should be_an_instance_of HentryConsumer::HCard
-  end
+    it "has a bookmark" do
+      entry.bookmark.should eq "http://g5.com/feed/entries/2012-08-26-20-09-0700"
+    end
 
-  describe "categories" do
-    it "has an array of categories" do
-      entry.categories.should be_an_instance_of Hash
+    it "should have 2 authors" do
+      entry.authors.should have(2).things HentryConsumer::HCard
     end
 
-    it "has a key of the content" do
-      entry.categories["New Customer"].should eq "http://g5.com/tag/new-customer"
+    it "has an author as an hcard" do
+      entry.authors.first.should be_an_instance_of HentryConsumer::HCard
+    end
+
+    describe "categories" do
+      it "has an array of categories" do
+        entry.categories.should be_an_instance_of Hash
+      end
+
+      it "has a key of the content" do
+        entry.categories["New Customer"].should eq "http://g5.com/tag/new-customer"
+      end
+    end
+
+    describe "content" do
+      let(:content) { entry.content }
+
+      it "should be a blob of html" do
+        content.first.should match /Locations/
+      end
+
+      it "should be a blob of html" do
+        content.first.should match /\<dt\>/
+      end
+
+      it "should be a blob of html" do
+        content.first.should_not match /time/
+      end
+
+    end
+
+    describe "json" do
+      let(:json) { JSON.parse(entry.to_json) }
+
+      it { json["items"].should be_an_instance_of Array }
+      it { json["items"].first["type"].should include 'h-entry'}
+      it { json["items"].first["properties"]["name"].should eq ['Senior Cat Living']}
+      it { json["items"].first["properties"]["content"].first.should match /Locations/ }
+      it { json["items"].first["properties"]["author"].should be_an_instance_of Array }
+      it { json["items"].first["properties"]["author"].first["items"].first["type"].should include "h-card" }
+      it { json["items"].first["properties"]["bookmark"].should eq "http://g5.com/feed/entries/2012-08-26-20-09-0700" }
+      it { json["items"].first["properties"]["published_at"].should eq ["2012-08-26 20:09-0700"] }
+      it { json["items"].first["properties"]["summary"].should be_an_instance_of Array }
     end
   end
 
-  describe "content" do
-    let(:content) { entry.content }
+  describe "nested_example.html" do
+    let(:result) { HentryConsumer.parse("spec/support/nested_example.html") }
+    let(:entry) { result.entries.first }
 
-    it "should be a blob of html" do
-      content.first.should match /Locations/
+    it "should have an array of entries" do
+      entry.should be_an_instance_of HentryConsumer::HEntry
     end
 
-    it "should be a blob of html" do
-      content.first.should match /\<dt\>/
+    it "has a name" do
+      entry.name.should eq ["Wabi Sabi Town"]
     end
 
-    it "should be a blob of html" do
-      content.first.should_not match /time/
+    it "has a summary" do
+      entry.summary.should eq ["Signed up with 2 locations"]
     end
 
-  end
-  
-  describe "json" do
-    let(:json) { JSON.parse(entry.to_json) }
-
-    it { json["items"].should be_an_instance_of Array }
-    it { json["items"].first["type"].should include 'h-entry'}
-    it { json["items"].first["properties"]["name"].should eq ['Senior Cat Living']}
-    it { json["items"].first["properties"]["content"].first.should match /Locations/ }
-    it { json["items"].first["properties"]["author"].should be_an_instance_of Array }
-    it { json["items"].first["properties"]["author"].first["items"].first["type"].should include "h-card" }
-    it { json["items"].first["properties"]["bookmark"].should eq "http://g5.com/feed/entries/2012-08-26-20-09-0700" }
-    it { json["items"].first["properties"]["published_at"].should eq ["2012-08-26 20:09-0700"] }
-    it { json["items"].first["properties"]["summary"].should be_an_instance_of Array }
-  end
+    it "has a time" do
+      entry.published_at.should eq ["2012-10-10T19:11:17Z"]
+    end
+
+    it "has a bookmark" do
+      entry.bookmark.should eq "http://localhost:3000/customers/3"
+    end
+
+    it "should have 1 author" do
+      entry.authors.should have(1).things HentryConsumer::HCard
+    end
+
+    it "has an author as an hcard" do
+      entry.authors.first.should be_an_instance_of HentryConsumer::HCard
+    end
+
+    describe "categories" do
+      it "has an array of categories" do
+        entry.categories.should be_an_instance_of Hash
+      end
 
+      it "has a key of the content" do
+        entry.categories["Some Category"].should eq "#"
+      end
+    end
+
+    describe "content" do
+      let(:content) { entry.content }
+
+      it "should be a blob of html" do
+        content.first.should match /Locations/
+      end
+
+      it "should be a blob of html" do
+        content.first.should match /\<dt\>/
+      end
+
+      it "should be a blob of html" do
+        content.first.should_not match /time/
+      end
+
+    end
+
+    describe "json" do
+      let(:json) { JSON.parse(entry.to_json) }
+
+      it { json["items"].should be_an_instance_of Array }
+      it { json["items"].first["type"].should include 'h-entry'}
+      it { json["items"].first["properties"]["name"].should eq ['Wabi Sabi Town']}
+      it { json["items"].first["properties"]["content"].first.should match /Locations/ }
+      it { json["items"].first["properties"]["author"].should be_an_instance_of Array }
+      it { json["items"].first["properties"]["author"].first["items"].first["type"].should include "h-card" }
+      it { json["items"].first["properties"]["bookmark"].should eq "http://localhost:3000/customers/3" }
+      it { json["items"].first["properties"]["published_at"].should eq ["2012-10-10T19:11:17Z"] }
+      it { json["items"].first["properties"]["summary"].should be_an_instance_of Array }
+    end
+  end
 end