microformats2 2.9.0 → 3.0.0

data/lib/microformats2/collection.rb

@@ -1,136 +0,0 @@
-module Microformats2
-  class Collection
-    attr_reader :items
-
-    def initialize(element, url = nil)
-      @element = element
-
-      @base = nil
-      if url != nil
-        @base = url
-      end
-      if @element.search("base").size > 0
-        @base = @element.search("base")[0].attribute("href")
-      end
-
-      @format_names = []
-      @rels = {}
-      @alternates = []
-    end
-
-    def parse
-      items
-      parse_rels
-      self
-    end
-
-    def items
-      @items ||= FormatParser.parse(@element, @base).each do |format|
-        save_format_name(format.method_name)
-        define_method(format.method_name)
-        set_value(format.method_name, format)
-      end
-    end
-
-    def all
-      warn "[DEPRECATION] `all` is deprecated and will be removed in the next release.  Please use `items` instead."
-      items
-    end
-
-    def first
-      warn "[DEPRECATION] `first` is deprecated and will be removed in the next release.  Please use `items.first` instead."
-      items.first
-    end
-
-    def last
-      warn "[DEPRECATION] `last` is deprecated and will be removed in the next release.  Please use `items.last` instead."
-      items.last
-    end
-
-    def to_hash
-      hash = { items: [], rels: @rels }
-      items.each do |format|
-        hash[:items] << format.to_hash
-      end
-      hash[:alternates] = @alternates unless @alternates.nil? || @alternates.empty?
-
-      hash
-    end
-
-    def to_json
-      to_hash.to_json
-    end
-
-    private
-
-    def save_format_name(format_name)
-      unless @format_names.include?(format_name)
-        @format_names << format_name
-      end
-    end
-
-    def define_method(mn)
-      unless respond_to?(mn)
-        #self.class.class_eval { attr_accessor mn }
-        self.class.class_eval("
-          def #{mn}(arg = nil);
-            if arg == :all
-              @#{mn}_array
-            else
-              @#{mn}
-            end
-          end") 
-        self.class.class_eval("def #{mn}=(x); @#{mn} = x; end") 
-      end
-      unless respond_to?(mn.pluralize)
-        #self.class.class_eval { attr_accessor mn.pluralize }
-        self.class.class_eval("def #{mn.pluralize};
-          warn \"[DEPRECATION] pluralized accessors are deprecated and will be removed in the next release. Please use `#{mn}(:all)` instead.\"
-          return @#{mn}_array; end") 
-        self.class.class_eval("def #{mn.pluralize}=(x); @#{mn}_array = x; end") 
-
-      end
-    end
-
-    def set_value(mn, value)
-      unless current = send(mn)
-        send("#{mn}=", value)
-      end
-      if current = send(mn, :all)
-        current = [current] if mn == mn.pluralize #otherwise h-news fails completely
-        current << value
-      else
-        send("#{mn.pluralize}=", [value])
-      end
-    end
-
-    def parse_rels
-      @element.search("*[@rel]").each do |rel|
-        rel_values = rel.attribute("rel").text.split(" ")
-
-        if rel_values.member?("alternate")
-          alternate_inst = {}
-          alternate_inst["url"] = Microformats2::AbsoluteUri.new(@base, rel.attribute("href").text).absolutize
-          alternate_inst["rel"] = (rel_values - ["alternate"]).join(" ")
-          unless rel.attribute("media").nil?
-            alternate_inst["media"] = rel.attribute("media").text
-          end
-          unless rel.attribute("hreflang").nil?
-            alternate_inst["hreflang"] = rel.attribute("hreflang").text
-          end
-          unless rel.attribute("type").nil?
-            alternate_inst["type"] = rel.attribute("type").text
-          end
-          @alternates << alternate_inst
-        else
-          rel_values.each do |rel_value|
-            @rels[rel_value] = [] unless @rels.has_key?(rel_value)
-            unless rel.attribute("href").nil?
-              @rels[rel_value] << Microformats2::AbsoluteUri.new(@base, rel.attribute("href").text).absolutize
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/microformats2/format.rb

@@ -1,151 +0,0 @@
-module Microformats2
-  class Format
-    CLASS_REG_EXP = /^(h-)/
-
-    attr_reader :method_name
-
-    def initialize(element, base)
-      @element = element
-      @base = base
-      @method_name = to_method_name(type.first)
-      @property_names = []
-      @child_formats = []
-      @child_formats_parsed = false
-    end
-
-    def parse
-      type
-      properties
-      self
-    end
-
-    def children
-      unless @child_formats_parsed
-        parse_child_formats
-        @child_formats_parsed = true
-      end
-      @child_formats
-    end
-
-    def format_types
-      warn "[DEPRECATION] `format_types` is deprecated and will be removed in the next release.  Please use `type` instead."
-      type
-    end
-
-    def type
-      @type ||= @element.attribute("class").to_s.split.select do |html_class|
-        html_class =~ Format::CLASS_REG_EXP
-      end
-    end
-
-    def properties
-      @properties ||= parse_properties.concat parse_implied_properties
-    end
-
-    def parse_properties
-      PropertyParser.parse(@element.children, @base).each do |property|
-        assign_property(property)
-      end
-    end
-
-    def parse_child_formats
-      FormatParser.parse(@element.children, @base, true).each do |child_format|
-        @child_formats.push(child_format)
-      end
-    end
-
-    def add_property(property_class, value)
-      property = Property.new(nil, property_class, value, @base)
-      assign_property(property)
-    end
-
-    def parse_implied_properties
-      ip = []
-      ip << ImpliedProperty::Name.new(@element, @base).parse unless property_present?(:name)
-      ip << ImpliedProperty::Url.new(@element, @base).parse unless property_present?(:url)
-      ip << ImpliedProperty::Photo.new(@element, @base).parse unless property_present?(:photo)
-      ip.compact.each do |property|
-        save_property_name(property.method_name)
-        define_method(property.method_name)
-        set_value(property.method_name, property)
-      end
-    end
-
-    def property_present?(property)
-      !! respond_to?(property) && send(property)
-    end
-
-    def to_hash
-      hash = { type: type, properties: {} }
-      @property_names.each do |method_name|
-        hash[:properties][method_name.to_sym] = send(method_name, :all).map(&:to_hash)
-      end
-      unless children.empty?
-        hash[:children] = []
-        children.each do |child_format|
-          hash[:children].push(child_format.to_hash)
-        end
-      end
-      hash
-    end
-
-    def to_json
-      to_hash.to_json
-    end
-
-    private
-
-    def assign_property(property)
-      save_property_name(property.method_name)
-      define_method(property.method_name)
-      set_value(property.method_name, property)
-    end
-
-    def to_method_name(html_class)
-      # p-class-name -> class_name
-      mn = html_class.downcase.split("-")[1..-1].join("_")
-      # avoid overriding Object#class
-      mn = "klass" if mn == "class"
-      mn
-    end
-
-    def save_property_name(property_name)
-      unless @property_names.include?(property_name)
-        @property_names << property_name
-      end
-    end
-
-    def define_method(mn)
-      unless respond_to?(mn)
-        #self.singleton_class.class_eval { attr_accessor mn }
-        self.singleton_class.class_eval("
-          def #{mn}(arg = nil);
-            if arg == :all
-              @#{mn}_array
-            else
-              @#{mn}
-            end
-          end") 
-        self.singleton_class.class_eval("def #{mn}=(x); @#{mn} = x; end") 
-      end
-      unless respond_to?(mn.pluralize)
-        #self.singleton_class.class_eval { attr_accessor mn.pluralize }
-        self.singleton_class.class_eval("def #{mn.pluralize};
-          warn \"[DEPRECATION] pluralized accessors are deprecated and will be removed in the next release. Please use `#{mn}(:all)` instead.\"
-          return @#{mn}_array; end") 
-        self.singleton_class.class_eval("def #{mn.pluralize}=(x); @#{mn}_array = x; end") 
-      end
-    end
-
-    def set_value(mn, value)
-      unless current = send(mn)
-        send("#{mn}=", value)
-      end
-      if current = send(mn,:all)
-        current << value if current.respond_to? :<<
-      else
-        send("#{mn.pluralize}=", [value])
-      end
-    end
-  end
-end

data/lib/microformats2/implied_property/foundation.rb

@@ -1,59 +0,0 @@
-module Microformats2
-  module ImpliedProperty
-    class Foundation
-
-      def initialize(element, base=nil)
-        @element = element
-        @base = base
-      end
-
-      def parse
-        self if to_s
-      end
-
-      def method_name
-        "foundation"
-      end
-
-      def to_s
-        @to_s ||= element_value || selector_value
-      end
-
-      def to_hash
-        to_s
-      end
-
-      def to_json
-        to_hash.to_json
-      end
-
-      protected
-
-      def element_value
-        name_map.each_pair do |elname, attr|
-          if elname == @element.name && @element.attribute(attr)
-            return @element.attribute(attr).to_s
-          end
-        end
-        nil
-      end
-
-      def name_map
-        {}
-      end
-
-      def selector_value
-        selector_map.each_pair do |sel, attr|
-          if selected_element = @element.css(sel).first
-            return selected_element.attribute(attr).to_s
-          end
-        end
-        nil
-      end
-
-      def selector_map
-        {}
-      end
-    end
-  end
-end

data/lib/microformats2/implied_property/name.rb

@@ -1,34 +0,0 @@
-module Microformats2
-  module ImpliedProperty
-    class Name < Foundation
-
-      def method_name
-        "name"
-      end
-
-      def to_s
-        @to_s ||= element_value || selector_value || text_value
-      end
-
-      protected
-
-      def name_map
-        { "img" => "alt",
-          "abbr" => "title" }
-      end
-
-      def selector_map
-        { ">img[alt]:only-of-type" => "alt",
-          ">abbr[title]:only-of-type" => "title",
-          ">:only-of-type>img[alt]:only-of-type" => "alt",
-          ">:only-of-type>abbr[title]:only-of-type" => "title" }
-      end
-
-      private
-
-      def text_value
-        @element.inner_text.gsub(/\n+/, " ").gsub(/\s+/, " ").strip
-      end
-    end
-  end
-end

data/lib/microformats2/implied_property/photo.rb

@@ -1,28 +0,0 @@
-module Microformats2
-  module ImpliedProperty
-    class Photo < Foundation
-
-      def method_name
-        "photo"
-      end
-
-      def to_s
-        @to_s = Microformats2::AbsoluteUri.new(@base, super.to_s).absolutize
-      end
-
-      protected
-
-      def name_map
-        { "img" => "src",
-          "object" => "data" }
-      end
-
-      def selector_map
-        { ">img[src]:only-of-type" => "src",
-          ">object[data]:only-of-type" => "data",
-          ">:only-child>img[src]:only-of-type" => "src",
-          ">:only-child>object[data]:only-of-type" => "data" }
-      end
-    end
-  end
-end

data/lib/microformats2/implied_property/url.rb

@@ -1,24 +0,0 @@
-module Microformats2
-  module ImpliedProperty
-    class Url < Foundation
-
-      def method_name
-        "url"
-      end
-
-      def to_s
-        @to_s = Microformats2::AbsoluteUri.new(@base, super.to_s).absolutize
-      end
-
-      protected
-
-      def name_map
-        { "a" => "href" }
-      end
-
-      def selector_map
-        { ">a[href]:only-of-type" => "href" }
-      end
-    end
-  end
-end

data/lib/microformats2/property.rb

@@ -1,21 +0,0 @@
-module Microformats2
-  module Property
-    CLASS_REG_EXP = /^(p-|u-|dt-|e-)/
-    PREFIX_CLASS_MAP = {
-      "p" => Text,
-      "u" => Url,
-      "dt" => DateTime,
-      "e" => Embedded }
-
-    class << self
-	    def new(element, property_class, value=nil, base=nil)
-	      # p-class-name -> p
-	      prefix = property_class.split("-").first
-	      # find ruby class for kind of property
-	      klass = PREFIX_CLASS_MAP[prefix]
-	      raise InvalidPropertyPrefix unless klass
-	      klass.new(element, property_class, value, base)
-	    end
-	  end
-  end
-end