hentry_consumer 0.5.1 → 0.5.2

data/lib/hentry_consumer/element.rb

@@ -1,39 +1,74 @@
 module HentryConsumer
   class Element
-    attr_accessor :element
+    attr_accessor :element, :items
     
+    # If a single element is give, return that
+    # If many elements are given, return as array
     def initialize(element)
       @element = element
-      parse_elements(@element)
+      @items = parse_elements(@element)
     end
 
     def parse_elements(elements)
+      # if there are many elements, parse each of them
       if elements.is_a?(Nokogiri::XML::NodeSet)
-        elements.each do |element|
+        # return an array of microformats contained in elements
+        elements.map do |element|
           parse_elements(element)
-        end
-      else
+        # just give me a simple array
+        end.flatten.compact
+      elsif elements.is_a?(Nokogiri::XML::Element)
         parse_element(elements)
+      else
+        nil # nothing to see here, move along
       end
     end
 
     def parse_element(element)
       classes = element["class"]
-      # element may be a microformat element
+      # if element has class with microformat prefix it must be a microformat
       if classes =~ /(p|n|e|i|u|dt)-/
-        classes.split.each do |c|
+        classes = cleanse_classes(classes)
+        # parse the element for each microformat class
+        classes.split.map do |c|
           parse_microformat(element, c)
         end
-      # element may contain a microformat element
-      else
+      # if element has children it may contain a microformat element
+      elsif element.children
         parse_elements(element.children)
+      else
+        nil # nothing to see here, move along
       end
     end
 
+    # :(
+    def cleanse_classes(classes)
+      if classes =~ /(h-card)/ 
+        if classes =~ /(p-author)/ || classes =~ /(e-g5-client)/
+          classes.gsub!(/h-card/, "")
+        end
+      end
+      classes.strip
+    end
+
     def parse_microformat(element, c)
-      assign_value(symbolize_class(c), element.text)
+      method = :"parse_#{c.underscore}"
+      if self.respond_to?(method)
+        self.send(method, element)
+      else
+        nil
+      end
+    end
+
+    def parse_h_card(element)
+      HCard.new(element.children)
+    end
+
+    def parse_h_entry(element)
+      HEntry.new(element.children)
     end
 
+
     def symbolize_class(c)
       c.to_s.downcase.gsub(/\w{1,2}-/, "").to_sym
     end
@@ -57,6 +92,18 @@ module HentryConsumer
       end
     end
 
+    def to_hash
+      { :type => ["element"],
+        :properties => {
+          :items => self.items,
+        }
+      }
+    end
+
+    def to_json(*a)
+      to_hash.to_json(a)
+    end
+
     def to_html
       @element.to_html
     end

data/lib/hentry_consumer/h_card.rb

@@ -3,18 +3,32 @@ module HentryConsumer
     attr_accessor :name, :email, :url
     alias_method :emails, :email
     alias_method :urls, :url
+
+    def parse_p_name(element)
+      assign_value :name, element.text
+    end
+
+    def parse_u_email(element)
+      assign_value :email, element["href"]
+    end
+
+    def parse_u_url(element)
+      assign_value :url, element["href"]
+    end
     
+    def to_hash
+      {
+        :type => ["h-card"],
+        :properties => {
+          :name  => self.name,
+          :email => self.email,
+          :url   => self.url
+        }
+      }
+    end
+
     def to_json(*a)
-      {:items => 
-        [{
-          :type => ["h-card"],
-          :properties => {
-            :name  => self.name,
-            :email => self.email,
-            :url   => self.url
-          }
-        }]
-      }.to_json(a)
+      to_hash.to_json(a)
     end
   end
 end

data/lib/hentry_consumer/h_entry.rb

@@ -3,58 +3,52 @@ module HentryConsumer
     attr_accessor :name, :categories, :author, :content, :bookmark, :published_at, :summary
     alias_method :authors, :author
 
-    # 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)
+    def parse_p_name(element)
+      assign_value :name, element.text
+    end
+
+    def parse_p_author(element)
       assign_value :author, HCard.new(element.children)
     end
 
-    def parse_category(element)
+    def parse_p_category(element)
       self.categories ||= {}
       self.categories[element.text.gsub("\n", " ").strip] = element["href"]
     end
 
-    def parse_content(element)
+    def parse_e_content(element)
       assign_value :content, element.inner_html
     end
 
-    def parse_published(element)
+    def parse_dt_published(element)
       assign_value :published_at, element["datetime"]
     end
 
-    def parse_uid(element)
+    def parse_u_uid(element)
       assign_value :bookmark, element["href"]
     end
 
-    def parse_general(element, c)
-      assign_value symbolize_class(c), element.text
+    def parse_p_summary(element)
+      assign_value :summary, element.text
+    end
+
+    def to_hash
+      {
+        :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
+        }
+      }
     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
-          }
-        }]
-      }.to_json(a)
+      to_hash.to_json(a)
     end
   end
 end

data/lib/hentry_consumer/h_feed.rb

@@ -20,13 +20,19 @@ module HentryConsumer
     end
     alias_method :to_s, :to_html
 
-    def to_json(*a)
-      json = {:items =>
+    def to_hash
+      {:items =>
         [{
           :type => ["h-feed"],
-          :properties => {:entries => self.entries}
+          :properties => {
+            :entries => self.entries
+          }
         }]
-      }.to_json(a)
+      }
+    end
+
+    def to_json(*a)
+      to_hash.to_json(a)
     end
     
   end

data/lib/hentry_consumer/version.rb

@@ -1,3 +1,3 @@
 module HentryConsumer
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/lib/hentry_consumer.rb

@@ -16,3 +16,13 @@ module HentryConsumer
     other.extend(ClassMethods)
   end
 end
+
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/spec/lib/hentry_consumer/format_rules_spec.rb

@@ -25,5 +25,4 @@ describe HentryConsumer::FormatRules do
   it "is unique" do
     HentryConsumer::FormatRules.unique?(:uid).should be_true
   end
-
-end
+end

data/spec/lib/hentry_consumer/h_card_spec.rb

@@ -12,7 +12,6 @@ describe HentryConsumer::HCard do
     subject { entry.authors.first }
 
     its(:name)  { should eq ["Jessica Suttles"]}
-
     its(:emails) { should have(1).things }
     its(:urls) { should have(2).things }
   end
@@ -23,7 +22,6 @@ describe HentryConsumer::HCard do
     subject { entry.authors.first }
 
     its(:name)  { should eq ["Jessica"]}
-
     its(:emails) { should have(1).things }
     its(:urls) { should have(1).things }
   end

data/spec/lib/hentry_consumer/h_entry_spec.rb

@@ -8,37 +8,26 @@ describe HentryConsumer::HEntry do
     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 "has a summary" do
       entry.summary.should eq ["Signed up with 3 locations"]
     end
-
     it "has a time" do
       entry.published_at.should eq ["2012-08-26 20:09-0700"]
     end
-
     it "has a bookmark" do
       entry.bookmark.should eq "http://g5.com/feed/entries/2012-08-26-20-09-0700"
     end
-
-    it "should have 2 authors" do
+    it "should have 2 authors as HCards" 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
-
     describe "categories" do
-      it "has an array of categories" do
+      it "is a hash" do
         entry.categories.should be_an_instance_of Hash
       end
-
-      it "has a key of the content" do
+      it "has a key of the category and value of it's UID" do
         entry.categories["New Customer"].should eq "http://g5.com/tag/new-customer"
       end
     end
@@ -49,29 +38,26 @@ describe HentryConsumer::HEntry do
       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 }
+      it { json.should be_an_instance_of Hash }
+      it { json["type"].should include 'h-entry'}
+      it { json["properties"]["name"].should eq ['Senior Cat Living']}
+      it { json["properties"]["content"].first.should match /Locations/ }
+      it { json["properties"]["author"].should be_an_instance_of Array }
+      it { json["properties"]["author"].first["type"].should include "h-card" }
+      it { json["properties"]["bookmark"].should eq "http://g5.com/feed/entries/2012-08-26-20-09-0700" }
+      it { json["properties"]["published_at"].should eq ["2012-08-26 20:09-0700"] }
+      it { json["properties"]["summary"].should be_an_instance_of Array }
     end
   end
 
@@ -82,37 +68,27 @@ describe HentryConsumer::HEntry do
     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 ["Wabi Sabi Town"]
     end
-
     it "has a summary" do
       entry.summary.should eq ["Signed up with 2 locations"]
     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
+    it "should have 1 author as an HCard" 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
+      it "is a Hash" do
         entry.categories.should be_an_instance_of Hash
       end
-
-      it "has a key of the content" do
+      it "has a key of the category and value of it's UID" do
         entry.categories["Some Category"].should eq "#"
       end
     end
@@ -123,29 +99,26 @@ describe HentryConsumer::HEntry do
       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 }
+      it { json.should be_an_instance_of Hash }
+      it { json["type"].should include 'h-entry'}
+      it { json["properties"]["name"].should eq ['Wabi Sabi Town']}
+      it { json["properties"]["content"].first.should match /Locations/ }
+      it { json["properties"]["author"].should be_an_instance_of Array }
+      it { json["properties"]["author"].first["type"].should include "h-card" }
+      it { json["properties"]["bookmark"].should eq "http://localhost:3000/customers/3" }
+      it { json["properties"]["published_at"].should eq ["2012-10-10T19:11:17Z"] }
+      it { json["properties"]["summary"].should be_an_instance_of Array }
     end
   end
 end

data/spec/lib/hentry_consumer/h_feed_spec.rb

@@ -7,8 +7,8 @@ describe HentryConsumer::HFeed do
     let(:json) { JSON.parse(feed.to_json) }
     it { json["items"].first["type"].should include 'h-feed'}
     it { json["items"].first["properties"]["entries"].should be_an_instance_of Array }
-    it { json["items"].first["properties"]["entries"].first["items"].should be_an_instance_of Array }
-    it { json["items"].first["properties"]["entries"].first["items"].first["type"].should include "h-entry" }
+    it { json["items"].first["properties"]["entries"].should be_an_instance_of Array }
+    it { json["items"].first["properties"]["entries"].first["type"].should include "h-entry" }
   end
   
   describe "#to_s" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hentry_consumer
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-14 00:00:00.000000000 Z
+date: 2012-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -152,7 +152,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -775147852953388774
+      hash: -4504941096207612030
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -161,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -775147852953388774
+      hash: -4504941096207612030
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24