bel 0.3.3 → 0.4.0.beta1

data/lib/bel/translator.rb

@@ -0,0 +1,69 @@
+module BEL
+
+  # The Translator module defines a plugin that reads a specific document
+  # format into BEL evidence and writes BEL evidence back to this document
+  # format.
+  #
+  # - Read
+  #   - {#read}:            read the input format and parse to
+  #     {::BEL::Model::Evidence} objects
+  # - Write
+  #   - {#write}:           write {::BEL::Model::Evidence} objects to the
+  #     output format
+  #
+  # @example Create a translator for conversion of YAML <-> BEL Evidence.
+  #   module Translator
+  #
+  #     include ::BEL::Translator
+  #
+  #     def read(data, options = {})
+  #       objects = YAML.load(data)
+  #       # map objects to BEL evidence
+  #       # return enumerator
+  #     end
+  #
+  #     def write(data, writer = nil, options = {})
+  #       # map BEL evidence to YAML objects
+  #       YAML.dump(data)
+  #     end
+  #   end
+  module Translator
+
+    # The Plugins module provides a namespace for translator plugins.
+    # Translator plugins must be defined within {::BEL::Translator::Plugins}
+    # in order to be discovered.
+    module Plugins; end
+
+    # Set BEL::Translator as a plugin container. All plugins are loaded from
+    # +bel/translator/plugins+ on the +LOAD_PATH+. Each plugin must define a
+    # module within {::BEL::Translator::Plugins} that corresponds to the file
+    # in the plugin path. For example the plugin module
+    # +::BEL::Translator::Plugins::Foo+ must be defined within the file
+    # +bel/translator/plugins/foo.rb+.
+    extend LittlePlugger(
+      :path   => 'bel/translator/plugins',
+      :module => BEL::Translator::Plugins
+    )
+
+    # Read BEL evidence from this translator's supported file format.
+    #
+    # @param  [IO, String]             data the data to read
+    # @param  [Hash{Symbol => Object}] options
+    # @return [#each]                  an object that responds to +each+ and
+    #         provides {::BEL::Model::Evidence} objects
+    def read(data, options = {})
+      raise NotImplementedError.new("#{__method__} is not implemented.")
+    end
+
+    # Writes BEL evidence +data+ to the provided IO +writer+.
+    #
+    # @param  [#each]                  data an object that responds to +each+ and
+    #         provides {::BEL::Model::Evidence} objects
+    # @param  [IO]                     writer an IO to write to
+    # @param  [Hash{Symbol => Object}] options
+    # @return [IO]                     the IO that was written to
+    def write(data, writer = StringIO.new, options = {})
+      raise NotImplementedError.new("#{__method__} is not implemented.")
+    end
+  end
+end

data/lib/bel/translator/plugins/bel_script.rb

@@ -0,0 +1,36 @@
+module BEL::Translator::Plugins
+
+  module BelScript
+
+    ID          = :bel
+    NAME        = 'BEL Script Translator'
+    DESCRIPTION = 'A translator that can read and write evidence to BEL Script (version 1.0).'
+    MEDIA_TYPES = %i(application/bel)
+    EXTENSIONS  = %i(bel)
+
+    def self.create_translator(options = {})
+      require_relative 'bel_script/translator'
+      BelScriptTranslator.new
+    end
+
+    def self.id
+      ID
+    end
+
+    def self.name
+      NAME
+    end
+
+    def self.description
+      DESCRIPTION
+    end
+
+    def self.media_types
+      MEDIA_TYPES
+    end
+
+    def self.file_extensions
+      EXTENSIONS
+    end
+  end
+end

data/lib/bel/translator/plugins/bel_script/bel_yielder.rb

