bel_parser 1.0.0.alpha.28 → 1.0.0.alpha.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 295069b6ea6197942707dbabab0a7b7d85b36684
-  data.tar.gz: e40f8170bfdd3feb80c49c554a83573ce58dda70
+  metadata.gz: 8a28ecd294f3b135b0e991bea16baa99164d95f8
+  data.tar.gz: a9ccd2c7036603beebebb0789fbafcb5fcdd3f6a
 SHA512:
-  metadata.gz: 711da9e459b181285f15155a59c6aa0ae8fc2cf7fac6ca0e8f7bed727b686b36866cb0897fa1f996b1cc07df9162417660846a4afb245feecdd1f99c0fa4567a
-  data.tar.gz: 9c2ebc3301472e59350139a9e707d903d0f8c2895bc62cc6ffd83b9dc3dbdb4b4401a6ab7065cfabe11820ea603b07c9873655ddb5cde1369b84d017cb576f6e
+  metadata.gz: 35f022dd4fcb5ffe865cf46a12d69c56d8ac4bbf3de00a69b10dfcbfee9824050b599310f00d011c294b780910ca6a9a8f2df8dba08d2a0985431caa01baffcc
+  data.tar.gz: 4e551f7640bb5380430e1119c92fb6338842486095bd65d42758b2d978243c9a300df53e1edb90bdc51f7ff18703775319b2ac8203a2491be94d75553c572ede

data/.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
                                  'Anthony Bargnesi',
                                  'Nick Bargnesi',
                                ]
-  spec.date                  = %q{2016-05-11}
+  spec.date                  = %q{2016-05-13}
   spec.email                 = %q{abargnesi@selventa.com}
   spec.files                 = [
                                  Dir.glob('lib/**/*.{rb,rl}'),

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: ruby
 authors:
 - Anthony Bargnesi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-11 00:00:00.000000000 Z
+date: 2016-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sparql-client