bel 0.3.3 → 0.4.0.beta1

data/lib/bel/extensions/jgf.rb

@@ -1,219 +0,0 @@
-require 'bel'
-
-module BEL::Extension::Format
-
-  class FormatJGF
-
-    include Formatter
-
-    ID            = :jgf
-    MEDIA_TYPES   = %i(application/vnd.jgf+json)
-    EXTENSIONS    = %i(jgf.json)
-    ResourceIndex = ::BEL::Namespace::ResourceIndex
-
-    def initialize
-      json_module = load_implementation_module!
-      @json_reader = json_module::JSONReader
-      @json_writer = json_module::JSONWriter
-    end
-    
-    def id
-      ID
-    end
-
-    def media_types
-      MEDIA_TYPES
-    end
-
-    def file_extensions
-      EXTENSIONS
-    end
-
-    def deserialize(data, options = {}, &block)
-      default_resource_index = options.fetch(:default_resource_index) {
-        ResourceIndex.openbel_published_index('20131211')
-      }
-
-      @json_reader.new(data).each.lazy.select { |obj|
-        obj.include?(:nodes) && obj.include?(:edges)
-      }.flat_map { |graph|
-        unwrap(graph, default_resource_index)
-      }
-    end
-
-    def serialize(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!
-
-      json_writer = @json_writer.new
-      writer     << json_writer.write_json_object(
-        {
-          :graph => graph
-        }
-      )
-      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.annotation_definitions = 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.namespace_definitions = namespaces if namespaces
-
-        ::BEL::Model::Evidence.create(
-          :bel_statement => bel_statement,
-          :metadata      => metadata,
-          :references    => references
-        )
-      }
-    end
-
-    # Load the most suitable JSON implementation available within ruby.
-    # The load order attempted is:
-    # - oj              (provides stream parsing utilizing event callbacks)
-    # - TODO jrjackson  (stream parsing support for JRuby)
-    # - multi_json      (simple buffering abstraction over multiple ruby libraries)
-    # - json            (stock ruby implementation)
-    def load_implementation_module!
-      impl_modules  = [
-        'json/oj',
-        'json/jrjackson',
-        'json/multi_json',
-        'json/ruby_json'
-      ]
-
-      load_success = impl_modules.any? { |impl_module|
-        begin
-          require_relative impl_module
-          true
-        rescue LoadError
-          # Could not load +impl_module+; try the next one
-          false
-        end
-      }
-
-      if load_success
-        BEL::Extension::Format::JSONImplementation
-      else
-        mod_s = impl_modules.join(', ')
-        msg   = "Could not load any JSON implementation (tried: #{mod_s})."
-        raise LoadError.new(msg)
-      end
-    end
-  end
-
-  register_formatter(FormatJGF.new)
-end

data/lib/bel/extensions/json/jrjackson.rb

@@ -1,31 +0,0 @@
-require 'jrjackson'
-# XXX Fake impl
-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).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/json/json.rb

@@ -1,133 +0,0 @@
-require 'bel/evidence_model'
-require 'bel/namespace'
-require 'bel/script'
-
-module BEL::Extension::Format
-
-  class FormatJSON
-
-    include Formatter
-    ID            = :json
-    MEDIA_TYPES   = %i(application/json)
-    EXTENSIONS    = %i(json)
-    EVIDENCE_ROOT = :evidence
-
-    def initialize
-      json_module = load_implementation_module!
-      @json_reader = json_module::JSONReader
-      @json_writer = json_module::JSONWriter
-    end
-
-    def id
-      ID
-    end
-
-    def media_types
-      MEDIA_TYPES
-    end
-
-    def file_extensions
-      EXTENSIONS
-    end
-
-    def deserialize(data)
-      @json_reader.new(data).each.lazy.select { |obj|
-        obj.include?(:evidence)
-      }.map { |hash|
-        unwrap(hash)
-      }
-    end
-
-    def serialize(objects, writer = StringIO.new)
-      json_writer = @json_writer.new
-      # json array start
-      writer << "["
-
-      # json objects
-      begin
-        evidence_enum = objects.each
-
-        # write first evidence
-        evidence = evidence_enum.next
-        writer  << json_writer.write_json_object(wrap(evidence))
-
-        # each successive evidence starts with a comma
-        while true
-          evidence = evidence_enum.next
-          writer  << ","
-          writer  << json_writer.write_json_object(wrap(evidence))
-        end
-      rescue StopIteration
-        # end of evidence hashes
-      end
-
-      # json array end
-      writer << "]"
-      writer
-    end
-
-    private
-
-    # Load the most suitable JSON implementation available within ruby.
-    # The load order attempted is:
-    # - oj              (provides stream parsing utilizing event callbacks)
-    # - TODO jrjackson  (stream parsing support for JRuby)
-    # - multi_json      (simple buffering abstraction over multiple ruby libraries)
-    # - json            (stock ruby implementation)
-    def load_implementation_module!
-      impl_modules  = [ 'oj', 'jrjackson', 'multi_json', 'ruby_json' ]
-
-      load_success = impl_modules.any? { |impl_module|
-        begin
-          require_relative impl_module
-          true
-        rescue LoadError
-          # Could not load +impl_module+; try the next one
-          false
-        end
-      }
-
-      if load_success
-        BEL::Extension::Format::JSONImplementation
-      else
-        mod_s = impl_modules.join(', ')
-        msg   = "Could not load any JSON implementation (tried: #{mod_s})."
-        raise LoadError.new(msg)
-      end
-    end
-
-    def wrap(evidence)
-      hash = evidence.to_h
-      {
-        EVIDENCE_ROOT => {
-          :bel_statement      => hash[:bel_statement].to_s,
-          :citation           => hash[:citation],
-          :summary_text       => hash[:summary_text],
-          :experiment_context => hash[:experiment_context],
-          :references         => hash[:references],
-          :metadata           => hash[:metadata]
-        }
-      }
-    end
-
-    def unwrap(hash)
-      evidence_hash          = hash[EVIDENCE_ROOT]
-      evidence               = ::BEL::Model::Evidence.create(evidence_hash)
-      namespace_definitions  = evidence.references.namespace_definitions
-      evidence.bel_statement = ::BEL::Script.parse(
-        "#{evidence.bel_statement}\n",
-        Hash[
-          namespace_definitions.map { |k, v|
-            [k, BEL::Namespace::NamespaceDefinition.new(k, v)]
-          }
-        ]
-      ).select { |obj|
-        obj.is_a? ::BEL::Model::Statement
-      }.first
-
-      evidence
-    end
-  end
-
-  register_formatter(FormatJSON.new)
-end

data/lib/bel/extensions/json/multi_json.rb

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

data/lib/bel/extensions/json/oj.rb

@@ -1,68 +0,0 @@
-require 'oj'
-
-module BEL::Extension::Format
-  module JSONImplementation
-
-    class JSONReader
-      def initialize(data)
-        @data = data
-      end
-
-      def each(&block)
-        if block_given?
-          Oj.sc_parse(EvidenceHandler.new(block), @data, :symbol_keys => true)
-        else
-          to_enum(:each)
-        end
-      end
-    end
-
-    class JSONWriter
-
-      def write_json_object(json_object)
-        Oj.dump(json_object, :mode => :compat)
-      end
-    end
-
-    private
-
-    class EvidenceHandler < Oj::ScHandler
-
-      def initialize(callable)
-        @callable = callable
-      end
-
-      def hash_start
-        {}
-      end
-
-      def hash_end
-        @callable.call @hash 
-      end
-
-      def hash_set(hash, key, value)
-        hash[key]  = value
-        @hash = hash
-      end
-
-      def array_start
-        @array = []
-        @array
-      end
-
-      def array_append(array, value)
-        array << value
-        @array = array
-      end
-
-      def array_end()
-        @callable.call @array
-      end
-
-      def error(message, line, column)
-        msg = "Parse error at line #{line}, column #{column}: #{message}"
-        raise Oj::ParseError.new(msg)
-      end
-    end
-  end
-end