microformats2 2.9.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cd6cf3a5932b16cf908e76912361c306a1c9191
-  data.tar.gz: 59a40a924d3a3ee9222f344459a445bd5925aefd
+  metadata.gz: c9559a7a2de17e3e15bebace4a04244e39fc5688
+  data.tar.gz: 341621db907b4ed4048a460e1c51e01ac3d26918
 SHA512:
-  metadata.gz: af7fd7f90d0031996b8164b934877f3168d8b6c6f348055332defd395313a332392ae5a626166911335443b78f8ded3ae4fbd40f5c1ec914d79b95d288337286
-  data.tar.gz: 12bf5d0b7122ef5d551b16ff0ee4aca635d94f92958bc65565283d2de3689ceecedfe8ad9d82c923032b4216dbaa907fd8273010e13b9d2e6df28ab913ea2934
+  metadata.gz: '07972e3897374e29c5244bd21663df40c202d01c2e22894c668832dc4c9f1b1763898f5614876f82b21b44c4a27d09822421c68e5ca1b78c8fa073e0770523a2'
+  data.tar.gz: 545a71b67fca0e7ccb1714b6155f0a89a358b5a5bc75509c371a72f7937ce593f2011a41ca48311b9fe41922b0552a0315cfd500dc52b55ff429e2befbbbe0f2

data/README.md

@@ -9,9 +9,8 @@ and return a collection of dynamically defined Ruby objects.
 
 ## Development Status
 
-This gem sat unmaintained for quite a long time. It's now under new management. Work will begin shortly on getting it on par with the other Microformats2 parsers and the current state of the spec. (2015-12-23)
+This gem has been almost completely rewritten and now supports almost all aspects of the Microformats2 parsing spec.  As such a few things have changed, however there is a 2.9.0 release that will add a few new features and slightly improved parsing without breaking any of your existing code. (2017-05-12)
 
-A work in progress.
 
 Implemented:
 
