mida 0.3.1 → 0.3.2

data/CHANGELOG.rdoc

@@ -1,3 +1,7 @@
+== 0.3.2 (9th July 2011)
+* Ensure <tt>bin/mida</tt> only searches if type regexp passed
+* Allow vocabularies to be included into other vocabularies
+
 == 0.3.1 (5th July 2011)
 * Add bin/mida exectuable
 * Changed <tt>Item#to_h</tt> to only return keys with values

data/README.rdoc

@@ -77,9 +77,7 @@ Mida allows you to define vocabularies, so that input data can be constrained to
 expected patterns.  By default a generic vocabulary (<tt>Mida::GenericVocabulary</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::Vocabulary</tt>
-and use +itemtype+, +has_one+, +has_many+ and +extract+ to describe the vocabulary.
-
+If you want to specify a vocabulary you create a class derived from <tt>Mida::Vocabulary</tt>.
 As an example the following describes a subset of Google's Review vocabulary:
 
   class Rating < Mida::Vocabulary
@@ -105,6 +103,29 @@ will only allow the specified properties and will reject any that don't have the
 will also set <tt>Item#vocabulary</tt> accordingly, e.g.
   doc.items.first.vocabulary      # => Review
 
+If you want to include the properties of another vocabulary you can use
++include_vocabulary+:
+  class Thing < Mida::Vocabulary
+    itemtype %r{http://example.com/vocab/thing}i
+    has_one 'name', 'description'
+  end
+
+  class Book < Mida::Vocabulary
+    itemtype %r{http://example.com/vocab/book}i
+    include_vocabulary Thing
+    has_one 'title', 'author'
+  end
+
+  class Collection < Mida::Vocabulary
+    itemtype %r{http://example.com/vocab/collection}i
+    has_many 'item' do
+      extract Thing
+    end
+  end
+
+In the above if you gave a +Book+ as an item of +Collection+ this would be
+accepted because it includes the +Thing+ vocabulary.
+
 == 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.3.1"
+  s.version     = "0.3.2"
   s.author      = "Lawrence Woodman"
   s.email       = "lwoodman@vlifesystems.com"
   s.homepage    = %q{http://lawrencewoodman.github.com/mida/}
@@ -18,6 +18,7 @@ spec = Gem::Specification.new do |s|
   s.rdoc_options << '--main' << 'README.rdoc'
   s.add_dependency('nokogiri', '>= 1.5')
   s.add_development_dependency('rspec', '>= 2.0' )
+  s.add_development_dependency('bundler')
 end
 Gem::PackageTask.new(spec).define
 

data/bin/mida

@@ -54,7 +54,7 @@ ARGV.options do |option|
   begin
     option.parse!
   rescue OptionParser::InvalidOption => error
-    puts "#{error}\n#{option}"; exit
+    puts "#{error.to_s.capitalize}\n#{option}"; exit
   end
   if ARGV.empty? then puts option; exit end
 end
@@ -85,8 +85,12 @@ def parse_source(source, options)
   begin
     open(source) do |f|
       doc = Mida::Document.new(f, url, options[:validate])
-      type = options[:type] || %r{}
-      items = doc.search(type)
+      items = if options[:type]
+        doc.search(options[:type])
+      else
+        doc.items
+      end
+
       if items.empty?
         puts "No microdata found in this document."; exit
       else

data/lib/mida/item.rb

@@ -140,10 +140,8 @@ module Mida
     # Returns whether the +itemtype+ is a valid type
     def valid_itemtype?(valid_types, itemtype)
       return true if valid_types.include?(:any)
-
-      valid_types.find do |type|
-        type.respond_to?(:itemtype) && type.itemtype =~ itemtype
-      end
+      vocabulary = Vocabulary.find(itemtype)
+      valid_types.find {|type| vocabulary.kind_of?(type) }
     end
 
     # Returns the extracted value or +nil+ if none of the datatypes

data/lib/mida/vocabulary.rb

@@ -8,15 +8,11 @@ module Mida
   class Vocabulary
 
     class << self
-      # Return the properties specification
-      attr_reader :properties
-
       # Return the registered vocabularies
       attr_reader :vocabularies
     end
 
     @vocabularies = Set.new
-    @properties = {}
 
     # Register a vocabulary that can be used when parsing,
     # later vocabularies are given precedence over earlier ones
@@ -41,14 +37,40 @@ module Mida
       register(subclass)
     end
 
+    # Return the properties specification
+    def self.properties
+      @properties ||= {}
+    end
+
+    # Return the included vocabularies
+    def self.included_vocabularies
+      @included_vocabularies ||= Set.new
+    end
+
+    # Include the properties from the specified <tt>vocabularies</tt>.
+    # This is the correct way to inherit properties from another vocabulary,
+    # rather than subclassing.
+    def self.include_vocabulary(*vocabularies)
+      vocabularies.each do |vocabulary|
+        included_vocabularies.merge(vocabulary.included_vocabularies)
+        included_vocabularies << vocabulary
+        properties.merge!(vocabulary.properties)
+      end
+    end
+
+    # As per the standard <tt>kind_of?</tt>, but also checks to see if vocabulary has
+    # been included by self
+    def self.kind_of?(vocabulary)
+      return true if self == vocabulary
+      return true if self.ancestors.include?(vocabulary)
+      included_vocabularies.include?(vocabulary)
+    end
+
     # 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
+    def self.itemtype(regexp=nil)
+      return @itemtype unless regexp
+      @itemtype = regexp
     end
 
 

data/spec/item_spec.rb

@@ -257,6 +257,63 @@ describe Mida::Item, 'when initialized with an itemscope containing another corr
 
 end
 
+describe Mida::Item, 'when initialized with an itemscope that has a property type that is a child of the specified type' do
+  before do
+    class Person < Mida::Vocabulary
+      itemtype %r{http://example.com/vocab/person}
+      has_one 'name'
+      has_many 'tel'
+    end
+
+    class Student < Mida::Vocabulary
+      itemtype %r{http://example.com/vocab/student}
+      include_vocabulary Person
+      has_one 'studying'
+    end
+
+    class Organization < Mida::Vocabulary
+      itemtype %r{http://example.com/vocab/organization}
+      has_one 'name'
+      has_many 'employee' do
+        extract Person
+      end
+    end
+
+    student_itemscope = mock(Mida::Itemscope)
+    student_itemscope.stub!(:kind_of?).any_number_of_times.with(Mida::Itemscope).and_return(true)
+    student_itemscope.stub!(:type).and_return("http://example.com/vocab/student")
+    student_itemscope.stub!(:id).and_return(nil)
+    student_itemscope.stub!(:properties).and_return(
+      { 'name' => ['Lorry Woodman'],
+        'tel' => ['000004847582'],
+        'studying' => ['Classics']
+      }
+    )
+
+    org_itemscope = mock(Mida::Itemscope)
+    org_itemscope.stub!(:kind_of?).any_number_of_times.with(Mida::Itemscope).and_return(true)
+    org_itemscope.stub!(:type).and_return("http://example.com/vocab/organization")
+    org_itemscope.stub!(:id).and_return(nil)
+    org_itemscope.stub!(:properties).and_return(
+      { 'name' => ['Acme Inc.'],
+        'employee' => [student_itemscope]
+      }
+    )
+    @item = Mida::Item.new(org_itemscope)
+  end
+
+  it 'should recognise an itemtype that is the child of that specified' do
+    @item.properties['employee'][0].vocabulary.should == Student
+    @item.properties['employee'][0].type.should == 'http://example.com/vocab/student'
+    @item.properties['employee'][0].properties.should == {
+      'name' => 'Lorry Woodman',
+      'tel' => ['000004847582'],
+      'studying' => 'Classics'
+    }
+  end
+
+end
+
 describe Mida::Item, 'when initialized with an itemscope containing another invalid itemscope' do
   before do
     class Person < Mida::Vocabulary

data/spec/vocabulary_spec.rb

@@ -126,6 +126,10 @@ describe Mida::Vocabulary, 'when subclassed' do
     Mida::Vocabulary.vocabularies.should include(Person)
   end
 
+  it '#included_vocabularies should be empty' do
+    Person.included_vocabularies.empty?.should be_true
+  end
+
 end
 
 describe Mida::Vocabulary, 'when subclassed and has no properties' do
@@ -146,3 +150,71 @@ describe Mida::Vocabulary, 'when subclassed and has no properties' do
   end
 
 end
+
+describe Mida::Vocabulary, 'when subclassed and using #include_vocabulary' do
+  before do
+    class Thing < Mida::Vocabulary
+      itemtype %r{http://example\.com.*?thing$}i
+      has_one 'description'
+    end
+
+    class Product < Mida::Vocabulary
+      include_vocabulary Thing
+      itemtype %r{http://example\.com.*?product$}i
+      has_one 'make', 'model'
+      has_many 'addons'
+    end
+
+    class Vehicle < Mida::Vocabulary
+      itemtype %r{http://example\.com.*?thing$}i
+      include_vocabulary Product
+      has_one 'colour'
+    end
+
+    class Car < Mida::Vocabulary
+      include_vocabulary Product, Vehicle
+      itemtype %r{http://example\.com.*?car$}i
+      has_one 'engine'
+      has_many 'stickers'
+    end
+  end
+
+  it '#itemtype should return the new regexp' do
+    Car.itemtype.should == %r{http://example\.com.*?car$}i
+  end
+
+  it "should contain included vocabularies' properties" do
+    ['description', 'make','model', 'colour'].each do
+      |prop| Car.properties[prop][:num].should == :one
+    end
+    Car.properties['addons'][:num].should == :many
+  end
+
+  it "should contain new properties" do
+    Car.properties['engine'][:num].should == :one
+    Car.properties['stickers'][:num].should == :many
+  end
+
+  it '#included_vocabularies should return the included vocabularies' do
+    [Thing, Product, Vehicle].each do |vocab|
+      Car.included_vocabularies.should include(vocab)
+    end
+  end
+
+  it '.kind_of? should still work with plain Vocabulary' do
+    Car.kind_of?(Mida::Vocabulary).should be_true
+  end
+
+  it '.kind_of? should recognize included vocabularies' do
+    Car.kind_of?(Car).should be_true
+    Car.kind_of?(Vehicle).should be_true
+    Vehicle.kind_of?(Product).should be_true
+    Car.kind_of?(Product).should be_true
+    Car.kind_of?(Thing).should be_true
+  end
+
+  it '.kind_of? should recognize vocabularies without a relationship' do
+    Vehicle.kind_of?(Car).should be_false
+    Thing.kind_of?(Product).should be_false
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: mida
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - Lawrence Woodman
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-05 00:00:00 Z
+date: 2011-07-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: nokogiri
@@ -34,6 +34,17 @@ dependencies:
         version: "2.0"
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: A Microdata parser and extractor library, based on the latest published version of the Microdata Specification, dated 5th April 2011.
 email: lwoodman@vlifesystems.com
 executables: