tripleloop 0.0.1

data/README.md

@@ -0,0 +1,64 @@
+# Tripleloop
+
+A DSL for extracting data from hash-like objects into RDF statements (i.e. triples or quads).
+
+## Usage
+
+Start by creating some extractor classes. Each extractor maps one or several document fragments
+to RDF statments.
+
+```ruby
+class ArticleCoreExtractor < Tripleloop::Extractor
+  bind(:doi) { |doc| RDF::DOI.send(doc[:doi]) }
+
+  map(:title)          { |title|   [doi, RDF::DC11.title, title, RDF::NPGG.articles] }
+  map(:published_date) { |date |   [doi, RDF::DC11.date, Date.parse(date), RDF::NPGG.articles] }
+  map(:product)        { |product| [doi, RDF::NPG.product, RDF::NPGP.nature, RDF::NPGG.articles] }
+end
+
+class SubjectsExtractor < Tripleloop::Extractor
+  bind(:doi) { |doc| RDF::DOI.send(doc[:doi]) }
+
+  map(:subjects) { |subjects|
+    subjects.map { |s|
+      [doi, RDF::NPG.hasSubject, RDF::NPGS.send(s) ]
+    }
+  }
+end
+```
+
+Once defined, extractors can be composed into a DocumentProcessor class.
+
+```ruby
+class NPGProcessor < Tripleloop::DocumentProcessor
+  extractors :article_core, :subjects
+end
+```
+
+The processor can then be fed with a collection of hash like documents and return RDF data grouped by
+extractor name.
+
+```ruby
+data = NPGProcessor.batch_process(documents)
+=> { :article_core => [[<RDF::URI:0x00000002651ce0(http://dx.doi.org/10.1038/481241e)>, 
+                        <RDF::URI:0x1b0c060(http://purl.org/dc/elements/1.1/title)>, 
+                       "Developmental biology: Watching cells die in real time"],...], 
+     :subjects => [...] }
+```
+
+Notice that the output retuned by the `batch_process` method is still a plain ruby data structure, and not an instance of RDF::Statement.
+The actual job of instantiating RDF statements and writing them to disc is in fact responsability of the `Tripleloop::RDFWriter` class, which can be used as follows:
+
+```ruby
+Tripleloop::RDFWriter.new(data, :dataset_path => Pathname.new("my-datasets")).write
+```
+
+This will create the following two files:
+
+- `my-dataset/article_core.nq`
+- `my-dataset/subjects.nq`
+
+When `#write` method is executed, `RDFWriter` will internally generate RDF triples, delegating the RDF serialisation job to RDF.rb's [`RDF::Writer`](http://rubydoc.info/github/ruby-rdf/rdf/master/RDF/Writer).
+The only logic involved in the implementation of `Tripleloop::RDFWriter#write` concerns the assignment of the right RDF serialisation format and file extension. When all the RDF statements
+generated by an extractor do specify also a graph (as in the example above), the writer will use the `RDF::NQuads::Writer`, falling back to `RDF::NTriples::Writer` otherwise.
+

data/lib/tripleloop.rb

@@ -0,0 +1,15 @@
+basedir = File.realpath(File.dirname(File.dirname(__FILE__)))
+$LOAD_PATH << "#{basedir}/lib/tripleloop"
+$LOAD_PATH << "#{basedir}/lib/tripleloop/support"
+
+module Tripleloop; end
+
+require 'extractor'
+require 'document_processor'
+require 'rdf_writer'
+require 'util'
+
+require 'pathname'
+require 'fileutils'
+require 'rdf'
+require 'rdf/ntriples'

data/lib/tripleloop/document_processor.rb

@@ -0,0 +1,62 @@
+module Tripleloop
+  class DocumentProcessor
+    attr_reader :document
+
+    def initialize(document)
+      @document = Util.with_nested_fetch(document)
+    end
+
+    def self.extractors(*args)
+      options = args.last.respond_to?(:fetch) ? args.pop : {}
+      @extractors ||= {}
+
+      args.each do |ext|
+        @extractors[ext] = options
+      end
+    end
+
+    def extracted_statements
+      @extracted_statements ||= Hash[extractor_instances.map { |extractor|
+        [extractor.name.to_sym, extractor.extract]
+      }]
+    end
+
+    def self.batch_process(documents)
+      documents.map { |doc|
+        self.new(doc).extracted_statements
+      }.reduce(Hash.new([])) { |accu, statements|
+        accu.merge(statements) { |k, olds, news|
+          olds.concat(news)
+        }
+      }
+    end
+
+  private
+    def extractor_instances
+      extractors = self.class.instance_variable_get(:@extractors)
+
+      @extractor_instances ||= extractors.map { |ext, opts|
+        klass   = extractor_class(ext)
+        context = get_context(opts[:context])
+        klass.new(context)
+      }
+    end
+
+    def extractor_class(extractor)
+      class_name = Tripleloop::Util::String.classify("#{extractor}_extractor")
+      scope.const_get(class_name)
+    rescue NameError
+      raise ExtractorNotFoundError, "Cannot find an extractor with class name '#{scope}::#{class_name}'"
+    end
+
+    def scope
+      Tripleloop::Util.module(self)
+    end
+
+    def get_context(context)
+      context ? document.get_in(*context) : document
+    end
+
+    class ExtractorNotFoundError < StandardError;end
+  end
+end

data/lib/tripleloop/extractor.rb

@@ -0,0 +1,69 @@
+class Tripleloop::Extractor
+  def initialize(context)
+    @context = context
+    bind_variables!
+  end
+
+  def name
+    class_name = self.class.name.split('::').last
+    Tripleloop::Util::String.snake_case(class_name).gsub(/_extractor$/,'')
+  end
+
+  def self.map(*fragment, &block)
+    @fragment_map ||= {}
+    @fragment_map.merge!(fragment => block)
+  end
+
+  def self.bind(name, &block)
+    @extractor_bindings ||= {}
+    @extractor_bindings[name.to_sym] = block
+  end
+
+  def self.fragment_map
+    @fragment_map || {}
+  end
+
+  def extract
+    self.class.fragment_map.reduce([]) do |memo, (path, block)|
+      fragment = Tripleloop::Util.with_nested_fetch(context).get_in(*path)
+      returned = instance_exec(fragment, &block)
+
+      if nested_triples?(returned)
+        returned.each do |value|
+          ensure_triple_or_quad(value)
+        end
+        memo.concat(returned)
+      else
+        ensure_triple_or_quad(returned)
+        memo << returned
+      end
+    end
+  end
+
+private
+  def nested_triples?(value)
+    value.all? { |object| object.is_a?(Array) }
+  end
+
+  def ensure_triple_or_quad(value)
+    message = "Cannot build a triple or a quad with #{value}."
+    raise BrokenMappingError, message unless is_triple_or_quad?(value)
+  end
+
+  def is_triple_or_quad?(value)
+    [3,4].include? value.length
+  end
+
+  def bind_variables!
+    klass = self.class
+    extractor_bindings = klass.instance_variable_get(:@extractor_bindings) || {}
+    extractor_bindings.each do |method, block|
+      klass.send(:define_method, method) do
+        block.call(context)
+      end
+    end
+  end
+
+  class BrokenMappingError < StandardError; end
+  attr_reader :context
+end

data/lib/tripleloop/rdf_writer.rb

@@ -0,0 +1,61 @@
+class Tripleloop::RDFWriter
+  def initialize(data, opts={})
+    @data    = data
+    @options = opts
+  end
+
+  def statements
+    @statements ||= Hash[@data.map { |extractor_name, statements|
+      [extractor_name,
+       statements.map { |s| as_statement(s) }]
+    }]
+  end
+
+  def write
+    FileUtils.mkdir_p(datasets_path)
+
+    statements.each do |extractor, extracted_statements|
+      build_writer(extractor, extracted_statements) do |writer|
+        extracted_statements.each do |statement|
+          writer << statement
+        end
+      end
+    end
+  end
+
+private
+  attr_reader :options
+
+  def datasets_path(filename=nil)
+    path = Pathname.new(options.fetch(:path, "datasets"))
+    filename ? path.join(filename) : path
+  end
+
+  def build_writer(extractor, statements, &block)
+    statements_format = format(statements)
+    ext               = extensions[statements_format]
+    folder_path       = options.fetch(:dataset_path, datasets_path)
+    path              = folder_path.join("#{extractor}.#{ext}")
+
+    FileUtils.mkdir_p(folder_path)
+    RDF::Writer.for(statements_format).open(path, &block)
+  end
+
+  def format(statements)
+    statements.all?(&:has_context?) ? :nquads : :ntriples
+  end
+
+  def extensions
+    {
+      :ntriples => "nt",
+      :nquads => "nq"
+    }
+  end
+
+  def as_statement(args)
+    statement_args = Hash[
+      [:subject, :predicate, :object, :context].zip(args)
+    ]
+    RDF::Statement.new(statement_args)
+  end
+end

data/lib/tripleloop/util.rb

@@ -0,0 +1,56 @@
+module Tripleloop
+  module Util
+    module NestedFetch
+      def get_in(*keys)
+        return self if keys.empty?
+
+        value = Util.with_nested_fetch(self[keys.shift])
+
+        if value.respond_to?(:get_in) && !keys.empty?
+          value.get_in(*keys)
+        else
+          value
+        end
+      end
+    end
+
+    module String
+      module_function
+
+      def classify(string)
+        string.split("_").reduce("") { |accu, chunk|
+          accu << chunk.capitalize
+        }
+      end
+
+      def snake_case(string)
+        string.gsub(/(.)([A-Z])/,'\1_\2').downcase
+      end
+    end
+
+    module Hash
+      def symbolize_keys
+        self.reduce({}){ |accu, (k,v)|
+          v = v.extend(Util::Hash).symbolize_keys if v.respond_to?(:keys)
+          accu.merge(k.to_sym => v) 
+        }
+      end
+    end
+
+  module_function
+    def with_nested_fetch(object)
+      object.is_a?(Enumerable) ? object.extend(NestedFetch) : object
+    end
+
+    def module(object)
+      constant(object.class.name.split('::')[0..-2])
+    end
+
+    def constant(names, context=Kernel)
+      return context if names.empty?
+
+      const_name = names.shift
+      constant(names, context.const_get(const_name))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+lib_path = File.realpath(File.dirname(File.dirname(__FILE__))) + "/lib"
+$LOAD_PATH << lib_path
+
+require 'tripleloop'
+require 'pry'