@@ -26,28 +25,44 @@ Implemented:
 * dynamic creation of properties
 * [rel](http://microformats.org/wiki/rel)
 * [normalize u-* property values](http://microformats.org/wiki/microformats2-parsing-faq#normalizing_u-.2A_property_values)
-
-Not Implemented:
-
 * nested microformat without associated property
 * [value-class-pattern](http://microformats.org/wiki/value-class-pattern)
-* [include-pattern](http://microformats.org/wiki/include-pattern)
 * recognition of [vendor extensions](http://microformats.org/wiki/microformats2#VENDOR_EXTENSIONS)
 * backwards compatible support for microformats v1
 
+Not Implemented:
+
+* [include-pattern](http://microformats.org/wiki/include-pattern)
+
 
 ## Current Version
 
-2.9.0
+3.0.0
+
+![Version 3.0.0](https://img.shields.io/badge/VERSION-3.0.0-green.svg)
 
-![Version 2.9.0](https://img.shields.io/badge/VERSION-2.9.0-green.svg)
+### Differences to 2.x
 
+Version 3 of the microformats2 parsing library makes several significant changes from version 2.
+Version 2 of the parser created new ruby objects for every root format and every property it parsed, this is no longer the case. 
+Instead, all parsing is done in to a hash and results are wrapped in a few different objects classes which will respond to many of the function calls that the old classes would.
+This means that the to_hash/to_h output is really the safest way to handle output data.
+
+The ParserResult class (akin to the old Format class) takes several steps to guess at what function is wanted when it is called.  
+For of of the following, if the result is an array it will return the first item in the array unless it is passed the argument :all.
+
+1. If the function called is a key of the current object, return the contents of that key.
+2. If the function called is a key of the 'properties' array of the current object, return the contents.
+3. Repeat #1 and #2, replacing underscores with hyphens.
+
+This drops the need for a .format function as the result is always a ParserResult object.
+
+Finally this also means that nokogiri elements are no longer accessible from the results of the parser.
 
 ## Requirements
 
 * [nokogiri](https://github.com/sparklemotion/nokogiri)
 * [json](https://github.com/flori/json)
-* [activesupport](https://github.com/rails/rails/tree/master/activesupport)
 
 
 ## Installation
@@ -78,31 +93,114 @@ require "microformats2"
 
 source = "<div class='h-card'><p class='p-name'>Jessica Lynn Suttles</p></div>"
 collection = Microformats2.parse(source)
-# using singular accessors
-collection.card.name.to_s #=> "Jessica Lynn Suttles"
-# using :all returns an array
-collection.card(:all)[0].name(:all).first.to_s #=> "Jessica Lynn Suttles"
+
+# getting a copy of the canonical microformats2 hash structure
+collection.to_hash
+
+# the above, as JSON in a string
+collection.to_json
+
+# shortcuts
+
+# return a string if there is only one item found
+collection.card.name #=> "Jessica Lynn Suttles"
 
 source = "<article class='h-entry'>
   <h1 class='p-name'>Microformats 2</h1>
-  <div class='h-card p-author'><p class='p-name'>Jessica Lynn Suttles</p></div>
+  <div class='h-card p-author'><p class='p-name'><span class='p-first-name'>Jessica</span> Lynn Suttles</p></div>
 </article>"
 collection = Microformats2.parse(source)
 collection.entry.name.to_s #=> "Microformats 2"
+
 # accessing nested microformats
 collection.entry.author.name.to_s #=> "Jessica Lynn Suttles"
 
-# getting a copy of the canonical microformats2 hash structure
-collection.to_hash
+# accessing nested microformats can use shortcuts or more expanded method
+collection.entry.author.name #=> "Jessica Lynn Suttles"
+collection.entry.properties.author.properties.name.to_s #=> "Jessica Lynn Suttles"
+
+# use _ instead of - to get these items
+collection.entry.author.first_name #=> "Jessica"
+collection.rel_urls #=> {}
+
+source = "<article class='h-entry'>
+  <h1 class='p-name'>Microformats 2</h1>
+  <div class='h-card p-author'><p class='p-name'><span class='p-first-name'>Jessica</span> Lynn Suttles</p></div>
+  <div class='h-card p-author'><p class='p-name'><span class='p-first-name'>Brandon</span> Edens</p></div>
+</article>"
+collection = Microformats2.parse(source)
+
+# arrays of items with always take the first item by default
+collection.entry.author.name #=> "Jessica Lynn Suttles"
+collection.entry.author(1).name #=> "Brandon Edens"
+
+# get the actual array with :all
+collection.entry.author(:all).count #=> 2
+collection.entry.author(:all)[1].name #=> "Brandon Edens"
 
-# the above, as JSON in a string
-collection.to_json
 ```
 
 * `source` can be a URL, filepath, or HTML
 
+
+## Ruby Gem release process
+
+Check out latest code from GitHub repo.
+
+```
+git pull origin master
+```
+
+Make sure the version has been bumped up in all four places:
+
+- [lib/microformats2/version.rb](https://github.com/indieweb/microformats2-ruby/blob/master/lib/microformats2/version.rb#L2)
+- [README.md (three places)](https://github.com/indieweb/microformats2-ruby/blob/master/README.md)
+
+Do a test build locally to make sure it builds properly.
+
+```
+rake build
+```
+
+If that works, then do a test install locally.
+
+  ```
+rake install
+```
+
+If that works, uninstall the gem.
+
+```
+gem uninstall microformats2
+```
+
+Clean up any mess made from testing.
+
+```
+rake clean
+rake clobber
+```
+
+Assuming your one of the gem owners and have release privileges, release the gem!
+
+```
+rake release
+```
+
+If that works, you’ve just release a new version of the gem! Yay! You can see it at:
+
+[https://rubygems.org/gems/microformats2](https://rubygems.org/gems/microformats2)
+
+If `rake release` failed because of an error with your authentication to rubygems.org, follow their instructions in the error message. Then repeat the `rake release` step.
+
+If any other errors failed along the way before `rake release`, try to figure them out or reach out to the IRC/Slack channel for help.
+
+Good luck.
+
+
 ## Authors
 
+- Ben Roberts / [@dissolve](https://github.com/dissolve)
 - Jessica Lynn Suttles / [@jlsuttles](https://github.com/jlsuttles)
 - Shane Becker / [@veganstraightedge](https://github.com/veganstraightedge)
 - Chris Stringer / [@jcstringer](https://github.com/jcstringer)
@@ -125,21 +223,23 @@ If you find bugs, have feature requests or questions, please
 [file an issue](https://github.com/indieweb/microformats2-ruby/issues).
 
 
-## Specs
+## Testing
 
-**TODO** remove this and use the [microformats tests repo](https://github.com/microformats/tests) instead.
+### Specs
 
-To update spec cases that are scraped from other sites.
-**Warning:** This could break specs.
-```
-rake specs:update
-```
+This uses a copy of  [microformats tests repo](https://github.com/microformats/tests).
 
 To run specs
 ```
 rake spec
 ```
 
+###Interactive
+
+You can use the code interacively for testing but running
+```
+bundle console
+```
 
 ## License
 

data/Rakefile

@@ -7,63 +7,3 @@ require "pp"
 RSpec::Core::RakeTask.new(:spec)
 task :default => [:spec]
 
-namespace :specs do
-  task :update do
-    sources = [
-      { dir: "microformats.org",
-        urls: ["http://microformats.org/wiki/microformats-2"],
-        html_selector: ".source-html4strict",
-        json_selector: ".source-javascript",
-        html_method: "inner_text"
-      },
-      { dir: "microformat2-node.jit.su",
-        urls: [
-          "http://microformat2-node.jit.su/h-adr.html",
-          "http://microformat2-node.jit.su/h-card.html",
-          "http://microformat2-node.jit.su/h-entry.html",
-          "http://microformat2-node.jit.su/h-event.html",
-          "http://microformat2-node.jit.su/h-geo.html",
-          "http://microformat2-node.jit.su/h-news.html",
-          "http://microformat2-node.jit.su/h-org.html",
-          "http://microformat2-node.jit.su/h-product.html",
-          "http://microformat2-node.jit.su/h-recipe.html",
-          "http://microformat2-node.jit.su/h-resume.html",
-          "http://microformat2-node.jit.su/h-review-aggregate.html",
-          "http://microformat2-node.jit.su/h-review.html",
-          "http://microformat2-node.jit.su/rel.html",
-          "http://microformat2-node.jit.su/includes.html",
-        ],
-        html_selector: ".e-x-microformat",
-        json_selector: ".language-json",
-        html_method: "inner_html"
-      }
-    ]
-
-    sources.each do |source|
-      source[:urls].each do |url|
-        document = Nokogiri::HTML(open(url).read)
-        html = document.css(source[:html_selector]).map { |e| e.send(source[:html_method]) }
-        json = document.css(source[:json_selector]).map { |e| e.inner_text }
-
-        name = url.split("/").last.gsub(/[.]\w+/, "")
-        path = File.join "spec/support/cases", source[:dir], name
-
-        FileUtils.mkdir_p(path)
-
-        ([html.length, json.length].min).times do |index|
-
-          File.open(File.join(path, "#{name}-#{index}.html"), "w") do |f|
-            f.write "<!-- #{url} -->\n"
-            f.write html[index]
-          end
-
-          File.open(File.join(path, "#{name}-#{index}.js"), "w") do |f|
-            f.write "// #{url}\n"
-            f.write json[index]
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/microformats2.rb

@@ -1,30 +1,22 @@
 require "nokogiri"
 require "open-uri"
 require "json"
-require "active_support/inflector"
 
 require "microformats2/version"
 require "microformats2/absolute_uri"
+require "microformats2/parser_core"
 require "microformats2/parser"
 require "microformats2/format_parser"
 require "microformats2/property_parser"
-require "microformats2/collection"
-require "microformats2/format"
-require "microformats2/property/foundation"
-require "microformats2/property/text"
-require "microformats2/property/url"
-require "microformats2/property/date_time"
-require "microformats2/property/embedded"
-require "microformats2/property"
-require "microformats2/implied_property/foundation"
-require "microformats2/implied_property/name"
-require "microformats2/implied_property/photo"
-require "microformats2/implied_property/url"
+require "microformats2/time_property_parser"
+require "microformats2/results/parser_result"
+require "microformats2/results/collection"
+require "microformats2/results/property_set"
 
 module Microformats2
   class << self
-    def parse(html)
-      Parser.new.parse(html)
+    def parse(html, base: nil)
+      Parser.new.parse(html, base: base)
     end
 
     def read_html(html)

data/lib/microformats2/absolute_uri.rb

@@ -2,13 +2,17 @@ module Microformats2
   class AbsoluteUri
     attr_accessor :base, :relative
 
-    def initialize(base, relative)
+    def initialize(relative, base: nil)
       @base = base
       @relative = relative
+      @base.strip! unless @base.nil?
+      @relative.strip! unless @relative.nil?
     end
 
     def absolutize
+      #TODO: i'm sure this could be improved a bit
       return nil if relative.nil? or relative == ""
+      return relative if relative =~ /^https?:\/\//
 
       uri = URI.parse(relative)
 

data/lib/microformats2/format_parser.rb

@@ -1,68 +1,343 @@
 module Microformats2
-  class FormatParser
-    class << self
-      def parse(element, base=nil, parsing_children = false)
-        @@base = base
-        parse_node(element, parsing_children).flatten.compact
-      end
+  class FormatParser < ParserCore
 
-      def parse_node(node, parsing_children=false)
-        case
-        when node.is_a?(Nokogiri::HTML::Document) then parse_node(node.children, parsing_children)
-        when node.is_a?(Nokogiri::XML::NodeSet)   then parse_nodeset(node, parsing_children)
-        when node.is_a?(Nokogiri::XML::Element)   then [parse_for_microformats(node, parsing_children)]
-        end
-      end
+    def parse(element, base:nil, element_type:nil, format_class_array:[], backcompat:false)
+      @base = base
 
-      def parse_nodeset(nodeset, parsing_children=false)
-        nodeset.map { |node| parse_node(node, parsing_children) }
-      end
+      @mode_backcompat = backcompat
 
-      def parse_for_microformats(element, parsing_children=false)
-        if property_classes(element).length >= 1 and parsing_children
-          #do nothing because we don't want properties obj in children
-        elsif format_classes(element).length >= 1
-          parse_microformat(element)
-        else
-          parse_nodeset(element.children, parsing_children)
+      @properties = {}
+      @children = []
+
+      @format_property_type = element_type
+      @value = nil
+
+      @mode_backcompat = backcompat
+
+      @fmt_classes =  format_class_array
+
+      parse_node(element.children)
+
+      ##### Implied Properties######
+      #NOTE: much of this code may be simplified by using element.css, not sure yet, but coding to have passing tests first
+      # can optimize this later
+      unless @mode_backcompat
+        if @properties['name'].nil?
+
+          if element.name == 'img' and not element.attribute('alt').nil?
+            @properties['name'] = [element.attribute('alt').value.strip]
+          elsif element.name == 'area' and not element.attribute('alt').nil?
+            @properties['name'] = [element.attribute('alt').value.strip]
+          elsif element.name == 'abbr' and not element.attribute('title').nil?
+            @properties['name'] = [element.attribute('title').value.strip]
+
+          else
+            child_nodes = element.children.select{|n| not n.is_a?(Nokogiri::XML::Text)}
+
+            if child_nodes.count == 1 and child_nodes.first.is_a?(Nokogiri::XML::Element) and format_classes(child_nodes.first).empty?
+              node = child_nodes.first
+
+              #else if .h-x>img:only-child[alt]:not([alt=""]):not[.h-*] then use that img’s alt for name
+              if node.name == 'img' and not node.attribute('alt').nil? and not node.attribute('alt').value.empty?
+                @properties['name'] = [node.attribute('alt').value.strip]
+
+              #else if .h-x>area:only-child[alt]:not([alt=""]):not[.h-*] then use that area’s alt for name
+              elsif node.name == 'area' and not node.attribute('alt').nil? and not node.attribute('alt').value.empty?
+                @properties['name'] = [node.attribute('alt').value.strip]
+
+              #else if .h-x>abbr:only-child[title]:not([title=""]):not[.h-*] then use that abbr title for name
+              elsif node.name == 'abbr' and not node.attribute('title').nil? and not node.attribute('title').value.empty?
+                @properties['name'] = [node.attribute('title').value.strip]
+
+              else
+                child_nodes = node.children.select{|n| not n.is_a?(Nokogiri::XML::Text)}
+                if child_nodes.count == 1 and child_nodes.first.is_a?(Nokogiri::XML::Element) and format_classes(child_nodes.first).empty?
+                  node = child_nodes.first
+
+                  #else if .h-x>:only-child:not[.h-*]>img:only-child[alt]:not([alt=""]):not[.h-*] then use that img’s alt for name
+                  if node.name == 'img' and not node.attribute('alt').nil? and not node.attribute('alt').value.empty?
+                    @properties['name'] = [node.attribute('alt').value.strip]
+
+                  #else if .h-x>:only-child:not[.h-*]>area:only-child[alt]:not([alt=""]):not[.h-*] then use that area’s alt for name
+                  elsif node.name == 'area' and not node.attribute('alt').nil? and not node.attribute('alt').value.empty?
+                    @properties['name'] = [node.attribute('alt').value.strip]
+
+                  #else if .h-x>:only-child:not[.h-*]>abbr:only-child[title]:not([title=""]):not[.h-*] use that abbr’s title for name
+                  elsif node.name == 'abbr' and not node.attribute('title').nil? and not node.attribute('title').value.empty?
+                    @properties['name'] = [node.attribute('title').value.strip]
+
+                  else
+                    @properties['name'] = [element.text.strip]
+
+                  end
+                else
+                  @properties['name'] = [element.text.strip]
+                end
+              end
+            else
+              @properties['name'] = [element.text.strip]
+            end
+          end
+        end # end implied name
+
+
+        if @properties['photo'].nil?
+          if element.name == 'img' and not element.attribute('src').nil?
+            @properties['photo'] = [element.attribute('src').value]
+          elsif element.name == 'object' and not element.attribute('data').nil?
+            @properties['photo'] = [element.attribute('data').value]
+          else
+
+            #else if .h-x>img[src]:only-of-type:not[.h-*] then use that img src for photo
+
+            child_img_tags_with_src = element.children.select do |child|
+              child.is_a?(Nokogiri::XML::Element) and child.name == 'img' and not child.attribute('src').nil?
+            end
+            if child_img_tags_with_src.count == 1
+              node = child_img_tags_with_src.first
+              if format_classes(node).empty?
+                @properties['photo'] = [node.attribute('src').value.strip]
+              end
+            end
+
+            if @properties['photo'].nil?
+
+              #else if .h-x>object[data]:only-of-type:not[.h-*] then use that object’s data for photo
+
+              child_object_tags_with_data = element.children.select do |child|
+                child.is_a?(Nokogiri::XML::Element) and child.name == 'object' and not child.attribute('data').nil?
+              end
+              if child_object_tags_with_data.count == 1
+                node = child_object_tags_with_data.first
+                if format_classes(node).empty?
+                  @properties['photo'] = [node.attribute('data').value.strip]
+                end
+              end
+            end
+
+            child_elements = element.children.select do |child| not child.is_a?(Nokogiri::XML::Text) end
+
+            if @properties['photo'].nil? and child_elements.count == 1 and format_classes(child_elements.first).empty?
+
+              #else if .h-x>:only-child:not[.h-*]>img[src]:only-of-type:not[.h-*], then use that img’s src for photo
+
+              child_img_tags_with_src = child_elements.first.children.select do |child|
+                child.is_a?(Nokogiri::XML::Element) and child.name == 'img' and not child.attribute('src').nil?
+              end
+              if child_img_tags_with_src.count == 1
+                node = child_img_tags_with_src.first
+                if format_classes(node).empty?
+                  @properties['photo'] = [node.attribute('src').value.strip]
+                end
+              end
+
+              if @properties['photo'].nil?
+
+                #else if .h-x>:only-child:not[.h-*]>object[data]:only-of-type:not[.h-*], then use that object’s data for photo
+                #
+                child_object_tags_with_data = child_elements.first.children.select do |child|
+                  child.is_a?(Nokogiri::XML::Element) and child.name == 'object' and not child.attribute('data').nil?
+                end
+                if child_object_tags_with_data.count == 1
+                  node = child_object_tags_with_data.first
+                  if format_classes(node).empty?
+                    @properties['photo'] = [node.attribute('data').value.strip]
+                  end
+                end
+              end
+            end
+
+          end
+          unless @properties['photo'].nil?
+            @properties['photo'] = [ Microformats2::AbsoluteUri.new(@properties['photo'].first, base: @base).absolutize ]
+          end
         end
-      end
 
-      def parse_microformat(element)
-        # only create ruby object for first format class
-        html_class = format_classes(element).first
-        const_name = constant_name(html_class)
-        klass = find_or_create_ruby_class(const_name)
+        if @properties['url'].nil?
+          if element.name == 'a' and not element.attribute('href').nil?
+            @properties['url'] = [element.attribute('href').value]
+          elsif element.name == 'area' and not element.attribute('href').nil?
+            @properties['url'] = [element.attribute('href').value]
+          else
+            #else if .h-x>a[href]:only-of-type:not[.h-*], then use that [href] for url
+            child_a_tags_with_href = element.children.select do |child|
+              child.is_a?(Nokogiri::XML::Element) and child.name == 'a' and not child.attribute('href').nil?
+            end
+            if child_a_tags_with_href.count == 1
+              node = child_a_tags_with_href.first
+              if format_classes(node).empty?
+                @properties['url'] = [node.attribute('href').value.strip]
+              end
+            end
+
+            if @properties['url'].nil?
+
+              #else if .h-x>area[href]:only-of-type:not[.h-*], then use that [href] for url
+              child_area_tags_with_href = element.children.select do |child|
+                child.is_a?(Nokogiri::XML::Element) and child.name == 'area' and not child.attribute('href').nil?
+              end
+              if child_area_tags_with_href.count == 1
+                node = child_area_tags_with_href.first
+                if format_classes(node).empty?
+                  @properties['url'] = [node.attribute('href').value.strip]
+                end
+              end
+            end
+
+            child_elements = element.children.select do |child| not child.is_a?(Nokogiri::XML::Text) end
+
+            if @properties['url'].nil? and child_elements.count == 1 and format_classes(child_elements.first).empty?
+              child_element = child_elements.first
+
+              #else if .h-x>:only-child:not[.h-*]>a[href]:only-of-type:not[.h-*], then use that [href] for url
+              child_a_tags_with_href = child_element.children.select do |child|
+                child.is_a?(Nokogiri::XML::Element) and child.name == 'a' and not child.attribute('href').nil?
+              end
+              if child_a_tags_with_href.count == 1
+                node = child_a_tags_with_href.first
+                if format_classes(node).empty?
+                  @properties['url'] = [node.attribute('href').value.strip]
+                end
+              end
+
+              if @properties['url'].nil?
+
+                #else if .h-x>:only-child:not[.h-*]>area[href]:only-of-type:not[.h-*], then use that [href] for url
+                child_area_tags_with_href = child_element.children.select do |child|
+                  child.is_a?(Nokogiri::XML::Element) and child.name == 'area' and not child.attribute('href').nil?
+                end
+                if child_area_tags_with_href.count == 1
+                  node = child_area_tags_with_href.first
+                  if format_classes(node).empty?
+                    @properties['url'] = [node.attribute('href').value.strip]
+                  end
+                end
+              end
+            end
+          end
+
+          unless @properties['url'].nil?
+            @properties['url'] = [ Microformats2::AbsoluteUri.new(@properties['url'].first, base: @base).absolutize ]
+          end
+        end
 
-        klass.new(element, @@base).parse
       end
+      ##### END Implied Properties when not in backcompat mode######
 
-      def property_classes(element)
-        element.attribute("class").to_s.split.select do |html_class|
-          html_class =~ Property::CLASS_REG_EXP
+      ### imply date for dt-end if dt-start is defined with a date ###
+      if not @properties['end'].nil? and not @properties['start'].nil?
+        start_date = nil
+        @properties['start'].each do |start_val|
+          if start_val =~ /^(\d{4}-[01]\d-[0-3]\d)/
+            start_date = $1 if start_date.nil?
+          elsif start_val =~ /^(\d{4}-[0-3]\d\d)/
+            start_date = $1 if start_date.nil?
+          end
+        end
+        unless start_date.nil?
+          @properties['end'].map! do |end_val|
+            if end_val=~ /^\d{4}-[01]\d-[0-3]\d/
+              end_val
+            elsif end_val=~ /^\d{4}-[0-3]\d\d/
+              end_val
+            else
+              start_date + ' ' + end_val
+            end
+          end
         end
       end
 
-      def format_classes(element)
-        element.attribute("class").to_s.split.select do |html_class|
-          html_class =~ Format::CLASS_REG_EXP
+      if @value.nil? or @value.empty?
+        if element_type == 'p' and not @properties['name'].nil? and not @properties['name'].empty?
+          @value = @properties['name'].first
+        elsif element_type == 'u' and not @properties['url'].nil? and not @properties['url'].empty?
+          @value = @properties['url'].first
+        elsif not element_type.nil?
+          @value = PropertyParser.new.parse(element, base: @base, element_type: element_type,  backcompat: @mode_backcompat)
         end
       end
 
-      def constant_name(html_class)
-        # html-Class -> html-class -> html_class -> Html_class -> HtmlClass
-        html_class.downcase.gsub("-","_").gsub(/^([a-z])/){$1.upcase}.gsub(/_(.)/){$1.upcase}
+      h_object = {}
+
+      h_object['value'] = @value unless @value.nil?
+      h_object['type'] = format_class_array
+      h_object['properties'] = @properties
+
+      h_object['children'] = @children unless @children.empty?
+
+      if @format_property_type == 'e'
+        h_object['value'] = element.text.strip
+        h_object['html'] = element.inner_html
       end
 
-      def find_or_create_ruby_class(const_name)
-        if Object.const_defined?(const_name)
-          klass = Object.const_get(const_name)
+      ##todo fall back to p- dt- u- parsing if value still not set?
+      #  not sure that is correct by the spec actually
+
+      h_object
+
+    end
+
+
+    def parse_element(element)
+
+      prop_classes = property_classes(element)
+      prop_classes = backcompat_property_classes(element) if @mode_backcompat
+
+      bc_classes_found = false
+      fmt_classes = format_classes(element)
+
+      if fmt_classes.empty?
+          fmt_classes = backcompat_format_classes(element)
+          bc_classes_found = true unless fmt_classes.empty?
+      end
+
+      if prop_classes.length >= 1
+
+        if fmt_classes.length >= 1
+
+          prop_classes.each do |element_class|
+            element_type = element_class.downcase.split('-')[0]
+            property_name = element_class.downcase.split('-')[1..-1].join('-')
+
+            parsed_format = FormatParser.new.parse(element, base:@base, element_type: element_type, format_class_array: fmt_classes, backcompat: bc_classes_found )
+
+            if @value.nil?
+              if @format_property_type == 'p' and property_name == 'name'
+                @value = parsed_format['value']
+              #elsif @format_property_type == 'dt' and property_name == '???'
+                #@value = parsed_format['value']
+              elsif @format_property_type == 'u' and property_name == 'url'
+                @value = parsed_format['value']
+              end
+            end
+
+            @properties[property_name] = []  if @properties[property_name].nil?
+            @properties[property_name] << parsed_format
+
+          end
+
         else
-          klass = Class.new(Microformats2::Format)
-          Object.const_set const_name, klass
+
+          prop_classes.each do |element_class|
+            element_type = element_class.downcase.split('-')[0]
+            property_name = element_class.downcase.split('-')[1..-1].join('-')
+
+            parsed_property = PropertyParser.new.parse(element, base: @base, element_type: element_type, backcompat:  @mode_backcompat)
+
+            if not parsed_property.nil? and not parsed_property.empty?
+              @properties[property_name] = []  if @properties[property_name].nil?
+              @properties[property_name] << parsed_property
+            end
+          end
+          parse_nodeset(element.children)
         end
-        klass
+
+      elsif fmt_classes.length >= 1
+        @children << FormatParser.new.parse(element, base: @base, format_class_array: fmt_classes, backcompat: bc_classes_found )
+      else
+        parse_nodeset(element.children)
       end
-    end # class << self
+    end
+
   end
 end