hmachine 0.0.1 → 0.1.0

data/lib/hmachine.rb

@@ -1,21 +1,130 @@
-require 'uri'
+require 'open-uri'
 require 'nokogiri'
 
-require 'hmachine/microformat'
-
 module HMachine
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
+  PRODID = "-//markwunsch.com//hMachine #{VERSION}//EN"
+
+  # Convenience method for HMachine::Microformat.find method
+  def self.find(document, format=nil)
+    HMachine::Microformat.find(document, format)
+  end
+  
+  # Get a string of html or a url and convert it to a Nokogiri Document
+  def self.get(html)
+    return html if html.is_a?(Nokogiri::XML::Node)
+    begin
+      url = URI.parse(html)
+      doc = url.is_a?(URI::HTTP) ? get_url(url.normalize.to_s) : get_document(html)
+    rescue URI::InvalidURIError
+      doc = get_document(html)
+    end
+    doc
+  end
+  
+  # Open a URL and convert the contents to a Nokogiri Document
+  def self.get_url(url)
+    uri = URI.parse(url)
+    doc = ''
+    uri.open do |web|
+      web.each_line {|line| doc += line }
+    end
+    get_document(doc, url)
+  end
+  
+  # Convert HTML to a Nokogiri Document
+  def self.get_document(html, url=nil)
+    html.is_a?(Nokogiri::XML::Node) ? html : Nokogiri::HTML.parse(html, url)
+  end
+  
+  def self.normalize(name)
+    name.to_s.strip.downcase.intern
+  end
+  
+  # Map a key to an element or design pattern
+  def self.map(key)
+    case normalize(key)
+      when :value_class, :valueclass, :abbr, :uri, :url, :typevalue
+        HMachine::Pattern.map(key)
+      when :hcard, :geo, :rellicense, :reltag, :votelinks, :xfn, :xmdp, :xoxo, :adr
+        HMachine::Microformat.map(key)
+      when :base
+        HMachine::POSH::Base
+      else
+        raise "#{key} is not a recognized parser."
+    end
+  end
   
-  def self.find(document)
-    html = get_document(document)
-    Microformat.find_all html
+  # Get/Set a function that defines how to find an element in a node.
+  # The Search function should return a Nokogiri::XML::NodeSet.
+  # eg. <tt>search {|node| node.css(element) }  
+  def search(&block)
+    @search = block if block_given?
+    @search || lambda {|node| node }
   end
   
-  def self.find_with_url(url)
-    # open url and call find method on resulting document
+  # Search for the element in a document 
+  def find_in(document)
+    search.call(document)
   end
   
-  def self.get_document(html)
-    html.is_a?(Nokogiri::XML::Node) ? html : Nokogiri::HTML.parse(html)
+  # Is the element found in node?
+  def found_in?(node)
+    find_in(node).eql?(node) || !find_in(node).empty?
   end
-end
+  
+  # Get/Set a function that tests to make sure a given node is
+  # the element we want. Should return truthy.
+  # Default just tests to see if the node passed is a child of its parent node.
+  def validate(&block)
+    @validate = block if block_given?
+    @validate || lambda { |node| find_in(node.parent).children.include?(node) }
+  end
+  
+  # Is this a valid node?
+  def valid?(node)
+    validate.call(node)
+  end
+  
+  # Define the pattern used to extract contents from node
+  # Can be a symbols that match to an Element parser, or a block
+  def extract(pattern = nil, &block)
+    if block_given?
+      @extract = block 
+    else
+      @extract = HMachine.map(pattern).extract if pattern
+    end
+    @extract || lambda{|node| node.content.strip }
+  end
+  
+  # Extract the content from the node
+  def extract_from(node)
+    extract.call(node)
+  end
+  
+  # Parse the document, finding every instance of the desired element, and extract their contents
+  def parse(document)
+    if found_in?(document)
+      contents = if find_in(document).respond_to?(:collect)
+        find_in(document).collect { |element| extract_from(element) }
+      else
+        extract_from(document)
+      end
+      return contents.first if contents.respond_to?(:length) && (contents.length == 1)
+      contents
+    end
+  end
+  
+  # Parse the document, extracting the content for the first instance of the element
+  def parse_first(document)
+    if found_in?(document)
+      elements = find_in(document)
+      extract_from elements.respond_to?(:first) ? elements.first : elements 
+    end
+  end 
+  
+end
+
+require 'hmachine/pattern'
+require 'hmachine/posh'
+require 'hmachine/microformat'

data/lib/hmachine/microformat.rb

@@ -1,30 +1,49 @@
-require 'hmachine/microformat/base'
-require 'hmachine/microformat/hcard'
-
 module HMachine
   module Microformat
-    
-    def self.find_hcard(html)
-      doc = HMachine.get_document(html)
-      find_in_node(HCard, doc)
+
+    def self.map(name)
+      map = microformats[HMachine.normalize(name)]
+      raise "#{name} is not a recognized microformat." unless map
+      map
     end
-    
-    def self.find_all(html)
-      find_hcard html
+
+    def self.microformats
+      { :hcard      => HMachine::Microformat::HCard,
+        :geo        => HMachine::Microformat::Geo,
+        :adr        => HMachine::Microformat::Adr,
+        :rellicense => HMachine::Microformat::RelLicense,
+        :reltag     => HMachine::Microformat::RelTag,
+        :votelinks  => HMachine::Microformat::VoteLinks,
+        :xfn        => HMachine::Microformat::XFN,
+        :xmdp       => HMachine::Microformat::XMDP,
+        :xoxo       => HMachine::Microformat::XOXO }
     end
-    
-    def self.find_in_node(microformat, node)
-      microformats = []
-      node.css(microformat::ROOT_SELECTOR).each do |node|
-        microformats << create_for_node(microformat, node) if microformat.validate(node)
+
+    def self.find(html, uformat = nil)
+      if uformat
+        map(uformat).parse HMachine.get(html)
+      else
+        find_all(html)
       end
-      microformats
     end
     
-    def self.create_for_node(microformat, node)
-      return unless microformat.validate(node)
-      microformat.new node
+    def self.find_all(html)
+      doc = HMachine.get(html)
+      uformats = microformats.values.collect do |uf|
+        uf.parse(doc)
+      end
+      uformats.compact.flatten
     end
     
   end
-end
+end
+
+require 'hmachine/microformat/reltag'
+require 'hmachine/microformat/rellicense'
+require 'hmachine/microformat/votelinks'
+require 'hmachine/microformat/xoxo'
+require 'hmachine/microformat/xmdp'
+require 'hmachine/microformat/xfn'
+require 'hmachine/microformat/geo'
+require 'hmachine/microformat/adr'
+require 'hmachine/microformat/hcard'

data/lib/hmachine/microformat/adr.rb

@@ -0,0 +1,22 @@
+module HMachine
+  module Microformat
+    class Adr < POSH::Base
+      FRIENDLY_NAME = "adr"
+      WIKI_URL = 'http://microformats.org/wiki/adr'
+      
+      name :adr
+                  
+      # http://microformats.org/wiki/adr-singular-properties      
+      has_one :post_office_box, :postal_code
+      has_many :street_address, :locality, :region, :extended_address, :country_name
+      
+      has_many :type do
+        extract do |node|
+          value = Pattern::ValueClass.extract_from(node)
+          HMachine.normalize(value) if value
+        end
+      end
+      
+    end
+  end
+end

data/lib/hmachine/microformat/geo.rb

@@ -0,0 +1,48 @@
+module HMachine
+  module Microformat
+    class Geo < POSH::Base
+      FRIENDLY_NAME = "geo"
+      WIKI_URL = 'http://microformats.org/wiki/geo'
+      
+      name :geo
+      
+      has_one :latitude do
+        search do |geo| 
+          lat = geo.css(".#{name}")
+          !lat.empty? ? lat : geo
+        end
+        
+        extract do |geo|
+          if geo['class'] && geo['class'].split.include?("#{name}")
+            HMachine::Pattern::ValueClass.extract_from(geo)
+          else
+            HMachine::Pattern::ValueClass.extract_from(geo).split(';')[0]
+          end
+        end
+      end
+      
+      has_one :longitude do
+        search do |geo| 
+          long = geo.css(".#{name}")
+          !long.empty? ? long : geo
+        end
+        
+        extract do |geo|
+          if geo['class'] && geo['class'].split.include?("#{name}")
+            HMachine::Pattern::ValueClass.extract_from(geo)
+          else
+            HMachine::Pattern::ValueClass.extract_from(geo).split(';')[1]
+          end
+        end
+      end
+            
+      alias lat latitude
+      alias long longitude
+      
+      def to_google_maps
+        "http://maps.google.com/?q=#{latitude},#{longitude}"
+      end
+      
+    end
+  end
+end

data/lib/hmachine/microformat/hcard.rb

@@ -1,24 +1,182 @@
 module HMachine
   module Microformat
-    class HCard < Base
-            
-      ROOT_CLASS = "vcard"
-      ROOT_SELECTOR = ".#{ROOT_CLASS}"
+    class HCard < POSH::Base
+      FRIENDLY_NAME = "hCard"
       WIKI_URL = "http://microformats.org/wiki/hcard"
+      XMDP = 'http://microformats.org/profile/hcard'
+      
+      name :vcard
+      
+      has_one :fn, :bday, :tz, :sort_string, :uid, :rev 
+      alias birthday bday
       
-      def initialize(node)
-        raise "hCard not found in node" unless self.class.validate(node)
-        @node = node
+      has_many :agent, :category, :key, :label,
+               :mailer, :nickname, :note, :role, :sound, 
+               :title
+                     
+      has_many :logo, :photo, :url do
+        extract :url
       end
       
-      def to_vcard
-        # convert to vcard
+      has_one :geo do
+        extract :geo
+      end
+      
+      has_many :email, :tel do
+        extract :typevalue
+      end
+      
+      has_many :adr do
+        extract :adr
+      end
+      alias address adr
+            
+      has_many :org do
+        has_one :organization_unit
+        has_one :organization_name do
+          search do |org|
+            org_name = org.css(".organization-name")
+            !org_name.empty? ? org_name : org
+          end
+        end        
       end
       
-      def self.infer_n_from_fn(fn)
-        # ...
+      has_one :n do
+        search do |doc|
+          n = doc.css(".#{name}")
+          !n.empty? ? n : parent.properties[:fn].find_in(doc)
+        end
+        
+        # N Optimization from Sumo:
+        # http://www.danwebb.net/2007/2/9/sumo-a-generic-microformats-parser-for-javascript
+        # See: http://microformats.org/wiki/hcard#Implied_.22n.22_Optimization
+        has_many :family_name, :given_name do
+          search do |node|
+            name_parts = node.css(".#{name}".gsub('_','-'))
+            !name_parts.empty? ? name_parts : node
+          end
+          
+          extract do |node|
+            if node['class'].split.include?("#{name}".gsub('_','-'))
+              HMachine::Pattern::ValueClass.extract_from(node)
+            else
+              fn = parent.parent[:fn].extract_from(node)
+              if (fn =~ /^(\w+) (\w+)$/)
+                if name.eql? :given_name
+                  Regexp.last_match[1]
+                elsif name.eql? :family_name
+                  Regexp.last_match[2]
+                end
+              elsif (fn =~ /^(\w+), (\w+)\.?$/)
+                if name.eql? :given_name
+                  Regexp.last_match[2]
+                elsif name.eql? :family_name
+                  Regexp.last_match[1]
+                end
+              end
+            end
+          end
+        end
+        
+        has_many :additional_name, :honorific_prefix, :honorific_suffix
       end
       