data/spec/tripleloop/document_processor_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Tripleloop::DocumentProcessor do
+  module Example
+    class FooExtractor < Tripleloop::Extractor
+      map(:attrs, :foo) { |foo| [:subject, foo, :object ] }
+    end
+
+    class BarExtractor < Tripleloop::Extractor
+      map(:attrs, :bar) { |bar| [:subject, bar, :object ] }
+    end
+
+    class BazExtractor < Tripleloop::Extractor
+      map(:baz) { |baz|
+        baz.map { |v| [:subject, v, :object ] }
+      }
+    end
+
+    class SampleProcessor < Tripleloop::DocumentProcessor
+      extractors :foo, :bar
+      extractors :baz, :context => [:attrs, :nested]
+    end
+
+    class ProcessorWithMissingExtractor < Tripleloop::DocumentProcessor
+      extractors :foo, :missing
+    end
+  end
+
+  let(:document) {{
+    :attrs => {
+      :foo => "foo-value",
+      :bar => "bar-value",
+      :nested => {
+        :baz => ["baz a", "baz b"]
+      }
+    }
+  }}
+
+  describe "#extracted_statements" do
+    subject { Example::SampleProcessor.new(document) }
+
+    context "when some of the registered extractors cannot be found" do
+      it "raises an ExtractorNotFound error" do
+        expect {
+          Example::ProcessorWithMissingExtractor.new(document).extracted_statements
+        }.to raise_error(Example::SampleProcessor::ExtractorNotFoundError, /Example::MissingExtractor/)
+      end
+    end
+
+    context "when all the registered extractors can be found" do
+      it "returns a hash mapping extractor names to extracted statements" do
+        subject.extracted_statements.should eq({
+          :foo => [[:subject, "foo-value", :object]],
+          :bar => [[:subject, "bar-value", :object]],
+          :baz => [[:subject, "baz a", :object],
+                   [:subject, "baz b", :object]]
+        })
+      end
+
+      it "runs the extractors only once" do
+        [Example::FooExtractor, Example::BarExtractor, Example::BazExtractor].each_with_index do |klass, i|
+          extractor = double('extractor', :name => "extractor_#{i}")
+          klass.stub(:new) { extractor }
+          extractor.should_receive(:extract).once.and_return { :extracted }
+        end
+
+        subject.extracted_statements.should eq({
+          :extractor_0 => :extracted,
+          :extractor_1 => :extracted,
+          :extractor_2 => :extracted
+        })
+      end
+    end
+  end
+
+  describe ".batch_process" do
+    let(:documents) {
+      3.times.map { |n| {
+        :attrs => {
+          :foo => "foo-value #{n}",
+          :bar => "bar-value #{n}",
+          :nested => {
+            :baz => ["baz a #{n}", "baz b #{n}"]
+          }
+        }}
+      }
+    }
+
+    subject { Example::SampleProcessor.batch_process(documents) }
+
+    it "returns a hash of combined statements, grouped by extractor name" do
+      subject.should eq({
+        :foo => [
+          [:subject, "foo-value 0", :object],
+          [:subject, "foo-value 1", :object],
+          [:subject, "foo-value 2", :object]
+        ],
+        :bar => [
+          [:subject, "bar-value 0", :object],
+          [:subject, "bar-value 1", :object],
+          [:subject, "bar-value 2", :object]
+        ],
+        :baz => [
+          [:subject, "baz a 0", :object],
+          [:subject, "baz b 0", :object],
+          [:subject, "baz a 1", :object],
+          [:subject, "baz b 1", :object],
+          [:subject, "baz a 2", :object],
+          [:subject, "baz b 2", :object],
+        ]
+      })
+    end
+  end
+end

data/spec/tripleloop/extractor_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Tripleloop::Extractor do
+  class SampleExtractor < Tripleloop::Extractor
+    map(:path, :to, :key) { |fragment|
+      [fragment, :predicate, :object]
+    }
+
+    map(:path, :to, :enumerable) { |enumerable|
+      enumerable.map { |item|
+        [:subject, item, :object]
+      }
+    }
+  end
+
+  class BrokenExtractor < Tripleloop::Extractor
+    map(:path, :to, :key) { |fragment|
+      [[:subject, fragment, :obj],
+       [:subject, :obj]] # <= missing predicate
+    }
+  end
+
+  let(:document) {{
+    :path => {
+      :to => {
+        :key => :test_key,
+        :enumerable => [ :foo, :bar, :baz]
+      }
+    }
+  }}
+
+  let(:extractor) {
+    SampleExtractor.new(document)
+  }
+
+  describe "#extract" do
+    let(:triples) { extractor.extract }
+
+    it "maps a document fragment to a block" do
+      triples.first.should eq([:test_key, :predicate, :object])
+    end
+
+    context "when a block returns multiple triples arguments" do
+      it "concats the returned values to the extracted list" do
+        triples[1..3].should eq([
+          [:subject, :foo, :object],
+          [:subject, :bar, :object],
+          [:subject, :baz, :object]
+        ])
+      end
+    end
+
+    context "when a block does not return a valid constructor argument for RDF::Statement" do
+      it "raises an ArgumentError" do
+        expect {
+          BrokenExtractor.new(document).extract
+        }.to raise_error(Tripleloop::Extractor::BrokenMappingError)
+      end
+    end
+  end
+
+  describe ".define" do
+    let(:document) {{
+      :doi => "10.1038/481241e",
+      :title => "Sample document"
+    }}
+
+    class ExtractorWithBinding < Tripleloop::Extractor
+      bind(:doi) { |doc| doc[:doi] }
+
+      map(:title) { |title|
+        [doi, RDF::DC11.title, title]
+      }
+    end
+
+    it "defines a binding which can be used from within a map block" do
+      extractor = ExtractorWithBinding.new(document)
+      extractor.extract.should eq([["10.1038/481241e", RDF::DC11.title, "Sample document"]])
+    end
+  end
+
+  describe "#name" do
+    it "returns the extractor name (in snake case)" do
+      extractor.name.should eq("sample")
+    end
+  end
+end

data/spec/tripleloop/rdf_writer_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'fakefs/spec_helpers'
+
+describe Tripleloop::RDFWriter do
+  class ExampleNs < RDF::Vocabulary("http://example.com/resources/"); end
+  class SampleGraph < RDF::Vocabulary("http://example.com/graphs/"); end
+
+  let(:triples) {[
+    [ExampleNs.my_resource, RDF::DC11.title, "My test resource"],
+    [ExampleNs.my_resource, RDF::DC11.author, "sample author"]
+  ]}
+
+  let(:triples_as_rdf) {[
+    RDF::Statement(:subject => ExampleNs.my_resource,
+                       :predicate => RDF::DC11.title, 
+                       :object => "My test resource"),
+
+    RDF::Statement(:subject => ExampleNs.my_resource,
+                   :predicate => RDF::DC11.author,
+                   :object => "sample author")
+  ]}
+
+  let(:quads) {[
+    [ExampleNs.my_resource, RDF::DOAP.homepage, ExampleNs.my_resource, SampleGraph.projects],
+    [ExampleNs.my_resource, RDF::DOAP.mailing_list, RDF::URI("mailto://example-list@mailman.example.com"), SampleGraph.projects]
+  ]}
+
+  let(:quads_as_rdf) {[
+    RDF::Statement(:subject => ExampleNs.my_resource,
+                   :predicate => RDF::DOAP.homepage, 
+                   :object => ExampleNs.my_resource,
+                   :context => SampleGraph.projects),
+
+    RDF::Statement(:subject => ExampleNs.my_resource,
+                   :predicate => RDF::DOAP.mailing_list,
+                   :object => RDF::URI("mailto://example-list@mailman.example.com"),
+                   :context => SampleGraph.projects)
+  ]}
+
+  let(:statements) {{
+    :triples => triples,
+    :quads => quads
+  }}
+
+  let(:options) {{}}
+
+  let(:rdf_writer) {
+    Tripleloop::RDFWriter.new(statements, options)
+  }
+
+  describe "#statements" do
+    it "returns 3 items long arrays as RDF triples" do
+      rdf_writer.statements[:triples].should eq(triples_as_rdf)
+    end
+
+    it "returns 4 items long arrays as RDF quads" do
+      rdf_writer.statements[:quads].should eq(quads_as_rdf)
+      rdf_writer.statements[:quads].each do |statement|
+        statement.context.should eq(SampleGraph.projects)
+      end
+    end
+  end
+
+  describe "#write" do
+    include FakeFS::SpecHelpers
+
+    before do
+      FakeFS.activate!
+      rdf_writer.write
+    end
+
+    context "when a dataset path is not supplied in the options" do
+      it "saves files in the standard 'datasets' folder" do
+        File.directory?("datasets").should be_true
+      end
+    end
+
+    context "when a dataset path is supplied" do
+      let(:options) {{
+        :dataset_path => Pathname.new("test-path")
+      }}
+
+      it "exports quads as .nq file" do
+        File.read("test-path/quads.nq").split(/\s*\.\n/).should eq([
+          "<#{ExampleNs.my_resource}> <#{RDF::DOAP.homepage}> <#{ExampleNs.my_resource}> <#{SampleGraph.projects}>",
+          "<#{ExampleNs.my_resource}> <#{RDF::DOAP.mailing_list}> <mailto://example-list@mailman.example.com> <#{SampleGraph.projects}>",
+        ])
+      end
+
+      it "exports triples as .n3 files" do
+        File.read("test-path/triples.nt").split(/\s*\.\n/).should eq([
+          "<#{ExampleNs.my_resource}> <#{RDF::DC11.title}> \"My test resource\"",
+          "<#{ExampleNs.my_resource}> <#{RDF::DC11.author}> \"sample author\"",
+        ])
+      end
+    end
+
+    after do
+      FakeFS.deactivate!
+    end
+  end
+end