@@ -0,0 +1,144 @@
+require 'bel'
+
+module BEL::Translator::Plugins
+
+  module BelScript
+
+    class BelYielder
+
+      def initialize(data, options = {})
+        @data = data
+        @write_header = (options[:write_header] || true)
+      end
+
+      def each
+        if block_given?
+          header_flag = true
+          @data.each { |evidence|
+            bel = to_bel(evidence)
+            if @write_header && header_flag
+              yield document_header(evidence.metadata.document_header)
+              yield namespaces(
+                evidence.references.namespaces
+              )
+              yield annotations(
+                evidence.references.annotations
+              )
+              header_flag = false
+            end
+
+            yield bel
+          }
+        else
+          to_enum(:each)
+        end
+      end
+
+      private
+
+      def document_header(header)
+        return "" unless header
+
+        header.reduce("") { |bel, (name, value)|
+          name_s  = name.to_s
+          value_s =
+            if value.respond_to?(:each)
+              value.join('|')
+            else
+              value.to_s
+            end
+
+          # handle casing for document properties (special case, contactinfo)
+          name_s = (name_s.downcase == 'contactinfo') ?
+            'ContactInfo' :
+            name_s.capitalize
+
+          bel << %Q{SET DOCUMENT #{name_s} = "#{value_s}"\n}
+          bel
+        }
+      end
+
+      def annotations(annotations)
+        return "" unless annotations
+
+        annotations.reduce("") { |bel, annotation|
+          keyword = annotation[:keyword]
+          type    = annotation[:type]
+          domain  = annotation[:domain]
+          bel << "DEFINE ANNOTATION #{keyword} AS "
+
+          case type.to_sym
+          when :uri
+            bel << %Q{URL "#{domain}"\n}
+          when :pattern
+            bel << %Q{PATTERN "#{domain}"\n}
+          when :list
+            bel << %Q|LIST {#{domain.inspect[1...-1]}}\n|
+          end
+          bel
+        }
+      end
+
+      def namespaces(namespaces)
+        return "" unless namespaces
+
+        binding.pry
+        namespaces.reduce("") { |bel, namespace|
+          keyword = namespace[:keyword]
+          uri     = namespace[:uri]
+          bel << %Q{DEFINE NAMESPACE #{keyword} AS URL "#{uri}"\n}
+          bel
+        }
+      end
+
+      def to_bel(evidence)
+        bel = ""
+
+        # Citation
+        citation = evidence.citation
+        if citation && citation.valid?
+          values = citation.to_a
+          values.map! { |v| v || "" }
+          values.map! { |v|
+            if v.respond_to?(:each)
+              v.join('|')
+            else
+              v
+            end
+          }
+          value_string = values.inspect[1...-1]
+          bel << "SET Citation = {#{value_string}}\n"
+        end
+
+        # Evidence
+        summary_text = evidence.summary_text
+        if summary_text && summary_text.value
+          value = summary_text.value
+          value.gsub!("\n", "")
+          value.gsub!('"', %Q{\\"})
+          bel << %Q{SET Evidence = "#{value}"\n}
+        end
+
+        # Annotation
+        experiment_context = evidence.experiment_context
+        if experiment_context
+          experiment_context.
+            sort_by { |obj| obj[:name] }.
+            each    { |obj|
+              name, value = obj.values_at(:name, :value)
+              if value.respond_to? :each
+                value = "{#{value.inspect[1...-1]}}"
+              else
+                value = value.inspect
+              end
+              bel << "SET #{name} = #{value}\n"
+            }
+        end
+
+        # BEL statement
+        bel << "#{evidence.bel_statement.to_s}\n"
+        bel
+      end
+    end
+  end
+end

data/lib/bel/translator/plugins/bel_script/evidence_yielder.rb

@@ -0,0 +1,95 @@
+require 'bel'
+
+module BEL::Translator::Plugins
+
+  module BelScript
+
+    class EvidenceYielder
+      include ::BEL::Model
+      include ::BEL::Quoting
+
+      SPECIAL_ANNOTATIONS = {
+        'Citation' => true,
+        'Evidence' => true,
+      }
+
+      def initialize(data)
+        @data                   = data
+        @references             = References.new
+        @metadata               = Metadata.new
+      end
+
+      def each
+        if block_given?
+          ::BEL::Script.parse(@data).each { |parsed_obj|
+            case parsed_obj
+            when ::BEL::Language::DocumentProperty
+              @metadata.document_header[parsed_obj.name] = parsed_obj.value
+            when ::BEL::Model::Statement
+              yield to_evidence(parsed_obj, @references, @metadata)
+            when ::BEL::Language::AnnotationDefinition
+              @references.annotations[parsed_obj.prefix] = {
+                :type   => parsed_obj.type,
+                :domain => parsed_obj.value
+              }
+            when ::BEL::Namespace::NamespaceDefinition
+              @references.namespaces[parsed_obj.prefix] = parsed_obj.url
+            end
+          }
+        else
+          to_enum(:each)
+        end
+      end
+
+      private
+
+      def to_evidence(statement, references, metadata)
+        evidence = Evidence.new
+        evidence.bel_statement = statement
+
+        if statement.annotations.include? 'Citation'
+          fields              = statement.annotations['Citation'].value
+          if fields.respond_to? :each
+            evidence.citation = Citation.new(
+              fields.map { |field|
+                remove_quotes(field)
+              }.to_a
+            )
+          end
+        end
+
+        if statement.annotations.include? 'Evidence'
+          value  = statement.annotations['Evidence'].value
+          evidence.summary_text.value = value
+        end
+
+        annotations = statement.annotations.dup
+        annotations.delete_if { |k, _| SPECIAL_ANNOTATIONS[k] }
+        evidence.experiment_context = ExperimentContext.new(
+          annotations.map { |k, v|
+            value = v.value
+            obj   = {
+              :name  => k,
+              :value => value
+            }
+
+            annotation_def = references.annotations[k]
+            if annotation_def
+              type, domain = annotation_def.values_at(:type, :domain)
+              if type == :url
+                obj[:uri] = "#{domain}/#{value}"
+                obj[:url] = domain
+              end
+            end
+
+            obj
+          }
+        )
+
+        evidence.references = references
+        evidence.metadata   = metadata
+        evidence
+      end
+    end
+  end
+end

data/lib/bel/translator/plugins/bel_script/translator.rb

@@ -0,0 +1,24 @@
+require_relative 'evidence_yielder'
+require_relative 'bel_yielder'
+
+module BEL::Translator::Plugins
+
+  module BelScript
+
+    class BelScriptTranslator
+
+      include ::BEL::Translator
+
+      def read(data, options = {})
+        EvidenceYielder.new(data)
+      end
+
+      def write(objects, writer = StringIO.new, options = {})
+        BelYielder.new(objects).each { |bel_part|
+          writer << "#{bel_part}"
+          writer.flush
+        }
+      end
+    end
+  end
+end

data/lib/bel/translator/plugins/jgf.rb

@@ -0,0 +1,37 @@
+module BEL::Translator::Plugins
+
+  module Jgf
+
+    ID          = :jgf
+    NAME        = 'JSON Graph Format Translator'
+    DESCRIPTION = 'A translator that can read and write evidence statements in a JSON Graph Format.'
+    MEDIA_TYPES   = %i(application/vnd.jgf+json)
+    EXTENSIONS    = %i(jgf.json)
+
+    def self.create_translator(options = {})
+      require_relative 'jgf/translator'
+
+      JgfTranslator.new
+    end
+
+    def self.id
+      ID
+    end
+
+    def self.name
+      NAME
+    end
+
+    def self.description
+      DESCRIPTION
+    end
+
+    def self.media_types
+      MEDIA_TYPES
+    end
+
+    def self.file_extensions
+      EXTENSIONS
+    end
+  end
+end

data/lib/bel/translator/plugins/jgf/translator.rb

@@ -0,0 +1,160 @@
+require 'bel'
+require 'bel/json'
+
+module BEL::Translator::Plugins
+
+  module Jgf
+
+    class JgfTranslator
+
+      include ::BEL::Translator
+
+      def read(data, options = {})
+        default_resource_index = options.fetch(:default_resource_index) {
+          ResourceIndex.openbel_published_index('20131211')
+        }
+
+        ::BEL::JSON.read(data, options).lazy.select { |obj|
+          obj.include?(:nodes) && obj.include?(:edges)
+        }.flat_map { |graph|
+          unwrap(graph, default_resource_index)
+        }
+      end
+
+      def write(objects, writer = StringIO.new, options = {})
+        graph = {
+          :type  => 'BEL-V1.0',
+          :nodes => [],
+          :edges => []
+        }
+
+        objects.each do |evidence|
+          stmt    = evidence.bel_statement
+          subject = stmt.subject.to_bel
+
+          graph[:nodes] << {
+            :id    => subject,
+            :label => subject
+          }
+
+          if stmt.object
+            object  = stmt.object.to_bel
+            graph[:nodes] << {
+              :id    => object,
+              :label => object
+            }
+            graph[:edges] << {
+              :source   => subject,
+              :relation => stmt.relationship,
+              :target   => object
+            }
+          end
+        end
+        graph[:nodes].uniq!
+
+        ::BEL::JSON.write({:graph => graph}, writer, options)
+        writer
+      end
+
+      private
+
+      def unwrap(graph, default_resource_index)
+        # index nodes
+        id_nodes = Hash[
+          graph[:nodes].map { |node|
+            [node[:id], (node[:label] || node[:id])]
+          }
+        ]
+        ids = id_nodes.keys.to_set
+
+        # map edges to statements
+        bel_statements = graph[:edges].map { |edge|
+          src, rel, tgt = edge.values_at(:source, :relation, :target)
+          source_node = id_nodes[src]
+          target_node = id_nodes[tgt]
+
+          if !source_node || !target_node
+            nil
+          else
+            ids.delete(source_node)
+            ids.delete(target_node)
+
+            # semantic default
+            rel  = 'association' unless rel
+
+            bel_statement = ::BEL::Script.parse(
+              "#{source_node} #{rel} #{target_node}\n").select { |obj| obj.is_a? ::BEL::Model::Statement }.first
+          end
+        }.compact
+
+        # map island nodes to bel statements
+        if !ids.empty?
+          bel_statements.concat(
+            ids.map { |id|
+              ::BEL::Script.parse(
+                "#{id_nodes[id]}\n"
+              ).select { |obj|
+                obj.is_a? ::BEL::Model::Statement
+              }.first
+            }
+          )
+        end
+
+        # map statements to evidence objects
+        bel_statements.map { |bel_statement|
+          graph_name = graph[:label] || graph[:id] || 'BEL Graph'
+          metadata   = ::BEL::Model::Metadata.new
+          references = ::BEL::Model::References.new
+
+          # establish document header
+          metadata.document_header[:Name]        = graph_name
+          metadata.document_header[:Description] = graph_name
+          metadata.document_header[:Version]     = '1.0'
+
+          # establish annotation definitions
+          annotations = graph.fetch(:metadata, {}).
+                              fetch(:annotation_definitions, nil)
+          if !annotations && default_resource_index
+            annotations = Hash[
+              default_resource_index.annotations.sort_by { |anno|
+                anno.prefix
+              }.map { |anno|
+                [
+                  anno.prefix,
+                  {
+                    :type   => anno.type,
+                    :domain => anno.value
+                  }
+                ]
+              }
+            ]
+          end
+          references.annotations = annotations if annotations
+
+          # establish namespace definitions
+          namespaces = graph.fetch(:metadata, {}).
+                             fetch(:namespace_definitions, nil)
+          if !namespaces && default_resource_index
+            namespaces = Hash[
+              default_resource_index.namespaces.sort_by { |ns|
+                ns.prefix
+              }.map { |ns|
+                [
+                  ns.prefix,
+                  ns.url
+                ]
+              }
+            ]
+          end
+          references.namespaces = namespaces if namespaces
+
+          ::BEL::Model::Evidence.create(
+            :bel_statement => bel_statement,
+            :metadata      => metadata,
+            :references    => references
+          )
+        }
+      end
+    end
+  end
+end