triple_parser 0.1.9

data/README.md

@@ -0,0 +1,43 @@
+Triple parser
+=============
+
+Converts text containing RDF triples between simple and complex versions
+
+For example:
+
+    triples = <<EOF
+    id:112121212111111111111   owl:event:time                   id:234242342342334234242432
+    id:234242342342334234242432   rdf:type                         owl:timeline:Interval
+    id:234242342342334234242432   owl:timeline:beginsAtDateTime    xml:date_time:'2010-02-15T12:00:00Z'
+    id:234242342342334234242432   owl:timeline:endsAtDateTime      xml:date_time:'2010-02-17T12:00:00Z'
+    EOF
+
+    TripleParser.to_rdf(triples)
+
+Outputs:
+
+    [
+      "<http://en.wikipedia.org/wiki/Triplestore/things/112121212111111111111#id> <http://purl.org/NET/c4dm/event.owl#time> <http://en.wikipedia.org/wiki/Triplestore/things/234242342342334234242432#id> .",
+      "<http://en.wikipedia.org/wiki/Triplestore/things/234242342342334234242432#id> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://purl.org/NET/c4dm/timeline.owl#Interval> .",
+      "<http://en.wikipedia.org/wiki/Triplestore/things/234242342342334234242432#id> <http://purl.org/NET/c4dm/timeline.owl#beginsAtDateTime> "2010-02-15T12:00:00Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .",
+      "<http://en.wikipedia.org/wiki/Triplestore/things/234242342342334234242432#id> <http://purl.org/NET/c4dm/timeline.owl#endsAtDateTime> "2010-02-17T12:00:00Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> ."
+    ]
+
+Setting site specific application url
+-------------------------------------
+The default application url is 'en.wikipedia.org/wiki/Triplestore' where you can read more about triplestores.
+To change this to your site specific url, use this (in a Rails initializer for example):
+
+    TripleParser::Settings.application_domain = 'undervale.co.uk' 
+
+Playground
+----------
+A simple Sinatra site is included, where you can enter triples and see how they converted by TripleParser.to_rdf
+
+To play:
+
+    ruby web.rb
+
+The page can then be viewed at http://localhost:4567
+
+Enter your triples in the text area and click submit. The output will appear below the text area

data/lib/main.rb

@@ -0,0 +1,16 @@
+require_relative 'triple_parser'
+
+text = <<EOF
+id:9108fe02-0bbb-4ed9-890f-b454877ce12c type_is Event
+id:9108fe02-0bbb-4ed9-890f-b454877ce12c name_is string:'Troops tighten grip on Taliban stronghold'
+id:9108fe02-0bbb-4ed9-890f-b454877ce12c has_time id:0237eb08-e4a5-463c-baaa-5a28f2b63707
+<http://www.undervale.co.uk/things/9108fe02-0bbb-4ed9-890f-b454877ce12c#id> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://purl.org/NET/c4dm/event.owl#Event>.
+EOF
+
+TripleParser.input(text)
+
+triples = TripleParser.triples
+
+triples.each do |t|
+  p t.object.value
+end

data/lib/triple_parser/bracketed_url_splitter.rb

@@ -0,0 +1,183 @@
+module TripleParser
+  
+  require_relative 'splitter'
+  
+  class BracketedUrlSplitter < Splitter
+
+    def self.can_split?(string)
+      bracketed_url_pattern =~ string
+    end
+    
+    def rdf_style
+      'bracketed_url'
+    end
+    
+    private
+    def self.bracketed_url_pattern
+      /\<http\:\/\/[\S]+\>/
+    end
+    
+    def get_parts
+      type_value_from_bracketed_url.merge(
+        :url => get_url
+      )
+    end
+    
+    def get_url
+      url_pattern = /http\:\/\/[\w\-\.]+\.[a-zA-Z]{2,7}(?:\/[\w\-\._]+)*/
+      match(url_pattern)[0]
+    end
+    
+    
+    def type_value_from_bracketed_url
+      if text_after_hash_pattern =~ self
+        type_value_from_text_after_hash_url
+        
+      elsif resource_url_pattern =~ self
+        type_value_for_resource
+        
+      elsif ontology_url_pattern =~ self
+        type_value_for_ontology
+        
+      elsif dc_terms_pattern =~ self
+        type_value_for_dc_terms
+        
+      elsif asset_pattern =~ self
+        type_value_for_asset
+        
+      else
+        type_value_for_unknown_url
+        
+      end
+    end
+    
+    def text_after_hash_pattern
+      /\#([a-zA-Z]+)/
+    end
+    
+    def after_hash 
+      @after_hash ||= match(text_after_hash_pattern)[1] if match(text_after_hash_pattern)
+    end
+    
+    def type_value_from_text_after_hash_url
+      
+      
+      if after_hash == 'id'
+        type_value_for_id_after_hash
+
+      elsif xml_data_pattern =~ self
+        type_value_for_xml_schema
+        
+      elsif rdf_url_pattern =~ self
+        type_value_for_rdf
+        
+      elsif owl_pattern =~ self
+        type_value_for_owl
+        
+      else
+        {}
+      end
+    end
+    
+    def xml_data_pattern
+      /["'](.+)["']\^{2}\<http/
+    end
+    
+    def type_value_for_xml_schema
+      {
+        :type => "xml:#{underscore(after_hash)}",
+        :value => match(xml_data_pattern)[1]
+      }
+    end
+    
+    def owl_pattern
+      /\.owl#/
+    end
+    
+    def type_value_for_owl
+      type = match(text_before_hash_pattern)[1]
+      {
+        :type => "owl:#{type.gsub(/\.owl/, "")}",
+        :value => after_hash
+      }      
+    end
+    
+    def rdf_url_pattern
+      /rdf\-syntax\-ns/
+    end
+    
+    def type_value_for_rdf
+      {
+        :type => 'rdf',
+        :value => after_hash
+      }     
+    end
+    
+    def type_value_for_id_after_hash
+      {
+        :type => 'id',
+        :value => match(text_before_hash_pattern)[1]
+      }
+    end
+    
+    def text_before_hash_pattern
+      /([\w\-\._]*)\#/
+    end
+    
+    def type_value_for_resource
+      {
+        :type => match(resource_url_pattern)[1],
+        :value => match(last_element_of_url_pattern)[1]
+      }
+    end
+    
+    def ontology_url_pattern
+      /data\.press\.net\/ontology\/(?:\w+\/)+(\w+)/
+    end
+    
+    def type_value_for_ontology
+      {
+        :type => 'ontology',
+        :value => match(ontology_url_pattern)[1]
+      }
+    end  
+    
+    def dc_terms_pattern
+      /\/dc\/terms\/([a-zA-Z_]+)/
+    end
+    
+    def type_value_for_dc_terms
+      {
+        :type => 'dc:terms',
+        :value => match(dc_terms_pattern)[1]
+      }
+    end
+    
+    def asset_pattern
+      /\/ontologies\/asset\/([a-zA-Z_]+)/
+    end
+    
+    def type_value_for_asset
+      {
+        :type => 'asset',
+        :value => match(asset_pattern)[1]
+      }      
+    end
+    
+    def type_value_for_unknown_url
+      {
+        :url => get_url
+      }
+    end
+    
+    def last_element_of_url_pattern 
+      /\/([a-zA-Z_]+)\>/
+    end
+    
+    def resource_url_pattern 
+      /(#{resource_identifiers.join('|')})\/[a-zA-Z_]+\>/
+    end
+   
+  end
+  
+end

data/lib/triple_parser/colon_separated_splitter.rb

@@ -0,0 +1,95 @@
+module TripleParser
+  
+  require_relative 'splitter'
+  
+  class ColonSeparatedSplitter < Splitter
+    
+    def self.can_split?(string)
+      colon_separated_rdf_pattern =~ string
+    end
+    
+    def rdf_style
+      'colon_separated'
+    end
+    
+    private
+    def self.colon_separated_rdf_pattern
+      colon_pair = '[a-z\-]+:[\w-]+' # this:example
+      colon_followed_by_quoted_string = %q{:(['"].+['"]|\w+)} # :'this example'
+      function = '\(.+\)' # (this, example)
+      colon_separated_text = "#{colon_pair}(#{colon_followed_by_quoted_string}|#{function})?" # this:example or this:example:'with string' or this:function(example)
+      
+      Regexp.new(colon_separated_text)
+    end
+    
+    def get_parts
+      if function_pattern =~ self
+        get_parts_for_function
+
+      elsif ontologies.include?(self)
+        get_ontology
+        
+      elsif double_colon_first_elements.include?(before_colon)
+        get_double_colon_entry
+        
+      elsif include?(':')
+        get_parts_for_type_value_pair  
+        
+      else
+         raise "Unable to get parts from '#{self}'"
+      end
+    end
+    
+        def function_pattern
+      /^[\w_:]+\(.+\)/
+    end
+
+    def get_parts_for_function
+      opening_bracket = index('(')
+      closing_bracket = index(')')
+      name = self[0, opening_bracket]
+      @arguments = self[opening_bracket + 1..closing_bracket - 1].split(/[\,\s]+/)
+      @arguments = @arguments.collect!{|r| TMaker.brew(r)}
+      {:type => 'function', :value => name}
+    end
+
+    def get_parts_for_type_value_pair
+      {:type => before_colon, :value => after_colon}
+    end
+    
+    def before_colon
+      @before_colon ||= self[0, (index(':'))] if include?(':')
+    end
+      
+    def after_colon
+      @after_colon ||= self[index(':') + 1..length] if include?(':')   
+    end 
+    
+    def remove_bracketing_quotes(text)
+      if /^'.+'$/ =~ text || /^".+"$/ =~ text
+        return text.gsub(/^['"]/, "").gsub(/['"]$/, "")
+      else
+        return text
+      end
+    end
+    
+    def double_colon_first_elements
+      %w{xml owl dc text}
+    end
+    
+    def get_double_colon_entry
+      elements = split(':')
+      text_after_second_colon = elements[2..elements.length].join(':')
+      {
+        :type => "#{elements[0]}:#{elements[1]}",
+        :value => remove_bracketing_quotes(text_after_second_colon)
+      }
+    end
+    
+    def get_ontology
+      {:type => 'ontology', :value => self}
+    end
+
+  end
+  
+end

data/lib/triple_parser/regional_text_splitter.rb

@@ -0,0 +1,41 @@
+module TripleParser
+  
+  class RegionalTextSplitter < Splitter
+    
+    def self.can_split?(string)
+      quoted_text_ampersand_and_language_identifier =~ string
+    end
+    
+    def rdf_style
+      'regional_text'
+    end
+    
+    private
+    def self.quoted_text_ampersand_and_language_identifier
+      /('.*'|".*")\@[\w\-_]+/
+    end
+    
+    def get_parts
+      {
+        :type => "text:#{region}",
+        :value => text
+      }
+    end
+    
+    def region
+      after_ampersand
+    end
+    
+    def text
+      before_ampersand.gsub(/['"]/, "")
+    end
+    
+    def after_ampersand
+      split(/@/).last
+    end
+    
+    def before_ampersand
+      split(/@/).first
+    end
+  end
+end

data/lib/triple_parser/settings.rb

@@ -0,0 +1,12 @@
+
+module TripleParser
+  module Settings
+    def self.application_domain
+      @@application_url ||= 'en.wikipedia.org/wiki/Triplestore'
+    end
+    
+    def self.application_domain=(url)
+      @@application_url = url
+    end
+  end
+end

data/lib/triple_parser/splitter.rb

@@ -0,0 +1,52 @@
+
+module TripleParser
+  class Splitter < String
+    
+    attr_accessor :parts, :arguments, :rdf_style, :url
+    
+    def self.can_split?(string)
+      raise "Need to define test to determine if string can be converted using this class"
+    end
+    
+    def parts
+      @parts ||= get_parts
+    end
+
+    def type
+      parts[:type]
+    end
+
+    def value
+      parts[:value]
+    end
+
+    def url
+      parts[:url]
+    end
+    
+    def rdf_style
+      raise "Need to define string that identifies rdf stype"
+    end
+    
+    private
+    def get_parts
+      raise "Need to define how to split text input into seperate parts"
+    end
+    
+    def underscore(text)
+      while letter_before_capital = text.index(/[a-z][A-Z]/)
+        text.insert(letter_before_capital + 1, '_')
+      end
+      text.downcase
+    end
+    
+    def resource_identifiers
+      %w{resource domain}
+    end
+    
+    def ontologies
+      %w{about mentions}
+    end    
+    
+  end
+end

data/lib/triple_parser/t_maker.rb

@@ -0,0 +1,63 @@
+module TripleParser
+  class TMaker
+    require_relative 'third'
+    require_relative 'bracketed_url_splitter'
+    require_relative 'colon_separated_splitter'
+    require_relative 'variable_splitter'
+    require_relative 'unspecified_splitter'
+    require_relative 'regional_text_splitter'
+    
+    attr_accessor :arguments, :rdf_style, :url
+    
+    def self.brew(*args)
+      t_maker = new(*args)
+      t_maker.third
+    end
+
+    def initialize(*args)
+      @string = args.first
+    end
+    
+    def third
+      begin
+        Third.new(
+          @string,
+          :type => split_text.type,
+          :value => split_text.value,
+          :url => split_text.url,
+          :rdf_style => split_text.rdf_style,
+          :arguments => split_text.arguments
+        )
+      rescue
+        Third.new(@string, :rdf_style => 'unknown')
+      end
+    end
+
+    def split_text
+      @split_text ||= get_split_text
+    end
+
+    private
+    def get_split_text
+      splitters.each do |splitter|
+        if splitter.can_split?(@string)
+          split_text = splitter.new(@string)
+          return split_text
+        end
+      end
+      raise "Unable to get parts for third from: '#{@string}'"
+    end
+  
+    def splitters
+      [
+        BracketedUrlSplitter, 
+        ColonSeparatedSplitter, 
+        VariableSplitter, 
+        RegionalTextSplitter, 
+        UnspecifiedSplitter
+      ]
+    end
+  
+
+  end
+end

data/lib/triple_parser/third.rb

@@ -0,0 +1,17 @@
+module TripleParser
+  
+  class Third < String
+    
+    attr_accessor :type, :value, :arguments, :rdf_style, :url
+    
+    def initialize(string, args = {})
+      @type = args[:type]
+      @value = args[:value]
+      @arguments = args[:arguments]
+      @rdf_style = args[:rdf_style]
+      @url = args[:url]
+      super(string)
+    end
+    
+  end
+end

data/lib/triple_parser/to_rdf.rb

@@ -0,0 +1,133 @@
+
+module TripleParser
+  class ToRdf
+    
+    def initialize(third)
+      @third = third
+    end
+    
+    def to_s
+      get_output.to_s
+    end
+    
+    protected
+    def get_output
+      if third_type
+        pass_to_type_method
+      else
+        unknown
+      end
+    end
+    
+    def third_type
+      @third_type ||= @third.type if @third.type
+    end    
+    
+    def pass_to_type_method
+      if type_if_known_colon_pair?
+        send(colon_prefix)
+        
+      elsif method_exists_for?(third_type)
+        send(third_type)
+        
+      else
+        unknown_type
+      end
+    end
+    
+    def type_if_known_colon_pair?
+      if colon_pair_pattern =~ third_type
+        method_exists_for?(colon_prefix)
+      end
+    end
+    
+    def method_exists_for?(name)
+      self.class.instance_methods.include?(name.to_sym)
+    end
+    
+    # prefix:suffix
+    def colon_pair_pattern
+      /([a-zA-Z\-\_]+)\:([a-zA-Z\-\_]+)/
+    end
+    
+     def colon_match
+      @colon_match ||= colon_pair_pattern.match(third_type)
+    end    
+    
+    def colon_prefix
+      @colon_prefix ||= colon_match[1]
+    end
+    
+    def colon_suffix
+      @colon_suffix ||= colon_match[2]
+    end 
+
+    def owl
+      "<http://purl.org/NET/c4dm/#{colon_suffix}.owl##{@third.value}>"
+    end
+
+    
+    def xml
+      %Q{"#{@third.value}"^^<http://www.w3.org/2001/XMLSchema##{camelcase(colon_suffix)}>}
+    end
+    
+    def dc
+      "<http://purl.org/dc/#{colon_suffix}/#{@third.value}>"
+    end
+    
+    def text
+      %Q{"#{@third.value}"@#{colon_suffix}}
+    end
+    
+    def unknown
+      @third
+    end
+    
+    def unknown_type
+      "#{third_type}:#{@third.value}"
+    end
+    
+    def id
+      "<http://#{Settings.application_domain}/things/#{@third.value}#id>"
+    end
+    
+    def domain
+      "<http://#{Settings.application_domain}/ontologies/domain/name>"
+    end
+    
+    def resource
+      "<http://dbpedia.org/resource/#{@third.value}>"
+    end
+    
+    def ontology
+      "<http://data.press.net/ontology/tag/#{@third.value}>"
+    end
+    
+    def asset
+      "<http://#{Settings.application_domain}/ontologies/asset/#{@third.value}>"
+    end
+    
+    def function
+      arguments = @third.arguments.collect{|a| self.class.new(a)}
+      "#{@third.value}(#{arguments.join(' ')})"
+    end
+    
+    def var
+      "?#{@third.value}"
+    end
+    
+    def rdf
+      "<http://www.w3.org/1999/02/22-rdf-syntax-ns##{@third.value}>"
+    end
+    
+    def camelcase(text)
+      while underscore_pos = text.index(/_[a-z]/)
+        letter_after_pos = underscore_pos + 1
+        letter_after = text[letter_after_pos, 1]
+        text[underscore_pos..letter_after_pos] = letter_after.upcase
+      end
+      return text
+    end
+    
+  end
+end

data/lib/triple_parser/triple_set.rb

@@ -0,0 +1,123 @@
+module TripleParser
+  class TripleSet
+    require_relative 't_maker'
+
+    def initialize(triple)
+      @triple = triple
+    end
+
+    def parts
+      @parts ||= get_parts
+    end
+
+    def subject
+      @subject ||= parts[0]    
+    end
+
+    def predicate
+      @predicate ||= parts[1]
+    end
+
+    def object
+      @object ||= (!parts[2] || parts[2].empty?) ? nil : parts[2]
+    end
+
+    private
+    def get_parts
+      match = pattern_to_split_triple.match(@triple)
+      matches = [1, 2, 3].collect{|i| match[i] if i != @skip_triple_part}.compact
+      matches.collect{|m| TMaker.brew(m)}
+    end
+
+    def pattern_to_split_triple
+      if triple_is_function?
+        @skip_triple_part = 3
+        pattern_to_split_function
+      else
+        triple_spitting_pattern
+      end
+    end
+
+    def triple_is_function?
+      function_pattern =~ @triple
+    end
+    
+    def function_pattern
+
+      Regexp.new([
+        start_with_possible_white_space_pattern,
+        start_variable_or_bracketed_url_pattern,
+        receiving_variable_or_bracketed_url_pattern,
+        function_name_pattern,
+        function_arguments_pattern,
+        closing_white_space_or_period_pattern,
+      ].join)
+  
+    end
+
+    def pattern_to_split_function
+      
+      receiving_element_pattern = '[\w?:\/_\-#<>\.]+'
+
+      Regexp.new(
+        [
+          '(', 
+            receiving_element_pattern,
+          ')', 
+          spaces, 
+          '(', 
+            function_name_pattern, 
+            function_arguments_pattern, 
+          ')'
+        ].join
+      )
+      
+    end
+    
+    def triple_spitting_pattern
+      triple_containing_single_quoted_text = %q{\S*\'.*\'\S*}
+      triple_containing_double_quoted_text = %q{\S*\".*\"\S*}
+      text_not_split_by_spaces = '\S*'
+      triple = [triple_containing_single_quoted_text, triple_containing_double_quoted_text, text_not_split_by_spaces].join('|')
+      spaced_triples = Array.new(3, "(#{triple})").join('\s+')
+      Regexp.new(spaced_triples)
+    end
+    
+    def spaces
+      '\s+'
+    end
+    
+    def start_with_possible_white_space_pattern
+      '^\s*'
+    end
+    
+    def start_variable_or_bracketed_url_pattern
+      '(\?|<http:\/\/)'
+    end
+    
+    def receiving_variable_or_bracketed_url_pattern
+      '[\w\/\-_#\.]+>?\s+'
+    end
+    
+    def basic_text_pattern
+      '\??[\w_\-:]+'
+    end
+    
+    def function_name_pattern
+      '[\w_\-:]+'
+    end
+    
+    def function_arguments_pattern
+      %q{\(([\w_\?:"']+[\s\,]*)+\)}
+    end
+    
+    def closing_white_space_or_period_pattern
+      '[\s\.]*$'
+    end
+    
+    def standard_rdf_element_or_text_pattern
+      '(?:<.*>|[\w\?\-:]+)'
+    end
+      
+  end
+end

data/lib/triple_parser/unspecified_splitter.rb

@@ -0,0 +1,27 @@
+module TripleParser
+  
+  require_relative 'splitter'
+  
+  class UnspecifiedSplitter < Splitter
+
+    def self.can_split?(string)
+      any_word_possibly_hyphenated =~ string
+    end
+    
+    def rdf_style
+      'unspecified'
+    end
+    
+    private
+    def self.any_word_possibly_hyphenated
+      /^\s*[\w\-]*\s*$/
+    end
+    
+    def get_parts
+      {}
+    end
+    
+    
+  end
+  
+end

data/lib/triple_parser/variable_splitter.rb

@@ -0,0 +1,30 @@
+module TripleParser
+  
+  class VariableSplitter < Splitter
+    
+    def self.can_split?(string)
+      any_word_starting_with_question_mark =~ string
+    end
+    
+    def rdf_style
+      'variable'
+    end
+    
+    private
+    def self.any_word_starting_with_question_mark
+      /^\s*\?[A-Za-z][\w\-]*\s*$/
+    end
+    
+    def get_parts
+      {
+        :type => 'var',
+        :value => variable_name
+      }
+    end
+    
+    def variable_name
+      self[1..length]
+    end
+    
+  end
+end

data/lib/triple_parser.rb

@@ -0,0 +1,46 @@
+require_relative 'triple_parser/t_maker'
+require_relative 'triple_parser/triple_set'
+require_relative 'triple_parser/to_rdf'
+require_relative 'triple_parser/settings'
+
+
+module TripleParser
+  def self.input(new_input)
+    @input = new_input
+  end
+  
+  def self.triples
+    @triples = Array.new
+    case @input.class.to_s
+      when 'String'
+        @input.each_line do |triple| 
+          next if /^\s*$/ =~ triple
+          @triples << TripleSet.new(triple)
+        end
+      when 'Array'
+        @input.compact.each do |triple|
+          @triples << TripleSet.new(triple)
+        end
+    else
+      raise "Input format not recognised"
+    end
+    
+    return @triples
+  end
+  
+  def self.to_rdf(input)
+    @input = input
+    output = triples.collect do |t|
+      [
+        get_rdf_for(t.subject),
+        get_rdf_for(t.predicate),
+        get_rdf_for(t.object)
+      ].join(' ') + " ."
+    end 
+    return output
+  end
+  
+  def self.get_rdf_for(third)
+    ToRdf.new(third).to_s if third
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: triple_parser
+version: !ruby/object:Gem::Version
+  version: 0.1.9
+  prerelease: 
+platform: ruby
+authors:
+- Rob Nichols
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-07 00:00:00.000000000Z
+dependencies: []
+description: Triple Parser - Parses RDF triples and converts them into standard format
+email: rob@undervale.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/main.rb
+- lib/triple_parser.rb
+- lib/triple_parser/triple_set.rb
+- lib/triple_parser/variable_splitter.rb
+- lib/triple_parser/third.rb
+- lib/triple_parser/t_maker.rb
+- lib/triple_parser/colon_separated_splitter.rb
+- lib/triple_parser/splitter.rb
+- lib/triple_parser/regional_text_splitter.rb
+- lib/triple_parser/to_rdf.rb
+- lib/triple_parser/unspecified_splitter.rb
+- lib/triple_parser/bracketed_url_splitter.rb
+- lib/triple_parser/settings.rb
+homepage: https://github.com/reggieb/triple_parser
+licenses: []
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Triple Parser - Parses RDF triples and converts them into standard format
+test_files: []