mida 0.1.3 → 0.2.0

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+== 0.2.0 (3rd May 2011)
+* Add ability to describe and conform to vocabularies
+* Rename Mida::Property to Mida::Itemprop to better reflect use
+* Make some of the Mida::Itemprop class methods private
+
 == 0.1.3 (18th April 2011)
 * Ensure itemprops are parsed properly if containing non-microdata elements
 * Support itemprops nested within other itemprops

data/README.rdoc

@@ -10,7 +10,7 @@ This is based on the latest Published version of the Microdata Specification
 dated {5th April 2011}[http://www.w3.org/TR/2011/WD-microdata-20110405/].
 
 == Installation
-With Ruby and Rubygems:
+Mida keeps RubyGems[http://rubygems.org/gems/mida] up-to-date with its latest version, so installing is as easy as:
   gem install mida
 
 === Requirements:
@@ -58,6 +58,29 @@ values will be an array of either +String+ or <tt>Mida::Item</tt> instances.
 To see the +properties+ of the +Item+:
   puts doc.items.first.properties
 
+=== Working with Vocabularies
+Mida allows you to define vocabularies, so that input data can be constrained to match
+expected patterns.  By default a generic vocabulary (<tt>Mida::Vocabulary::Generic</tt>)
+is registered which will match against any +itemtype+ with any number of properties.
+
+If you want to specify a vocabulary you create a class derived from <tt>Mida::VocabularyDesc</tt>
+and use +itemtype+, +has_one+, +has_many+ and +types+ to describe the vocabulary.
+
+As an example the following describes a subset of Google's Review vocabulary:
+  class Review < Mida::VocabularyDesc
+    itemtype %r{http://data-vocabulary.org/review}
+    has_one 'itemreviewed'
+    has_one 'rating'
+  end
+
+To register the above Vocabulary use:
+  Mida::Vocabulary.register(Review)
+
+Now if Mida is parsing some input and manages to match against the +Review+ +itemtype+, it
+will only allow the specified properties and will reject any that don't have the correct number.  It
+will also set <tt>Item#vocabulary</tt> accordingly, e.g.
+  doc.items.first.vocabulary      # => Review
+
 == Bugs/Feature Requests
 If you find a bug or want to make a feature request, please report it at the
 Mida project's {issues tracker}[https://github.com/LawrenceWoodman/mida/issues]

data/Rakefile

@@ -6,7 +6,7 @@ spec = Gem::Specification.new do |s|
   s.name        = "mida"
   s.summary     = "A Microdata parser/extractor library"
   s.description = "A Microdata parser and extractor library, based on the latest published version of the Microdata Specification, dated 5th April 2011."
-  s.version     = "0.1.3"
+  s.version     = "0.2.0"
   s.author      = "Lawrence Woodman"
   s.email       = "lwoodman@vlifesystems.com"
   s.homepage    = %q{http://github.com/LawrenceWoodman/mida}

data/lib/mida.rb

@@ -3,4 +3,7 @@ Dir[File.dirname(__FILE__) + '/mida/*.rb'].each { |f| require f }
 
 # Mida is a Microdata parser and extractor.
 module Mida
+
 end
+
+require_relative 'mida/vocabulary/generic'

data/lib/mida/document.rb

@@ -11,7 +11,7 @@ module Mida
 
     # Create a new Microdata object
     #
-    # [target] The string containing the html that you want to parse
+    # [target] The string containing the html that you want to parse.
     # [page_url] The url of target used for form absolute urls. This must
     #            include the filename, e.g. index.html.
     def initialize(target, page_url=nil)
@@ -23,26 +23,31 @@ module Mida
     # Returns an array of matching Mida::Item objects
     #
     # [vocabulary] A regexp to match the item types against
+    #              or a Class derived from Mida::VocabularyDesc
+    #              to match against
     def search(vocabulary, items=@items)
       found_items = []
+      regexp_passed = vocabulary.kind_of?(Regexp)
+      regexp = if regexp_passed then vocabulary else vocabulary.itemtype end
+
       items.each do |item|
         # Allows matching against empty string, otherwise couldn't match
         # as item.type can be nil
-        if (item.type.nil? && "" =~ vocabulary) || (item.type =~ vocabulary)
+        if (item.type.nil? && "" =~ regexp) || (item.type =~ regexp)
           found_items << item
         end
-        found_items += search_values(item.properties.values, vocabulary)
+        found_items += search_values(item.properties.values, regexp)
       end
       found_items
     end
 
   private
     def extract_items
-      items_doc = @doc.search('//*[@itemscope and not(@itemprop)]')
-      return nil unless items_doc
+      itemscopes = @doc.search('//*[@itemscope and not(@itemprop)]')
+      return nil unless itemscopes
 
-      items_doc.collect do |item_doc|
-        Item.new(item_doc, @page_url)
+      itemscopes.collect do |itemscope|
+        Item.new(itemscope, @page_url)
       end
     end
 

data/lib/mida/item.rb

@@ -4,6 +4,9 @@ module Mida
 
   # Class that holds each item/itemscope
   class Item
+    # The vocabulary used to interpret this item
+    attr_reader :vocabulary
+
     # The Type of the item
     attr_reader :type
 
@@ -17,20 +20,27 @@ module Mida
 
     # Create a new Item object
     #
-    # [itemscope] The itemscope that you want to parse
-    # [page_url] The url of target used for form absolute urls
+    # [itemscope] The itemscope that you want to parse.
+    # [page_url] The url of target used for form absolute url.
     def initialize(itemscope, page_url=nil)
       @itemscope, @page_url = itemscope, page_url
       @type, @id = extract_attribute('itemtype'), extract_attribute('itemid')
+      @vocabulary = Mida::Vocabulary.find(@type)
       @properties = {}
       add_itemref_properties
-      traverse_elements(extract_elements(itemscope))
+      parse_elements(extract_elements(@itemscope))
+      validate_properties
     end
 
     # Return a Hash representation
-    # of the form {type: 'The item type', properties: {'a name' => 'avalue' }}
+    # of the form:
+    #   { vocabulary: 'http://example.com/vocab/review',
+    #     type: 'The item type',
+    #     id: 'urn:isbn:1-934356-08-5',
+    #     properties: {'a name' => 'avalue' }
+    #   }
     def to_h
-      {type: @type, id: @id, properties: properties_to_h(@properties)}
+      {vocabulary: @vocabulary, type: @type, id: @id, properties: properties_to_h(@properties)}
     end
 
     def to_s
@@ -38,11 +48,55 @@ module Mida
     end
 
     def ==(other)
-      @type == other.type and @id == other.id and @properties == other.properties
+      @vocabulary == other.vocabulary && @type == other.type &&
+      @id == other.id && @properties == other.properties
     end
 
   private
 
+    # Validate the properties so that they are in their proper form
+    def validate_properties
+      @properties =
+      @properties.each_with_object({}) do |(property, values), hash|
+        if valid_property?(property, values)
+          hash[property] = valid_values(property, values)
+        end
+      end
+    end
+
+    # Return whether the number of values conforms to the spec
+    def valid_num_values?(property, values)
+      return false unless @vocabulary.prop_spec.has_key?(property)
+      property_spec = @vocabulary.prop_spec[property]
+      (property_spec[:num] == :many ||
+        (property_spec[:num] == :one && values.length == 1))
+    end
+
+    def valid_property?(property, values)
+      [property, :any].any? {|prop| valid_num_values?(prop, values)}
+    end
+
+    def valid_values(property, values)
+      prop_types = if @vocabulary.prop_spec.has_key?(property)
+        @vocabulary.prop_spec[property][:types]
+      else
+        @vocabulary.prop_spec[:any][:types]
+      end
+
+      values.select {|value| valid_type(prop_types, value) }
+    end
+
+    def valid_type(prop_types, value)
+      if value.respond_to?(:vocabulary)
+        if prop_types.include?(value.vocabulary) || prop_types.include?(:any)
+          return true
+        end
+      elsif prop_types.include?(value.class) || prop_types.include?(:any)
+        return true
+      end
+      false
+    end
+
     def extract_attribute(attribute)
       (value = @itemscope.attribute(attribute)) ? value.value : nil
     end
@@ -66,31 +120,33 @@ module Mida
     end
 
     def properties_to_h(properties)
-      hash = {}
-      properties.each { |name, value| hash[name] = value_to_h(value) }
-      hash
+      properties.each_with_object({}) do |(name, value), hash|
+        hash[name] = value_to_h(value)
+      end
     end
 
     # Add any properties referred to by 'itemref'
     def add_itemref_properties
       itemref = extract_attribute('itemref')
       if itemref
-        itemref.split.each {|id| traverse_elements(find_with_id(id))}
+        itemref.split.each {|id| parse_elements(find_with_id(id))}
       end
     end
 
-    def traverse_elements(elements)
-      elements.each do |element|
-        itemscope = element.attribute('itemscope')
-        itemprop = element.attribute('itemprop')
-        internal_elements = extract_elements(element)
-        add_itemprop(element) if itemscope || itemprop
-        traverse_elements(internal_elements) if internal_elements && !itemscope
-      end
+    def parse_elements(elements)
+      elements.each {|element| parse_element(element)}
+    end
+
+    def parse_element(element)
+      itemscope = element.attribute('itemscope')
+      itemprop = element.attribute('itemprop')
+      internal_elements = extract_elements(element)
+      add_itemprop(element) if itemscope || itemprop
+      parse_elements(internal_elements) if internal_elements && !itemscope
     end
 
     def add_itemprop(itemprop)
-      properties = Property.parse(itemprop, @page_url)
+      properties = Itemprop.parse(itemprop, @page_url)
       properties.each { |name, value| (@properties[name] ||= []) << value }
     end
 

data/lib/mida/{property.rb → itemprop.rb}

@@ -4,7 +4,7 @@ require 'uri'
 module Mida
 
   # Module that parses itemprop elements
-  module Property
+  module Itemprop
 
     # Returns a Hash representing the property.
     # Hash is of the form {'property name' => 'value'}
@@ -63,6 +63,9 @@ module Mida
       end
     end
 
+    private_class_method :make_absolute_url, :extract_property_names
+    private_class_method :extract_property_value, :extract_property
+
   end
 
 end

data/lib/mida/vocabulary.rb

@@ -0,0 +1,26 @@
+module Mida
+
+  # Module to register the Vocabularies with
+  module Vocabulary
+
+    # Register a vocabulary that can be used when parsing,
+    # later vocabularies are given precedence over earlier ones
+    def self.register(vocabulary)
+      (@vocabularies ||= []) << vocabulary
+    end
+
+    # Find the last vocabulary registered that matches the itemtype
+    def self.find(itemtype)
+      @vocabularies.reverse_each do |vocabulary|
+        if ((itemtype || "") =~ vocabulary.itemtype) then return vocabulary end
+      end
+      nil
+    end
+
+    # Return the registered vocabularies
+    def self.vocabularies
+      @vocabularies
+    end
+
+  end
+end

data/lib/mida/vocabulary/generic.rb

@@ -0,0 +1,15 @@
+module Mida
+  module Vocabulary
+
+    # A Generic vocabulary that will match against anything
+    class Generic < Mida::VocabularyDesc
+      itemtype %r{}
+      has_many :any do
+        types :any
+      end
+    end
+
+    register(Generic)
+  end
+
+end

data/lib/mida/vocabularydesc.rb

@@ -0,0 +1,57 @@
+module Mida
+
+  # Class used to describe a vocabulary
+  #
+  # To specify a vocabulary use the following methods:
+  # +itemtype+, +has_one+, +has_many+, +types+
+  class VocabularyDesc
+
+    # Sets the regular expression to match against the +itemtype+
+    # or returns the current regular expression
+    def self.itemtype(regexp_arg=nil)
+      if regexp_arg
+        @itemtype = regexp_arg
+      else
+        @itemtype
+      end
+    end
+
+    # Getter to read the created propeties specification
+    def self.prop_spec
+      @prop_spec || {}
+    end
+
+    # The types a property can take. E.g. +String+, or another +Vocabulary+
+    # If you want to say any type, then use +:any+ as the class
+    # This should be used within a +has_one+ or +has_many+ block
+    def self.types(*type_classes)
+      {types: type_classes}
+    end
+
+    # Defines the properties as only containing one value
+    # If want to say any property name, then use +:any+ as a name
+    def self.has_one(*property_names, &block)
+      has(:one, *property_names, &block)
+    end
+
+    # Defines the properties as containing many values
+    # If want to say any property name, then use +:any+ as a name
+    def self.has_many(*property_names, &block)
+      has(:many, *property_names, &block)
+    end
+
+    def self.has(num, *property_names, &block)
+      @prop_spec ||= {}
+      property_names.each_with_object(@prop_spec) do |name, prop_spec|
+        prop_spec[name] = if block_given?
+          {num: num}.merge(yield)
+        else
+          {num: num, types: [String]}
+        end
+      end
+    end
+
+    private_class_method :has
+
+  end
+end

data/spec/document_spec.rb

@@ -94,8 +94,10 @@ describe Mida::Document, 'when run with a document containing textContent and no
 
     it 'should return all the properties and types with the correct values' do
       expected_results = [
-        { type: nil, id: nil, properties: {'link_field' => ['']} },
-        { type: nil,
+        { vocabulary: Mida::Vocabulary::Generic,
+          type: nil, id: nil, properties: {'link_field' => ['']} },
+        { vocabulary: Mida::Vocabulary::Generic,
+          type: nil,
           id: nil,
           properties: {
             'span_field' => ['Some span content'],
@@ -130,11 +132,13 @@ describe Mida::Document, 'when run with a document containing textContent and no
 
     it 'should return all the properties and types with the correct values' do
       expected_results = [
-        { type: nil, id: nil, properties: {
+        { vocabulary: Mida::Vocabulary::Generic,
+          type: nil, id: nil, properties: {
           'link_field' => ['http://example.com/start/stylesheet.css']
           }
         },
-        { type: nil,
+        { vocabulary: Mida::Vocabulary::Generic,
+          type: nil,
           id: nil,
           properties: {
             'span_field' => ['Some span content'],
@@ -192,6 +196,7 @@ describe Mida::Document, 'when run against a full html document containing one i
 
   it 'should return all the properties and types with the correct values' do
     expected_results = [{
+      vocabulary: Mida::Vocabulary::Generic,
       type: nil,
       id: nil,
       properties: {
@@ -238,11 +243,13 @@ describe Mida::Document, 'when run against a full html document containing one i
 
   it 'should return all the properties and types with the correct values' do
     expected_results = [{
+      vocabulary: Mida::Vocabulary::Generic,
       type: nil,
       id: nil,
       properties: {
         'itemreviewed' => ['Romeo Pizza'],
         'address' => [{
+          vocabulary: Mida::Vocabulary::Generic,
           type: nil, id: nil, properties: {
             'firstline' => ['237 Italian Way'],
             'country' => ['United Kingdom']
@@ -287,15 +294,18 @@ describe Mida::Document, 'when run against a full html document containing one i
 
   it 'should return all the properties and types with the correct values' do
     expected_results = [{
+      vocabulary: Mida::Vocabulary::Generic,
       type: nil,
       id: nil,
       properties: {
         'itemreviewed' => ['Romeo Pizza'],
         'address' => [{
+          vocabulary: Mida::Vocabulary::Generic,
           type: nil,
           id: nil,
           properties: {
             'firstline' => [{
+              vocabulary: Mida::Vocabulary::Generic,
               type: nil,
               id: nil,
               properties: {
@@ -351,6 +361,7 @@ describe Mida::Document, 'when run against a full html document containing one i
 
   it 'should return all the properties and types with the correct values' do
     expected_results = [{
+      vocabulary: Mida::Vocabulary::Generic,
       type: 'http://data-vocabulary.org/Review',
       id: nil,
       properties: {
@@ -412,6 +423,7 @@ describe Mida::Document, 'when run against a full html document containing two n
 
   it 'should return all the properties and types with the correct values for 1st itemscope' do
     expected_results = [{
+      vocabulary: Mida::Vocabulary::Generic,
       type: 'http://data-vocabulary.org/Review',
       id: nil,
       properties: {
@@ -424,6 +436,7 @@ describe Mida::Document, 'when run against a full html document containing two n
 
   it 'should return all the properties from the text for 2nd itemscope' do
     expected_results = [{
+      vocabulary: Mida::Vocabulary::Generic,
       type: 'http://data-vocabulary.org/Organization',
       id: nil,
       properties: {
@@ -474,12 +487,14 @@ describe Mida::Document, 'when run against a full html document containing one
   context "when looking at the outer vocabulary" do
     it 'should return all the properties from the text with the correct values' do
       expected_results = [{
+        vocabulary: Mida::Vocabulary::Generic,
         type: 'http://data-vocabulary.org/Product',
         id: nil,
         properties: {
           'name' => ['DC07'],
           'brand' => ['Dyson'],
           'review' => [{
+            vocabulary: Mida::Vocabulary::Generic,
             type: 'http://data-vocabulary.org/Review-aggregate',
             id: nil,
             properties: {
@@ -580,11 +595,13 @@ describe Mida::Document, 'when run against a document using itemrefs' do
 
   it 'should return all the properties from the text with the correct values' do
     expected_results = [{
+      vocabulary: Mida::Vocabulary::Generic,
       type: nil,
       id: nil,
       properties: {
         'name' => ['Amanda'],
         'band' => [{
+          vocabulary: Mida::Vocabulary::Generic,
           type: nil,
           id: nil,
           properties: {
@@ -634,13 +651,15 @@ describe Mida::Document, 'when run against a document using multiple itemprops w
 
   it 'should return all the properties from the text with the correct values' do
     expected_results = [{
+      vocabulary: Mida::Vocabulary::Generic,
       type: 'icecreams',
       id: nil,
       properties: {
         'flavour' => [
           'Lemon sorbet',
           'Apricot sorbet',
-          { type: 'icecream-type',
+          { vocabulary: Mida::Vocabulary::Generic,
+            type: 'icecream-type',
             id: nil,
             properties: {
               'fruit' => ['Strawberry'],
@@ -671,6 +690,7 @@ describe Mida::Document, 'when run against a document using an itemprop with mul
 
   it 'should return all the properties from the text with the correct values' do
     expected_results = [{
+      vocabulary: Mida::Vocabulary::Generic,
       type: nil,
       id: nil,
       properties: {
@@ -682,3 +702,63 @@ describe Mida::Document, 'when run against a document using an itemprop with mul
     test_parsing(@md, %r{}, expected_results)
   end
 end
+
+describe Mida::Document, 'when run against a full html document containing an itemtype that matches a registered vocabulary' do
+
+  before do
+    html = '
+      <html><body>
+        There is some text here
+        <div>
+          and also some here
+          <div itemscope itemtype="http://data-vocabulary.org/Review">
+            <span itemprop="itemreviewed">Romeo Pizza</span>
+            Reviewed by <span itemprop="reviewer">Ulysses Grant</span> on
+            <time itemprop="dtreviewed" datetime="2009-01-06">Jan 6</time>.
+            <span itemprop="summary">Delicious, tasty pizza in Eastlake!</span>
+            <span itemprop="description">This is a very nice pizza place.</span>
+            Rating: <span itemprop="rating">4.5</span>
+          </div>
+        </div>
+      </body></html>
+    '
+
+    class Review < Mida::VocabularyDesc
+      itemtype %r{http://data-vocabulary.org/Review}
+      has_one 'itemreviewed', 'reviewer', 'dtreviewed', 'summary'
+      has_one 'rating', 'description'
+    end
+    Mida::Vocabulary.register(Review)
+
+    @md = Mida::Document.new(html)
+
+  end
+
+  it_should_behave_like 'one root itemscope'
+
+  it '#search should match against Review' do
+    @md.search(Review).size.should == 1
+  end
+
+  it 'should specify the correct type' do
+    @md.search(Review).first.type.should == 'http://data-vocabulary.org/Review'
+  end
+
+  it 'should return all the properties and types with the correct values' do
+    expected_results = [{
+      vocabulary: Review,
+      type: 'http://data-vocabulary.org/Review',
+      id: nil,
+      properties: {
+        'itemreviewed' => ['Romeo Pizza'],
+        'reviewer' => ['Ulysses Grant'],
+        'dtreviewed' => ['2009-01-06'],
+        'summary' => ['Delicious, tasty pizza in Eastlake!'],
+        'description'  => ['This is a very nice pizza place.'],
+        'rating' => ['4.5']
+      }
+    }]
+    test_parsing(@md, Review, expected_results)
+  end
+
+end

data/spec/item_spec.rb

@@ -17,6 +17,10 @@ describe Mida::Item, 'when initialized with an itemscope containing just itempro
       @item = Mida::Item.new(itemscope_el)
     end
 
+    it '#vocabulary should return the correct vocabulary' do
+      @item.vocabulary.should == Mida::Vocabulary::Generic
+    end
+
     it '#type should return the correct type' do
       @item.type.should == nil
     end
@@ -34,7 +38,7 @@ describe Mida::Item, 'when initialized with an itemscope containing just itempro
 
     it '#to_h should return the correct type and properties' do
       @item.to_h.should == {
-        type: nil, id: nil, properties: {
+        vocabulary: Mida::Vocabulary::Generic, type: nil, id: nil, properties: {
           'first_name' => ['Lorry'],
           'last_name' => ['Woodman']
         }
@@ -49,6 +53,10 @@ describe Mida::Item, 'when initialized with an itemscope containing just itempro
       @item = Mida::Item.new(itemscope_el)
     end
 
+    it '#vocabulary should return the correct vocabulary' do
+      @item.vocabulary.should == Mida::Vocabulary::Generic
+    end
+
     it '#type should return the correct type' do
       @item.type.should == 'person'
     end
@@ -66,6 +74,7 @@ describe Mida::Item, 'when initialized with an itemscope containing just itempro
 
     it '#to_h should return the correct type and properties' do
       @item.to_h.should == {
+        vocabulary: Mida::Vocabulary::Generic,
         type: 'person',
         id: nil,
         properties: {
@@ -112,6 +121,10 @@ describe Mida::Item, 'when initialized with an itemscope containing itemprops su
     @item.type.should == 'person'
   end
 
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Mida::Vocabulary::Generic
+  end
+
   it '#id should return the correct id' do
     @item.id.should == nil
   end
@@ -125,6 +138,7 @@ describe Mida::Item, 'when initialized with an itemscope containing itemprops su
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
+      vocabulary: Mida::Vocabulary::Generic,
       type: 'person',
       id: nil,
       properties: {
@@ -145,6 +159,10 @@ describe Mida::Item, "when initialized with an itemscope containing itemprops
     @item = Mida::Item.new(itemscope)
   end
 
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Mida::Vocabulary::Generic
+  end
+
   it '#type should return the correct type' do
     @item.type.should == nil
   end
@@ -161,6 +179,7 @@ describe Mida::Item, "when initialized with an itemscope containing itemprops
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
+      vocabulary: Mida::Vocabulary::Generic,
       type: nil,
       id: nil,
       properties: {
@@ -184,6 +203,10 @@ describe Mida::Item, "when initialized with an itemscope containing an itemprop
     @item = Mida::Item.new(itemscope)
   end
 
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Mida::Vocabulary::Generic
+  end
+
   it '#type should return the correct type' do
     @item.type.should == nil
   end
@@ -201,6 +224,7 @@ describe Mida::Item, "when initialized with an itemscope containing an itemprop
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
+      vocabulary: Mida::Vocabulary::Generic,
       type: nil,
       id: nil,
       properties: {
@@ -239,6 +263,10 @@ describe Mida::Item, 'when initialized with an itemscope containing itemprops wi
     @item = Mida::Item.new(icecreams)
   end
 
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Mida::Vocabulary::Generic
+  end
+
   it '#type should return the correct type' do
     @item.type.should == 'icecreams'
   end
@@ -259,13 +287,15 @@ describe Mida::Item, 'when initialized with an itemscope containing itemprops wi
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
+      vocabulary: Mida::Vocabulary::Generic,
       type: 'icecreams',
       id: nil,
       properties: {
         'flavour' => [
           'Lemon Sorbet',
           'Apricot Sorbet',
-          { type: 'icecream-type',
+          { vocabulary: Mida::Vocabulary::Generic,
+            type: 'icecream-type',
             id: nil,
             properties: {
               'fruit' => ['Strawberry'],
@@ -306,6 +336,10 @@ describe Mida::Item, 'when initialized with an itemscope containing itemrefs' do
     @item = Mida::Item.new(age_div)
   end
 
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Mida::Vocabulary::Generic
+  end
+
   it '#type should return the correct type' do
     @item.type.should == nil
   end
@@ -324,12 +358,14 @@ describe Mida::Item, 'when initialized with an itemscope containing itemrefs' do
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
+      vocabulary: Mida::Vocabulary::Generic,
       type: nil,
       id: nil,
       properties: {
         'age' => ['30'],
         'name' => ['Amanda'],
         'band' => [{
+          vocabulary: Mida::Vocabulary::Generic,
           type: nil,
           id: nil,
           properties: {
@@ -358,6 +394,10 @@ describe Mida::Item, 'when initialized with an itemscope containing an itemid' d
     @item = Mida::Item.new(book)
   end
 
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Mida::Vocabulary::Generic
+  end
+
   it '#type should return the correct type' do
     @item.type.should == 'book'
   end
@@ -375,6 +415,7 @@ describe Mida::Item, 'when initialized with an itemscope containing an itemid' d
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
+      vocabulary: Mida::Vocabulary::Generic,
       type: 'book',
       id: 'urn:isbn:978-1-849510-50-9',
       properties: {
@@ -425,6 +466,10 @@ describe Mida::Item, 'when initialized with an itemscope containing itemscopes a
   before do
   end
 
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Mida::Vocabulary::Generic
+  end
+
   it '#type should return the correct type' do
     @item.type.should == 'review'
   end
@@ -443,18 +488,21 @@ describe Mida::Item, 'when initialized with an itemscope containing itemscopes a
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
+      vocabulary: Mida::Vocabulary::Generic,
       type: 'review',
       id: nil,
       properties: {
         'item_name' => ['Acme Anvil'],
         'rating' => ['5'],
         'reviewer' => [{
+          vocabulary: Mida::Vocabulary::Generic,
           type: 'person',
           id: nil,
           properties: {
             'first_name' => ['Lorry'],
             'last_name' => ['Woodman'],
             'represents' => [{
+              vocabulary: Mida::Vocabulary::Generic,
               type: 'organization',
               id: nil,
               properties: {
@@ -467,3 +515,70 @@ describe Mida::Item, 'when initialized with an itemscope containing itemscopes a
     }
   end
 end
+
+describe Mida::Item, 'when initialized with an itemscope that matches a non-generic registered vocabulary' do
+  before do
+
+    class Colour < Mida::VocabularyDesc
+      itemtype %r{http://example.com/vocab/colour}
+      has_one 'red', 'green', 'blue'
+    end
+    Mida::Vocabulary.register(Colour)
+
+    class Person < Mida::VocabularyDesc
+      itemtype %r{http://example.com/vocab/person}
+      has_one 'name'
+      has_one 'url'
+      has_many 'limbs'
+      has_many 'favourite-colours' do
+        types Colour
+      end
+    end
+    Mida::Vocabulary.register(Person)
+
+    red = mock_element('span', {'itemprop' => 'red'}, '0xFF')
+    green = mock_element('span', {'itemprop' => 'green'}, '0x00')
+    blue = mock_element('span', {'itemprop' => 'blue'}, '0xFF')
+    purple = mock_element('div', {'itemscope' => true,
+                                  'itemtype' => 'http://example.com/vocab/colour',
+                                  'itemprop' => 'favourite-colours'},
+                                 nil, [red, green, blue])
+    orange = mock_element('span', {'itemprop' => 'favourite-colours'}, 'Orange')
+
+    name1 = mock_element('span', {'itemprop' => 'name'}, 'Lawrence Woodman')
+    name2 = mock_element('span', {'itemprop' => 'name'}, 'Lorry Woodman')
+    url = mock_element('a', {'itemprop' => 'url', 'href' => 'http://example.com/myhomepage'})
+    arm = mock_element('span', {'itemprop' => 'limbs'}, 'Arm')
+    leg = mock_element('span', {'itemprop' => 'limbs'}, 'Leg')
+    robert_wilson = mock_element('span', {'itemprop' => 'favourite-author'}, 'Robert Wilson')
+    itemscope_el = mock_element('div', {'itemscope' => true,
+                                        'itemtype' =>'http://example.com/vocab/person'
+                                       }, nil, [name1, name2, url, arm, leg, purple, orange, robert_wilson])
+    @item = Mida::Item.new(itemscope_el, "http://example.com")
+  end
+
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Person
+  end
+
+  it 'should reject properties that have multiple values if has_one specified' do
+    @item.properties.should_not have_key('name')
+  end
+
+  it 'should accept properties that have a single value if has_one specified' do
+    @item.properties['url'].should == ['http://example.com/myhomepage']
+  end
+
+  it 'should accept properties that have a many values if has_many specified' do
+    @item.properties['limbs'].should == ['Arm', 'Leg']
+  end
+
+  it 'should register properties using the specified types' do
+    @item.properties['favourite-colours'].size.should == 1
+    @item.properties['favourite-colours'].first.vocabulary.should == Colour
+  end
+
+  it 'should reject properties that are not specified' do
+    @item.properties.should_not have_key('favourite-author')
+  end
+end

data/spec/{property_spec.rb → itemprop_spec.rb}

@@ -2,27 +2,27 @@ require_relative 'spec_helper'
 require_relative '../lib/mida'
 
 
-describe Mida::Property, 'when parsing an element without an itemprop attribute' do
+describe Mida::Itemprop, 'when parsing an element without an itemprop attribute' do
   before do
     @element = mock_element('span')
   end
 
   it '#parse should return an empty Hash' do
-    Mida::Property.parse(@element).should == {}
+    Mida::Itemprop.parse(@element).should == {}
   end
 end
 
-describe Mida::Property, 'when parsing an element with one itemprop name' do
+describe Mida::Itemprop, 'when parsing an element with one itemprop name' do
   before do
     @element = mock_element('span', {'itemprop' => 'reviewer'}, 'Lorry Woodman')
   end
 
   it '#parse should return a Hash with the correct name/value pair' do
-    Mida::Property.parse(@element).should == {'reviewer' => 'Lorry Woodman'}
+    Mida::Itemprop.parse(@element).should == {'reviewer' => 'Lorry Woodman'}
   end
 end
 
-describe Mida::Property, "when parsing an element who's inner text contains\
+describe Mida::Itemprop, "when parsing an element who's inner text contains\
   non microdata elements" do
   before do
     html = '<span itemprop="reviewer">Lorry <em>Woodman</em></span>'
@@ -31,11 +31,11 @@ describe Mida::Property, "when parsing an element who's inner text contains\
   end
 
   it '#parse should return a Hash with the correct name/value pair' do
-    Mida::Property.parse(@itemprop).should == {'reviewer' => 'Lorry Woodman'}
+    Mida::Itemprop.parse(@itemprop).should == {'reviewer' => 'Lorry Woodman'}
   end
 end
 
-describe Mida::Property, 'when parsing an itemscope element that has a relative url' do
+describe Mida::Itemprop, 'when parsing an itemscope element that has a relative url' do
   before do
 
     # The first_name element
@@ -54,7 +54,7 @@ describe Mida::Property, 'when parsing an itemscope element that has a relative
   end
 
   it '#parse should return a Hash with the correct name/value pair' do
-    property = Mida::Property.parse(@itemscope_el, "http://example.com")
+    property = Mida::Itemprop.parse(@itemscope_el, "http://example.com")
     property.size.should == 1
     reviewer = property['reviewer']
     reviewer.type.should == 'person'
@@ -66,13 +66,13 @@ describe Mida::Property, 'when parsing an itemscope element that has a relative
   end
 end
 
-describe Mida::Property, 'when parsing an element with multiple itemprop names' do
+describe Mida::Itemprop, 'when parsing an element with multiple itemprop names' do
   before do
     @element = mock_element('span', {'itemprop' => 'reviewer friend person'}, 'the property text')
   end
 
   it '#parse should return a Hash with the name/value pairs' do
-    Mida::Property.parse(@element).should == {
+    Mida::Itemprop.parse(@element).should == {
       'reviewer' => 'the property text',
       'friend' => 'the property text',
       'person' => 'the property text'
@@ -80,7 +80,7 @@ describe Mida::Property, 'when parsing an element with multiple itemprop names'
   end
 end
 
-describe Mida::Property, 'when parsing an element with non text content url values' do
+describe Mida::Itemprop, 'when parsing an element with non text content url values' do
   before :all do
     URL_ELEMENTS = {
       'a' => 'href',     'area' => 'href',
@@ -98,7 +98,7 @@ describe Mida::Property, 'when parsing an element with non text content url valu
       url = 'register/index.html'
       URL_ELEMENTS.each do |tag, attr|
         element = mock_element(tag, {'itemprop' => 'url', attr => url})
-        Mida::Property.parse(element).should == {'url' => ''}
+        Mida::Itemprop.parse(element).should == {'url' => ''}
       end
     end
 
@@ -112,7 +112,7 @@ describe Mida::Property, 'when parsing an element with non text content url valu
       urls.each do |url|
         URL_ELEMENTS.each do |tag, attr|
           element = mock_element(tag, {'itemprop' => 'url', attr => url})
-          Mida::Property.parse(element).should == {'url' => url}
+          Mida::Itemprop.parse(element).should == {'url' => url}
         end
       end
     end
@@ -127,7 +127,7 @@ describe Mida::Property, 'when parsing an element with non text content url valu
       url = 'register/index.html'
       URL_ELEMENTS.each do |tag, attr|
         element = mock_element(tag, {'itemprop' => 'url', attr => url})
-        Mida::Property.parse(element, @page_url).should ==
+        Mida::Itemprop.parse(element, @page_url).should ==
           {'url' => 'http://example.com/test/register/index.html'}
       end
     end
@@ -142,7 +142,7 @@ describe Mida::Property, 'when parsing an element with non text content url valu
       urls.each do |url|
         URL_ELEMENTS.each do |tag, attr|
           element = mock_element(tag, {'itemprop' => 'url', attr => url})
-          Mida::Property.parse(element, @page_url).should == {'url' => url}
+          Mida::Itemprop.parse(element, @page_url).should == {'url' => url}
         end
       end
     end
@@ -150,16 +150,16 @@ describe Mida::Property, 'when parsing an element with non text content url valu
   end
 end
 
-describe Mida::Property, 'when parsing an element with non text content non url values' do
+describe Mida::Itemprop, 'when parsing an element with non text content non url values' do
   it 'should get values from a meta content attribute' do
     element = mock_element('meta', {'itemprop' => 'reviewer',
                                     'content' => 'Lorry Woodman'})
-    Mida::Property.parse(element).should == {'reviewer' => 'Lorry Woodman'}
+    Mida::Itemprop.parse(element).should == {'reviewer' => 'Lorry Woodman'}
   end
 
   it 'should get time from an time datatime attribute' do
     element = mock_element('time', {'itemprop' => 'dtreviewed',
                                     'datetime' => '2011-04-04'})
-    Mida::Property.parse(element).should == {'dtreviewed' => '2011-04-04'}
+    Mida::Itemprop.parse(element).should == {'dtreviewed' => '2011-04-04'}
   end
 end

data/spec/vocabularydesc_spec.rb

@@ -0,0 +1,106 @@
+require_relative 'spec_helper'
+require_relative '../lib/mida'
+
+describe Mida::VocabularyDesc, 'when subclassed and given has statements with no blocks' do
+  before do
+    class Organization < Mida::VocabularyDesc
+      itemtype %r{http://example\.com.*?organization$}i
+      has_one 'name'
+      has_many 'tel', 'url'
+    end
+  end
+
+  it '#itemtype should return the correct regexp' do
+    Organization.itemtype.should == %r{http://example\.com.*?organization$}i
+  end
+
+  it 'should specify name to appear once' do
+    Organization.prop_spec['name'][:num].should == :one
+  end
+
+  it 'should specify tel and url to appear many times' do
+    Organization.prop_spec['tel'][:num].should == :many
+    Organization.prop_spec['url'][:num].should == :many
+  end
+end
+
+describe Mida::VocabularyDesc, 'when subclassed and given has statements with blocks' do
+  before do
+    class Rating < Mida::VocabularyDesc
+      itemtype %r{http://example\.com.*?rating$}i
+      has_one 'best', 'value'
+    end
+
+    class Comment < Mida::VocabularyDesc
+      itemtype %r{http://example\.com.*?comment$}i
+      has_one 'commentor', 'comment'
+    end
+
+    class Review < Mida::VocabularyDesc
+      itemtype %r{http://example\.com.*?review$}i
+      has_one 'itemreviewed'
+      has_one 'rating' do
+        types Rating, String
+      end
+      has_many 'comments' do
+        types Comment
+      end
+    end
+  end
+
+  it '#itemtype should return the correct regexp' do
+    Review.itemtype.should == %r{http://example\.com.*?review$}i
+  end
+
+  it 'should specify itemreviewed to appear once' do
+    Review.prop_spec['itemreviewed'][:num].should == :one
+  end
+
+  it 'should specify that itemreviewed only have the type String' do
+    Review.prop_spec['itemreviewed'][:types].should == [String]
+  end
+
+  it 'should specify rating to appear once' do
+    Review.prop_spec['rating'][:num].should == :one
+  end
+
+  it 'should specify rating to only have the types: Rating, String' do
+    Review.prop_spec['rating'][:types].should == [Rating, String]
+  end
+
+  it 'should specify comments to appear many times' do
+    Review.prop_spec['comments'][:num].should == :many
+  end
+
+  it 'should specify that comments only have the type Comment' do
+    Review.prop_spec['comments'][:types].should == [Comment]
+  end
+end
+
+describe Mida::VocabularyDesc, 'when subclassed and used with :any for properties and types' do
+  before do
+    class Person < Mida::VocabularyDesc
+      itemtype %r{}
+      has_one 'name'
+      has_many :any do
+        types :any
+      end
+    end
+  end
+
+  it '#itemtype should return the correct regexp' do
+    Person.itemtype.should == %r{}
+  end
+
+  it 'should specify that name only appears once' do
+    Person.prop_spec['name'][:num].should == :one
+  end
+
+  it 'should specify that any other property can appear many times' do
+    Person.prop_spec[:any][:num].should == :many
+  end
+  
+  it 'should specify that any other property can have any type' do
+    Person.prop_spec[:any][:types].should == [:any]
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: mida
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors: 
 - Lawrence Woodman
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-18 00:00:00 Z
+date: 2011-05-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: nokogiri
@@ -46,13 +46,17 @@ extra_rdoc_files:
 - CHANGELOG.rdoc
 files: 
 - lib/mida.rb
-- lib/mida/property.rb
 - lib/mida/item.rb
 - lib/mida/document.rb
-- spec/property_spec.rb
+- lib/mida/vocabulary/generic.rb
+- lib/mida/vocabularydesc.rb
+- lib/mida/itemprop.rb
+- lib/mida/vocabulary.rb
+- spec/itemprop_spec.rb
 - spec/document_spec.rb
 - spec/item_spec.rb
 - spec/spec_helper.rb
+- spec/vocabularydesc_spec.rb
 - TODO.rdoc
 - CHANGELOG.rdoc
 - README.rdoc