bel_parser 1.0.0.alpha.47-java → 1.0.0.alpha.48-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c2fddeaf52fe437892c924831ae99758ab14b95
-  data.tar.gz: 0e473e2c5900240e0e02e9e8831bfa41a043418e
+  metadata.gz: ea63f6fcf85946d6713d061c08d7413da2f35300
+  data.tar.gz: 884d2ad127e8a8f6b4f6ce84519eb432605c39a9
 SHA512:
-  metadata.gz: 9913e3f53f9feec89720dac1fb43d78c2713e45b75da34a86e59d3a20f1831384ef13b1a13a2db34067e8b36bff4f7752e79d5774f48896ee3948ad7033a23d3
-  data.tar.gz: 16f4963203ecc695f70065a3320c147a32187ae86f7779d72edf39744d47ba8eefa5b34b111b894c083878f719081073a103aad2d308ba30653c486c769f15d6
+  metadata.gz: d93b622bc38d63de8f7a13c77a6f871ea84635014b6ea8db6e513e65db5df11f0da8f6cb02f937e96b0a86c5377490bf676cba0c1419682f1ab5fbdf0fc97a64
+  data.tar.gz: 3b10d096fb15423b9419714dbec613fec3e839c930e89ebec940dc633ba1149362913450725d198edf09786bfaaf6ce3c225c7662b4ebb901ee6c1e95928b620

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha.47
+1.0.0.alpha.48

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

@@ -1,4 +1,3 @@
-require 'bel_parser/quoting'
 require 'bel_parser/resource'
 
 module BELParser
@@ -8,8 +7,6 @@ module BELParser
       # identify parameter values like genes (e.g. _AKT1_),
       # diseases (e.g. _hypertropia_), and processes (e.g. _anaphase_).
       class Namespace
-        include Enumerable
-
         attr_accessor :keyword
         attr_accessor :uri
         attr_accessor :url
@@ -23,11 +20,11 @@ module BELParser
           @url     = url
 
           # configure reader for URIs (RDF).
-          @uri_reader = options.fetch(:uri_reader, nil)
+          @uri_reader = options.fetch(:uri_reader, BELParser::Resource.default_uri_reader)
           BELParser::Resource::Reader.assert_reader(@uri_reader, 'uri_reader')
 
           # configure reader for URLs (Resource files).
-          @url_reader = options.fetch(:url_reader, nil)
+          @url_reader = options.fetch(:url_reader, BELParser::Resource.default_url_reader)
           BELParser::Resource::Reader.assert_reader(@url_reader, 'url_reader')
         end
 
@@ -47,13 +44,33 @@ module BELParser
           !@url.nil?
         end
 
+        def include?(value)
+          resolved_value =
+            if uri? && @uri_reader
+              @uri_reader.retrieve_value_from_resource(@uri, value)
+            elsif url? && @url_reader
+              @url_reader.retrieve_value_from_resource(@url, value)
+            else
+              nil
+            end
+          !resolved_value.nil?
+        end
+
         def [](value)
-          if uri? && @uri_reader
-            @uri_reader.retrieve_value_from_resource(@uri, value)
-          elsif url? && @url_reader
-            @url_reader.retrieve_value_from_resource(@url, value)
+          resolved_value =
+            if uri? && @uri_reader
+              @uri_reader.retrieve_value_from_resource(@uri, value)
+            elsif url? && @url_reader
+              @url_reader.retrieve_value_from_resource(@url, value)
+            else
+              nil
+            end
+
+          if resolved_value
+            value = resolved_value.first
+            Parameter.new(self, value.name, value.encodings)
           else
-            nil
+            Parameter.new(self, value, nil)
           end
         end
 
@@ -68,7 +85,7 @@ module BELParser
                 []
               end
             values.each do |value|
-              yield value
+              yield Parameter.new(self, value.name, value.encodings)
             end
           else
             to_enum(:each)
@@ -96,15 +113,38 @@ module BELParser
       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))
+        def ast_to_namespace(ast, namespace_hash = {})
+          return nil if ast.nil?
+
+          case ast
+          when BELParser::Parsers::AST::Prefix
+            if ast.namespace
+              dataset = ast.namespace
+              case
+              when dataset.uri?
+                Namespace.new(dataset.keyword, dataset.identifier, nil)
+              when dataset.url?
+                Namespace.new(dataset.keyword, nil, dataset.identifier)
+              else
+                Namespace.new(dataset.keyword, nil, nil)
+              end
+            else
+              return nil unless ast.identifier
+              prefix_s = ast.identifier.string_literal
+              namespace_hash[prefix_s]
+            end
+          when BELParser::Parsers::AST::NamespaceDefinition
+            keyword, domain = ast.children
+            keyword_s       = keyword.identifier.string_literal
+            case
+            when domain.uri?
+              uri = domain.child.string_literal
+              Namespace.new(keyword_s, uri, nil)
+            when domain.url?
+              url = domain.child.string_literal
+              Namespace.new(keyword_s, ast.uri, url)
+            end
+          end
         end
       end
     end

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

@@ -8,45 +8,33 @@ module BELParser
         include BELParser::Quoting
         include Comparable
 
-        attr_reader :namespace, :value
+        attr_reader :namespace, :value, :encoding
 
-        def initialize(namespace, value)
-          raise(ArgumentError, 'value is nil') unless value
-          unless namespace.nil? || namespace.is_a?(Namespace)
-            raise(
-              ArgumentError,
-              "namespace: expected nil or Namespace, actual #{namespace.class}")
-          end
+        def initialize(namespace, value, encoding = nil)
+          assert_namespace_type(namespace)
+          assert_value_type(value)
           @namespace = namespace
           @value     = value
+          @encoding  = encoding
         end
 
         def namespace=(namespace)
-          unless namespace.nil? || namespace.is_a?(Namespace)
-            raise(
-              ArgumentError,
-              "namespace: expected nil or Namespace, actual #{namespace.class}")
-          end
-
+          assert_namespace_type(namespace)
           @namespace = namespace
         end
 
         def value=(value)
-          raise(ArgumentError, 'value is nil') unless value
-
+          assert_value_type(value)
           @value = value
         end
 
-        def encoding
-          nsv = @namespace[@value]
-          return nil unless nsv
-          nsv.first.encodings
+        def valid?
+          return true if @namespace.nil?
+          @namespace.include?(@value)
         end
 
-        def valid?
-          return false unless @value
-          return true unless @namespace
-          !@namespace[@value].nil?
+        def invalid?
+          !valid?
         end
 
         def <=>(other)
@@ -76,24 +64,30 @@ module BELParser
           end
           %Q{#{prefix}#{quote_if_needed(@value)}}
         end
+
+        private
+
+        def assert_namespace_type(namespace)
+          unless namespace.nil? || namespace.is_a?(Namespace)
+            msg = "namespace: expected nil or Namespace, actual #{namespace.class}"
+            raise(ArgumentError, msg)
+          end
+        end
+
+        def assert_value_type(value)
+          unless value.is_a?(String)
+            msg = "value: expected String, actual #{value.class}"
+            raise(ArgumentError, msg)
+          end
+        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
-              namespace_hash[prefix.identifier.string_literal]
-            else
-              nil
-            end
-          Parameter.new(
-            namespace,
-            value.children[0].string_literal)
+          namespace = ast_to_namespace(ast.prefix, namespace_hash)
+          namespace[ast.value.children[0].string_literal]
         end
       end
     end

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

@@ -25,8 +25,12 @@ module BELParser
         # @param [Term, Statement] object
         # @param [String] comment
         def initialize(subject, relationship = nil, object = nil, comment = nil)
-          raise(ArgumentError, 'subject is nil') unless subject
-          @subject      = subject
+          if subject.nil? || !subject.is_a?(Term)
+            raise(
+              ArgumentError,
+              "subject: expected Term, actual #{subject.class}")
+          end
+          @subject = subject
 
           unless relationship.nil? || relationship.is_a?(BELParser::Language::Relationship)
             raise(
@@ -68,8 +72,29 @@ module BELParser
           @object && @object.is_a?(Statement)
         end
 
+        def namespaces
+          ns = @subject.namespaces
+          ns.concat(@object.namespaces) unless @object.nil?
+          ns
+        end
+
+        def validation(
+          spec       = BELParser::Language.latest_supported_specification,
+          uri_reader = BELParser::Resource.default_uri_reader,
+          url_reader = BELParser::Resource.default_url_reader)
+
+          validator =
+            BELParser::Expression::Validator.new(
+              spec,
+              Hash[namespaces.map { |ns| [ns.keyword, ns] }],
+              uri_reader,
+              url_reader)
+          _, _, _, result = validator.each(StringIO.new("#{to_s}\n")).first
+          result
+        end
+
         def valid?
-          # TODO Use expression validator.
+          @subject.valid? && @object.valid?
         end
 
         def hash

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

@@ -1,3 +1,5 @@
+require_relative '../validator'
+
 module BELParser
   module Expression
     module Model
@@ -17,7 +19,7 @@ module BELParser
               ArgumentError,
               %(function: expected Function, actual #{function.class}))
           end
-          @function  = function
+          @function = function
         end
 
         def arguments=(*args)
@@ -25,7 +27,7 @@ module BELParser
           invalid = args.any?(&method(:invalid_argument?))
           raise(
             ArgumentError,
-            'args must be Parameter or Term objects') if invalid
+            "args: expected Parameter or Term objects") if invalid
 
           @arguments = args
         end
@@ -33,12 +35,50 @@ module BELParser
         def <<(arg)
             raise(
               ArgumentError,
-              'argument must be Parameter or Term') if invalid_argument?(arg)
+              'arg: expected Parameter or Term') if invalid_argument?(arg)
           @arguments << item
         end
 
-        def valid?
-          # TODO Use expression validator.
+        def namespaces
+          @arguments.flat_map do |arg|
+            case arg
+            when Term
+              arg.namespaces
+            when Parameter
+              arg.namespace
+            end
+          end
+        end
+
+        def validation(
+          spec       = BELParser::Language.latest_supported_specification,
+          uri_reader = BELParser::Resource.default_uri_reader,
+          url_reader = BELParser::Resource.default_url_reader)
+
+          validator =
+            BELParser::Expression::Validator.new(
+              spec,
+              Hash[namespaces.map { |ns| [ns.keyword, ns] }],
+              uri_reader,
+              url_reader)
+          _, _, _, result = validator.each(StringIO.new("#{to_s}\n")).first
+          result
+        end
+
+        def valid?(
+          spec       = BELParser::Language.latest_supported_specification,
+          uri_reader = BELParser::Resource.default_uri_reader,
+          url_reader = BELParser::Resource.default_url_reader)
+
+          validation(spec, uri_reader, url_reader).valid?
+        end
+
+        def invalid?(
+          spec = BELParser::Language.latest_supported_specification,
+          uri_reader = BELParser::Resource.default_uri_reader,
+          url_reader = BELParser::Resource.default_url_reader)
+
+          !validation(spec, uri_reader, url_reader).valid?
         end
 
         def hash
@@ -66,8 +106,7 @@ module BELParser
         private
 
         def invalid_argument?(arg)
-          !arg.is_a?(BELParser::Expression::Model::Parameter) &&
-            !arg.is_a?(BELParser::Expression::Model::Term)
+          arg.nil? || [Parameter, Term].none? { |type| arg.is_a?(type) }
         end
       end
 

data/lib/bel_parser/expression/parser.rb

@@ -165,7 +165,19 @@ module BELParser
 end
 
 if __FILE__ == $PROGRAM_NAME
-  BELParser::Expression.parse($stdin).each do |obj|
-    puts "  #{obj.class.name.split('::')[-1]}: #{obj}"
-  end
+  namespaces =
+    Hash[
+      ARGV.map do |ns|
+        keyword, uri = ns.split('=')
+        [keyword, BELParser::Expression::Model::Namespace.new(keyword, uri, nil)]
+      end.compact
+    ]
+
+  BELParser::Expression.parse(
+    $stdin,
+    BELParser::Language.latest_supported_specification,
+    namespaces
+  ).each do |obj|
+      puts "  #{obj.class.name.split('::')[-1]}: #{obj}"
+    end
 end

data/lib/bel_parser/expression/validator.rb

@@ -3,6 +3,7 @@ require_relative '../ast_generator'
 require_relative '../parsers/expression'
 require_relative '../language'
 require_relative '../language/expression_validator'
+require_relative 'model'
 
 module BELParser
   module Expression
@@ -52,27 +53,24 @@ if __FILE__ == $PROGRAM_NAME
     exit 1
   end
 
-  uri_reader = BELParser::Resource.default_uri_reader
-  url_reader = BELParser::Resource.default_url_reader
-  namespaces      =
+  namespaces =
     Hash[
       ARGV[1..-1]
       .map do |ns|
-        prefix, identifier = ns.split('=')
-        [prefix, uri_reader.retrieve_resource(identifier)]
+        keyword, identifier = ns.split('=')
+        [keyword, BELParser::Expression::Model::Namespace.new(keyword, identifier, nil)]
       end
     ]
+
   BELParser::Expression::Validator
-    .new(ARGV.first, namespaces, uri_reader, url_reader)
-    .each($stdin) do |(line_number, line, ast, results)|
-      results.select { |res| res.is_a? BELParser::Language::Syntax::SyntaxError }
+    .new(
+      BELParser::Language.specification(ARGV.first),
+      namespaces,
+      BELParser::Resource.default_uri_reader,
+      BELParser::Resource.default_url_reader)
+    .each($stdin) do |(line_number, line, ast, result)|
       puts "#{line_number}: #{line}"
-      puts "  AST Type: #{ast.type}"
-      puts results
-        .map { |r| "#{r}\n" }
-        .join
-        .each_line
-        .map { |l| "  #{l}" }
-        .join
+      puts "AST Type:  #{ast.type}"
+      puts result
     end
 end

data/lib/bel_parser/language/apply_namespace_encoding.rb

@@ -49,9 +49,9 @@ module BELParser
       end
 
       def on_parameter(parameter_node)
-        @type    = nil
-        @dataset = nil
-        @prefix  = nil
+        @type      = nil
+        @namespace = nil
+        @prefix    = nil
         process(parameter_node.prefix)
         process(parameter_node.value)
       end
@@ -60,29 +60,25 @@ module BELParser
         return prefix_node unless prefix_node.identifier
 
         @prefix         = prefix_node.identifier.string_literal
-        @type, @dataset = @namespace_hash[@prefix.downcase]
-        return prefix_node unless @dataset
+        @namespace      = @namespace_hash[@prefix]
+        return prefix_node unless @namespace
 
-        prefix_node.namespace = @dataset
+        prefix_node.namespace = @namespace
         prefix_node
       end
 
       def on_value(value_node)
-        return value_node unless @dataset
-        value_node.namespace = @dataset
-        identifier           = @dataset.identifier
-        value_literal        = value_node.children[0].string_literal
+        return value_node unless @namespace
+        value_node.prefix    = @prefix
+        value_node.namespace = @namespace
 
-        reader = @type == :uri ? @uri_reader : @url_reader
-        values = reader.retrieve_value_from_resource(identifier, value_literal)
+        value_literal        = value_node.children[0].string_literal
+        value                = @namespace[value_literal]
 
-        value_node.prefix = @prefix
-        if values
-          value = values.first
+        if value
           value_node.encoding =
-            value
-            .encodings
-            .map(&@language_spec.method(:value_encoding))
+            value.encoding &&
+            value.encoding.map(&@language_spec.method(:value_encoding))
           value_node.namespace_value = value
         else
           value_node.encoding        = nil