RubyGems - bel - Versions diffs - 0.3.3 → 0.4.0.beta1 - Mend

bel 0.3.3 → 0.4.0.beta1

Files changed (73) hide show

checksums.yaml +4 -4
data/README.md +53 -8
data/bel.gemspec +10 -15
data/bin/bel +63 -4
data/bin/bel2rdf.rb +1 -1
data/bin/bel_compare.rb +1 -1
data/bin/bel_parse.rb +1 -1
data/bin/bel_rdfschema.rb +1 -1
data/bin/bel_summarize.rb +1 -1
data/bin/bel_upgrade.rb +1 -1
data/lib/bel.rb +8 -10
data/lib/bel/completion.rb +3 -2
data/lib/bel/completion/value_match_rule.rb +10 -0
data/lib/bel/evidence_model/citation.rb +101 -43
data/lib/bel/evidence_model/evidence.rb +2 -2
data/lib/bel/evidence_model/experiment_context.rb +1 -0
data/lib/bel/evidence_model/metadata.rb +15 -2
data/lib/bel/evidence_model/references.rb +10 -10
data/lib/bel/json.rb +63 -0
data/lib/bel/json/adapter/multi_json.rb +36 -0
data/lib/bel/json/adapter/oj.rb +65 -0
data/lib/bel/json/adapter/ruby_json.rb +28 -0
data/lib/bel/json/reader.rb +9 -0
data/lib/bel/json/writer.rb +9 -0
data/lib/bel/libbel.rb +1 -4
data/lib/bel/parser.rb +2 -2
data/lib/bel/rdf_repository.rb +18 -0
data/lib/bel/rdf_repository/plugins/memory.rb +28 -0
data/lib/bel/rdf_repository/plugins/mongo.rb +28 -0
data/lib/bel/resource.rb +24 -0
data/lib/bel/resource/namespace.rb +122 -0
data/lib/bel/resource/namespace_value.rb +69 -0
data/lib/bel/resource/namespaces.rb +83 -0
data/lib/bel/resource/search.rb +26 -0
data/lib/bel/resource/search/api.rb +36 -0
data/lib/bel/resource/search/search_result.rb +32 -0
data/lib/bel/translate.rb +108 -0
data/lib/bel/translator.rb +69 -0
data/lib/bel/translator/plugins/bel_script.rb +36 -0
data/lib/bel/translator/plugins/bel_script/bel_yielder.rb +144 -0
data/lib/bel/translator/plugins/bel_script/evidence_yielder.rb +95 -0
data/lib/bel/translator/plugins/bel_script/translator.rb +24 -0
data/lib/bel/translator/plugins/jgf.rb +37 -0
data/lib/bel/translator/plugins/jgf/translator.rb +160 -0
data/lib/bel/translator/plugins/json_evidence.rb +38 -0
data/lib/bel/translator/plugins/json_evidence/translator.rb +90 -0
data/lib/bel/translator/plugins/rdf.rb +48 -0
data/lib/bel/translator/plugins/rdf/bel_schema.rb +339 -0
data/lib/bel/translator/plugins/rdf/monkey_patch.rb +310 -0
data/lib/bel/translator/plugins/rdf/reader.rb +173 -0
data/lib/bel/translator/plugins/rdf/translator.rb +40 -0
data/lib/bel/translator/plugins/rdf/writer.rb +45 -0
data/lib/bel/translator/plugins/xbel.rb +36 -0
data/lib/bel/translator/plugins/xbel/evidence_handler.rb +468 -0
data/lib/bel/translator/plugins/xbel/evidence_yielder.rb +24 -0
data/lib/bel/translator/plugins/xbel/translator.rb +24 -0
data/lib/bel/translator/plugins/xbel/xbel_yielder.rb +414 -0
data/lib/bel/vendor/little-plugger.rb +323 -0
data/lib/bel/version.rb +1 -1
metadata +44 -158
data/lib/bel/extension.rb +0 -37
data/lib/bel/extension_format.rb +0 -207
data/lib/bel/extensions/bel.rb +0 -258
data/lib/bel/extensions/jgf.rb +0 -219
data/lib/bel/extensions/json/jrjackson.rb +0 -31
data/lib/bel/extensions/json/json.rb +0 -133
data/lib/bel/extensions/json/multi_json.rb +0 -29
data/lib/bel/extensions/json/oj.rb +0 -68
data/lib/bel/extensions/json/ruby_json.rb +0 -29
data/lib/bel/extensions/rdf/bel_rdf.rb +0 -338
data/lib/bel/extensions/rdf/rdf.rb +0 -584
data/lib/bel/extensions/xbel.rb +0 -923
data/lib/bel/format.rb +0 -58

data/lib/bel/extensions/json/ruby_json.rb DELETED

@@ -1,29 +0,0 @@
-require 'json'
-module BEL::Extension::Format
-  module JSONImplementation
-    class JSONReader
-      def initialize(data)
-        @data = data
-      end
-      def each(&block)
-        if block_given?
-          JSON.load(@data, nil, :symbolize_names => true).each do |obj|
-            yield obj
-          end
-        else
-          to_enum(:each)
-        end
-      end
-    end
-    class JSONWriter
-      def write_json_object(json_object)
-        JSON.dump(json_object)
-      end
-    end
-  end
-end

data/lib/bel/extensions/rdf/bel_rdf.rb DELETED

@@ -1,338 +0,0 @@
-# vim: ts=2 sw=2:
-# Defines the RDF vocabulary for BEL structures.
-# rename rdf module to avoid conflict within BEL::RDF
-RUBYRDF = RDF
-module BEL
-  module RDF
-    # uri prefixes
-    BELR    = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/')
-    BELV    = RUBYRDF::Vocabulary.new('http://www.openbel.org/vocabulary/')
-    PUBMED  = RUBYRDF::Vocabulary.new('http://bio2rdf.org/pubmed:')
-    RDF     = RUBYRDF
-    RDFS    = RUBYRDF::RDFS
-    # annotations
-    Anatomy       = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/anatomy/')
-    Cell          = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/cell/')
-    CellLine      = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/cell-line/')
-    CellStructure = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/cell-structure/')
-    Disease       = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/disease/')
-    MeSHAnatomy   = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/mesh-anatomy/')
-    MeSHDisease   = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/mesh-diseases/')
-    Species       = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/species-taxonomy-id/')
-    # maps outer function to bel/vocabulary class
-    FUNCTION_TYPE = {
-      a:                       BELV.Abundance,
-      act:                     BELV.AbundanceActivity,
-      bp:                      BELV.BiologicalProcess,
-      cat:                     BELV.AbundanceActivity,
-      chap:                    BELV.AbundanceActivity,
-      complex:                 BELV.ComplexAbundance,
-      composite:               BELV.CompositeAbundance,
-      deg:                     BELV.Degradation,
-      fus:                     BELV.Fusion,
-      g:                       BELV.GeneAbundance,
-      gtp:                     BELV.AbundanceActivity,
-      kin:                     BELV.AbundanceActivity,
-      m:                       BELV.microRNAAbundance,
-      p:                       BELV.ProteinAbundance,
-      path:                    BELV.Pathology,
-      pep:                     BELV.AbundanceActivity,
-      phos:                    BELV.AbundanceActivity,
-      pmod:                    BELV.ProteinModification,
-      r:                       BELV.RNAAbundance,
-      ribo:                    BELV.AbundanceActivity,
-      rxn:                     BELV.Reaction,
-      sec:                     BELV.CellSecretion,
-      sub:                     BELV.Substitution,
-      surf:                    BELV.CellSurfaceExpression,
-      tloc:                    BELV.Translocation,
-      tport:                   BELV.AbundanceActivity,
-      tscript:                 BELV.AbundanceActivity,
-      abundance:               BELV.Abundance,
-      biologicalProcess:       BELV.BiologicalProcess,
-      catalyticActivity:       BELV.AbundanceActivity,
-      cellSecretion:           BELV.CellSecretion,
-      cellSurfaceExpression:   BELV.CellSurfaceExpression,
-      chaperoneActivity:       BELV.AbundanceActivity,
-      complexAbundance:        BELV.ComplexAbundance,
-      compositeAbundance:      BELV.CompositeAbundance,
-      degradation:             BELV.Degradation,
-      fusion:                  BELV.Fusion,
-      geneAbundance:           BELV.GeneAbundance,
-      gtpBoundActivity:        BELV.AbundanceActivity,
-      kinaseActivity:          BELV.AbundanceActivity,
-      list:                    BELV.List,
-      microRNAAbundance:       BELV.microRNAAbundance,
-      molecularActivity:       BELV.AbundanceActivity,
-      pathology:               BELV.Pathology,
-      peptidaseActivity:       BELV.AbundanceActivity,
-      phosphataseActivity:     BELV.AbundanceActivity,
-      products:                BELV.Products,
-      proteinAbundance:        BELV.ProteinAbundance,
-      proteinModification:     BELV.ProteinModification,
-      reactants:               BELV.Reactants,
-      reaction:                BELV.Reaction,
-      ribosylationActivity:    BELV.AbundanceActivity,
-      rnaAbundance:            BELV.RNAAbundance,
-      substitution:            BELV.Substitution,
-      transcriptionalActivity: BELV.AbundanceActivity,
-      translocation:           BELV.Translocation,
-      transportActivity:       BELV.AbundanceActivity,
-      truncation:              BELV.Truncation,
-    }
-    RELATIONSHIP_TYPE = {
-        '--'                     => BELV.Association,
-        '-|'                     => BELV.Decreases,
-        '=|'                     => BELV.DirectlyDecreases,
-        '=>'                     => BELV.DirectlyIncreases,
-        '->'                     => BELV.Increases,
-        ':>'                     => BELV.TranscribedTo,
-        '>>'                     => BELV.TranslatedTo,
-        'actsIn'                 => BELV.ActsIn,
-        'analogous'              => BELV.Analogous,
-        'association'            => BELV.Association,
-        'biomarkerFor'           => BELV.BiomarkerFor,
-        'causesNoChange'         => BELV.CausesNoChange,
-        'decreases'              => BELV.Decreases,
-        'directlyDecreases'      => BELV.DirectlyDecreases,
-        'directlyIncreases'      => BELV.DirectlyIncreases,
-        'hasComponent'           => BELV.HasComponent,
-        'hasComponents'          => BELV.HasComponents,
-        'hasMember'              => BELV.HasMember,
-        'hasMembers'             => BELV.HasMembers,
-        'hasModification'        => BELV.HasModification,
-        'hasProduct'             => BELV.HasProduct,
-        'hasVariant'             => BELV.HasVariant,
-        'includes'               => BELV.Includes,
-        'increases'              => BELV.Increases,
-        'isA'                    => BELV.IsA,
-        'negativeCorrelation'    => BELV.NegativeCorrelation,
-        'orthologous'            => BELV.Orthologous,
-        'positiveCorrelation'    => BELV.PositiveCorrelation,
-        'prognosticBiomarkerFor' => BELV.PrognosticBiomarkerFor,
-        'rateLimitingStepOf'     => BELV.RateLimitingStepOf,
-        'reactantIn'             => BELV.ReactantIn,
-        'subProcessOf'           => BELV.SubProcessOf,
-        'transcribedTo'          => BELV.TranscribedTo,
-        'translatedTo'           => BELV.TranslatedTo,
-        'translocates'           => BELV.Translocates,
-    }
-    RELATIONSHIP_CLASSIFICATION = {
-        :'--'                     => BELV.CorrelativeRelationship,
-        :'-|'                     => BELV.Decreases,
-        :'=|'                     => BELV.DirectlyDecreases,
-        :'=>'                     => BELV.DirectlyIncreases,
-        :'->'                     => BELV.Increases,
-        :'association'            => BELV.CorrelativeRelationship,
-        :'biomarkerFor'           => BELV.BiomarkerFor,
-        :'causesNoChange'         => BELV.CausesNoChange,
-        :'decreases'              => BELV.Decreases,
-        :'directlyDecreases'      => BELV.DirectlyDecreases,
-        :'directlyIncreases'      => BELV.DirectlyIncreases,
-        :'hasComponent'           => BELV.HasComponent,
-        :'hasMember'              => BELV.HasMember,
-        :'increases'              => BELV.Increases,
-        :'isA'                    => BELV.IsA,
-        :'negativeCorrelation'    => BELV.NegativeCorrelation,
-        :'positiveCorrelation'    => BELV.PositiveCorrelation,
-        :'prognosticBiomarkerFor' => BELV.PrognosticBiomarkerFor,
-        :'rateLimitingStepOf'     => BELV.RateLimitingStepOf,
-        :'subProcessOf'           => BELV.SubProcessOf,
-    }
-    ACTIVITY_TYPE = {
-      act:                     BELV.Activity,
-      cat:                     BELV.Catalytic,
-      chap:                    BELV.Chaperone,
-      gtp:                     BELV.GtpBound,
-      kin:                     BELV.Kinase,
-      pep:                     BELV.Peptidase,
-      phos:                    BELV.Phosphatase,
-      ribo:                    BELV.Ribosylase,
-      tport:                   BELV.Transport,
-      tscript:                 BELV.Transcription,
-      catalyticActivity:       BELV.Catalytic,
-      chaperoneActivity:       BELV.Chaperone,
-      gtpBoundActivity:        BELV.GtpBound,
-      kinaseActivity:          BELV.Kinase,
-      molecularActivity:       BELV.Activity,
-      peptidaseActivity:       BELV.Peptidase,
-      phosphataseActivity:     BELV.Phosphatase,
-      ribosylationActivity:    BELV.Ribosylase,
-      transcriptionalActivity: BELV.Transcription,
-      transportActivity:       BELV.Transport,
-    }
-    # maps modification types to bel/vocabulary class
-    MODIFICATION_TYPE = {
-      'A'   => BELV.Acetylation,
-      'F'   => BELV.Farnesylation,
-      'G'   => BELV.Glycosylation,
-      'H'   => BELV.Hydroxylation,
-      'M'   => BELV.Methylation,
-      'P'   => BELV.Phosphorylation,
-      'P,S' => BELV.PhosphorylationSerine,
-      'P,T' => BELV.PhosphorylationThreonine,
-      'P,Y' => BELV.PhosphorylationTyrosine,
-      'R'   => BELV.Ribosylation,
-      'S'   => BELV.Sumoylation,
-      'U'   => BELV.Ubiquitination,
-    }
-    # protein variant
-    PROTEIN_VARIANT = [:fus, :fusion, :sub, :substitution, :trunc, :truncation]
-    def self.vocabulary_rdf
-      [
-        # Classes
-          # Concept - Annotations
-          [BELV.AnnotationConcept, RDF::RDFS.subClassOf, RDF::SKOS.Concept],
-          [BELV.AnnotationConceptScheme, RDF::RDFS.subClassOf, RDF::SKOS.ConceptScheme],
-          # Concept - Namespaces
-          [BELV.AbundanceConcept, RDF::RDFS.subClassOf, BELV.NamespaceConcept],
-          [BELV.BiologicalProcessConcept, RDF::RDFS.subClassOf, BELV.NamespaceConcept],
-          [BELV.ComplexConcept, RDF::RDFS.subClassOf, BELV.AbundanceConcept],
-          [BELV.GeneConcept, RDF::RDFS.subClassOf, BELV.AbundanceConcept],
-          [BELV.MicroRNAConcept, RDF::RDFS.subClassOf, BELV.RNAConcept],
-          [BELV.NamespaceConceptScheme, RDF::RDFS.subClassOf, RDF::SKOS.ConceptScheme],
-          [BELV.NamespaceConcept, RDF::RDFS.subClassOf, RDF::SKOS.Concept],
-          [BELV.ProteinConcept, RDF::RDFS.subClassOf, BELV.AbundanceConcept],
-          [BELV.RNAConcept, RDF::RDFS.subClassOf, BELV.AbundanceConcept],
-          [BELV.PathologyConcept, RDF::RDFS.subClassOf, BELV.BiologicalProcessConcept],
-          # BEL Language
-          [BELV.Abundance, RDF.type, RDF::RDFS.Class],
-          [BELV.Activity, RDF.type, RDF::RDFS.Class],
-          [BELV.Evidence, RDF.type, RDF::RDFS.Class],
-          [BELV.Modification, RDF.type, RDF::RDFS.Class],
-          [BELV.Relationship, RDF.type, RDF::RDFS.Class],
-          [BELV.Statement, RDF.type, RDF::RDFS.Class],
-          [BELV.Term, RDF.type, RDF::RDFS.Class],
-          # Relationships
-          [BELV.Association, RDF::RDFS.subClassOf, BELV.CorrelativeRelationship],
-          [BELV.BiomarkerFor, RDF::RDFS.subClassOf, BELV.Relationship],
-          [BELV.CausesNoChange, RDF::RDFS.subClassOf, BELV.CausalRelationship],
-          [BELV.CausalRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
-          [BELV.CorrelativeRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
-          [BELV.Decreases, RDF::RDFS.subClassOf, BELV.CausalRelationship],
-          [BELV.Decreases, RDF::RDFS.subClassOf, BELV.NegativeRelationship],
-          [BELV.DirectlyDecreases, RDF::RDFS.subClassOf, BELV.CausalRelationship],
-          [BELV.DirectlyDecreases, RDF::RDFS.subClassOf, BELV.NegativeRelationship],
-          [BELV.DirectlyDecreases, RDF::RDFS.subClassOf, BELV.DirectRelationship],
-          [BELV.DirectlyDecreases, RDF::RDFS.subClassOf, BELV.Decreases],
-          [BELV.DirectlyIncreases, RDF::RDFS.subClassOf, BELV.CausalRelationship],
-          [BELV.DirectlyIncreases, RDF::RDFS.subClassOf, BELV.PositiveRelationship],
-          [BELV.DirectlyIncreases, RDF::RDFS.subClassOf, BELV.DirectRelationship],
-          [BELV.DirectlyIncreases, RDF::RDFS.subClassOf, BELV.Increases],
-          [BELV.DirectRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
-          [BELV.HasComponent, RDF::RDFS.subClassOf, BELV.MembershipRelationship],
-          [BELV.HasMember, RDF::RDFS.subClassOf, BELV.MembershipRelationship],
-          [BELV.Increases, RDF::RDFS.subClassOf, BELV.CausalRelationship],
-          [BELV.Increases, RDF::RDFS.subClassOf, BELV.PositiveRelationship],
-          [BELV.IsA, RDF::RDFS.subClassOf, BELV.MembershipRelationship],
-          [BELV.MembershipRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
-          [BELV.NegativeCorrelation, RDF::RDFS.subClassOf, BELV.CorrelativeRelationship],
-          [BELV.NegativeCorrelation, RDF::RDFS.subClassOf, BELV.NegativeRelationship],
-          [BELV.NegativeRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
-          [BELV.PositiveCorrelation, RDF::RDFS.subClassOf, BELV.CorrelativeRelationship],
-          [BELV.PositiveCorrelation, RDF::RDFS.subClassOf, BELV.PositiveRelationship],
-          [BELV.PositiveRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
-          [BELV.PrognosticBiomarkerFor, RDF::RDFS.subClassOf, BELV.BiomarkerFor],
-          [BELV.RateLimitingStepOf, RDF::RDFS.subClassOf, BELV.Increases],
-          [BELV.RateLimitingStepOf, RDF::RDFS.subClassOf, BELV.CausalRelationship],
-          [BELV.RateLimitingStepOf, RDF::RDFS.subClassOf, BELV.SubProcessOf],
-          [BELV.SubProcessOf, RDF::RDFS.subClassOf, BELV.MembershipRelationship],
-          # Abundances
-          [BELV.AbundanceActivity, RDF::RDFS.subClassOf, BELV.Process],
-          [BELV.BiologicalProcess, RDF::RDFS.subClassOf, BELV.Process],
-          [BELV.CellSecretion, RDF::RDFS.subClassOf, BELV.Translocation],
-          [BELV.ComplexAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
-          [BELV.CompositeAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
-          [BELV.Degradation, RDF::RDFS.subClassOf, BELV.Transformation],
-          [BELV.GeneAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
-          [BELV.MicroRNAAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
-          [BELV.ModifiedProteinAbundance, RDF::RDFS.subClassOf, BELV.ProteinAbundance],
-          [BELV.Pathology, RDF::RDFS.subClassOf, BELV.BiologicalProcess],
-          [BELV.Process, RDF.type, RDF::RDFS.Class],
-          [BELV.ProteinAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
-          [BELV.ProteinVariantAbundance, RDF::RDFS.subClassOf, BELV.ProteinAbundance],
-          [BELV.Reaction, RDF::RDFS.subClassOf, BELV.Transformation],
-          [BELV.RNAAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
-          [BELV.Transformation, RDF::RDFS.subClassOf, BELV.Process],
-          [BELV.Translocation, RDF::RDFS.subClassOf, BELV.Transformation],
-          # Activities
-          [BELV.Activity, RDF::RDFS.subClassOf, BELV.Activity],
-          [BELV.Catalytic, RDF::RDFS.subClassOf, BELV.Activity],
-          [BELV.Chaperone, RDF::RDFS.subClassOf, BELV.Activity],
-          [BELV.GtpBound, RDF::RDFS.subClassOf, BELV.Activity],
-          [BELV.Kinase, RDF::RDFS.subClassOf, BELV.Activity],
-          [BELV.Peptidase, RDF::RDFS.subClassOf, BELV.Activity],
-          [BELV.Phosphatase, RDF::RDFS.subClassOf, BELV.Activity],
-          [BELV.Ribosylase, RDF::RDFS.subClassOf, BELV.Activity],
-          [BELV.Transcription, RDF::RDFS.subClassOf, BELV.Activity],
-          [BELV.Transport, RDF::RDFS.subClassOf, BELV.Activity],
-          # Modifications
-          [BELV.Acetylation, RDF::RDFS.subClassOf, BELV.Modification],
-          [BELV.Farnesylation, RDF::RDFS.subClassOf, BELV.Modification],
-          [BELV.Glycosylation, RDF::RDFS.subClassOf, BELV.Modification],
-          [BELV.Hydroxylation, RDF::RDFS.subClassOf, BELV.Modification],
-          [BELV.Methylation, RDF::RDFS.subClassOf, BELV.Modification],
-          [BELV.Phosphorylation, RDF::RDFS.subClassOf, BELV.Modification],
-          [BELV.Ribosylation, RDF::RDFS.subClassOf, BELV.Modification],
-          [BELV.Sumoylation, RDF::RDFS.subClassOf, BELV.Modification],
-          [BELV.Ubiquitination, RDF::RDFS.subClassOf, BELV.Modification],
-          [BELV.PhosphorylationSerine, RDF::RDFS.subClassOf, BELV.Phosphorylation],
-          [BELV.PhosphorylationTyrosine, RDF::RDFS.subClassOf, BELV.Phosphorylation],
-          [BELV.PhosphorylationThreonine, RDF::RDFS.subClassOf, BELV.Phosphorylation],
-        # Properties
-          # Term
-          [BELV.hasActivityType, RDF.type, RDF.Property],
-          [BELV.hasActivityType, RDF::RDFS.range, BELV.Activity],
-          [BELV.hasActivityType, RDF::RDFS.domain, BELV.Term],
-          [BELV.hasChild, RDF.type, RDF.Property],
-          [BELV.hasChild, RDF::RDFS.range, BELV.Term],
-          [BELV.hasChild, RDF::RDFS.domain, BELV.Term],
-          [BELV.hasConcept, RDF.type, RDF.Property],
-          [BELV.hasConcept, RDF::RDFS.range, BELV.NamespaceConcept],
-          [BELV.hasConcept, RDF::RDFS.domain, BELV.Term],
-          [BELV.hasModificationPosition, RDF.type, RDF.Property],
-          [BELV.hasModificationPosition, RDF::RDFS.range, RDF::XSD.integer],
-          [BELV.hasModificationPosition, RDF::RDFS.domain, BELV.Term],
-          [BELV.hasModificationType, RDF.type, RDF.Property],
-          [BELV.hasModificationType, RDF::RDFS.range, BELV.Activity],
-          [BELV.hasModificationType, RDF::RDFS.domain, BELV.Term],
-          # Statement
-          [BELV.hasEvidence, RDF.type, RDF.Property],
-          [BELV.hasEvidence, RDF::RDFS.range, BELV.Evidence],
-          [BELV.hasEvidence, RDF::RDFS.domain, BELV.Statement],
-          [BELV.hasObject, RDF::RDFS.subPropertyOf, BELV.hasChild],
-          [BELV.hasObject, RDF::RDFS.range, BELV.Term],
-          [BELV.hasObject, RDF::RDFS.domain, BELV.Statement],
-          [BELV.hasRelationship, RDF.type, RDF.Property],
-          [BELV.hasRelationship, RDF::RDFS.range, BELV.Relationship],
-          [BELV.hasRelationship, RDF::RDFS.domain, BELV.Statement],
-          [BELV.hasSubject, RDF::RDFS.subPropertyOf, BELV.hasChild],
-          [BELV.hasSubject, RDF::RDFS.range, BELV.Term],
-          [BELV.hasSubject, RDF::RDFS.domain, BELV.Statement],
-          # Evidence
-          [BELV.hasAnnotation, RDF.type, RDF.Property],
-          [BELV.hasAnnotation, RDF::RDFS.range, BELV.AnnotationConcept],
-          [BELV.hasAnnotation, RDF::RDFS.domain, BELV.Evidence],
-          [BELV.hasCitation, RDF.type, RDF.Property],
-          [BELV.hasCitation, RDF::RDFS.domain, BELV.Evidence],
-          [BELV.hasEvidenceText, RDF::RDFS.range, RDF::XSD.string],
-          [BELV.hasEvidenceText, RDF::RDFS.domain, BELV.Evidence],
-          [BELV.hasStatement, RDF.type, RDF.Property],
-          [BELV.hasStatement, RDF::RDFS.range, BELV.Statement],
-          [BELV.hasStatement, RDF::RDFS.domain, BELV.Evidence]
-      ]
-    end
-  end
-end

data/lib/bel/extensions/rdf/rdf.rb DELETED

@@ -1,584 +0,0 @@
-# Load RDF library dependencies
-begin
-  require 'rdf'
-  require 'addressable/uri'
-  require 'uuid'
-rescue LoadError => e
-  # Raise LoadError if the requirements were not met.
-  raise
-end
-require_relative 'bel_rdf'
-# OpenClass to contribute RDF functionality to BEL Model.
-class ::BEL::Namespace::NamespaceDefinition
-  def to_uri
-    @rdf_uri
-  end
-  def to_rdf_vocabulary
-    RUBYRDF::Vocabulary.new("#{@rdf_uri}/")
-  end
-end
-class ::BEL::Model::Parameter
-  def to_uri
-    @ns.to_rdf_vocabulary[URI::encode(@value)]
-  end
-  def to_rdf
-    uri = to_uri
-    encodings = ['A'].concat(@enc.to_s.each_char.to_a).uniq
-    if block_given?
-      encodings.map { |enc| concept_statement(enc, uri) }.each do |stmt|
-        yield stmt
-      end
-    else
-      encodings.map { |enc| concept_statement(enc, 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 BEL::Model::Term
-  def to_uri
-    tid = to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
-    BEL::RDF::BELR[URI::encode(tid)]
-  end
-  def rdf_type
-    if respond_to? 'fx'
-      fx = @fx.respond_to?(:short_form) ? @fx.short_form : @fx.to_s.to_sym
-      if [:p, :proteinAbundance].include?(fx) &&
-         @arguments.find{ |x|
-           if x.is_a? BEL::Model::Term
-             arg_fx = x.fx
-             arg_fx = arg_fx.respond_to?(:short_form) ? arg_fx.short_form : arg_fx.to_s.to_sym
-             [:pmod, :proteinModification].include?(arg_fx)
-           else
-             false
-           end
-         }
-        return BEL::RDF::BELV.ModifiedProteinAbundance
-      end
-      if [:p, :proteinAbundance].include?(fx) &&
-         @arguments.find{ |x|
-           if x.is_a? BEL::Model::Term
-             arg_fx = x.fx
-             arg_fx = arg_fx.respond_to?(:short_form) ? arg_fx.short_form : arg_fx.to_s.to_sym
-             BEL::RDF::PROTEIN_VARIANT.include?(arg_fx)
-           else
-             false
-           end
-         }
-        return BEL::RDF::BELV.ProteinVariantAbundance
-      end
-      BEL::RDF::FUNCTION_TYPE[fx] || 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]
-    fx = @fx.respond_to?(:short_form) ? @fx.short_form : @fx.to_s.to_sym
-    if BEL::RDF::ACTIVITY_TYPE.include? fx
-      statements << [uri, BEL::RDF::BELV.hasActivityType, BEL::RDF::ACTIVITY_TYPE[fx]]
-    end
-    # rdfs:label
-    statements << [uri, BEL::RDF::RDFS.label, to_s.force_encoding('UTF-8')]
-    # special proteins (does not recurse into pmod)
-    if [:p, :proteinAbundance].include?(fx)
-      pmod =
-        @arguments.find{ |x|
-          if x.is_a? BEL::Model::Term
-            arg_fx = x.fx
-            arg_fx = arg_fx.respond_to?(:short_form) ? arg_fx.short_form : arg_fx.to_s.to_sym
-            [:pmod, :proteinModification].include?(arg_fx)
-          else
-            false
-          end
-        }
-      if 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? BEL::Model::Parameter}
-        (root_id, root_statements) = BEL::Model::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? BEL::Model::Term and BEL::RDF::PROTEIN_VARIANT.include? x.fx}
-        # link root protein abundance as hasChild
-        root_param = @arguments.find{|x| x.is_a? BEL::Model::Parameter}
-        (root_id, root_statements) = BEL::Model::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? BEL::Model::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? BEL::Model::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 BEL::Model::Statement
-  def to_uri
-    case
-    when subject_only?
-      tid = @subject.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
-      BEL::RDF::BELR[URI::encode(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[URI::encode("#{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[URI::encode("#{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.force_encoding('UTF-8')]
-    # 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('"', '').force_encoding('UTF-8')
-      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
-module BEL::Extension::Format
-  class FormatRDF
-    include Formatter
-    ID          = :rdf
-    MEDIA_TYPES = %i(
-      application/n-quads
-      application/n-triples
-      application/rdf+xml
-      application/turtle
-      application/x-turtle
-      text/turtle
-    )
-    EXTENSIONS  = %i(
-      nq
-      nt
-      rdf
-      ttl
-    )
-    def id
-      ID
-    end
-    def media_types
-      MEDIA_TYPES
-    end
-    def file_extensions
-      EXTENSIONS
-    end
-    def deserialize(data)
-      RDFReader::UnbufferedEvidenceYielder.new(data)
-    end
-    def serialize(objects, writer = StringIO.new, options = {})
-      format = options[:format] || :ntriples
-      rdf_writer = RDFWriter::RDFYielder.new(writer, format)
-      objects.each do |evidence|
-        rdf_writer << evidence
-      end
-      rdf_writer.done
-      writer
-    end
-  end
-  module RDFReader
-    module EvidenceYielder
-      RDF  = BEL::RDF::RDF
-      RDFS = RDF::RDFS
-      BELV = BEL::RDF::BELV
-      include ::BEL::Model
-      include ::BEL::Quoting
-      # Find described resources by +type+ in +graph+.
-      #
-      # @param  [RDF::Resource] type the RDF type to find instances for
-      # @param  [RDF::Graph]    graph the RDF graph to query
-      # @return [Enumerator]    an enumerator of described resource instances
-      def resources_of_type(type, graph)
-        graph.query([nil, RDF.type, type])
-          .lazy
-          .map { |rdf_statement|
-            describe(rdf_statement.subject, graph)
-          }
-      end
-      # Describes an RDF +resource+ contained within +graph+. Describing an RDF
-      # resource will retrieve the neighborhood of RDF statements with
-      # +resource+ in the subject position.
-      #
-      # @param  [RDF::Resource] resource the RDF resource to describe
-      # @param  [RDF::Graph]    graph the RDF graph to query
-      # @return [Hash]          a hash of predicate to object in the
-      #         neighborhood of +resource+
-      def describe(resource, graph)
-        graph.query([resource, nil, nil]).reduce({}) { |hash, statement|
-          hash[statement.predicate] = statement.object
-          hash
-        }
-      end
-      # Iterate the {BELV.Evidence} predicated statements, from the
-      # {RUBYRDF::Graph graph}, and yield those correspdonding {Evidence}
-      # objects.
-      #
-      # @param  [RDF::Graph]     graph the RDF graph to query
-      # @yield  [evidence_model] yields an {Evidence} object
-      def evidence_yielder(graph)
-        resources_of_type(BELV.Evidence, graph).each do |evidence|
-          yield make_evidence(evidence, graph)
-        end
-      end
-      # Create an {Evidence} object from RDF statements found in
-      # the {RUBYRDF::Graph graph}.
-      #
-      # @param  [Hash]       evidence a hash of predicate to object
-      #         representing the described evidence
-      # @param  [RDF::Graph] graph the RDF graph to query
-      # @return [Evidence]   the evidence model
-      def make_evidence(evidence, graph)
-        statement     = describe(evidence[BELV.hasStatement], graph)
-        # values
-        bel_statement = statement[RDFS.label].value
-        ev_text       = evidence[BELV.hasEvidenceText]
-        citation      = evidence[BELV.hasCitation]
-        # model
-        ev_model               = Evidence.new
-        ev_model.bel_statement = ::BEL::Script.parse(bel_statement)
-                                   .find { |obj|
-                                     obj.is_a? Statement
-                                   }
-        ev_model.summary_text  = SummaryText.new(ev_text.value) if ev_text
-        if citation.respond_to?(:value)
-          ev_model.citation =
-            case citation.value
-            when /pubmed:(\d+)$/
-              pubmed_id = $1.to_i
-              Citation.create(
-                :type => 'PubMed',
-                :id   => pubmed_id,
-                :name => "PubMed Citation - #{pubmed_id}"
-              )
-            else
-              nil
-            end
-        end
-        ev_model
-      end
-    end
-    class BufferedEvidenceYielder
-      include EvidenceYielder
-      def initialize(data, format = :ntriples)
-        @data   = data
-        @format = format
-      end
-      def each
-        if block_given?
-          graph = RUBYRDF::Graph.new
-          RUBYRDF::Reader.for(@format).new(@data) do |reader|
-            reader.each_statement do |statement|
-              graph << statement
-            end
-          end
-          evidence_yielder(graph) do |evidence_model|
-            yield evidence_model
-          end
-        else
-          to_enum(:each)
-        end
-      end
-    end
-    class UnbufferedEvidenceYielder
-      include EvidenceYielder
-      def initialize(data, format = :ntriples)
-        @data   = data
-        @format = format
-      end
-      def each
-        if block_given?
-          graph             = RUBYRDF::Graph.new
-          evidence_resource = nil
-          RUBYRDF::Reader.for(@format).new(@data) do |reader|
-            reader.each_statement do |statement|
-              case
-              when statement.object == BELV.Evidence &&
-                   statement.predicate == RDF.type
-                evidence_resource = statement.subject
-              when evidence_resource &&
-                   statement.predicate != BELV.hasEvidence &&
-                   statement.subject != evidence_resource
-                # yield current graph as evidence model
-                yield make_evidence(
-                  describe(evidence_resource, graph),
-                  graph
-                )
-                # reset parse state
-                graph.clear
-                evidence_resource = nil
-                # insert this RDF statement
-                graph << statement
-              else
-                graph << statement
-              end
-            end
-          end
-          # yield last graph as evidence model
-          yield make_evidence(
-            describe(evidence_resource, graph),
-            graph
-          )
-        else
-          to_enum(:each)
-        end
-      end
-    end
-  end
-  module RDFWriter
-    class RDFYielder
-      attr_reader :writer
-      def initialize(io, format)
-        rdf_writer = find_writer(format)
-        @writer = rdf_writer.new(io, { :stream => true })
-      end
-      def <<(evidence)
-        triples = evidence.bel_statement.to_rdf[1]
-        triples.each do |triple|
-          @writer.write_statement(RDF::Statement(*triple))
-        end
-      end
-      def done
-        @writer.write_epilogue
-      end
-      private
-      def find_writer(format)
-        case format.to_s.to_sym
-        when :nquads
-          BEL::RDF::RDF::NQuads::Writer
-        when :turtle
-          begin
-            require 'rdf/turtle'
-            BEL::RDF::RDF::Turtle::Writer
-          rescue LoadError
-            $stderr.puts """Turtle format not supported.
-    Install the 'rdf-turtle' gem."""
-            raise
-          end
-        when :ntriples
-          BEL::RDF::RDF::NTriples::Writer
-        end
-      end
-    end
-  end
-  register_formatter(FormatRDF.new)
-end