mida_vocabulary 0.1 → 0.1.1

data/.gitignore

@@ -0,0 +1,6 @@
+# vi swap files
+*.swp
+
+# Gem pkg directory
+pkg/
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+# just let autotest know about rspec

data/.travis.yml

@@ -0,0 +1,4 @@
+script: "bundle exec rake"
+rvm:
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gemspec
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    mida_vocabulary (0.1)
+      blankslate
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    blankslate (2.1.2.4)
+    diff-lcs (1.1.3)
+    rake (0.9.2.2)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  mida_vocabulary!
+  rake
+  rspec (~> 2.7.0)

data/mida_vocabulary.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = "mida_vocabulary"
+  s.summary     = "Microdata vocabularies for mida parser/extractor library"
+  s.description = "Microdata schema.org vocabularies"
+  s.version     = "0.1.1"
+  s.author      = "Pavel Evstigneev"
+  s.email       = "pavel.evst@gmail.com"
+  s.homepage    = %q{http://github.com/Paxa/mida_vocabulary}
+  s.platform    = Gem::Platform::RUBY
+  s.required_ruby_version = '>=1.9'
+  s.files       = `git ls-files`.split("\n")
+  s.executables = []
+  s.extra_rdoc_files = ['README.md']
+  s.add_dependency('blankslate')
+  s.add_development_dependency('rspec', '~> 2.7.0' )
+  s.add_development_dependency('bundler')
+end

data/resources/schema.org/generate.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+# Creates the vocabulary and enumeration classes for schema.org from
+# vocabularies.json which is held at:
+#   https://github.com/LawrenceWoodman/schema.org_schemas
+# The classes are created in vocabularies/
+require 'erb'
+require 'json'
+require 'set'
+
+ENUMERATION_TEMPLATE = <<-EOB
+require 'mida_vocabulary/datatype'
+
+module Mida
+  module SchemaOrg
+
+    # <%= type.description %>
+    class <%= type.name %> < Mida::DataType::Enumeration
+      VALID_VALUES = [
+% num_instances = type.instances.size
+% type.instances.first(num_instances-1).each do |instance|
+        [::Mida::DataType::URL, %r{http://schema.org/<%= instance %>}i],
+% end
+        [::Mida::DataType::URL, %r{http://schema.org/<%= type.instances.last %>}i]
+      ]
+    end
+
+  end
+end
+EOB
+
+VOCABULARY_TEMPLATE = <<-EOB
+require 'mida_vocabulary/vocabulary'
+
+module Mida
+  module SchemaOrg
+
+% type.types_used.each do |klass|
+    autoload :<%= klass %>, 'mida_vocabulary/vocabularies/schemaorg/<%= klass.downcase %>'
+% end
+
+    # <%= type.description %>
+    class <%= type.name %> < Mida::Vocabulary
+      itemtype %r{http://schema.org/<%= type.name %>}i
+% type.vocabularies.each do |include_vocabulary|
+      include_vocabulary Mida::SchemaOrg::<%= include_vocabulary %>
+% end
+% type.properties.each do |property|
+
+      # <%= property.description %>
+%   if property.types.size == 1 && property.types[0].name == 'Text'
+      has_many '<%= property.name %>'
+%   else
+      has_many '<%= property.name %>' do
+%     property.types.each do |prop_type|
+        extract <%= prop_type.full_name %>
+%     end
+      end
+%   end
+% end
+    end
+
+  end
+end
+EOB
+
+DATATYPES = [
+  {'name' => 'Boolean', 'full_name' => 'Mida::DataType::Boolean'},
+  {'name' => 'Date', 'full_name' => 'Mida::DataType::ISO8601Date'},
+  {'name' => 'Float', 'full_name' => 'Mida::DataType::Float'},
+  {'name' => 'Integer', 'full_name' => 'Mida::DataType::Integer'},
+  {'name' => 'Number', 'full_name' => 'Mida::DataType::Number'},
+  {'name' => 'URL', 'full_name' => 'Mida::DataType::URL'},
+  {'name' => 'Text', 'full_name' => 'Mida::DataType::Text'},
+]
+
+class Property
+  
+  attr_reader :name, :description, :types
+
+  def initialize(name, description, types)
+    @name = name
+    @description = description
+    @types = (types || []).collect {|type| Type.find(type)}.sort
+    add_text_type(@types)
+  end
+
+  def add_text_type(types)
+    if types.any? {|type| type.vocabulary?} &&
+       types.none? {|type| type.name == 'Text'}
+      @types << Type.find('Text')
+    end
+  end
+
+end
+
+class Type
+  include Comparable
+
+  attr_reader :name, :full_name, :description, :vocabularies, :properties
+  attr_reader :instances
+
+  def initialize(definition)
+    @name = definition['name']
+    @ancestors = definition['ancestors'] || []
+    @description = definition['description']
+    @vocabularies = definition['vocabularies'] || []
+    @properties = definition['properties'] || []
+    @instances = definition['instances'] || []
+    @full_name = definition['full_name'] || "Mida::SchemaOrg::#{@name}"
+    (@@types ||= []) << self
+  end
+
+  # Returns the found type or nil of not found
+  def self.find(name)
+    found_types = @@types.find_all {|type| type.name == name}
+    found_types.any? ? found_types[0] : nil
+  end
+
+  def process_properties
+    @properties = @properties.collect do |property|
+      Property.new(property['name'], property['description'], property['types'])
+    end
+  end
+
+  def types_used
+    types = Set.new
+    @vocabularies.each do |vocabulary|
+      types << vocabulary
+    end
+
+    @properties.each do |property|
+      property.types .each do |type|
+        unless type.datatype?
+          types << type.name
+        end
+      end
+    end
+    types
+  end
+
+  def get_requires(vocabulary)
+    types = types_used(vocabulary)
+    types.collect do |type|
+      "mida_vocabulary/vocabularies/schemaorg/#{type.name.downcase}"
+    end
+  end
+
+  def enumeration?
+    @ancestors.include?('Enumeration')
+  end
+
+  def datatype?
+    full_name =~ /^Mida::DataType::/
+  end
+
+  def vocabulary?
+    !enumeration? && !datatype?
+  end
+
+  def <=>(other)
+    if full_name =~ /^Mida::DataType::Text/ &&
+       other.full_name !=~/^Mida::DataType::Text/
+      1
+    elsif other.full_name =~ /^Mida::DataType::Text/ &&
+           full_name !=~/^Mida::DataType::Text/
+      -1
+    else
+      full_name <=> other.full_name
+    end
+  end
+end
+
+types = JSON.parse(File.read('vocabularies.json'))
+types = types.collect {|type| Type.new(type)}
+datatypes = DATATYPES.collect {|type| Type.new(type)}
+types.each {|type| type.process_properties}
+
+Dir.mkdir('enumerations') unless File.directory?('enumerations')
+Dir.mkdir('vocabularies') unless File.directory?('vocabularies')
+
+types.each do |type|
+  if type.enumeration?
+    File.open("enumerations/#{type.name.downcase}.rb", 'w') do |file|
+      file.puts ERB.new(ENUMERATION_TEMPLATE, 0, '%').result(binding)
+    end
+  elsif type.vocabulary?
+    File.open("vocabularies/#{type.name.downcase}.rb", 'w') do |file|
+      file.puts ERB.new(VOCABULARY_TEMPLATE, 0, '%').result(binding)
+    end
+  end
+end