bel_parser 1.0.0.alpha.57-java → 1.0.0.alpha.58-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60beaba7ec588b49f39e177c3c2ae31cdf9c48c6
-  data.tar.gz: 47feab6424d1532624d3841f00ae126fd88cc5ff
+  metadata.gz: 2e51f1fc03c4170844be82ca4fd6635b4de3d7f3
+  data.tar.gz: c33c9a32f0849c0778e715c3e4a305769b21306a
 SHA512:
-  metadata.gz: 258561f22b61be0fdd2d850a2d43b83a4e4248a05ef19a945a755a6826ef72665542ff997ae489bbce2297ee807b529dcbbc2762c57168e586ef5046d93b59bf
-  data.tar.gz: 399dfffc0c57a4d1915a8962e78e81ae163ce214308957dff0f2b4f0386061dd910b578857d66af9a5319ba24e102aa2052ddabf490843644a2619f01d7ddef9
+  metadata.gz: aa0e04a26cd31039e0681cefb9576b748e6f87f31002b5899f5be742dcfc7e2bb1967b36ea3f2d03f6eb322775b9dda8d16fd27b51db26fd98fad492bde3d30b
+  data.tar.gz: eadf57c356bc3679f19da497ef82f069a1a6a294ebea3f1a053acbb5c215412049c581c8168353d9025917bd82c2cf769be63f90309d7d0cc51ce3a8720aca0d

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha.57
+1.0.0.alpha.58

data/bin/bel2_debug_ast

@@ -33,7 +33,6 @@ io   =
   else
     $stdin
   end
-puts options[:complete]
 
 class ::AST::Node
 

data/bin/bel2_upgrade

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(
+  File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
+
+require 'optparse'
+require 'bel_parser'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = <<-USAGE.gsub(/^ {4}/, '')
+    Convert BEL 1.0 to 2.0.
+
+    Read from a BEL Script file.
+    usage: #$PROGRAM_NAME --file [FILE]
+
+    Read BEL Script from standard input.
+    usage: #$PROGRAM_NAME
+  USAGE
+
+  opts.on('-f', '--file FILE', 'BEL script file to read.') do |bel|
+    options[:file] = bel
+  end
+end.parse!
+
+file = options[:file]
+io   =
+  if file
+    File.open(file, external_encoding: 'UTF-8')
+  else
+    $stdin
+  end
+
+CONVERSION_TYPES = [
+  :simple_statement,
+  :nested_statement,
+  :observed_term
+]
+
+spec     = BELParser::Language.specification('1.0')
+upgrades = spec.upgrades.map(&:new)
+
+include BELParser::Parsers
+include BELParser::Parsers::AST::Sexp
+
+puts serialize(
+  document_property(
+    name(
+      identifier('BELVersion')),
+    value(
+      string('"2.0"'))))
+BELParser::ASTGenerator.new(io).each do |result|
+  line_number, line, asts = result
+
+  document_property =
+    asts.find { |ast|
+      ast && ast.type == :document_property
+    }
+  next if document_property && document_property.name.identifier.string_literal.downcase == 'belversion'
+
+  ast =
+    asts.find do |ast|
+      ast && CONVERSION_TYPES.include?(ast.type)
+    end
+
+  if ast
+    ast =
+      upgrades.reduce(ast) do |ast, upgrade|
+        upgrade.process(ast)
+      end
+    puts serialize(ast)
+  else
+    puts line
+  end
+end

data/lib/bel_parser/language/base_specification.rb

@@ -8,7 +8,7 @@ module BELParser
 
       def self.load_version_path(version_path)
         base_path = File.expand_path(File.dirname(__FILE__)) + File::SEPARATOR
-        ['return_types', 'value_encodings', 'functions', 'relationships']
+        ['return_types', 'value_encodings', 'functions', 'relationships', 'upgrades']
           .each do |set|
             Dir[File.join(base_path, version_path, set, '*.rb')]
               .each do |ruby_file|
@@ -25,6 +25,7 @@ module BELParser
         load_value_encodings(version_module)
         load_functions(version_module)
         load_relationships(version_module)
+        load_upgrades(version_module)
       end
 
       private
@@ -77,6 +78,17 @@ module BELParser
         @indexed_relationships = index_long_short(@relationships)
         assign_relationship_categories(@relationships)
       end
+
+      def load_upgrades(version_module)
+        # Collect upgrades
+        upgrade_classes =
+          version_module::Upgrades.constants.collect do |symbol|
+            const = version_module::Upgrades.const_get(symbol)
+            const if
+              const.include?(BELParser::Language::TermTransformation)
+          end
+        @upgrades = upgrade_classes.compact
+      end
     end
   end
 end

data/lib/bel_parser/language/specification.rb

@@ -45,6 +45,10 @@ module BELParser
         end
       end
 
+      def upgrades
+        @upgrades.freeze
+      end
+
       attr_reader :causal_relationships
       attr_reader :correlative_relationships
       attr_reader :decreasing_relationships

data/lib/bel_parser/language/term_transformation.rb

@@ -0,0 +1,88 @@
+require          'bel_parser/vendor/ast'
+require          'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module TermTransformation
+      include AST::Processor::Mixin
+      include BELParser::Parsers::AST::Sexp
+
+      ACTIVITIES = {
+        'cat' => 'cat',
+        'catalyticActivity' => 'cat',
+        'chap' => 'chap',
+        'chaperoneActivity' => 'chap',
+        'gtp' => 'gtp',
+        'gtpBoundActivity' => 'gtp',
+        'kin' => 'kin',
+        'kinaseActivity' => 'kin',
+        'act' => 'act',
+        'molecularActivity' => 'act',
+        'pep' => 'pep',
+        'peptidaseActivity' => 'pep',
+        'phos' => 'phos',
+        'phosphataseActivity' => 'phos',
+        'ribo' => 'ribo',
+        'ribosylationActivity' => 'ribo',
+        'tscript' => 'tscript',
+        'transcriptionalActivity' => 'tscript',
+        'tport' => 'tport',
+        'transportActivity' => 'tport'
+      }
+
+      PMODTYPES = {
+        'P' => 'Ph',
+        'A' => 'Ac',
+        'F' => 'Farn',
+        'G' => 'Glyco',
+        'H' => 'Hy',
+        'M' => 'Me',
+        'R' => 'ADPRib',
+        'S' => 'Sumo',
+        'U' => 'Ub'
+      }
+
+      def on_observed_term(observed_term_node)
+        observed_term_node.updated([process(observed_term_node.statement)])
+      end
+
+      def on_nested_statement(nested_statement_node)
+        nested_statement_node.updated([process(nested_statement_node.statement)])
+      end
+
+      def on_simple_statement(simple_statement_node)
+        simple_statement_node.updated([process(simple_statement_node.statement)])
+      end
+
+      def on_statement(statement_node)
+        statement_node.updated([process(statement_node.subject), statement_node.relationship, process(statement_node.object), statement_node.comment])
+      end
+
+      def on_subject(subject_node)
+        subject_node.updated([process(subject_node.term)])
+      end
+
+      def on_object(object_node)
+        return if object_node.nil?
+        object_node.updated([process(object_node.child)])
+      end
+
+      def on_argument(argument_node)
+        argument_node.updated([process(argument_node.child)])
+      end
+
+      def on_function(function_node)
+        function_node.updated([process(function_node.identifier)])
+      end
+
+      # Called when visiting nodes of type +term+.
+      def on_term(term_node)
+        term_node.updated([process(term_node.function), term_node.arguments.map! {|arg| process(arg)}].flatten())
+      end
+
+      def collapse(node)
+        node.to_sexp(indent=0).gsub("\n", '')
+      end
+    end
+  end
+end

data/lib/bel_parser/language/version1_0/upgrades/activity_transformation.rb

@@ -0,0 +1,48 @@
+require 'bel_parser/vendor/ast'
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/language/term_transformation'
+
+module BELParser
+  module Language
+    module Version1_0
+      module Upgrades
+        class ActivityTransformation
+          include AST::Processor::Mixin
+          include BELParser::Parsers::AST::Sexp
+          include BELParser::Language::TermTransformation
+
+          def on_term(term_node)
+            if ACTIVITIES.keys.include?(term_node.function.identifier.string_literal)
+              term_node.updated([
+                                  # activity function
+                                  process(term_node.function),
+                                  # original arguments
+                                  term_node.arguments.map! {|arg| argument(process(arg.child))},
+                                  # additional molecularActivity argument
+                                  add_molecular_activity(ACTIVITIES[term_node.function.identifier.string_literal])
+                              ].flatten)
+
+            end
+          end
+
+          def add_molecular_activity(_activity_identifier)
+            argument(
+              term(
+                function(
+                  identifier('molecularActivity')),
+                argument(
+                  parameter(
+                    prefix(
+                      identifier('default')),
+                    value(
+                      identifier(_activity_identifier))))))
+          end
+
+          def on_function(function_node)
+            function_node.updated([identifier('activity')])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/version1_0/upgrades/fusion_transformation.rb

@@ -0,0 +1,69 @@
+require 'bel_parser/vendor/ast'
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/language/term_transformation'
+
+module BELParser
+  module Language
+    module Version1_0
+      module Upgrades
+        class FusionTransformation
+          include AST::Processor::Mixin
+          include BELParser::Parsers::AST::Sexp
+          include BELParser::Language::TermTransformation
+
+          def fusion_node?(term_node)
+            fusion_func = false
+
+            fusionable_func =
+              [
+                'p', 'proteinAbundance',
+                'r', 'rnaAbundance',
+                'g', 'geneAbundance'
+              ].include?(term_node.function.identifier.string_literal)
+            return false unless fusionable_func
+
+            if term_node.arguments[1] && term_node.arguments[1].child.respond_to?('function')
+                ['fus', 'fusion'].include?(term_node.arguments[1].child.function.identifier.string_literal)
+            else
+              false
+            end
+          end
+
+          def on_term(term_node)
+            if fusion_node?(term_node)
+              fusionable_func = term_node.function.identifier.string_literal
+              parameter = term_node.arguments[0].child
+
+              first_prefix = parameter.prefix.identifier.string_literal
+              first_value = parameter.value.children[0].string_literal
+              parameter = term_node.arguments[1].child.arguments[0].child
+              second_prefix = parameter.prefix.identifier.string_literal
+              second_value = parameter.value.children[0].string_literal
+
+              term(
+                function(
+                  identifier(fusionable_func)),
+                  term(
+                    function(
+                      identifier('fus')),
+                    argument(
+                      parameter(
+                        prefix(
+                          identifier(first_prefix)),
+                        value(
+                          identifier(first_value)))),
+                    argument(
+                      parameter(
+                        prefix(
+                          identifier(second_prefix)),
+                        value(
+                            identifier(second_value))))))
+            else
+              term_node.updated([process(term_node.function), term_node.arguments.map! {|arg| process(arg)}].flatten())
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/version1_0/upgrades/protein_modification_transformation.rb

@@ -0,0 +1,36 @@
+require 'bel_parser/vendor/ast'
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/language/term_transformation'
+
+module BELParser
+  module Language
+    module Version1_0
+      module Upgrades
+        class ProteinModificationTransformation
+          include AST::Processor::Mixin
+          include BELParser::Parsers::AST::Sexp
+          include BELParser::Language::TermTransformation
+
+          def on_term(term_node)
+            if ['pmod', 'proteinmodification'].include?(term_node.function.identifier.string_literal)
+              # straightforward replacement of first argument to pmod with pmodtype value
+              term_node.updated([term_node.function, update_pmod(term_node.arguments[0]), term_node.arguments[1], term_node.arguments[2] ].flatten)
+            else
+              term_node.updated([process(term_node.function), term_node.arguments.map! {|arg| process(arg)}].flatten())
+            end
+          end
+
+          def update_pmod(argument_node)
+            param_value = argument_node.child.value.children[0].string_literal
+            argument(
+              parameter(
+                prefix(
+                  identifier('default')),
+                value(
+                  identifier(PMODTYPES[param_value]))))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/version1_0/upgrades/translocation_transformation.rb

@@ -0,0 +1,40 @@
+require 'bel_parser/vendor/ast'
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/language/term_transformation'
+
+module BELParser
+  module Language
+    module Version1_0
+      module Upgrades
+        class TranslocationTransformation
+          include AST::Processor::Mixin
+          include BELParser::Parsers::AST::Sexp
+          include BELParser::Language::TermTransformation
+
+          def on_term(term_node)
+            if ['tloc', 'translocation'].include?(term_node.function.identifier.string_literal)
+              term_node.updated([term_node.function, term_node.arguments[0], add_loc_func(term_node.arguments[1], 'fromLoc'), add_loc_func(term_node.arguments[2], 'toLoc') ].flatten)
+            else
+              term_node.updated([process(term_node.function), term_node.arguments.map! {|arg| process(arg)}].flatten())
+            end
+          end
+
+          def add_loc_func(argument_node, function_name)
+            prefix_name = argument_node.child.prefix.children[0].string_literal
+            value_name = argument_node.child.value.children[0].string_literal
+            argument(
+              term(
+                function(
+                  identifier(function_name)),
+                argument(
+                  parameter(
+                    prefix(
+                      identifier(prefix_name)),
+                    value(
+                      identifier(value_name))))))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/version1_0/upgrades/variation_transformation.rb

@@ -0,0 +1,166 @@
+require 'bel_parser/vendor/ast'
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/language/term_transformation'
+
+module BELParser
+  module Language
+    module Version1_0
+      module Upgrades
+        class VariationTransformation
+          include AST::Processor::Mixin
+          include BELParser::Parsers::AST::Sexp
+          include BELParser::Language::TermTransformation
+
+          def on_term(term_node)
+            is_parent_func = ['p', 'proteinAbundance', 'r', 'rnaAbundance', 'g', 'geneAbundance'].include?(term_node.function.identifier.string_literal)
+            parent_func    = term_node.function.identifier.string_literal
+
+            unless is_parent_func
+              return term_node.updated([process(term_node.function), term_node.arguments.map! {|arg| process(arg)}].flatten())
+            end
+
+            if term_node.arguments[0].parameter?
+              param_prefix = term_node.arguments[0].child.prefix.identifier.string_literal
+              param_value  = term_node.arguments[0].child.value.children[0].string_literal
+            end
+
+            if term_node.arguments[1].respond_to?('child') && term_node.arguments[1].child.respond_to?('function') && term_node.arguments[1].child.function
+              is_sub_func = ['sub', 'substitution'].include?(term_node.arguments[1].child.function.identifier.string_literal)
+              is_trunc_func = ['trunc', 'truncation'].include?(term_node.arguments[1].child.function.identifier.string_literal)
+            end
+
+            if is_sub_func || is_trunc_func
+              if is_parent_func && is_sub_func
+                variant_node = term_node.arguments[1].child
+                ref = variant_node.arguments[0].child.value.children[0].string_literal
+                loc = variant_node.arguments[1].child.value.children[0].string_literal
+                alt = variant_node.arguments[2].child.value.children[0].string_literal
+
+                if ['p'].include?(parent_func)
+                  return protein_sub_conversion(parent_func, param_prefix, param_value, ref, loc, alt)
+                else
+                  return dna_sub_conversion(parent_func, param_prefix, param_value, ref, loc, alt)
+                end
+              end
+
+              if is_parent_func && is_trunc_func
+
+                variant_node = term_node.arguments[1].child
+                loc = variant_node.arguments[0].child.value.children[0].string_literal
+
+                if ['p'].include?(parent_func)
+                  return protein_trunc_conversion(parent_func, param_prefix, param_value, loc)
+                else
+                  return dna_trunc_conversion(parent_func, param_prefix, param_value, loc)
+                end
+
+              end
+            else
+              term_node.updated([process(term_node.function), term_node.arguments.map! {|arg| process(arg)}].flatten())
+            end
+          end
+
+          def protein_sub_conversion(parent_func, param_prefix, param_value, ref, loc, alt)
+            term(
+              function(
+                identifier(parent_func)),
+              argument(
+                parameter(
+                  prefix(
+                    identifier(param_prefix)),
+                  value(
+                    identifier(param_value)))),
+              argument(
+                term(
+                  function(
+                    identifier('var')),
+                  argument(
+                    parameter(
+                      value(
+                        identifier(%("#{parent_func}.#{ref}#{loc}#{alt}"))))))))
+          end
+
+          def dna_sub_conversion(parent_func, param_prefix, param_value, ref, loc, alt)  # and RNA
+            converted_parent_func =
+              case parent_func
+              when 'p', 'proteinAbundance'
+                'p'
+              when 'g', 'geneAbundance'
+                'c'
+              when 'r', 'rnaAbundance'
+                'r'
+              end
+
+            term(
+              function(
+                identifier(parent_func)),
+              argument(
+                parameter(
+                  prefix(
+                    identifier(param_prefix)),
+                  value(
+                    identifier(param_value)))),
+              argument(
+                term(
+                  function(
+                    identifier('var')),
+                  argument(
+                    parameter(
+                      value(
+                        identifier(%("#{converted_parent_func}.#{loc}#{ref}>#{alt}"))))))))
+          end
+
+          def protein_trunc_conversion(parent_func, param_prefix, param_value, loc)
+            term(
+              function(
+                identifier(parent_func)),
+              argument(
+                parameter(
+                  prefix(
+                    identifier(param_prefix)),
+                  value(
+                    identifier(param_value)))),
+              argument(
+                term(
+                  function(
+                    identifier('var')),
+                  argument(
+                    parameter(
+                      value(
+                        identifier(%("#{parent_func}.#{loc}*"))))))))
+          end
+
+          def dna_trunc_conversion(parent_func, param_prefix, param_value, loc)  # and RNA
+            converted_parent_func =
+              case parent_func
+              when 'p', 'proteinAbundance'
+                'p'
+              when 'g', 'geneAbundance'
+                'c'
+              when 'r', 'rnaAbundance'
+                'r'
+              end
+
+            term(
+              function(
+                identifier(parent_func)),
+              argument(
+                parameter(
+                  prefix(
+                    identifier(param_prefix)),
+                  value(
+                    identifier(param_value)))),
+              argument(
+                term(
+                  function(
+                    identifier('var')),
+                  argument(
+                    parameter(
+                      value(
+                        identifier(%("#{converted_parent_func}.#{loc}*"))))))))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language.rb

@@ -5,6 +5,7 @@ require_relative 'language/semantics'
 require_relative 'language/signature'
 require_relative 'language/specification'
 require_relative 'language/expression_validator'
+require_relative 'language/term_transformation'
 
 module BELParser
   # Language defines the concepts needed to define, represent, and

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bel_parser
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha.57
+  version: 1.0.0.alpha.58
 platform: java
 authors:
 - Anthony Bargnesi
@@ -42,6 +42,7 @@ dependencies:
 description: Implements language versions 1.0 and 2.0.
 email: abargnesi@selventa.com
 executables:
+- bel2_upgrade
 - bel2_debug_ast
 - bel2_validator
 - bel_script_reader
@@ -54,6 +55,7 @@ files:
 - README.md
 - VERSION
 - bin/bel2_debug_ast
+- bin/bel2_upgrade
 - bin/bel2_validator
 - bin/bel_script_reader
 - lib/bel/translator/plugins/bel_script.rb
@@ -113,6 +115,7 @@ files:
 - lib/bel_parser/language/syntax_function.rb
 - lib/bel_parser/language/syntax_result.rb
 - lib/bel_parser/language/syntax_warning.rb
+- lib/bel_parser/language/term_transformation.rb
 - lib/bel_parser/language/version1_0.rb
 - lib/bel_parser/language/version1_0/functions/abundance.rb
 - lib/bel_parser/language/version1_0/functions/biological_process.rb
@@ -199,6 +202,11 @@ files:
 - lib/bel_parser/language/version1_0/return_types/transcriptional_activity.rb
 - lib/bel_parser/language/version1_0/return_types/transport_activity.rb
 - lib/bel_parser/language/version1_0/return_types/truncation.rb
+- lib/bel_parser/language/version1_0/upgrades/activity_transformation.rb
+- lib/bel_parser/language/version1_0/upgrades/fusion_transformation.rb
+- lib/bel_parser/language/version1_0/upgrades/protein_modification_transformation.rb
+- lib/bel_parser/language/version1_0/upgrades/translocation_transformation.rb
+- lib/bel_parser/language/version1_0/upgrades/variation_transformation.rb
 - lib/bel_parser/language/version1_0/value_encodings/abundance.rb
 - lib/bel_parser/language/version1_0/value_encodings/any.rb
 - lib/bel_parser/language/version1_0/value_encodings/biological_process.rb