bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/expression/parser.rb

@@ -0,0 +1,72 @@
+require_relative '../ast_generator'
+require_relative '../parsers/common'
+require_relative '../parsers/expression'
+
+module BELParser
+  module Expression
+    # Parser for BEL Expression.
+    class Parser
+      def parse(input, &block)
+        case input
+        when String
+          parse_string(input, &block)
+        when Array
+          parse_array(input, &block)
+        when IO, StringIO
+          parse_io(input, &block)
+        else
+          raise ArgumentError,
+            %(expected "input" to be one of String, Array, IO: #{input.class})
+        end
+      end
+
+      protected
+
+      def parse_string(string)
+        filter = Filter.new(
+          BELParser::ASTGenerator.new(StringIO.new(string)))
+        num, line, results = filter.each.first
+        if block_given?
+          yield results
+          nil
+        else
+          results
+        end
+      end
+
+      def parse_array(array)
+        if block_given?
+          array.each do |expression|
+            yield parse_string(expression.to_s)
+          end
+          nil
+        else
+          array.map do |expression|
+            parse_string(expression.to_s)
+          end
+        end
+      end
+
+      def parse_io(io)
+        if block_given?
+          filter = Filter.new(BELParser::ASTGenerator.new(io))
+          filter.each do |(num, line, results)|
+            yield results
+          end
+          nil
+        else
+          enum_for(:parse_io, io)
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  BELParser::Expression::Parser.new.each($stdin) do |(line_number, line, res)|
+    puts "#{line_number}: #{line}"
+    res.each do |ast|
+      puts ast.to_s(1)
+    end
+  end
+end

data/lib/bel_parser/expression/validator.rb

@@ -0,0 +1,79 @@
+require_relative '../ast_filter'
+require_relative '../ast_generator'
+require_relative '../parsers/expression'
+require_relative '../language'
+require_relative '../language/expression_validator'
+
+module BELParser
+  module Expression
+    # Parser for BEL Expression.
+    class Validator
+      include BELParser::Parsers::Common
+      include BELParser::Parsers::Expression
+
+      TYPES = [
+        :parameter,
+        :term,
+        :simple_statement,
+        :observed_term,
+        :nested_statement
+      ]
+
+      def initialize(specification_version, namespaces, resource_reader)
+        @spec      = BELParser::Language.specification(specification_version)
+        @validator = BELParser::Language::ExpressionValidator.new(
+          @spec, namespaces, resource_reader)
+      end
+
+      def each(io)
+        if block_given?
+          filter = BELParser::ASTFilter.new(
+            BELParser::ASTGenerator.new(io),
+            *TYPES)
+          filter.each do |(num, line, results)|
+            results.each do |ast|
+              yield [num, line, ast, @validator.validate(ast)]
+            end
+          end
+        else
+          enum_for(:each, io)
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  unless ARGV.first
+    program = File.basename($PROGRAM_NAME)
+    $stderr.puts <<-USAGE.gsub(/ {6}/, '')
+      usage: #{program} [BEL specification version] [PREFIX=URI]...
+    USAGE
+    exit 1
+  end
+
+  require 'bel_parser/resource/resource_url_reader'
+
+  resource_reader = BELParser::Resource::ResourceURLReader.new
+  namespaces      =
+    Hash[
+      ARGV[1..-1]
+      .map do |ns|
+        prefix, identifier = ns.split('=')
+        [prefix, resource_reader.retrieve_resource(identifier)]
+      end
+    ]
+  BELParser::Expression::Validator
+    .new(ARGV.first, namespaces, resource_reader)
+    .each($stdin) do |(line_number, line, ast, results)|
+      results.select { |res| res.is_a? BELParser::Language::Syntax::SyntaxError }
+      puts "#{line_number}: #{line}"
+      puts "  AST Type: #{ast.type}"
+      puts results
+        .map { |r| "#{r}\n" }
+        .join
+        .each_line
+        .map { |l| "  #{l}" }
+        .join
+    end
+end

data/lib/bel_parser/language.rb

@@ -0,0 +1,114 @@
+require_relative 'language/amino_acid'
+require_relative 'language/function'
+require_relative 'language/syntax'
+require_relative 'language/semantics'
+require_relative 'language/signature'
+require_relative 'language/specification'
+require_relative 'language/expression_validator'
+
+module BELParser
+  # Language defines the concepts needed to define, represent, and
+  # validate a BEL specification. This includes:
+  #
+  # - {BELParser::Language::Specification BEL specifications}
+  #   - Functions
+  #   - ReturnTypes
+  #   - Signatures
+  #   - Relationships
+  #   - Encodings
+  #   - Syntax validations
+  #   - Semantic validations
+  # - Generic Syntax validations
+  # - Generic signature validation
+  module Language
+    # Mutex to synchronize creation of BEL specifications.
+    LOCK = Mutex.new
+    private_constant :LOCK
+
+    # Indicates if +version+ is a defined BEL specification.
+    #
+    # @param  [#to_s] version the BEL version string (e.g. +"2.0"+)
+    # @return [Boolean] +true+ if +version+ is defined; +false+ if not
+    def self.defines_version?(version)
+      specification(version)
+      true
+    rescue ArgumentError, LoadError
+      false
+    end
+
+    # Returns all version strings that are defined and supported by this
+    # project.
+    #
+    # @return [Array<String>] BEL language versions
+    def self.versions
+      Dir[
+        File.join(
+          File.expand_path('..', __FILE__),
+          'language',
+          'version*.rb'
+        )
+      ].map do |path|
+        file_name = File.basename(path)
+        file_name.scan(/[0-9]+_[0-9]+/).first.sub('_', '.')
+      end.sort
+    end
+
+    # Returns the latest supported version string according to the
+    # _MAJOR.MINOR_ pattern.
+    #
+    # @return [String] latest supported version
+    def self.latest_supported_version
+      versions.max_by { |version| version.to_f }
+    end
+
+    # Returns all language {Specification specifications}.
+    #
+    # @return [Array<Specification>] BEL specifications
+    def self.specifications
+      versions.map { |version| specification(version) }
+    end
+
+    # Returns the {Specification} for a BEL specification +version+.
+    #
+    # @param  [#to_s] version the BEL version string (e.g. +"2.0"+)
+    # @return [Specification] the BEL specification
+    # @raise  [ArgumentError] if the version string is malformed or is not
+    #         supported
+    # @see    {.defines?}
+    def self.specification(version)
+      version_string         =  version.to_s
+      unless version_string  =~ /^[0-9]+\.[0-9]+/
+        raise ArgumentError, 'Version format incorrect; expecting MAJOR.MINOR'
+      end
+
+      LOCK.synchronize do
+        version_sym           = version_string.to_sym
+        @specs              ||= {}
+        @specs[version_sym] ||= create_specification(version_string)
+        @specs[version_sym]
+      end
+    end
+
+    # Create the {Specification} for a BEL +version+.
+    #
+    # @param  [String] version the BEL version string (e.g. +"2.0"+)
+    # @return [Specification] the BEL specification
+    # @raise  [ArgumentError] if the version string is malformed or is not
+    #         supported
+    # @see    {.defines?}
+    def self.create_specification(version)
+      major, minor = version.split('.')
+      version_file = "language/version#{major}_#{minor}"
+
+      begin
+        require_relative version_file
+        version_const  = :"Version#{major}_#{minor}"
+        version_module = BELParser::Language.const_get(version_const)
+        version_module::Specification.new
+      rescue LoadError
+        raise ArgumentError, "Version #{version} is not supported."
+      end
+    end
+    private_class_method :create_specification
+  end
+end

data/lib/bel_parser/language/amino_acid.rb

@@ -0,0 +1,68 @@
+module BELParser
+  module Language
+    # AminoAcid defines a controlled vocabulary of twenty Amino Acids that are
+    # encoded by the universal genetic code. It does not contain the additional
+    # Amino Acids incorporated into proteins by synthetic means.
+    #
+    # see https://en.wikipedia.org/wiki/Amino_acid
+    module AminoAcid
+      Alanine       = [:Alanine, :A, :Ala].freeze
+      Arginine      = [:Arginine, :R, :Arg].freeze
+      Asparagine    = [:Asparagine, :N, :Asn].freeze
+      AsparticAcid  = [:'Aspartic Acid', :D, :Asp].freeze
+      Cysteine      = [:Cysteine, :C, :Cys].freeze
+      GlutamicAcid  = [:'Glutamic Acid', :E, :Glu].freeze
+      Glutamine     = [:Glutamine, :Q, :Gln].freeze
+      Glycine       = [:Glycine, :G, :Gly].freeze
+      Histidine     = [:Histidine, :H, :His].freeze
+      Isoleucine    = [:Isoleucine, :I, :Ile].freeze
+      Leucine       = [:Leucine, :L, :Leu].freeze
+      Lysine        = [:Lysine, :K, :Lys].freeze
+      Methionine    = [:Methionine, :M, :Met].freeze
+      Phenylalanine = [:Phenylalanine, :F, :Phe].freeze
+      Proline       = [:Proline, :P, :Pro].freeze
+      Serine        = [:Serine, :S, :Ser].freeze
+      Threonine     = [:Threonine, :T, :Thr].freeze
+      Tryptophan    = [:Tryptophan, :W, :Trp].freeze
+      Tyrosine      = [:Tyrosine, :Y, :Tyr].freeze
+      Valine        = [:Valine, :V, :Val].freeze
+
+      # Determines if +sym+ represents an amino acid code.
+      #
+      # @param [#to_sym] sym amino acid code
+      # @return [Boolean] +true+ if +sym+ amino acid code is included in
+      # supported amino acids; +false+ if not supported
+      def self.includes?(sym)
+        @hash.key?(sym.to_sym)
+      end
+
+      # Gets all supported amino acid names.
+      def self.names
+        @names
+      end
+
+      # Gets all supported amino acid codes (i.e. name, 1-Letter, 3-Letter).
+      def self.values
+        @values
+      end
+
+      unless defined? @hash
+        @hash = {}
+        constants.map(&method(:const_get)).each do |values|
+          @hash.update(
+            Hash[values.map { |v| [v, values.first] }]
+          )
+        end
+        @hash.freeze
+      end
+
+      unless defined? @names
+        @names = constants.map(&method(:const_get)).map(&:first).sort.freeze
+      end
+
+      unless defined? @values
+        @values = constants.map(&method(:const_get)).map(&:to_a).flatten.freeze
+      end
+    end
+  end
+end

data/lib/bel_parser/language/apply_namespace_encoding.rb

@@ -0,0 +1,98 @@
+require 'bel_parser/quoting'
+
+module BELParser
+  module Language
+    # ApplyNamespaceEncoding applies _namespace_ and _encoding_ properties to
+    # {BELParser::Parsers::AST::Parameter} child nodes.
+    class ApplyNamespaceEncoding
+      include AST::Processor::Mixin
+      include BELParser::Quoting
+
+      def initialize(language_spec, namespace_hash, resource_reader)
+        @language_spec   = language_spec
+        @namespace_hash  = namespace_hash
+        @resource_reader = resource_reader
+      end
+
+      def on_observed_term(observed_term_node)
+        process(observed_term_node.statement)
+      end
+
+      def on_simple_statement(simple_statement_node)
+        process(simple_statement_node.statement)
+      end
+
+      def on_nested_statement(nested_statement_node)
+        process(nested_statement_node.statement)
+      end
+
+      def on_statement(statement_node)
+        process(statement_node.subject)
+        process(statement_node.object) if statement_node.object?
+      end
+
+      def on_subject(subject_node)
+        process(subject_node.term)
+      end
+
+      def on_object(object_node)
+        process(object_node.child)
+      end
+
+      # Called when visiting nodes of type +term+.
+      def on_term(term_node)
+        term_node.arguments.each do |argument_node|
+          process(argument_node)
+        end
+      end
+
+      def on_argument(argument_node)
+        process(argument_node.child)
+      end
+
+      def on_parameter(parameter_node)
+        @resolved_dataset = nil
+        @prefix           = nil
+        process(parameter_node.prefix)
+        process(parameter_node.value)
+      end
+
+      def on_prefix(prefix_node)
+        return prefix_node unless prefix_node.identifier
+
+        @prefix    = prefix_node.identifier.string_literal
+        dataset    = @namespace_hash[@prefix]
+        return prefix_node unless dataset
+
+        @resolved_dataset     = dataset
+        prefix_node.namespace = dataset
+
+        prefix_node
+      end
+
+      def on_value(value_node)
+        return value_node unless @resolved_dataset
+        value_node.namespace = @resolved_dataset
+        identifier           = @resolved_dataset.identifier
+        value_literal        = unquote(value_node.children[0].string_literal)
+
+        value =
+          @resource_reader
+          .retrieve_value_from_resource(identifier, value_literal)
+
+        value_node.prefix = @prefix
+        if value
+          value_node.encoding =
+            value
+            .encodings
+            .map(&@language_spec.method(:value_encoding))
+          value_node.namespace_value = value
+        else
+          value_node.encoding        = nil
+          value_node.namespace_value = nil
+        end
+        value_node
+      end
+    end
+  end
+end

data/lib/bel_parser/language/base_specification.rb

@@ -0,0 +1,82 @@
+require_relative 'specification'
+
+module BELParser
+  module Language
+    # BaseSpecification defines behaviour for loading BEL version files.
+    class BaseSpecification
+      include Specification
+
+      def self.load_version_path(version_path)
+        base_path = File.expand_path(File.dirname(__FILE__)) + File::SEPARATOR
+        ['return_types', 'value_encodings', 'functions', 'relationships']
+          .each do |set|
+            Dir[File.join(base_path, version_path, set, '*.rb')]
+              .each do |ruby_file|
+                ruby_file.sub!(/^#{Regexp.escape(base_path)}/, '')
+                require_relative ruby_file
+              end
+          end
+      end
+
+      protected
+
+      def load_language_constants(version_module)
+        load_return_types(version_module)
+        load_value_encodings(version_module)
+        load_functions(version_module)
+        load_relationships(version_module)
+      end
+
+      private
+
+      def load_return_types(version_module)
+        # Collect return types
+        ret_classes =
+          version_module::ReturnTypes.constants.collect do |symbol|
+            const = version_module::ReturnTypes.const_get(symbol)
+            const if const.respond_to?(:subtypes)
+          end
+        @return_types         = ret_classes.compact
+        @indexed_return_types = index_sym(@return_types)
+      end
+
+      def load_value_encodings(version_module)
+        # Collect value encodings
+        enc_classes =
+          version_module::ValueEncodings.constants.collect do |symbol|
+            const = version_module::ValueEncodings.const_get(symbol)
+            const if const.respond_to?(:subtypes)
+          end
+        @value_encodings         = enc_classes.compact
+        @indexed_value_encodings = index_sym(@value_encodings)
+      end
+
+      def load_functions(version_module)
+        # Collect functions
+        function_classes =
+          version_module::Functions.constants.collect do |symbol|
+            const = version_module::Functions.const_get(symbol)
+            const if
+              const.respond_to?(:short) &&
+              const.respond_to?(:long)
+          end
+        @functions         = function_classes.compact
+        @indexed_functions = index_long_short(@functions)
+      end
+
+      def load_relationships(version_module)
+        # Collect relationships
+        rel_classes =
+          version_module::Relationships.constants.collect do |symbol|
+            const = version_module::Relationships.const_get(symbol)
+            const if
+              const.respond_to?(:short) &&
+              const.respond_to?(:long)
+          end
+        @relationships         = rel_classes.compact
+        @indexed_relationships = index_long_short(@relationships)
+        assign_relationship_categories(@relationships)
+      end
+    end
+  end
+end