mida_vocabulary 0.1

data/lib/mida_vocabulary/vocabularies/schemaorg/wpsidebar.rb

@@ -0,0 +1,17 @@
+require 'mida_vocabulary/vocabulary'
+
+module Mida
+  module SchemaOrg
+
+    autoload :Thing, 'mida_vocabulary/vocabularies/schemaorg/thing'
+    autoload :CreativeWork, 'mida_vocabulary/vocabularies/schemaorg/creativework'
+
+    # A sidebar section of the page.
+    class WPSideBar < Mida::Vocabulary
+      itemtype %r{http://schema.org/WPSideBar}i
+      include_vocabulary Mida::SchemaOrg::Thing
+      include_vocabulary Mida::SchemaOrg::CreativeWork
+    end
+
+  end
+end

data/lib/mida_vocabulary/vocabularies/schemaorg/zoo.rb

@@ -0,0 +1,19 @@
+require 'mida_vocabulary/vocabulary'
+
+module Mida
+  module SchemaOrg
+
+    autoload :Thing, 'mida_vocabulary/vocabularies/schemaorg/thing'
+    autoload :Place, 'mida_vocabulary/vocabularies/schemaorg/place'
+    autoload :CivicStructure, 'mida_vocabulary/vocabularies/schemaorg/civicstructure'
+
+    # A zoo.
+    class Zoo < Mida::Vocabulary
+      itemtype %r{http://schema.org/Zoo}i
+      include_vocabulary Mida::SchemaOrg::Thing
+      include_vocabulary Mida::SchemaOrg::Place
+      include_vocabulary Mida::SchemaOrg::CivicStructure
+    end
+
+  end
+end

data/lib/mida_vocabulary/vocabularies/schemaorg.rb

@@ -0,0 +1 @@
+Dir.glob(File.dirname(__FILE__) + '/schemaorg/*.rb') {|file| require file}

data/lib/mida_vocabulary/vocabulary.rb

@@ -0,0 +1,109 @@
+require 'set'
+module Mida
+
+  # Class used to describe a vocabulary
+  #
+  # To specify a vocabulary use the following methods:
+  # +itemtype+, +has_one+, +has_many+
+  class Vocabulary
+
+    class << self
+      # Return the registered vocabularies
+      attr_reader :vocabularies
+    end
+
+    @vocabularies = Set.new
+
+    # Register a vocabulary that can be used when parsing,
+    # later vocabularies are given precedence over earlier ones
+    def self.register(vocabulary)
+      @vocabularies << vocabulary
+    end
+
+    # Un-register a vocabulary
+    def self.unregister(vocabulary)
+      @vocabularies.delete(vocabulary)
+    end
+
+    # Find the last vocabulary registered that matches the itemtype
+    def self.find(itemtype)
+      @vocabularies.sort_by {|v| v.itemtype ? v.itemtype.source.size : 0 }.reverse.each do |vocabulary|
+        if ((itemtype || "") =~ vocabulary.itemtype)
+          return vocabulary
+        end
+      end
+      nil
+    end
+    
+    def self.inherited(subclass)
+      register(subclass)
+    end
+
+    # Return the properties specification
+    # This won't work properly until all the included_vocabularies
+    # have finished being defined in case of circular dependancies
+    def self.properties
+      return @properties if @properties
+      @properties = @this_properties || {}
+      included_vocabularies.each do |vocabulary|
+        @properties.merge!(vocabulary.properties)
+      end
+      @properties
+    end
+
+    # Return the included vocabularies
+    def self.included_vocabularies
+      @included_vocabularies ||= Set.new
+    end
+
+    # Specify which +vocabularies+ will have their properties included.
+    # 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
+      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=nil)
+      return @itemtype unless regexp
+      @itemtype = regexp
+    end
+
+    # Defines the properties as only containing one value
+    # If want to say any property name, then use +:any+ as a name
+    # Within a block you can use the methods of the class +PropertyDesc+
+    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
+    # Within a block you can use the methods of the class +PropertyDesc+
+    def self.has_many(*property_names, &block)
+      has(:many, *property_names, &block)
+    end
+
+    def self.has(num, *property_names, &block)
+      @this_properties ||= {}
+      property_names.each_with_object(@this_properties) do |name, properties|
+        property_desc = PropertyDesc.new(num, &block)
+        properties[name] = property_desc.to_h
+      end
+    end
+
+    private_class_method :has
+
+  end
+end

data/lib/mida_vocabulary.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+Dir[File.dirname(__FILE__) + '/mida_vocabulary/*.rb'].each { |f| require f }
+
+# Mida is a Microdata parser and extractor.
+module Mida
+
+end
+
+require 'mida_vocabulary/vocabularies/genericvocabulary'
+require 'mida_vocabulary/vocabularies/schemaorg'

data/spec/datatype/boolean_spec.rb

@@ -0,0 +1,40 @@
+require 'mida_vocabulary/datatype'
+
+describe Mida::DataType::Boolean do
+
+  it '#parse should raise an exception if a invalid text passed' do
+    test = lambda {Mida::DataType::Boolean.parse('example')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::Boolean.parse('')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should return true for "True" whatever the case' do
+    ['true', 'True', 'TRUE', 'tRUE'].each do |true_text|
+      Mida::DataType::Boolean.parse(true_text).should be_true
+    end
+  end
+
+  it '#parse should return false for "False" whatever the case' do
+    ['false', 'False', 'FALSE', 'fALSE'].each do |false_text|
+      Mida::DataType::Boolean.parse(false_text).should be_false
+    end
+  end
+
+  it '#to_s should return proper string representation of boolean' do
+    Mida::DataType::Boolean.parse('fALSE').to_s.should == 'False'
+    Mida::DataType::Boolean.parse('tRUE').to_s.should == 'True'
+  end
+
+  it '! should negate as if a TrueClass/FalseClass' do
+    true_boolean = Mida::DataType::Boolean.parse('true')
+    false_boolean = Mida::DataType::Boolean.parse('false')
+
+    (!true_boolean).should be_false
+    (!false_boolean).should be_true
+  end
+
+end

data/spec/datatype/enumeration_spec.rb

@@ -0,0 +1,30 @@
+require 'mida_vocabulary/datatype'
+require 'mida_vocabulary/datatype/url'
+
+describe Mida::DataType::Enumeration do
+  before :all do
+    class BookType < Mida::DataType::Enumeration
+      VALID_VALUES = [
+        [::Mida::DataType::URL, %r{http://example.com/ebook}i],
+        [::Mida::DataType::URL, %r{http://example.com/paperback}i]
+      ]
+    end
+  end
+
+  it '#parse should raise an exception if an invalid url passed' do
+    test = lambda {BookType.parse('http://example.com/hardback')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {BookType.parse('')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should accept a valid value' do
+    url_text = 'http://example.com/ebook'
+    url = BookType.parse(url_text)
+    url.to_s.should == url_text
+  end
+
+end

data/spec/datatype/float_spec.rb

@@ -0,0 +1,21 @@
+require 'mida_vocabulary/datatype'
+
+describe Mida::DataType::Float do
+
+  it '#parse should raise an exception if not a number' do
+    test = lambda {Mida::DataType::Float.parse('hello')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::Float.parse('')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should accept a valid number' do
+    float_text = '3.14'
+    float = Mida::DataType::Float.parse(float_text)
+    float.to_s.should == float_text
+  end
+
+end

data/spec/datatype/generic_spec.rb

@@ -0,0 +1,44 @@
+require 'mida_vocabulary/datatype'
+
+describe Mida::DataType::Generic do
+
+  before do
+    class Number < Mida::DataType::Generic
+      def initialize(value)
+        @parsedValue = Float(value)  
+      end
+    end
+  end
+
+  it '#parse should provide pass value straight to #new' do
+    number = Number.parse('2.34')
+    number == 2.34
+  end
+
+  it "should provide access to the underlying type's methods" do
+    number = Number.new('2.34')
+    number.floor.should == 2
+  end
+
+  it '#to_s should use the underlying types #to_s method' do
+    number = Number.parse('2.34')
+    number.to_s.should == '2.34'
+  end
+
+  it '#to_yaml should provide a yaml representation of the items #to_s method' do
+    number = Number.parse('2.34')
+    number.to_yaml.should =~ /---\s+['"]2.34['"]\n/
+  end
+
+  it '#== should match against underlying type, string representation and self' do
+    number = Number.new('2.34')
+    (number == 2.34).should be_true
+    (number == '2.34').should be_true
+    (number == number).should be_true
+
+    (number == 2.44).should be_false
+    (number == '2.44').should be_false
+    (number == Number.new('2.44')).should be_false
+  end
+
+end

data/spec/datatype/integer_spec.rb

@@ -0,0 +1,26 @@
+require 'mida_vocabulary/datatype'
+
+describe Mida::DataType::Integer do
+
+  it '#parse should raise an exception if not a number' do
+    test = lambda {Mida::DataType::Integer.parse('hello')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should raise an exception if not an integer' do
+    test = lambda {Mida::DataType::Integer.parse('3.14')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::Integer.parse('')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should accept a valid number' do
+    integer_text = '3'
+    integer = Mida::DataType::Integer.parse(integer_text)
+    integer.to_s.should == integer_text
+  end
+
+end

data/spec/datatype/iso8601date_spec.rb

@@ -0,0 +1,27 @@
+require 'mida_vocabulary/datatype'
+
+describe Mida::DataType::ISO8601Date do
+
+  it '#parse should raise an exception if invalid date format' do
+    test = lambda {Mida::DataType::ISO8601Date.parse('27th August 2009')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::ISO8601Date.parse('')}
+    test.should raise_error(ArgumentError)
+  end
+
+  context 'when passed a valid date' do
+    before do
+      @date_text = "2009-08-27T01:13:04+05:10"
+      @date = Mida::DataType::ISO8601Date.parse(@date_text)
+    end
+
+    it '#to_s should return the date as an rfc822 text string' do
+      @date.to_s.should == "Thu, 27 Aug 2009 01:13:04 +0510"
+    end
+
+  end
+
+end

data/spec/datatype/number_spec.rb

@@ -0,0 +1,21 @@
+require 'mida_vocabulary/datatype'
+
+describe Mida::DataType::Number do
+
+  it '#parse should raise an exception if not a number' do
+    test = lambda {Mida::DataType::Number.parse('hello')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::Number.parse('')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should accept a valid number' do
+    num_text = '3.14'
+    num = Mida::DataType::Number.parse(num_text)
+    num.to_s.should == num_text
+  end
+
+end

data/spec/datatype/text_spec.rb

@@ -0,0 +1,16 @@
+require 'mida_vocabulary/datatype'
+
+describe Mida::DataType::Text do
+
+  it '#parse should accept an empty string' do
+    text = Mida::DataType::Text.parse('')
+    text.should == ''
+  end
+
+  it '#parse should return the input value' do
+    test_text = 'Some text'
+    text = Mida::DataType::Text.parse(test_text)
+    text.should == test_text
+  end
+
+end

data/spec/datatype/url_spec.rb

@@ -0,0 +1,27 @@
+require 'mida_vocabulary/datatype'
+require 'yaml'
+
+describe Mida::DataType::URL do
+
+  it '#parse should raise an exception if a bad url passed' do
+    test = lambda {Mida::DataType::URL.parse('example.com')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::URL.parse('')}
+    test.should raise_error(ArgumentError)
+  end
+
+  it '#parse should accept a valid url' do
+    url_text = 'http://example.com/test/'
+    url = Mida::DataType::URL.parse(url_text)
+    url.to_s.should == url_text
+  end
+
+
+  it '#parse should accept a valid url' do
+    url_text = 'http://example.com/test/'
+    url = Mida::DataType::URL.parse(url_text)
+  end
+end

data/spec/propertydesc_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'mida_vocabulary/propertydesc'
+
+describe Mida::PropertyDesc, 'when initialized without a block' do
+  before do
+    @propertyDesc = Mida::PropertyDesc.new(3)
+  end
+
+  it '#to_h[:num] should equal num passed' do
+    @propertyDesc.to_h[:num].should == 3
+  end
+
+  it '#to_h[:types] should equal DataType::Text' do
+    @propertyDesc.to_h[:types].should == [Mida::DataType::Text]
+  end
+end
+
+describe Mida::PropertyDesc, 'when initialized with a block with no specified types' do
+  before do
+    @propertyDesc = Mida::PropertyDesc.new(3) {}
+  end
+
+  it '#to_h[:types] should equal DataType::Text' do
+    @propertyDesc.to_h[:types].should == [Mida::DataType::Text]
+  end
+end
+
+describe Mida::PropertyDesc, 'when initialized with a block that specifies types with extract()' do
+  before do
+    @propertyDesc = Mida::PropertyDesc.new(3) { extract String, Array}
+  end
+
+  it '#to_h[:types] should equal [String, Array]' do
+    @propertyDesc.to_h[:types].should == [String, Array]
+  end
+end
+
+describe Mida::PropertyDesc, 'when initialized with a block that specifies types with types()' do
+  before do
+    @propertyDesc = nil
+    @error = last_stderr do
+      @propertyDesc = Mida::PropertyDesc.new(3) { types String, Array}
+    end
+  end
+
+  it 'should warn on initialization if types() is used in the block' do
+    @error.should eq("[DEPRECATION] Mida::PropertyDesc#types is deprecated.  "+
+      "Please use Mida::PropertyDesc#extract instead."
+    )
+  end
+
+  it '#to_h[:types] should equal [String, Array]' do
+    @propertyDesc.to_h[:types].should == [String, Array]
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'bundler/setup'
+require 'rspec'
+
+def html_wrap(html)
+  "<!DOCTYPE html><html><body>#{html}</body></html>"
+end
+
+# Return the last error message on STDERR.
+# Prevents the message being output to STDERR.
+def last_stderr
+  orig_stderr = $stderr
+  $stderr = StringIO.new
+  yield
+  $stderr.rewind
+  message = $stderr.string.chomp
+  $stderr = orig_stderr
+  message
+end