microformats2 2.9.0 → 3.0.0

data/lib/microformats2/property_parser.rb

@@ -1,52 +1,122 @@
 module Microformats2
-  class PropertyParser
-    class << self
-      def parse(element, base)
-        @@base = base
-        parse_node(element).flatten.compact
-      end
+  class PropertyParser < ParserCore
+
+    def parse(element, base: nil, element_type: , format_class_array: [], backcompat: nil)
+      @base = base
+      @value = nil
+      @property_type = element_type
+
+      @fmt_classes = format_class_array
+      @mode_backcompat = backcompat
 
-      def parse_node(node)
-        case
-        when node.is_a?(Nokogiri::XML::NodeSet) then parse_nodeset(node)
-        when node.is_a?(Nokogiri::XML::Element) then [parse_for_properties(node)]
+      if element_type == 'p'
+        parse_value_class_pattern(element)
+
+        if @value.nil?
+          if element.name == 'abbr' and not element.attribute('title').nil?
+            @value = element.attribute('title').value.strip
+          elsif (element.name == 'data' or element.name == 'input') and not element.attribute('value').nil?
+            @value = element.attribute('value').value.strip
+          elsif (element.name == 'img' or element.name == 'area') and not element.attribute('alt').nil?
+            @value = element.attribute('alt').value.strip
+          else
+            @value = render_text_and_replace_images(element, base: @base)
+          end
         end
-      end
 
-      def parse_nodeset(nodeset)
-        nodeset.map { |node| parse_node(node) }
-      end
+      elsif element_type == 'e'
+        @value = {
+          value: render_text(element, base: @base), #TODO the spec doesn't say to remove script and style tags, assuming this to be in error
+          html: element.inner_html.gsub(/\A +/, '').gsub(/ +\Z/, '')
+        }
 
-      def parse_for_properties(element)
-        if property_classes(element).length >= 1
-          parse_property(element)
-        elsif format_classes(element).length >= 1
-          #do nothing because we don't want child elements ending up with their properties here
-        else
-          parse_nodeset(element.children)
+      elsif element_type == 'u'
+        if ['a', 'area'].include? element.name and not element.attribute('href').nil?
+          @value = element.attribute('href').value.strip
+        elsif ['img', 'audio', 'video', 'source'].include? element.name and not element.attribute('src').nil?
+          @value = element.attribute('src').value.strip
+        elsif element.name == 'video' and not element.attribute('poster').nil?
+          @value = element.attribute('poster').value.strip
+        elsif element.name == 'object' and not element.attribute('data').nil?
+          @value = element.attribute('data').value.strip
         end
-      end
 
-      def parse_property(element)
-        property_classes(element).map do |property_class|
-          property   = Property.new(element, property_class, nil, @@base).parse
-          properties = format_classes(element).empty? ? PropertyParser.parse(element.children, @@base) : []
+        if not @value.nil?
+          @value = Microformats2::AbsoluteUri.new(@value, base: @base).absolutize
+        else
+
+          parse_value_class_pattern(element)
 
-          [property].concat properties
+          if @value.nil?
+            if element.name == 'abbr' and not element.attribute('title').nil?
+              @value = element.attribute('title').value.strip
+            elsif (element.name == 'data' or element.name == 'input') and not element.attribute('value').nil?
+              @value = element.attribute('value').value.strip
+            else
+              @value = render_text(element, base: @base)
+            end
+
+          end
         end
+
+      elsif element_type == 'dt'
+        @value = Microformats2::TimePropertyParser.new.parse(element, base: base, element_type: element_type, format_class_array: format_class_array, backcompat: backcompat)
+
       end
 
-      def property_classes(element)
-        element.attribute("class").to_s.split.select do |html_class|
-          html_class =~ Property::CLASS_REG_EXP
+      @value
+    end
+
+    def parse_value_class_pattern(element)
+      @value_class_pattern_value = []
+      parse_node(element.children)
+      @value = @value_class_pattern_value.join unless @value_class_pattern_value.empty?
+    end
+
+    def parse_element(element)
+      if value_title_classes(element).length >= 1
+        @value_class_pattern_value << element.attribute('title').value.strip
+
+      elsif value_classes(element).length >= 1
+        if element.name == 'img' or element.name == 'area' and not element.attribute('alt').nil?
+          @value_class_pattern_value << element.attribute('alt').value.strip
+        elsif element.name == 'data' and not element.attribute('value').nil?
+          @value_class_pattern_value << element.attribute('value').value.strip
+        elsif element.name == 'abbr' and not element.attribute('title').nil?
+          @value_class_pattern_value << element.attribute('title').value.strip
+        else
+          @value_class_pattern_value << element.text.strip
+        end
+      else
+        p_classes = property_classes(element)
+        p_classes = backcompat_property_classes(element) if @mode_backcompat
+        if p_classes.length == 0 and format_classes(element).length == 0
+          parse_node(element.children)
         end
       end
+    end
 
-      def format_classes(element)
-        element.attribute("class").to_s.split.select do |html_class|
-          html_class =~ Format::CLASS_REG_EXP
+    def render_text_and_replace_images(node, base: nil)
+      new_doc = Nokogiri::HTML(node.inner_html)
+      new_doc.xpath('//script').remove
+      new_doc.xpath('//style').remove
+      new_doc.traverse do |node|
+        if node.name == 'img' and not node.attribute('alt').nil?
+          node.replace(' ' + node.attribute('alt').value.to_s + ' ')
+        elsif node.name == 'img' and not node.attribute('src').nil?
+          absolute_url = Microformats2::AbsoluteUri.new(node.attribute('src').value.to_s, base: @base).absolutize
+          node.replace(' ' + absolute_url  + ' ')
         end
       end
-    end # class << self
+      new_doc.text.strip
+    end
+
+    def render_text(node, base: nil)
+      new_doc = Nokogiri::HTML(node.inner_html)
+      new_doc.xpath('//script').remove
+      new_doc.xpath('//style').remove
+      new_doc.text.strip
+    end
+
   end
 end

data/lib/microformats2/results/collection.rb

@@ -0,0 +1,121 @@
+module Microformats2
+
+  #stub to get around the tests for now
+  class Collection
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def to_h
+      @hash
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def to_s
+      if @hash['value']
+        return @hash['value']
+      else
+        super
+      end
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def value
+      @hash['value']
+    end
+
+    def items
+      @hash['items'].map do |item|
+        ParserResult.new(item)
+      end
+    end
+
+    def rels
+      @hash['rels']
+    end
+
+    def rel_urls
+      @hash['rel-urls']
+    end
+
+    def respond_to?(sym, include_private = false)
+      has_item?(sym) || super(sym, include_private)
+    end
+
+    def method_missing(sym, *args, &block)
+
+      name = sym.to_s
+      name_dash = name.gsub('_', '-') if name.include? '_'
+
+      if not @hash['items'].nil?
+        result_hash = @hash['items'].select do |x|
+            x['type'].include?('h-' + name)
+        end
+        if result_hash.empty? and not name_dash.nil?
+          result_hash = @hash['items'].select do |x|
+            x['type'].include?('h-' + name_dash)
+          end
+        end
+      end
+
+      super(sym, *args, &block) if result_hash.empty?
+
+      if result_hash.is_a? Array
+        if args[0].nil?
+          result_hash = result_hash[0] #will return nil for an empty array
+
+        elsif args[0] == :all
+          return result_hash.map do |x|
+            ParserResult.new(x)
+          end
+
+        elsif args[0].to_i < result_hash.count
+          result_hash = result_hash[args[0].to_i]
+
+        else
+          result_hash = result_hash[0] #will return nil for an empty array
+        end
+      end
+
+      if result_hash.nil? or result_hash.empty?
+        result_hash
+      elsif result_hash.is_a? Hash
+        ParserResult.new(result_hash)
+      else
+        result_hash
+      end
+    end
+
+    private
+
+    def has_item?(name)
+      name = name.to_s
+      name_dash = name.gsub('_', '-') if name.include? '_'
+      if not @hash['items'].nil?
+        result_hash = @hash['items'].select do |x|
+          x['type'].include?('h-' + name)
+        end
+        if result_hash.empty? and not name_dash.nil?
+          result_hash = @hash['items'].select do |x|
+            x['type'].include?('h-' + name_dash)
+          end
+        end
+      end
+
+      not result_hash.empty?
+    end
+
+  end
+end
+

data/lib/microformats2/results/parser_result.rb

@@ -0,0 +1,111 @@
+module Microformats2
+
+  #stub to get around the tests for now
+  class ParserResult
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def to_h
+      @hash
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def to_s
+      if @hash['value']
+        return @hash['value']
+      else
+        super
+      end
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def value
+      @hash['value']
+    end
+
+    def properties
+      PropertySet.new( @hash['properties'])
+    end
+
+    def respond_to?(sym, include_private = false)
+      has_key?(sym) || has_property?(sym) || super(sym, include_private)
+    end
+
+    def method_missing(sym, *args, &block)
+
+      name = sym.to_s
+      name_dash = name.gsub('_', '-') if name.include? '_'
+
+      if not @hash[name].nil?
+        result_hash = @hash[name]
+
+      elsif not @hash['properties'].nil? and not @hash['properties'][name].nil?
+        result_hash = @hash['properties'][name]
+
+      elsif not name_dash.nil? and not @hash[name_dash].nil?
+        result_hash = @hash[name_dash]
+
+      elsif not name_dash.nil? and not @hash['properties'].nil? and not @hash['properties'][name_dash].nil?
+        result_hash = @hash['properties'][name_dash]
+
+      else
+        super(sym, *args, &block)
+      end
+
+      if result_hash.is_a? Array
+        if args[0].nil?
+          result_hash = result_hash[0] #will return nil for an empty array
+
+        elsif args[0] == :all
+          return result_hash.map do |x|
+            ParserResult.new(x)
+          end
+
+        elsif args[0].to_i < result_hash.count
+          result_hash = result_hash[args[0].to_i]
+
+        else
+          result_hash = result_hash[0] #will return nil for an empty array
+        end
+      end
+
+      if result_hash.nil? or result_hash.empty?
+        result_hash
+      elsif result_hash.is_a? Hash
+        ParserResult.new(result_hash)
+      else
+        result_hash
+      end
+    end
+
+    private
+
+    def has_key?(name)
+      name = name.to_s
+      name_dash = name.gsub('_', '-') if name.include? '_'
+
+      not @hash[name].nil? or not @hash[name_dash].nil?
+    end
+    
+    def has_property?(name)
+      name = name.to_s
+      name_dash = name.gsub('_', '-') if name.include? '_'
+      return false if @hash['properties'].nil?
+      not @hash['properties'][name].nil? or not @hash['properties'][name_dash].nil?
+    end
+
+  end
+end
+

data/lib/microformats2/results/property_set.rb

@@ -0,0 +1,87 @@
+module Microformats2
+
+  #stub to get around the tests for now
+  class PropertySet 
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def to_h
+      @hash
+    end
+
+    def to_hash
+      @hash.to_hash
+    end
+
+    def to_json
+      @hash.to_hash.to_json
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def respond_to?(sym, include_private = false)
+      has_key?(sym) || super(sym, include_private)
+    end
+
+
+    def method_missing(mname, *args, &block)
+
+      if respond_to? mname
+        result_hash = get_val? mname
+        if result_hash.is_a? Array
+          if args[0].nil?
+            result_hash = result_hash[0] #will return nil for an empty array
+
+          elsif args[0] == :all
+            return result_hash.map do |x|
+              ParserResult.new(x)
+            end
+
+          elsif args[0].to_i < result_hash.count
+            result_hash = result_hash[args[0].to_i]
+
+          else
+            result_hash = result_hash[0] #will return nil for an empty array
+          end
+        end
+
+        if result_hash.is_a? Hash
+          ParserResult.new(result_hash)
+        else
+          result_hash
+        end
+      else
+         super(mname, *args, &block)
+      end
+
+    end
+
+    private
+
+    def has_key?(name)
+      name = name.to_s
+      name_dash = name.gsub('_', '-') if name.include? '_'
+      not @hash[name].nil? or  not @hash[name_dash].nil? 
+    end
+
+    def get_val?(name)
+      name = name.to_s
+      name_dash = name.gsub('_', '-') if name.include? '_'
+
+      if not @hash[name].nil?
+        result_hash = @hash[name]
+
+      elsif not @hash[name_dash].nil?
+        result_hash = @hash[name_dash]
+      else
+        nil
+      end
+    end
+
+  end
+end
+