bel 0.3.3 → 0.4.0.beta1

data/lib/bel/extension.rb

@@ -1,37 +0,0 @@
-module BEL
-
-  # The {Extension} module defines specific areas of customization within the
-  # *bel* gem:
-  #
-  # - Document formats: see {BEL::Extension::Format}
-  module Extension
-
-    # Loads BEL extensions from the +$LOAD_PATH+ under the path
-    # +bel/extensions/{extension}+. These extensions are merely ruby scripts
-    # meant to extend functionality within the *bel* gem.
-    #
-    # For example, let's say we created the foo.rb file containing a Foo
-    # extension. We must do the following to load it:
-    #
-    # - Locate foo.rb at +bel/extensions/foo.rb+ anywhere on the +$LOAD_PATH+.
-    # - Instantiate and register our extension.
-    # - Call +BEL.extension :foo+ to load the extension.
-    #
-    # @param [Array<#to_s>] extensions the extensions to load
-    def self.load_extension(*extensions)
-      extensions.each do |ext|
-        Kernel.require "bel/extensions/#{ext}"
-      end
-    end
-
-    class ExtensionRegistrationError < StandardError
-
-      attr_reader :extension
-
-      def initialize(extension, msg = "Extension error for #{extension}")
-        super(msg)
-        @extension = extension
-      end
-    end
-  end
-end

data/lib/bel/extension_format.rb

@@ -1,207 +0,0 @@
-module BEL
-  module Extension
-
-    # The {Format} module defines a framework for adding new document formats.
-    # This is useful when reading, writing, and {BEL::Translation translating}
-    # BEL data.
-    #
-    # A {Format} extension is defined and registered in the following steps:
-    #
-    # - Create a ruby source file located under +bel/extensions/+ on the
-    #   +$LOAD_PATH+.
-    # - Within the file, create a class that implements the protocol specified
-    #   by {Format::Formatter}.
-    # - Instantiate and register your format extension by calling
-    #   {Format.register_formatter}.
-    #
-    # To see how to define a new format extension have a look at the
-    # {Format::Formatter} module.
-    #
-    module Format
-
-      FORMATTER_MUTEX = Mutex.new
-      private_constant :FORMATTER_MUTEX
-
-      # Registers the +formatter+ object as available to callers. The
-      # +formatter+ should respond to the methods defined in the
-      # {Format::Formatter} module.
-      #
-      # @param  [Format::Formatter] formatter the formatter to register
-      # @return [Format::Formatter] the +formatter+ parameter is returned
-      #         for convenience
-      def self.register_formatter(formatter)
-        FORMATTER_MUTEX.synchronize {
-          @@formatters ||= []
-          # vivified hash, like: { :foo => { :bar => [] } }
-          @@index ||= (
-            Hash.new do |h0, k0|
-              h0[k0] = Hash.new do |h1, k1|
-                h1[k1] = []
-              end
-            end
-          )
-          
-          if _formatters(formatter.id)
-            raise ExtensionRegistrationError.new(formatter.id)
-          end
-
-          # track registered formatters
-          @@formatters << formatter
-
-          # index formatter by its id
-          @@index[:id][symbolize(formatter.id)] << formatter
-
-          # index formatter by one or more file extensions
-          [formatter.file_extensions].flatten.compact.to_a.each do |file_ext|
-            @@index[:file_extension][symbolize(file_ext)] << formatter
-          end
-
-          # index formatter by one or more media types
-          [formatter.media_types].flatten.compact.to_a.each do |media_type|
-            @@index[:media_type][symbolize(media_type)] << formatter
-          end
-
-          formatter
-        }
-      end
-
-      # Returns the {Format::Formatter formatters} found for the +values+
-      # splat. The returned matches have the same cardinality as the +values+
-      # splat to allow destructuring.
-      #
-      # @example Retrieve a single formatter by id.
-      #   bel_formatter  = Format.formatters(:bel)
-      # @example Retrieve a single formatter by file extension.
-      #   xbel_formatter = Format.formatters(:xml)
-      # @example Retrieve a single formatter by media type.
-      #   json_formatter = Format.formatters(%s(application/json))
-      # @example Retrieve multiple formatters using mixed values.
-      #   belf, xbelf, jsonf = Format.formatters(:bel, :xml, "application/json")
-      #
-      # @param  [Array<#to_s>] values the splat that identifies formatters
-      # @return [Format::Formatter Array<Format::Formatter>] for each
-      #         consecutive value in the +values+ splat; if the +values+ splat
-      #         contains one value then a single formatter reference is returned
-      #         (e.g. not an Array)
-      def self.formatters(*values)
-        FORMATTER_MUTEX.synchronize {
-          _formatters(*values)
-        }
-      end
-
-      def self._formatters(*values)
-        if values.empty?
-          Array.new @@formatters
-        else
-          index = (@@index ||= {})
-          matches = values.map { |value|
-            value = symbolize(value)
-            @@index.values_at(:id, :file_extension, :media_type).
-              compact.
-              inject([]) { |result, coll|
-                if coll.has_key?(value)
-                  result.concat(coll[value])
-                end
-                result
-              }.uniq.first
-          }
-          matches.size == 1 ? matches.first : matches
-        end
-      end
-      private_class_method :_formatters
-
-      def self.symbolize(key)
-        key.to_s.to_sym
-      end
-      private_class_method :symbolize
-
-      # The Formatter module defines methods to be implemented by a format
-      # extension +Class+. It is broken up into three parts:
-      #
-      # - Metadata
-      #   - {#id}:              the runtime-wide unique extension id
-      #   - {#media_types}:     the media types this format supports
-      #   - {#file_extensions}: the file extensions this format supports
-      # - Deserialize
-      #   - {#deserialize}:     read the implemented document format and return
-      #     {::BEL::Model::Evidence} objects
-      # - Serialize
-      #   - {#serialize}:       write {::BEL::Model::Evidence} objects to the
-      #     implemented document format
-      #
-      # @example Typical creation of a {Formatter} class.
-      #   class FormatYAML
-      #     include BEL::Extension::Format::Formatter
-      #     # override methods
-      #   end
-      #
-      # @example Create a YAML format extension.
-      #   class FormatYAML
-      #     include BEL::Extension::Format::Formatter
-      #
-      #     ID          = :yaml
-      #     MEDIA_TYPES = %i(text/yaml)
-      #     EXTENSIONS  = %i(yaml)
-      #
-      #     def id
-      #       ID
-      #     end
-      #
-      #     def media_types
-      #       MEDIA_TYPES
-      #     end
-      #
-      #     def file_extensions
-      #       EXTENSIONS
-      #     end
-      #
-      #     def deserialize(data)
-      #       YAML.load(data)
-      #     end
-      #
-      #     def serialize(data)
-      #       YAML.dump(data)
-      #     end
-      #   end
-      module Formatter
-
-        def id
-          raise NotImplementedError.new("#{__method__} is not implemented.")
-        end
-
-        def media_types
-          # optional
-          nil
-        end
-
-        def file_extensions
-          # optional
-          nil
-        end
-
-        def evidence_hash(object)
-          raise NotImplementedError.new("#{__method__} is not implemented.")
-        end
-
-        def deserialize(data)
-          raise NotImplementedError.new("#{__method__} is not implemented.")
-        end
-
-        def serialize(data, writer = nil)
-          raise NotImplementedError.new("#{__method__} is not implemented.")
-        end
-      end
-
-      # FormatError represents an error when the specified format is not
-      # supported by the {Format} extension framework.
-      class FormatError < StandardError
-
-        FORMAT_ERROR = %Q{Format "%s" is not supported.}
-
-        def initialize(format)
-          super(FORMAT_ERROR % format)
-        end
-      end
-    end
-  end
-end

data/lib/bel/extensions/bel.rb

@@ -1,258 +0,0 @@
-require 'bel'
-
-module BEL::Extension::Format
-
-  class FormatBEL
-
-    include Formatter
-
-    ID          = :bel
-    MEDIA_TYPES = %i(application/bel)
-    EXTENSIONS  = %i(bel)
-    
-    def id
-      ID
-    end
-
-    def media_types
-      MEDIA_TYPES
-    end
-
-    def file_extensions
-      EXTENSIONS
-    end
-
-    def deserialize(data, &block)
-      EvidenceYielder.new(data)
-    end
-
-    def serialize(objects, writer = StringIO.new, options = {})
-      BELYielder.new(objects).each { |bel_part|
-        writer << "#{bel_part}"
-        writer.flush
-      }
-    end
-  end
-
-  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.annotation_definitions[parsed_obj.prefix] = {
-              :type   => parsed_obj.type,
-              :domain => parsed_obj.value
-            }
-          when ::BEL::Namespace::NamespaceDefinition
-            @references.namespace_definitions[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.annotation_definitions[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
-
-  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 namespace_definitions(
-              evidence.references.namespace_definitions
-            )
-            yield annotation_definitions(
-              evidence.references.annotation_definitions
-            )
-            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 annotation_definitions(annotation_definitions)
-      return "" unless annotation_definitions
-
-      annotation_definitions.reduce("") { |bel, (prefix, annotation)|
-        bel << "DEFINE ANNOTATION #{prefix} AS "
-        type   = annotation[:type]   || annotation["type"]
-        domain = annotation[:domain] || annotation["domain"]
-        case type.to_sym
-        when :url
-          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 namespace_definitions(namespace_definitions)
-      return "" unless namespace_definitions
-
-      namespace_definitions.reduce("") { |bel, (prefix, url)|
-        bel << %Q{DEFINE NAMESPACE #{prefix} AS URL "#{url}"\n}
-        bel
-      }
-    end
-
-    def to_bel(evidence)
-      bel = ""
-
-      # Citation
-      citation = evidence.citation
-      if citation && citation.values.any?
-        values = citation.values
-        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
-
-  register_formatter(FormatBEL.new)
-end