data/spec/tripleloop/util_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Tripleloop::Util do
+  subject { Tripleloop::Util }
+
+  describe ".with_nested_fetch" do
+    context "when supplied argument is an array" do
+      it "extends it with the NestedFetch module" do
+        subject.with_nested_fetch({}).should respond_to(:get_in)
+      end
+    end
+
+    context "when supplied argument is an hash" do
+      it "extends it with the NestedFetch module" do
+        subject.with_nested_fetch([]).should respond_to(:get_in)
+      end
+    end
+
+    context "when supplied argument is not enumerable" do
+      it "returns the supplied argument" do
+        subject.with_nested_fetch(Object.new).should_not respond_to(:get_in)
+      end
+    end
+  end
+
+  describe ".module" do
+    module Test
+      module Foo
+        class Bar; end
+      end
+      class Baz; end
+    end
+
+    context "when the supplied object's class is within a nested namespace" do
+      it "returns the parent module as a constant" do
+        subject.module(Test::Foo::Bar.new).should eq(Test::Foo)
+        subject.module(Test::Baz.new).should eq(Test)
+      end
+    end
+
+    context "when the supplied object class is not noested within a namespace" do
+      it "returns the Kernel constant" do
+        subject.module(Object.new).should eq(Kernel)
+      end
+    end
+  end
+
+  describe Tripleloop::Util::NestedFetch do
+    describe "#get_in" do
+      context "when object is a hash" do
+        subject { Tripleloop::Util.with_nested_fetch({
+          :path => {
+            :to => {
+              :value => :ok
+            }
+          }
+        })}
+
+        it "returns the value corresponding to the supplied path" do
+          subject.get_in(:path, :to, :value).should eq(:ok)
+        end
+
+        it "returns nothing when the corresponding value cannot be found" do
+          subject.get_in(:wrong, :path).should be_nil
+        end
+      end
+
+      context "when object is an array" do
+        subject { Tripleloop::Util.with_nested_fetch([
+          [0,1,2,[
+            [:ok]
+          ]]
+        ])}
+
+        it "returns the value corresponding to the supplied path" do
+          subject.get_in(0,3,0,0).should eq(:ok)
+        end
+
+        it "returns nothing when no corresponding value can be found" do
+          subject.get_in(0,3,1).should be_nil
+        end
+      end
+    end
+  end
+
+  describe Tripleloop::Util::String do
+    subject { Tripleloop::Util::String }
+
+    describe ".classify" do
+      it "turns 'snake case' into 'camel case'" do
+        subject.classify("foo_bar_baz").should eq("FooBarBaz")
+      end
+    end
+  end
+
+  describe Tripleloop::Util::Hash do
+    subject { {"foo" => 1, 
+               "bar" => 2, 
+               "baz" => {"k" => "v"}
+              }.extend(Tripleloop::Util::Hash) }
+
+    describe ".symbolize_keys" do
+      it "returns a copy of the supplied hash replacing symbols with strings" do
+        subject.symbolize_keys.should eq({
+          :foo => 1,
+          :bar => 2,
+          :baz => {:k => "v"}
+        })
+
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: tripleloop
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Andrea Fiore
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: &12159420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *12159420
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &12277940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: *12277940
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: &12276080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :development
+  prerelease: false
+  version_requirements: *12276080
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &12274760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12274760
+- !ruby/object:Gem::Dependency
+  name: babosa
+  requirement: &12221100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12221100
+description: Simple tool for extracting RDF triples from Ruby hashes
+email: andrea.giulio.fiore@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/tripleloop.rb
+- lib/tripleloop/document_processor.rb
+- lib/tripleloop/extractor.rb
+- lib/tripleloop/rdf_writer.rb
+- lib/tripleloop/util.rb
+- spec/spec_helper.rb
+- spec/tripleloop/document_processor_spec.rb
+- spec/tripleloop/extractor_spec.rb
+- spec/tripleloop/rdf_writer_spec.rb
+- spec/tripleloop/util_spec.rb
+homepage: http://github.com/afiore/tripleloop
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: tripleloop
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 2
+summary: Simple tool for extracting RDF triples from Ruby hashes
+test_files: []
+has_rdoc: