bel 0.2.1 → 0.3.0.beta1

data/ext/mri/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+# if set in environment, set compiler for make
+# example:
+#   CC=gcc-4.8 gem install bel.rb
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+create_makefile('libbel')

data/ext/mri/libbel.c

@@ -0,0 +1,5 @@
+void Init_libbel() {
+    // initialization for bel_ext extension
+    // empty; loaded using ffi
+}
+

data/ext/mri/libbel.def

@@ -0,0 +1,26 @@
+EXPORTS
+Init_libbel
+bel_ast_as_string
+bel_copy_ast_node
+bel_free_ast
+bel_free_ast_node
+bel_new_ast
+bel_new_ast_node_token
+bel_new_ast_node_value
+bel_new_token
+bel_new_token_iterator
+bel_new_token_list
+bel_parse_statement
+bel_parse_term
+bel_print_ast
+bel_print_ast_node
+bel_print_token
+bel_print_token_list
+bel_set_value
+bel_token_iterator_end
+bel_token_iterator_get
+bel_token_iterator_next
+bel_tokenize_term
+free_bel_token
+free_bel_token_iterator
+free_bel_token_list

data/lib/bel.rb

@@ -1,7 +1,17 @@
+# Load core objects
+require_relative 'libbel'
+require_relative 'bel/completion'
+require_relative 'bel/language'
+require_relative 'bel/namespace'
+include BEL::Language
+include BEL::Namespace
+
 module BEL
-  autoload :Language,  "#{File.dirname(__FILE__)}/bel/language"
-  autoload :Namespace, "#{File.dirname(__FILE__)}/bel/namespace"
   autoload :Script,    "#{File.dirname(__FILE__)}/bel/script"
+  autoload :RDF,       "#{File.dirname(__FILE__)}/bel/rdf"
+
+  require_relative './features.rb'
+  require_relative './util.rb'
 end
 # vim: ts=2 sw=2:
 # encoding: utf-8

data/lib/bel/completion.rb

@@ -0,0 +1,53 @@
+require_relative '../libbel'
+require_relative 'completion_rule'
+require_relative 'language'
+require_relative 'namespace'
+
+module BEL
+  module Completion
+
+    # Provides completions on BEL expressions.
+    #
+    # If +bel_expression+ is +nil+ then its assumed to be the empty string
+    # otherwise the +to_s+ method is called. An empty +bel_expression+ will
+    # return all BEL functions as possible completions.
+    #
+    # If +search+ is +nil+ then namespace values will not be provided as
+    # completion. +search+ is expected to implement {IdentifierSearch}.
+    #
+    # If +position+ is +nil+ then its assumed to be the last index of
+    # +bel_expression+ otherwise the +to_i+ method is called.
+    #
+    # If +position+ is negative or greater than the length of +bel_expression+
+    # an +IndexError+ is raised.
+    #
+    # @param bel_expression   [responds to #to_s] the bel expression to
+    # complete on
+    # @param search           [IdentifierSearch] the search object used to
+    # provide namespace value completions
+    # @param position         [responds to #to_i] the position to complete from
+    # @return [Array<Completion>]
+    def self.complete(bel_expression, search = nil, position = nil)
+      bel_expression = (bel_expression || '').to_s
+      position = (position || bel_expression.length).to_i
+      if position < 0 or position > bel_expression.length
+        msg = %Q{position #{position}, bel_expression "#{bel_expression}"}
+        fail IndexError, msg
+      end
+
+      token_list = LibBEL::tokenize_term(bel_expression)
+      active_token, active_index = token_list.token_at(position)
+
+      # no active token indicates the position is out of
+      # range of all tokens in the list.
+      return [] unless active_token
+
+      tokens = token_list.to_a
+      options = {
+        :search => search
+      }
+      BEL::Completion::run_rules(tokens, active_index, active_token, options)
+    end
+  end
+end
+

data/lib/bel/completion_rule.rb

@@ -0,0 +1,236 @@
+require_relative 'language'
+require_relative 'namespace'
+require_relative 'quoting'
+require 'uri'
+
+module BEL
+  module Completion
+
+    SORTED_FUNCTIONS  = BEL::Language::FUNCTIONS.keys.sort.map(&:to_s)
+    SORTED_NAMESPACES = BEL::Namespace::NAMESPACE_LATEST.keys.sort.map(&:to_s)
+    EMPTY_MATCH       = []
+
+    def self.run_rules(tokens, active_index, active_token, options = {})
+      self.rules.reduce([]) { |completion_results, rule|
+        completion_results.concat(
+          rule.apply(tokens, active_token, active_index, options)
+        )
+      }
+    end
+
+    def self.rules
+      [
+        MatchFunctionRule.new,
+        MatchNamespacePrefixRule.new,
+        MatchNamespaceValueRule.new
+      ]
+    end
+
+    module Rule
+
+      def apply(token_list, active_token, active_token_index, options = {})
+        matches = _apply(token_list, active_token, active_token_index, options)
+
+        matches.map { |match|
+          match = map_highlight(match, active_token)
+          match = map_actions(match, active_token)
+          match.delete(:offset)
+          match
+        }
+      end
+
+      protected
+
+      def _apply(token_list, active_token, active_token_index, options = {})
+        raise NotImplementedError
+      end
+
+      def map_highlight(match, active_token)
+        if active_token and not [:O_PAREN, :COMMA].include?(active_token.type)
+          value_start = match[:value].downcase.index(active_token.value.downcase)
+          if value_start
+            value_end = value_start + active_token.value.length
+            highlight = {
+              :start_position => value_start,
+              :end_position   => value_end,
+              :range_type     => :inclusive
+            }
+          else
+            highlight = nil
+          end
+        else
+          highlight = nil
+        end
+        match.merge!({:highlight => highlight})
+      end
+
+      def map_actions(match, active_token)
+        position_start = active_token ? active_token.pos_start : 0
+        actions = []
+
+        if active_token and not [:O_PAREN, :COLON].include?(active_token.type)
+          # delete from start of active token to end of a
+          actions.push({
+            :delete => {
+              :start_position => position_start,
+              :end_position   => active_token.pos_end - 1,
+              :range_type     => :inclusive
+            }
+          })
+        end
+
+        # add the active_token length if we do not need to delete it
+        if active_token and actions.empty?
+          position_start += active_token.value.length
+        end
+
+        actions.concat([
+          {
+            :insert => {
+              :position => position_start,
+              :value    => match[:value]
+            }
+          },
+          {
+            :move_cursor => {
+              :position => position_start + match[:value].length + match[:offset]
+            }
+          }
+        ])
+        match.merge!({:actions => actions})
+      end
+    end
+
+    class MatchFunctionRule
+      include Rule
+
+      def _apply(token_list, active_token, active_token_index, options = {})
+        if token_list.empty? or active_token.type == :O_PAREN
+          return SORTED_FUNCTIONS.map { |fx| map_function(fx) }.uniq.sort_by { |fx|
+            fx[:label]
+          }
+        end
+
+        if active_token.type == :IDENT
+          value = active_token.value.downcase
+          return SORTED_FUNCTIONS.find_all { |x|
+            x.downcase.include? value
+          }.map { |fx| map_function(fx) }.uniq.sort_by { |fx| fx[:label] }
+        end
+
+        return EMPTY_MATCH
+      end
+
+      protected
+
+      def map_function(fx_name)
+        fx = Function.new(FUNCTIONS[fx_name.to_sym])
+        if fx
+          {
+            :id     => fx.short_form,
+            :type   => :function,
+            :label  => fx.long_form,
+            :value  => "#{fx.short_form}()",
+            :offset => -1
+          }
+        else
+          nil
+        end
+      end
+    end
+
+    class MatchNamespacePrefixRule
+      include Rule
+
+      def _apply(token_list, active_token, active_token_index, options = {})
+        if token_list.empty? or active_token.type == :O_PAREN
+          return SORTED_NAMESPACES.map { |ns_prefix|
+            map_namespace_prefix(ns_prefix)
+          }
+        end
+
+        # first token is always function
+        return [] if active_token == token_list[0]
+
+        if active_token.type == :IDENT
+          value = active_token.value.downcase
+          return SORTED_NAMESPACES.find_all { |x|
+            x.downcase.include? value
+          }.map { |ns_prefix|
+            map_namespace_prefix(ns_prefix)
+          }
+        end
+
+        return EMPTY_MATCH
+      end
+
+      private
+
+      def map_namespace_prefix(ns_prefix)
+        {
+          :id     => ns_prefix,
+          :type   => :namespace_prefix,
+          :label  => ns_prefix,
+          :value  => "#{ns_prefix}:",
+          :offset => 0
+        }
+      end
+    end
+
+    class MatchNamespaceValueRule
+      include Rule
+      include BEL::Quoting
+
+      def _apply(token_list, active_token, active_token_index, options = {})
+        search = options.delete(:search)
+        return EMPTY_MATCH if not search or token_list.empty?
+
+        if active_token.type == :IDENT && active_token.value.length > 1
+          previous_token = token_list[active_token_index - 1]
+          if previous_token and previous_token.type == :COLON
+            # search within a namespace
+            prefix_token = token_list[active_token_index - 2]
+            if prefix_token and prefix_token.type == :IDENT
+              namespace = BEL::Namespace::NAMESPACE_LATEST[prefix_token.value.to_sym]
+              if namespace
+                scheme_uri = namespace[1]
+                return search.search_namespace(
+                  URI(scheme_uri),
+                  "#{active_token.value}*",
+                  :start => 0,
+                  :size  => 10
+                ).
+                  map { |search_result|
+                    map_namespace_value(search_result.pref_label)
+                  }.to_a
+              end
+            end
+          else
+            return search.search(
+              active_token.value,
+              :start => 0,
+              :size  => 10
+            ).
+              map { |search_result|
+                map_namespace_value(search_result.pref_label)
+              }.to_a
+          end
+        end
+
+        return EMPTY_MATCH
+      end
+
+      protected
+
+      def map_namespace_value(ns_value)
+        {
+          :id     => ns_value,
+          :type   => :namespace_value,
+          :label  => ns_value,
+          :value  => ensure_quotes(ns_value),
+          :offset => 0
+        }
+      end
+    end
+  end
+end

data/lib/bel/language.rb

@@ -1,5 +1,305 @@
+require_relative '../features'
+require_relative 'quoting'
 module BEL
   module Language
+
+    class Newline
+      def to_bel
+        ""
+      end
+      alias_method :to_s, :to_bel
+    end
+    NEW_LINE = Newline.new
+
+    Comment = Struct.new(:text) do
+      def to_bel
+        %Q{##{self.text}}
+      end
+      alias_method :to_s, :to_bel
+    end
+
+    DocumentProperty = Struct.new(:name, :value) do
+      include BEL::Quoting
+
+      def to_bel
+        %Q{SET DOCUMENT #{self.name} = #{ensure_quotes(self.value)}}
+      end
+      alias_method :to_s, :to_bel
+    end
+
+    AnnotationDefinition = Struct.new(:type, :prefix, :value) do
+      def to_bel
+        case self.type
+        when :list
+          %Q{DEFINE ANNOTATION #{self.prefix} AS LIST {#{self.value.join(',')}}}
+        when :pattern
+          %Q{DEFINE ANNOTATION #{self.prefix} AS PATTERN "#{self.value}"}
+        when :url
+          %Q{DEFINE ANNOTATION #{self.prefix} AS URL "#{self.value}"}
+        end
+      end
+      alias_method :to_s, :to_bel
+    end
+
+    class Parameter
+      include BEL::Quoting
+      include Comparable
+      attr_accessor :ns, :value, :enc, :signature
+
+      def initialize(ns, value, enc=nil)
+        @ns = ns
+        @value = value
+        @enc = enc || ''
+        @signature = E.new(@enc)
+      end
+
+      def <=>(other)
+        ns_compare = @ns <=> other.ns
+        if ns_compare == 0
+          @value <=> other.value
+        else
+          ns_compare
+        end
+      end
+
+      def valid?
+        return false unless value
+        return true unless @ns
+        @ns.respond_to?(:values) && ns.values.include?(value)
+      end
+
+      def hash
+        [@ns, @value].hash
+      end
+
+      def ==(other)
+        return false if other == nil
+        @ns == other.ns && @value == other.value
+      end
+
+      alias_method :eql?, :'=='
+
+      def to_bel
+        %Q{#{@ns ? @ns.prefix.to_s + ':' : ''}#{ensure_quotes(@value)}}
+      end
+
+      alias_method :to_s, :to_bel
+    end
+
+    class Function
+      attr_reader :short_form, :long_form, :return_type,
+                  :description, :signatures
+
+      def initialize args
+        args.each do |k,v|
+          instance_variable_set("@#{k}", v) unless v.nil?
+        end
+      end
+
+      def [](key)
+        instance_variable_get("@#{key}")
+      end
+
+      def hash
+        [@short_form, @long_form, @return_type, @description, @signatures].hash
+      end
+
+      def ==(other)
+        return false if other == nil
+        @short_form == other.short_form &&
+        @long_form == other.long_form &&
+        @return_type == other.return_type &&
+        @description == other.description &&
+        @signatures == other.signatures
+      end
+
+      alias_method :eql?, :'=='
+
+      def to_sym
+        @short_form
+      end
+
+      def to_s
+        @long_form.to_s
+      end
+    end
+
+    class Term
+      include Comparable
+      attr_accessor :fx, :arguments, :signature
+
+      def initialize(fx, *arguments)
+        @fx = case fx
+        when String
+        when Symbol
+          Function.new(FUNCTIONS[fx.to_sym])
+        when Function
+          fx
+        when nil
+          raise ArgumentError, 'fx must not be nil'
+        end
+        @arguments = (arguments ||= []).flatten
+        @signature = Signature.new(
+          @fx[:short_form],
+          *@arguments.map { |arg|
+            case arg
+            when Term
+              F.new(arg.fx.return_type)
+            when Parameter
+              E.new(arg.enc)
+            when nil
+              NullE.new
+            end
+          })
+      end
+
+      def <<(item)
+        @arguments << item
+      end
+
+      def valid?
+        invalid_signatures = @arguments.find_all { |arg|
+          arg.is_a? Term
+        }.find_all { |term|
+          not term.valid?
+        }
+        return false if not invalid_signatures.empty?
+
+        sigs = @fx.signatures
+        sigs.any? do |sig| (@signature <=> sig) >= 0 end
+      end
+
+      def valid_signatures
+        @fx.signatures.find_all { |sig| (@signature <=> sig) >= 0 }
+      end
+
+      def invalid_signatures
+        @fx.signatures.find_all { |sig| (@signature <=> sig) < 0 }
+      end
+
+      def hash
+        [@fx, @arguments].hash
+      end
+
+      def ==(other)
+        return false if other == nil
+        @fx == other.fx && @arguments == other.arguments
+      end
+
+      alias_method :eql?, :'=='
+
+      def to_bel
+        "#{@fx[:short_form]}(#{[@arguments].flatten.map(&:to_bel).join(',')})"
+      end
+
+      alias_method :to_s, :to_bel
+    end
+
+    Annotation = Struct.new(:name, :value) do
+      include BEL::Quoting
+
+      def to_bel
+        if self.value.respond_to? :each
+          value = self.value.map {|v| always_quote(v)}
+          value = "{#{value.join(',')}}"
+        else
+          value = ensure_quotes(self.value)
+        end
+        "SET #{self.name} = #{value}"
+      end
+
+      alias_method :to_s, :to_bel
+    end
+
+    UnsetAnnotation = Struct.new(:name) do
+      def to_bel
+        %Q{UNSET #{self.name}}
+      end
+
+      alias_method :to_s, :to_bel
+    end
+
+    class Statement
+      attr_accessor :subject, :relationship, :object, :annotations, :comment
+
+      def initialize(subject=nil, relationship=nil, object=nil, annotations=[], comment=nil)
+        @subject = subject
+        @relationship = relationship
+        @object = object
+        @annotations = annotations
+        @comment = comment
+      end
+
+      def subject_only?
+        !@relationship
+      end
+
+      def simple?
+        @object and @object.is_a? Term
+      end
+
+      def nested?
+        @object and @object.is_a? Statement
+      end
+
+      def hash
+        [@subject, @relationship, @object, @annotations, @comment].hash
+      end
+
+      def ==(other)
+        return false if other == nil
+        @subject == other.subject &&
+        @relationship == other.relationship &&
+        @object == other.object &&
+        @annotations == other.annotations &&
+        @comment == comment
+      end
+
+      alias_method :eql?, :'=='
+
+      def to_bel
+        lbl = case
+        when subject_only?
+          @subject.to_s
+        when simple?
+          "#{@subject.to_s} #{@relationship} #{@object.to_s}"
+        when nested?
+          "#{@subject.to_s} #{@relationship} (#{@object.to_s})"
+        else
+          ''
+        end
+        comment ? lbl + ' //' + comment : lbl
+      end
+
+      alias_method :to_s, :to_bel
+    end
+
+    StatementGroup = Struct.new(:name, :statements, :annotations) do
+      include BEL::Quoting
+
+      def <=>(other_group)
+        if not other_group || other_group.is_a?
+          1
+        else
+          (statements || []) <=> (other_group.statements || [])
+        end
+      end
+
+      def to_bel
+        %Q{SET STATEMENT_GROUP = #{ensure_quotes(self.name)}}
+      end
+
+      alias_method :to_s, :to_bel
+    end
+
+    UnsetStatementGroup = Struct.new(:name) do
+      def to_bel
+        %Q{UNSET STATEMENT_GROUP}
+      end
+
+      alias_method :to_s, :to_bel
+    end
+
     class Signature
       attr_reader :fx, :arguments
       def initialize(fx, *arguments)
@@ -18,8 +318,8 @@ module BEL
       end
 
       def ==(other)
-        return false if @fx != other.fx
-        @arguments == other.arguments
+        return false if other == nil
+        @fx == other.fx && @arguments == other.arguments
       end
 
       def <=>(other)
@@ -44,8 +344,8 @@ module BEL
       end
 
       def ==(other)
+        return false if other == nil
         return false if not other.respond_to? :func_return
-
         @func_return == other.func_return and @var == other.var
       end
 
@@ -110,100 +410,6 @@ module BEL
       end
     end
 
-    class Parameter
-      include Comparable
-      attr_reader :ns_def, :value, :enc, :signature
-
-      def initialize(ns_def, value, enc)
-        @ns_def = ns_def
-        @value = value
-        @enc = enc || ''
-        @signature = E.new(@enc)
-      end
-
-      def <=>(other)
-        ns_compare = ns_def <=> other.ns_def
-        if ns_compare == 0
-          value <=> other.value
-        else
-          ns_compare
-        end
-      end
-
-      def to_s
-        value = @value
-        if value =~ %r{\W}
-          value = %Q{"#{value}"}
-        end
-        "#{@ns_def}:#{value}"
-      end
-    end
-
-    class Statement
-      attr_accessor :subject, :relationship, :object
-
-      def initialize(subject, relationship=nil, object=nil)
-        raise ArgumentError, 'subject must not be nil' unless subject
-        @subject = subject
-        @relationship = relationship
-        @object = object
-      end
-    end
-
-    class Function
-      attr_reader :short_form, :long_form, :return_type,
-                  :description, :signatures
-
-      def initialize args
-        args.each do |k,v|
-          instance_variable_set("@#{k}", v) unless v.nil?
-        end
-      end
-    end
-
-    class Term
-      include Comparable
-      attr_reader :fx, :arguments, :signature
-
-      def initialize(fx, *arguments)
-        @fx = fx
-        @arguments = arguments ||= []
-        @signature = Signature.new(
-          @fx.short_form,
-          *@arguments.map { |arg|
-            case arg
-            when Term
-              F.new(arg.fx.return_type)
-            when Parameter
-              E.new(arg.enc)
-            when nil
-              NullE.new
-            end
-          })
-      end
-
-      def validate_signature
-        invalids = []
-        @arguments.select { |arg| Term === arg }.each do |term|
-          invalids << term if not term.validate_signature
-        end
-
-        sigs = fx.signatures
-        match = sigs.any? do |sig| (@signature <=> sig) >= 0 end
-        invalids << self if not match
-        if block_given? and not invalids.empty?
-          invalids.each do |term|
-            yield term, term.fx.signatures
-          end
-        end
-        invalids.empty?
-      end
-
-      def to_s
-        "#{@fx.short_form}(#{@arguments.map(&:to_s).join(',')})"
-      end
-    end
-
     FUNCTIONS = {
       a: {
         short_form: :a,
@@ -271,6 +477,15 @@ module BEL
           Signature.new(:complex, F.new(:a, true))
         ]
       },
+      composite: {
+        short_form: :composite,
+        long_form: :compositeAbundance,
+        description: 'Denotes the frequency or abundance of events in which members are present',
+        return_type: :a,
+        signatures: [
+          Signature.new(:composite, F.new(:a, true))
+        ]
+      },
       deg: {
         short_form: :deg,
         long_form: :degradation,
@@ -570,6 +785,267 @@ module BEL
         Term.new(func, *args)
       end
     end
+
+    if BEL::Features.rdf_support?
+      require_relative 'rdf'
+
+      class Parameter
+        def to_uri
+          @ns.to_rdf_vocabulary[@value]
+        end
+
+        def to_rdf
+          uri = to_uri
+          char_enum = @enc.to_s.each_char
+          if block_given?
+            char_enum.map {|c| concept_statement(c, uri) }.each do |stmt|
+              yield stmt
+            end
+          else
+            char_enum.map { |c| concept_statement(c, uri)}
+          end
+        end
+
+        private
+        def concept_statement(encoding_character, uri)
+            case encoding_character
+            when 'G'
+              RUBYRDF::Statement(uri, RUBYRDF.type, BEL::RDF::BELV.GeneConcept)
+            when 'R'
+              RUBYRDF::Statement(uri, RUBYRDF.type, BEL::RDF::BELV.RNAConcept)
+            when 'P'
+              RUBYRDF::Statement(uri, RUBYRDF.type, BEL::RDF::BELV.ProteinConcept)
+            when 'M'
+              RUBYRDF::Statement(uri, RUBYRDF.type, BEL::RDF::BELV.MicroRNAConcept)
+            when 'C'
+              RUBYRDF::Statement(uri, RUBYRDF.type, BEL::RDF::BELV.ComplexConcept)
+            when 'B'
+              RUBYRDF::Statement(uri, RUBYRDF.type, BEL::RDF::BELV.BiologicalProcessConcept)
+            when 'A'
+              RUBYRDF::Statement(uri, RUBYRDF.type, BEL::RDF::BELV.AbundanceConcept)
+            when 'O'
+              RUBYRDF::Statement(uri, RUBYRDF.type, BEL::RDF::BELV.PathologyConcept)
+            end
+        end
+      end
+
+      class Term
+        def to_uri
+          tid = to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
+          BEL::RDF::BELR[tid]
+        end
+
+        def rdf_type
+          if respond_to? 'fx'
+            if @fx.short_form == :p and @arguments.find{|x| x.is_a? Term and x.fx.short_form == :pmod}
+              return BEL::RDF::BELV.ModifiedProteinAbundance
+            end
+            if @fx.short_form == :p and @arguments.find{|x| x.is_a? Term and BEL::RDF::PROTEIN_VARIANT.include? x.fx}
+              return BEL::RDF::BELV.ProteinVariantAbundance
+            end
+
+            BEL::RDF::FUNCTION_TYPE[@fx.short_form] || BEL::RDF::BELV.Abundance
+          end
+        end
+
+        def to_rdf
+          uri = to_uri
+          statements = []
+
+          # rdf:type
+          type = rdf_type
+          statements << [uri, BEL::RDF::RDF.type, BEL::RDF::BELV.Term]
+          statements << [uri, BEL::RDF::RDF.type, type]
+          if BEL::RDF::ACTIVITY_TYPE.include? @fx.short_form
+            statements << [uri, BEL::RDF::BELV.hasActivityType, BEL::RDF::ACTIVITY_TYPE[@fx.short_form]]
+          end
+
+          # rdfs:label
+          statements << [uri, BEL::RDF::RDFS.label, to_s]
+
+          # special proteins (does not recurse into pmod)
+          if @fx.short_form == :p
+            if @arguments.find{|x| x.is_a? Term and x.fx.short_form == :pmod}
+              pmod = @arguments.find{|x| x.is_a? Term and x.fx.short_form == :pmod}
+              mod_string = pmod.arguments.map(&:to_s).join(',')
+              mod_type = BEL::RDF::MODIFICATION_TYPE.find {|k,v| mod_string.start_with? k}
+              mod_type = (mod_type ? mod_type[1] : BEL::RDF::BELV.Modification)
+              statements << [uri, BEL::RDF::BELV.hasModificationType, mod_type]
+              last = pmod.arguments.last.to_s
+              if last.match(/^\d+$/)
+                statements << [uri, BEL::RDF::BELV.hasModificationPosition, last.to_i]
+              end
+              # link root protein abundance as hasChild
+              root_param = @arguments.find{|x| x.is_a? Parameter}
+              (root_id, root_statements) = Term.new(:p, [root_param]).to_rdf
+              statements << [uri, BEL::RDF::BELV.hasChild, root_id]
+              statements += root_statements
+              return [uri, statements]
+            elsif @arguments.find{|x| x.is_a? Term and BEL::RDF::PROTEIN_VARIANT.include? x.fx}
+              # link root protein abundance as hasChild
+              root_param = @arguments.find{|x| x.is_a? Parameter}
+              (root_id, root_statements) = Term.new(:p, [root_param]).to_rdf
+              statements << [uri, BEL::RDF::BELV.hasChild, root_id]
+              statements += root_statements
+              return [uri, statements]
+            end
+          end
+
+          # BEL::RDF::BELV.hasConcept]
+          @arguments.find_all{ |x|
+            x.is_a? Parameter and x.ns != nil
+          }.each do |param|
+            concept_uri = param.ns.to_rdf_vocabulary[param.value.to_s]
+            statements << [uri, BEL::RDF::BELV.hasConcept, BEL::RDF::RDF::URI(Addressable::URI.encode(concept_uri))]
+          end
+
+          # BEL::RDF::BELV.hasChild]
+          @arguments.find_all{|x| x.is_a? Term}.each do |child|
+            (child_id, child_statements) = child.to_rdf
+            statements << [uri, BEL::RDF::BELV.hasChild, child_id]
+            statements += child_statements
+          end
+
+          return [uri, statements]
+        end
+      end
+
+      class Statement
+        def to_uri
+          case
+          when subject_only?
+            tid = @subject.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
+            BEL::RDF::BELR[tid]
+          when simple?
+            sub_id = @subject.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
+            obj_id = @object.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
+            rel = BEL::RDF::RELATIONSHIP_TYPE[@relationship.to_s]
+            if rel
+              rel = rel.path.split('/')[-1]
+            else
+              rel = @relationship.to_s
+            end
+            BEL::RDF::BELR["#{sub_id}_#{rel}_#{obj_id}"]
+          when nested?
+            sub_id = @subject.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
+            nsub_id = @object.subject.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
+            nobj_id = @object.object.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
+            rel = BEL::RDF::RELATIONSHIP_TYPE[@relationship.to_s]
+            if rel
+              rel = rel.path.split('/')[-1]
+            else
+              rel = @relationship.to_s
+            end
+            nrel = BEL::RDF::RELATIONSHIP_TYPE[@object.relationship.to_s]
+            if nrel
+              nrel = nrel.path.split('/')[-1]
+            else
+              nrel = @object.relationship.to_s
+            end
+            BEL::RDF::BELR["#{sub_id}_#{rel}_#{nsub_id}_#{nrel}_#{nobj_id}"]
+          end
+        end
+
+        def to_rdf
+          uri = to_uri
+          statements = []
+
+          case
+          when subject_only?
+            (sub_uri, sub_statements) = @subject.to_rdf
+            statements << [uri, BEL::RDF::BELV.hasSubject, sub_uri]
+            statements += sub_statements
+          when simple?
+            (sub_uri, sub_statements) = @subject.to_rdf
+            statements += sub_statements
+
+            (obj_uri, obj_statements) = @object.to_rdf
+            statements += obj_statements
+
+            rel = BEL::RDF::RELATIONSHIP_TYPE[@relationship.to_s]
+            statements << [uri, BEL::RDF::BELV.hasSubject, sub_uri]
+            statements << [uri, BEL::RDF::BELV.hasObject, obj_uri]
+            statements << [uri, BEL::RDF::BELV.hasRelationship, rel]
+          when nested?
+            (sub_uri, sub_statements) = @subject.to_rdf
+            (nsub_uri, nsub_statements) = @object.subject.to_rdf
+            (nobj_uri, nobj_statements) = @object.object.to_rdf
+            statements += sub_statements
+            statements += nsub_statements
+            statements += nobj_statements
+            rel = BEL::RDF::RELATIONSHIP_TYPE[@relationship.to_s]
+            nrel = BEL::RDF::RELATIONSHIP_TYPE[@object.relationship.to_s]
+            nuri = BEL::RDF::BELR["#{strip_prefix(nsub_uri)}_#{nrel}_#{strip_prefix(nobj_uri)}"]
+
+            # inner
+            statements << [nuri, BEL::RDF::BELV.hasSubject, nsub_uri]
+            statements << [nuri, BEL::RDF::BELV.hasObject, nobj_uri]
+            statements << [nuri, BEL::RDF::BELV.hasRelationship, nrel]
+
+            # outer
+            statements << [uri, BEL::RDF::BELV.hasSubject, sub_uri]
+            statements << [uri, BEL::RDF::BELV.hasObject, nuri]
+            statements << [uri, BEL::RDF::BELV.hasRelationship, rel]
+          end
+
+          # common statement triples
+          statements << [uri, BEL::RDF::RDF.type, BEL::RDF::BELV.Statement]
+          statements << [uri, RDF::RDFS.label, to_s]
+
+          # evidence
+          evidence_bnode = BEL::RDF::RDF::Node.uuid
+          statements << [evidence_bnode, BEL::RDF::RDF.type, BEL::RDF::BELV.Evidence]
+          statements << [uri, BEL::RDF::BELV.hasEvidence, evidence_bnode]
+          statements << [evidence_bnode, BEL::RDF::BELV.hasStatement, uri]
+
+          # citation
+          citation = @annotations.delete('Citation')
+          if citation
+            value = citation.value.map{|x| x.gsub('"', '')}
+            if citation and value[0] == 'PubMed'
+              pid = value[2]
+              statements << [
+                evidence_bnode,
+                BEL::RDF::BELV.hasCitation,
+                BEL::RDF::RDF::URI(BEL::RDF::PUBMED[pid])
+              ]
+            end
+          end
+
+          # evidence
+          evidence_text = @annotations.delete('Evidence')
+          if evidence_text
+            value = evidence_text.value.gsub('"', '')
+            statements << [evidence_bnode, BEL::RDF::BELV.hasEvidenceText, value]
+          end
+
+          # annotations
+          @annotations.each do |name, anno|
+            name = anno.name.gsub('"', '')
+
+            if BEL::RDF::const_defined? name
+              annotation_scheme = BEL::RDF::const_get name
+              [anno.value].flatten.map{|x| x.gsub('"', '')}.each do |val|
+                value_uri = BEL::RDF::RDF::URI(Addressable::URI.encode(annotation_scheme[val.to_s]))
+                statements << [evidence_bnode, BEL::RDF::BELV.hasAnnotation, value_uri]
+              end
+            end
+          end
+
+          return [uri, statements]
+        end
+
+        private
+
+        def strip_prefix(uri)
+          if uri.to_s.start_with? 'http://www.openbel.org/bel/'
+            uri.to_s[28..-1]
+          else
+            uri
+          end
+        end
+      end
+    end
   end
 end
 # vim: ts=2 sw=2: