bel_parser 1.0.0.alpha.12 → 1.0.0.alpha.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b28b03b903a5a3a1a62f4c36063c81292714cbd6
-  data.tar.gz: 631a26bb0628a77abc19f4c35a028b6851939838
+  metadata.gz: a431be1d3646bca92e1e4df5371f3d8bf8865c3f
+  data.tar.gz: ca8bd4846cbfb847efff3ba22840df28e2d222d7
 SHA512:
-  metadata.gz: cb71fff841dfba8b106cd03e5929fd7ff353796c17155b18703f481a142d2c67886c1322cca1a6d9443f278a104e0fcc57dc5205249624482ef6a47a080d3c81
-  data.tar.gz: 2349ecf4f921f28c9b9431cd9b6f66369b46e94aa3dc27eb27c0f95f5945ce1e98eb686bd4538bf85fbc2c7c65de66292b10b82afb38d0068723bf7d68e240f6
+  metadata.gz: 621944ea9d667b47e61b017fdbdf05632355c25dc7d214ec5515ce872faee31ea84e2cf47147daf82c28a278be31c4116d2ce12b1ad87339fb6765621e979b12
+  data.tar.gz: a2102f77e4bc6419c7d28fdfea8c12005f08588c91b854b6a5b30d9987b70235af5ef0d00df8ec538af3423661e7d92e28c89304a7efee858591f272f5242f85

data/.gemspec

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

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha.12
+1.0.0.alpha.13

data/bin/bel2_validator

@@ -11,17 +11,44 @@ unless ARGV.first
 end
 namespaces = Hash[ARGV[1..-1].map { |ns| ns.split('=') }]
 
+def syntax_results(results)
+  results.select do |res|
+    res.is_a? BELParser::Language::Syntax::SyntaxResult
+  end
+end
+
+def semantics_results(results)
+  results.select do |res|
+    res.is_a? BELParser::Language::Semantics::SemanticsResult
+  end
+end
+
 require 'bel_parser'
 require 'bel_parser/expression/validator'
+require 'bel_parser/resource/resource_file_reader'
+
+resource_reader = BELParser::Resource::ResourceFileReader.new
 BELParser::Expression::Validator
-  .new(ARGV.first, namespaces)
-  .each($stdin) do |(line_number, line, ast, messages)|
+  .new(ARGV.first, namespaces, resource_reader)
+  .each($stdin) do |(line_number, line, ast, results)|
     puts "#{line_number}: #{line}"
     puts "  AST Type: #{ast.type}"
-    puts messages
-      .map { |r| "#{r}\n" }
-      .join
-      .each_line
-      .map { |l| "  #{l}" }
-      .join
+
+    puts "  Syntax results:"
+    syntax_results(results).each do |res|
+      puts "    #{res}"
+    end
+
+    puts "  Semantics results:"
+    semantics_results(results).each do |res|
+      if res.is_a?(BELParser::Language::Semantics::SignatureMappingSuccess)
+        puts "    Matched signature: #{res.signature.string_form}"
+      end
+      if res.is_a?(BELParser::Language::Semantics::SignatureMappingWarning)
+        puts "    Failed signature: #{res.signature.string_form}"
+        res.results.select(&:failure?).each do |warning|
+          puts "      #{warning}"
+        end
+      end
+    end
   end

data/lib/bel_parser/expression/validator.rb

@@ -18,10 +18,10 @@ module BELParser
         :simple_statement,
         :nested_statement)
 
-      def initialize(specification_version, namespaces)
+      def initialize(specification_version, namespaces, resource_reader)
         @spec      = BELParser::Language.specification(specification_version)
         @validator = BELParser::Language::ExpressionValidator.new(
-          @spec, namespaces)
+          @spec, namespaces, resource_reader)
       end
 
       def each(io)
@@ -52,6 +52,7 @@ if __FILE__ == $PROGRAM_NAME
   BELParser::Expression::Validator
     .new(ARGV.first, namespaces)
     .each($stdin) do |(line_number, line, ast, messages)|
+      results.select { |res| res.is_a? BELParser::Language::Syntax::SyntaxError }
       puts "#{line_number}: #{line}"
       puts "  AST Type: #{ast.type}"
       puts messages

data/lib/bel_parser/language/apply_namespace_encoding.rb

@@ -0,0 +1,96 @@
+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, identifier_hash, resource_reader)
+        @language_spec   = language_spec
+        @identifier_hash = identifier_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
+        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
+
+        identifier            = @identifier_hash[prefix]
+        return prefix_node unless identifier
+
+        dataset               = @resource_reader.retrieve_resource(identifier)
+        @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)
+
+        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
+      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

data/lib/bel_parser/language/expression_validator.rb

@@ -1,5 +1,6 @@
 require_relative 'syntax'
 require_relative 'semantics'
+require_relative 'apply_namespace_encoding'
 
 module BELParser
   module Language
@@ -7,11 +8,13 @@ module BELParser
     # when supplied a {BELParser::Language::Specification} and Hash of
     # namespaces.
     class ExpressionValidator
-      def initialize(spec, namespaces)
+      def initialize(spec, namespaces, resource_reader)
         @spec                = spec
         @namespaces          = namespaces
         @syntax_functions    = Syntax.syntax_functions
         @semantics_functions = Semantics.semantics_functions
+        @transform           =
+          ApplyNamespaceEncoding.new(@spec, @namespaces, resource_reader)
       end
 
       # Validate the syntax and semantics of
@@ -20,6 +23,7 @@ module BELParser
       # @param  [BELParser::Parsers::AST::Node] expression_node to validate
       # @return [BELParser::Language::Syntax::SyntaxResult] syntax results
       def validate(expression_node)
+        @transform.process(expression_node)
         results = syntax(expression_node)
         if results.empty?
           results << Syntax::Valid.new(expression_node, @spec)
@@ -38,7 +42,7 @@ module BELParser
 
       def semantics(expression_node)
         expression_node.traverse.flat_map do |node|
-          @semantics_functions.map { |func| func.map(node, @spec, @namespaces) }
+          @semantics_functions.flat_map { |func| func.map(node, @spec, @namespaces) }
         end.compact
       end
     end

data/lib/bel_parser/language/relationship.rb

@@ -70,7 +70,7 @@ module BELParser
       end
 
       def ==(other)
-        return true if self.equal?(other)
+        return true if equal?(other)
         return false if other.nil?
         short == other || long == other
       end

data/lib/bel_parser/language/semantics/signature_mapping.rb

@@ -20,45 +20,41 @@ module BELParser
         def self.map(term_node, spec, _namespaces)
           return nil unless term_node.is_a?(BELParser::Parsers::AST::Term)
 
-          successes, failures = map_signatures(term_node, spec)
+          function_name = term_node.function.identifier.string_literal
+          function      = spec.function(function_name.to_sym)
+          mapsig        = method(:map_signature).to_proc.curry[term_node][spec]
 
-          if successes.empty?
-            SignatureMappingWarning.new(term_node, spec, failures)
-          else
-            SignatureMappingSuccess.new(term_node, spec, successes, failures)
-          end
+          function.signatures.map(&mapsig)
         end
 
-        def self.map_signatures(term_node, spec)
-          function_name = term_node.function.identifier.string_literal
-          function      = spec.function(function_name.to_sym)
-          match = BELParser::Language::Semantics.method(:match)
-          function
-            .signatures
-            .map { |sig| [sig, match.call(term_node, sig.semantic_ast, spec)] }
-            .partition { |(_sig, results)| results.all?(&:success?) }
+        def self.map_signature(term_node, spec, signature)
+          results = BELParser::Language::Semantics.match(
+            term_node,
+            signature.semantic_ast,
+            spec)
+          if results.all?(&:success?)
+            SignatureMappingSuccess.new(term_node, spec, signature, results)
+          else
+            SignatureMappingWarning.new(term_node, spec, signature, results)
+          end
         end
       end
 
       # SignatureMappingSuccess defines a {SemanticsResult} that indicates
       # a successful signature match.
       class SignatureMappingSuccess < SemanticsResult
-        attr_reader :success_signatures
-        attr_reader :failure_signatures
+        attr_reader :signature
+        attr_reader :results
 
-        def initialize(term_node, spec, successes, failures)
+        def initialize(term_node, spec, signature, results)
           super(term_node, spec)
-          @success_signatures = successes
-          @failure_signatures = failures
+          @signature = signature
+          @results   = results
         end
 
         def to_s
-          sig_list = success_signatures
-                     .map { |(sig, _results)| sig.string_form }
-                     .join("\n  ")
           <<-MSG.gsub(/ {12}/, '').gsub(/\n$/, '')
-            Term matches function signatures:
-              #{sig_list}
+            Term matched function signature: #{@signature.string_form}
           MSG
         end
       end
@@ -66,20 +62,18 @@ module BELParser
       # SignatureMappingWarning defines a {SemanticsWarning} that indicates
       # an unsuccessful signature match.
       class SignatureMappingWarning < SemanticsWarning
-        attr_reader :failure_signatures
+        attr_reader :signature
+        attr_reader :results
 
-        def initialize(term_node, spec, failure_signatures)
+        def initialize(term_node, spec, signature, results)
           super(term_node, spec)
-          @failure_signatures = failure_signatures
+          @signature = signature
+          @results   = results
         end
 
         def to_s
-          sig_list = failure_signatures
-                     .map { |(sig, _results)| sig.string_form }
-                     .join("\n  ")
           <<-MSG.gsub(/ {12}/, '').gsub(/\n$/, '')
-            Term did not conform to function signatures:
-              #{sig_list}
+            Term did not match function signature: #{@signature.string_form}
           MSG
         end
       end