+      has_one! :class
+      
+      def organization?
+        if org
+          fn == org[:organization_name]
+        end
+      end
+      alias company? organization?
+      
+      # http://tools.ietf.org/html/rfc2426
+      # TODO: Make this less ugly
+      def to_vcard
+        @vcard = "BEGIN:VCARD\x0D\x0AVERSION:3.0\x0D\x0APRODID:#{HMachine::PRODID}"
+        @vcard += "\x0D\x0ANAME:#{node.document.css('title').first.content}" if node.document.css('title').first
+        @vcard += "\x0D\x0ASOURCE:#{@source}" if @source
+        @vcard += "\x0D\x0AFN:#{fn}" if fn
+        @vcard += n_vcard if n
+        if nickname
+          @vcard += "\x0D\x0ANICKNAME" + (nickname.respond_to?(:join) ? nickname.join(',') : nickname)
+        end
+        @vcard += "\x0D\x0APHOTO;VALUE=uri:#{photo.first}" if photo
+        @vcard += "\x0D\x0ABDAY:#{bday.strftime('%Y-%m-%d')}" if bday
+        if adr
+          if adr.respond_to?(:each)
+            adr.each { |address| @vcard += adr_vcard(address) }
+          else
+            @vcard += adr_vcard(adr)
+          end           
+        end
+        if tel
+          if tel.respond_to?(:join)
+            tel.each { |phone| @vcard += "\x0D\x0ATEL#{type_value_vcard(phone)}" }
+          else
+            @vcard += "\x0D\x0ATEL#{type_value_vcard(phone)}"
+          end
+        end
+        if email
+          if email.respond_to?(:join)
+            email.each { |mail| @vcard += "\x0D\x0AEMAIL#{type_value_vcard(mail)}" }
+          else
+            @vcard += "\x0D\x0AEMAIL#{type_value_vcard(email)}"
+          end
+        end
+        mailer.each {|software| @vcard += "\x0D\x0AMAILER:#{software}" } if mailer
+        @vcard += "\x0D\x0ATZ:#{tz}" if tz
+        @vcard += "\x0D\x0AGEO:#{geo[:latitude]};#{geo[:longitude]}" if geo
+        title.each {|titl| @vcard += "\x0D\x0ATITLE:#{titl}" } if title
+        role.each {|roll| @vcard += "\x0D\x0AROLE:#{roll}" } if role
+        logo.each { |log| @vcard += "\x0D\x0ALOGO;VALUE=uri:#{log}" } if logo
+        agent.each {|mrsmith| @vcard += "\x0D\x0AAGENT:#{mrsmith}" } if agent
+        @vcard += "\x0D\x0AORG:#{org[:organization_name]};#{org[:organization_unit]}" if org
+        @vcard += "\x0D\x0ACATEGORIES:#{join_vcard_values(category).upcase}" if category
+        note.each {|notes| @vcard += "\x0D\x0ANOTE:#{notes}" } if note
+        @vcard += "\x0D\x0AREV:#{rev.iso8601}" if rev
+        @vcard += "\x0D\x0ASORT-STRING:#{sort_string}" if sort_string
+        sound.each {|audio| @vcard += "\x0D\x0ASOUND;VALUE=uri:#{audio}" } if sound
+        @vcard += "\x0D\x0AUID:#{uid}" if uid
+        url.each {|web| @vcard += "\x0D\x0AURL:#{web}" } if url
+        @vcard += "\x0D\x0ACLASS:#{to_h[:class]}" if has_property?(:class)
+        key.each {|auth| @vcard += "\x0D\x0AKEY:#{key}" }if key
+        @vcard += "\x0D\x0AEND:VCARD\x0D\x0A\x0D\x0A"
+      end
+      
+      private
+      
+        def join_vcard_values(values)
+          values.respond_to?(:join) ? values.join(',') : values.to_s.strip
+        end
+        
+        def type_value_vcard(communication)
+          if communication.respond_to?(:keys)
+            _comm = ";TYPE=#{join_vcard_values(communication[:type])}:#{communication[:value]}"
+          else
+            _comm = ":#{communication}"
+          end
+          _comm
+        end
+      
+        def adr_vcard(address)
+          addresses = "\x0D\x0AADR"
+          adr_vcard = {}
+          adr.to_h.each_pair { |key,value| adr_vcard[key] = join_vcard_values(value) }
+          if address[:type]
+            addresses += ";TYPE=" + (address[:type].respond_to?(:join) ? address[:type].join(',') : address[:type].to_s)
+          end
+          addresses += ":#{address[:post_office_box]};#{adr_vcard[:extended_address]};#{adr_vcard[:street_address]};"
+          addresses += "#{adr_vcard[:locality]};#{adr_vcard[:region]};#{address[:postal_code]};#{adr_vcard[:country_name]}"
+        end
+      
+        def n_vcard
+          n_vcard = {}
+          n.each_pair { |key,value| n_vcard[key] = join_vcard_values(value) }
+          "\x0D\x0AN:#{n_vcard[:family_name]};#{n_vcard[:given_name]};#{n_vcard[:additional_name]};"+\
+          "#{n_vcard[:honorific_prefix]};#{n_vcard[:honorific_suffix]}"
+        end
+            
     end
   end
 end