bel_parser 1.0.0.alpha.28-java → 1.0.0.alpha.29-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13215ac795faa5077028725921572827bb24953b
-  data.tar.gz: 94c3c72300afd58322ff396a0ddcb30a8d71109f
+  metadata.gz: 0bc31ba20b70f6f178ef0de0afb03e85a217cf51
+  data.tar.gz: 8b0b3e1498b5612bf671caa7ac99fc275506ba12
 SHA512:
-  metadata.gz: 68c9dba99dad0c8a19c00dfe78b99d8c882a54c55754f87b421e2353495f42e591e167c0473570ec6df12e76c034f7498c4d4216693e560b9442d1abe61b204d
-  data.tar.gz: c490a891dd8cc5bfc2c2abee8d16d49807d19abebb9695ab486059fff6c5b4bd4022c2c489ce0759a1d3c1deb86c10bafa26b14380729dc06527a52ff44ff77d
+  metadata.gz: c7aa0257dbba3e9f3228a18c03a9e4de0c461be5599e097525cd5b937a2bb7287a0c706ca40c3762244e780213d38584bac53c8598b9121ac9ddc18763d1502a
+  data.tar.gz: 306cbf52c38ea63a5e2e34b4b44a9b3a2a39727f394595530173120fa676ccc38ca579e90201bbdadd6ffbaad7ad82fbdf9ce028df7f4ec9bc6b27073a548324

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha.28
+1.0.0.alpha.29

data/lib/bel_parser/ast_filter.rb

@@ -8,14 +8,14 @@ module BELParser
       @types    = types
     end
 
-    def each
+    def each(enum = @ast_enum)
       if block_given?
-        @ast_enum.each do |(line_number, line, ast_results)|
+        enum.each do |(line_number, line, ast_results)|
           selected = filter(ast_results)
           yield([line_number, line, selected]) unless selected.empty?
         end
       else
-        enum_for(:each)
+        enum_for(:each, enum)
       end
     end
 

data/lib/bel_parser/expression/filter.rb

@@ -27,5 +27,29 @@ module BELParser
         end
       end
     end
+
+    def self.filter
+      BELParser::ASTFilter.new(nil, *Filter::TYPES)
+    end
+
+    def self.parameter_filter
+      BELParser::ASTFilter.new(
+        nil,
+        BELParser::Parsers::AST::Parameter.ast_type)
+    end
+
+    def self.term_filter
+      BELParser::ASTFilter.new(
+        nil,
+        BELParser::Parsers::AST::Term.ast_type)
+    end
+
+    def self.statement_filter
+      BELParser::ASTFilter.new(
+        nil,
+        BELParser::Parsers::AST::SimpleStatement.ast_type,
+        BELParser::Parsers::AST::ObservedTerm.ast_type,
+        BELParser::Parsers::AST::NestedStatement.ast_type)
+    end
   end
 end

data/lib/bel_parser/expression/model/namespace.rb

@@ -1,3 +1,4 @@
+require 'bel_parser/quoting'
 require 'bel_parser/resource'
 
 module BELParser
@@ -84,6 +85,19 @@ module BELParser
           @keyword.to_s
         end
       end
+
+      module Converters
+        include BELParser::Quoting
+
+        def ast_to_namespace(ast)
+          return nil if ast.nil? ||
+            !ast.is_a?(BELParser::Parsers::AST::NamespaceDefinition)
+          keyword, domain = ast.children
+          # TODO Support URI when it's an available domain.
+          url = domain.child.string.string_literal
+          Namespace.new(keyword, nil, unquote(url))
+        end
+      end
     end
   end
 end

data/lib/bel_parser/expression/model/parameter.rb

@@ -21,6 +21,12 @@ module BELParser
           @value     = value
         end
 
+        def encoding
+          nsv = @namespace[@value]
+          return nil unless nsv
+          nsv.first.encodings
+        end
+
         def valid?
           return false unless @value
           return true unless @namespace
@@ -46,7 +52,7 @@ module BELParser
         end
         alias_method :eql?, :'=='
 
-        def to_s(_)
+        def to_s(_ = :short)
           if @namespace
             prefix = "#{@namespace.keyword}:"
           else
@@ -55,6 +61,26 @@ module BELParser
           %Q{#{prefix}#{quote_if_needed(@value)}}
         end
       end
+
+      module Converters
+        include BELParser::Quoting
+
+        def ast_to_parameter(ast, namespace_hash = {})
+          return nil if ast.nil? ||
+            !ast.is_a?(BELParser::Parsers::AST::Parameter)
+          prefix, value = ast.children
+          namespace =
+            if prefix.identifier
+              keyword = prefix.identifier.string_literal
+              namespace_hash[keyword]
+            else
+              nil
+            end
+          Parameter.new(
+            namespace,
+            unquote(value.children[0].string_literal))
+        end
+      end
     end
   end
 end

data/lib/bel_parser/expression/model/statement.rb

@@ -1,3 +1,5 @@
+require 'bel_parser/quoting'
+
 module BELParser
   module Expression
     module Model
@@ -42,6 +44,7 @@ module BELParser
           @comment      = comment
 
           if @relationship && !@object
+            require 'pry'; binding.pry
             raise(
               ArgumentError,
               "object must be set when specifying a relationship")
@@ -109,6 +112,48 @@ module BELParser
           comment ? lbl + ' //' + comment : lbl
         end
       end
+
+      module Converters
+        include BELParser::Quoting
+        include BELParser::Parsers::AST
+
+        def ast_to_statement(ast, spec, namespaces = {})
+          statement =
+            case ast
+            when BELParser::Parsers::AST::Statement
+              ast
+            when ObservedTerm, SimpleStatement, NestedStatement
+              ast.statement
+            else
+              nil
+            end
+          return nil if statement.nil?
+
+          spec ||= BELParser::Language.latest_supported_specification
+
+          Statement.new(
+            ast_to_term(statement.subject.term, spec, namespaces),
+            convert_relationship(statement.relationship, spec),
+            convert_object(statement.object, spec, namespaces),
+            statement.comment && statement.comment.children[0])
+        end
+
+        def convert_relationship(ast, spec)
+          relationship = ast.string_literal
+          relationship && spec.relationship(relationship.to_sym)
+        end
+
+        def convert_object(ast, spec, namespaces)
+          case
+          when ast.term?
+            ast_to_term(ast.child, spec, namespaces)
+          when ast.statement?
+            ast_to_statement(ast.child, spec, namespaces)
+          else
+            nil
+          end
+        end
+      end
     end
   end
 end

data/lib/bel_parser/expression/model/term.rb

@@ -1,3 +1,5 @@
+require 'bel_parser/quoting'
+
 module BELParser
   module Expression
     module Model
@@ -46,6 +48,45 @@ module BELParser
           end
         end
       end
+
+      module Converters
+        include BELParser::Quoting
+
+        def ast_to_term(ast, spec, namespaces = {})
+          return nil if ast.nil? ||
+            !ast.is_a?(BELParser::Parsers::AST::Term)
+          spec    ||= BELParser::Language.latest_supported_specification
+          convert   = method(:convert_argument).to_proc.curry[spec][namespaces]
+
+          Term.new(
+            convert_function(ast.function, spec),
+            ast.arguments.map(&convert))
+        end
+
+        def convert_function(ast, spec)
+          func      = ast.identifier.string_literal
+          spec_func = spec.function(func.to_sym)
+
+          unless spec_func
+            raise(
+              ArgumentError,
+              %(ast has invalid function "#{func}" for BEL #{spec.version}))
+          end
+          spec_func
+        end
+
+        def convert_argument(spec, namespaces, argument)
+          child = argument.child
+          case child
+          when BELParser::Parsers::AST::Parameter
+            ast_to_parameter(child, namespaces)
+          when BELParser::Parsers::AST::Term
+            ast_to_term(child, spec, namespaces)
+          else
+            nil
+          end
+        end
+      end
     end
   end
 end

data/lib/bel_parser/expression/parser.rb

@@ -1,31 +1,131 @@
 require_relative '../ast_generator'
+require_relative '../language'
 require_relative '../parsers/common'
 require_relative '../parsers/expression'
+require_relative '../resource'
+require_relative 'filter'
+require_relative 'model'
 
 module BELParser
   module Expression
-    # Parser for BEL Expression.
+
+    def self.parse(
+      input,
+      spec = BELParser::Language.latest_supported_specification,
+      namespaces = {})
+
+      parser = Parser.new(input, Expression.filter, spec, namespaces)
+      parser.parse
+    end
+
+    def self.parse_parameters(
+      input,
+      spec = BELParser::Language.latest_supported_specification,
+      namespaces = {})
+
+      parser = Parser.new(input, Expression.parameter_filter, spec, namespaces)
+      parser.parse
+    end
+
+    def self.parse_terms(
+      input,
+      spec = BELParser::Language.latest_supported_specification,
+      namespaces = {})
+
+      parser = Parser.new(input, Expression.term_filter, spec, namespaces)
+      parser.parse
+    end
+
+    def self.parse_statements(
+      input,
+      spec = BELParser::Language.latest_supported_specification,
+      namespaces = {})
+
+      parser = Parser.new(input, Expression.statement_filter, spec, namespaces)
+      parser.parse
+    end
+
+    # Parser for BEL expressions that return common objects.
     class Parser
-      def parse(input, &block)
-        case input
-        when String
-          parse_string(input, &block)
+      include BELParser::Expression::Model::Converters
+      include BELParser::Parsers::AST
+
+      def initialize(
+        input,
+        filter     = Expression.filter,
+        spec       = BELParser::Language.latest_supported_specification,
+        namespaces = {})
+
+        @input      = input
+        @filter     = filter
+        @spec       = spec
+        @namespaces = namespaces
+      end
+
+      def parse
+        case @input
+        when ::String # conflicts with ...AST::String
+          convert_ast(
+            @spec,
+            @namespaces,
+            parse_string(@input, @filter).first)
         when Array
-          parse_array(input, &block)
+          convert_multiple(
+            parse_array(@input, @filter),
+            @spec,
+            @namespaces)
         when IO, StringIO
-          parse_io(input, &block)
+          convert_stream(
+            parse_io(@input, @filter),
+            @spec,
+            @namespaces)
         else
           raise ArgumentError,
-            %(expected "input" to be one of String, Array, IO: #{input.class})
+            %(expected "input" to be one of String, Array, IO: #{@input.class})
         end
       end
 
-      protected
+      private
+
+      def convert_ast(spec, namespaces, ast)
+        case ast
+        when Parameter
+          ast_to_parameter(ast, namespaces)
+        when Term
+          ast_to_term(ast, spec, namespaces)
+        when Statement, ObservedTerm, SimpleStatement, NestedStatement
+          ast_to_statement(ast, spec, namespaces)
+        else
+          nil
+        end
+      end
 
-      def parse_string(string)
-        filter = Filter.new(
+      def convert_multiple(asts, spec, namespaces)
+        mult = method(:convert_ast).to_proc.curry[spec][namespaces]
+        asts.lazy.map do |ast|
+          if ast.respond_to?(:each)
+            ast.map(&mult)
+          else
+            convert_ast(spec, namespaces, ast)
+          end
+        end
+      end
+
+      def convert_stream(asts, spec, namespaces)
+        mult = method(:convert_ast).to_proc.curry[spec][namespaces]
+        asts.lazy.flat_map do |ast|
+          if ast.respond_to?(:each)
+            ast.map(&mult)
+          else
+            convert_ast(spec, namespaces, ast)
+          end
+        end
+      end
+
+      def parse_string(string, filter)
+        enum = filter.each(
           BELParser::ASTGenerator.new(StringIO.new(string)))
-        num, line, results = filter.each.first
+        num, line, results = enum.first
         if block_given?
           yield results
           nil
@@ -34,28 +134,28 @@ module BELParser
         end
       end
 
-      def parse_array(array)
+      def parse_array(array, filter)
         if block_given?
           array.each do |expression|
-            yield parse_string(expression.to_s)
+            yield parse_string(expression.to_s, filter)
           end
           nil
         else
           array.map do |expression|
-            parse_string(expression.to_s)
+            parse_string(expression.to_s, filter)
           end
         end
       end
 
-      def parse_io(io)
+      def parse_io(io, filter)
         if block_given?
-          filter = Filter.new(BELParser::ASTGenerator.new(io))
-          filter.each do |(num, line, results)|
+          enum = filter.each(BELParser::ASTGenerator.new(io))
+          enum.each do |(num, line, results)|
             yield results
           end
           nil
         else
-          enum_for(:parse_io, io)
+          enum_for(:parse_io, io, filter)
         end
       end
     end
@@ -63,10 +163,7 @@ module BELParser
 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
+  BELParser::Expression.parse($stdin).each do |obj|
+    puts "  #{obj.class.name.split('::')[-1]}: #{obj}"
   end
 end

data/lib/bel_parser/language.rb

@@ -61,6 +61,15 @@ module BELParser
       versions.max_by { |version| version.to_f }
     end
 
+    # Returns the latest supported specification according to the
+    # _MAJOR.MINOR_ pattern.
+    #
+    # @return [Specification] latest supported specification
+    def self.latest_supported_specification
+      latest_version = versions.max_by { |version| version.to_f }
+      specification(latest_version)
+    end
+
     # Returns all language {Specification specifications}.
     #
     # @return [Array<Specification>] BEL specifications

data/lib/bel_parser/resource/jena_tdb_reader.rb

@@ -44,9 +44,7 @@ module BELParser
             pref_label = solution.object.to_s
           end
         end
-        return nil unless types.any? do |type_uri|
-          type_uri == BELV.AnnotationConceptScheme || type_uri == BELV.NamespaceConceptScheme
-        end
+        return nil unless types.any?(&method(:scheme_class?))
         ConceptScheme.new(uri, domain, prefix, pref_label, types)
       end
 
@@ -74,6 +72,10 @@ module BELParser
 
       private
 
+      def scheme_class?(uri)
+        uri == BELV.AnnotationConceptScheme || uri == BELV.NamespaceConceptScheme
+      end
+
       def find_value_uris(resource_uri, value)
         VALUE_PREDICATE_ORDER.each do |predicate|
           subjects =

data/lib/bel_parser/resource/resource_url_reader.rb

@@ -41,7 +41,9 @@ module BELParser
       # @param  [String] resource_identifier the resource identifier
       # @return [FileResource] the file resource
       def retrieve_resource(resource_identifier)
-        read_resource(resource_identifier)[:dataset]
+        dataset = read_resource(resource_identifier)[:dataset]
+        return nil if dataset.types.all?(&:nil?)
+        dataset
       end
 
       def retrieve_value_from_resource(resource_identifier, value)
@@ -54,6 +56,7 @@ module BELParser
       def retrieve_values_from_resource(resource_identifier)
         resource = read_resource(resource_identifier)
         dataset  = resource[:dataset]
+        return nil if resource[:values].size.zero?
         resource[:values].lazy.map do |value, encoding|
           FileResourceValue.new(dataset, value, encoding)
         end

data/lib/bel_parser/resource/sparql_reader.rb

@@ -37,8 +37,10 @@ module BELParser
         sparql_query     = RESOLVE_CONCEPT.result(template_binding)
         concept_scheme   = retrieve_resource(resource_identifier)
         to_concept       = method(:hash_to_concept).to_proc.curry[concept_scheme]
+        concepts         = execute_select(sparql_query).map(&to_concept).compact
 
-        execute_select(sparql_query).map(&to_concept)
+        return nil if concepts.empty?
+        concepts
       end
 
       def retrieve_values_from_resource(resource_identifier)
@@ -47,8 +49,10 @@ module BELParser
         sparql_query     = RESOLVE_CONCEPTS.result(template_binding)
         concept_scheme   = retrieve_resource(resource_identifier)
         to_concept       = method(:hash_to_concept).to_proc.curry[concept_scheme]
+        concepts         = execute_select(sparql_query).map(&to_concept).compact
 
-        execute_select(sparql_query).map(&to_concept)
+        return nil if concepts.empty?
+        concepts
       end
 
       protected

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bel_parser
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha.28
+  version: 1.0.0.alpha.29
 platform: java
 authors:
 - Anthony Bargnesi