bel 0.2.1 → 0.3.0.beta1

data/bin/bel_upgrade

@@ -2,10 +2,10 @@
 # bel_upgrade: Upgrade BEL content to a new set of resources.
 #
 # From BEL file
-# usage: ruby bel_upgrade -b file.bel -c file.json
+# usage: bel_upgrade -b file.bel -c file.json
 #
 # From standard in
-# usage: echo "<BEL DOCUMENT STRING>" | ruby bel_upgrade -c file.json
+# usage: echo "<BEL DOCUMENT STRING>" | bel_upgrade -c file.json
 
 require 'bel'
 require 'json'
@@ -16,9 +16,9 @@ require 'open-uri'
 # setup and parse options
 options = {}
 OptionParser.new do |opts|
-  opts.banner = "Usage: upgrade-namespaces.rb [options] [.bel file]"
+  opts.banner = "Usage: bel_upgrade [options] [.bel file]"
   opts.on('-b', '--bel FILE', 'BEL file to upgrade.  STDIN (standard in) can also be used for BEL content.') do |bel|
-    options['bel'] = bel
+    options[:bel] = bel
   end
   opts.on("-c", "--changelog [FILE | URI]", "Change log JSON") do |change_log|
     options['change_log'] = change_log
@@ -26,7 +26,7 @@ OptionParser.new do |opts|
 end.parse!
 
 # option guards
-unless options['bel'] or not STDIN.tty?
+unless options[:bel] or not STDIN.tty?
   $stderr.puts "No bel content provided.  Either use --bel option or STDIN (standard in).  Use -h / --help for details." 
   exit 1
 end
@@ -47,13 +47,18 @@ if not File.exists? options['change_log']
     exit 1
   end
 end
-if options['bel'] and not File.exists? options['bel']
-  $stderr.puts "No file for bel, #{options['bel']}"
+if options[:bel] and not File.exists? options[:bel]
+  $stderr.puts "No file for bel, #{options[:bel]}"
   exit 1
 end
 
 # read bel content
-content = (STDIN.tty?) ? File.open(options['bel']).read : $stdin.read
+content =
+if options[:bel]
+  File.open(options[:bel]).read
+else
+  $stdin.read
+end
 
 # read change log
 changelog = nil
@@ -74,70 +79,87 @@ end
 class Main
 
   EvidenceMatcher = Regexp.compile(/SET Evidence = ([0-9a-zA-Z]+)/)
+  LostReplaceValues = ['unresolved', 'withdrawn']
   attr_reader :ttl
 
   def initialize(content, change_log)
     @change_log = change_log
+    @redefine_section = @change_log['redefine']
     @keywords_seen = Set.new
-    parser = BEL::Script::Parser.new
-    parser.add_observer self
-    parser.parse(content)
-  end
-  def update(obj)
-    # redefine namespace based on change log's `redefine` block
-    if obj.is_a? BEL::Script::NamespaceDefinition
-      if @change_log.has_key? 'redefine'
-        redefine = @change_log['redefine']
-        if redefine.has_key? obj.prefix
-          entry = redefine[obj.prefix]
-          obj.prefix = entry['new_keyword']
-          obj.value = entry['new_url']
+    BEL::Script.parse(content) do |obj|
+      # redefine namespace based on change log's `redefine` block
+      if obj.is_a? NamespaceDefinition
+        if @change_log.has_key? 'redefine'
+          redefine = @change_log['redefine']
+          if redefine.has_key? obj.prefix.to_s
+            entry = redefine[obj.prefix.to_s]
+            new_keyword = entry['new_keyword'].to_sym
+            new_url = entry['new_url']
+            obj = NamespaceDefinition.new(new_keyword, new_url)
+          end
         end
-      end
 
-      # deduplicate namespaces for output purposes
-      if @keywords_seen.include? obj.prefix
-        return
+        # deduplicate namespaces for output purposes
+        if @keywords_seen.include? obj.prefix
+          next
+        end
+        @keywords_seen.add(obj.prefix)
       end
-      @keywords_seen.add(obj.prefix)
-    end
 
-    if obj.is_a? BEL::Script::Annotation
-      if obj.name == 'Evidence'
-        ev = obj.to_s
-        ev.gsub!(EvidenceMatcher, 'SET Evidence = "\1"')
-        puts ev
-        return
+      # evidence always needs quoting; backwards-compatibility
+      if obj.is_a? Annotation
+        if obj.name == 'Evidence'
+          ev = obj.to_s
+          ev.gsub!(EvidenceMatcher, 'SET Evidence = "\1"')
+          puts ev.to_s
+          next
+        end
       end
-    end
 
-    if obj.is_a? BEL::Script::Parameter
-      if @change_log.has_key? obj.ns
-        clog_ns = @change_log[obj.ns]
-        if clog_ns.has_key? obj.value
-          replacement = clog_ns[obj.value]
-          if replacement == 'unresolved' or replacement == 'withdrawn'
-            $stderr.puts "no replacement value for #{obj.ns} '#{obj.value}' - value '#{replacement}'"
-            return
+      if obj.is_a? Parameter and obj.ns
+        # first try replacing by existing namespace prefix...
+        prefix = obj.ns.prefix.to_s
+        replacements = @change_log[prefix]
+        if replacements
+          replacement_value = replacements[obj.value]
+          if replacement_value
+            if LostReplaceValues.include? replacement_value
+              $stderr.puts "no replacement value for #{obj.ns} '#{obj.value}' - value '#{replacement_value}'"
+            else
+              obj.value = replacement_value
+            end
           end
-          obj.value = replacement
         end
-      end
-      # redefine param namespace based on change log's `redefine` block
-      if @change_log.has_key? 'redefine'
-        redefine = @change_log['redefine']
-        if redefine.has_key? obj.ns
-          obj.ns = redefine[obj.ns]['new_keyword']
+
+        # ...then change namespace if redefined...
+        if @redefine_section
+          redefinition = @redefine_section[prefix]
+          if redefinition
+            new_prefix = redefinition['new_keyword']
+            new_url = redefinition['new_url']
+            obj.ns = NamespaceDefinition.new(new_prefix, new_url)
+
+            # ...and replace value using new namespace prefix
+            replacements = @change_log[new_prefix]
+            if replacements
+              replacement_value = replacements[obj.value]
+              if replacement_value
+                if LostReplaceValues.include? replacement_value
+                  $stderr.puts "no replacement value for #{obj.ns} '#{obj.value}' - value '#{replacement_value}'"
+                else
+                  obj.value = replacement_value
+                end
+              end
+            end
+          end
         end
       end
-      return
-    end
 
-    if obj.is_a? BEL::Script::Term
-      return # do not print (part of statement)
+      # do not print Parameter and Term; they are included in Statement
+      if not obj.is_a? Parameter and not obj.is_a? Term
+        puts obj.to_bel
+      end
     end
-
-    puts obj.to_s
   end
 
   private

data/bin/bel_upgrade_term

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+# bel_upgrade_term: Upgrade BEL terms to a new set of resources.
+#
+# Terms as CLI option.
+# usage: bel_upgrade_term -t "p(HGNC:A2LD1)" -n "1.0" -c change_log.json
+#
+# Terms from standard in.
+# usage: echo -e "p(EGID:84)\np(HGNC:A2LD1)" | bel_upgrade_term -n "1.0" -c change_log.json
+# usage: cat terms.bel | bel_upgrade_term -n "1.0" -c change_log.json
+
+require 'bel'
+require 'json'
+require 'optparse'
+require 'set'
+require 'open-uri'
+
+# setup and parse options
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: bel_upgrade [options] [.bel file]"
+  opts.on('-t', '--terms TERM[\nTERM...]', 'BEL terms to upgrade (line-separated).') do |terms|
+    options[:terms] = terms
+  end
+  opts.on('-n', '--nsversion NAMESPACE VERSION', 'Assume BEL is described by this namespace version.') do |nsv|
+    options[:namespace_version] = nsv
+  end
+  opts.on("-c", "--changelog [FILE | URI]", "Change log JSON.") do |change_log|
+    options['change_log'] = change_log
+  end
+end.parse!
+
+# option guards
+if not options[:namespace_version]
+  $stderr.puts "The --nsversion option is required. Use -h / --help for details."
+  exit 1
+end
+unless options[:terms] or not STDIN.tty?
+  $stderr.puts "No bel terms provided; try --term, or STDIN (standard in). Use -h / --help for details."
+  exit 1
+end
+unless options['change_log']
+  $stderr.puts "Missing --changelog option. Use -h / --help for details."
+  exit 1
+end
+if not File.exists? options['change_log']
+  begin
+    open(options['change_log']) do |f|
+      unless f.content_type == 'application/json'
+        $stderr.puts "Expected application/json content type, actual: #{f.content_type}"
+        exit 1
+      end
+    end
+  rescue OpenURI::HTTPError => e
+    $stderr.puts "Cannot read URI for change_log, #{options['change_log']}, status: #{e}"
+    exit 1
+  end
+end
+
+# read bel content
+content =
+if options[:terms]
+  options[:terms]
+else
+  $stdin.read
+end
+
+if content.strip().empty?
+  $stderr.puts "Empty bel term content. Check input."
+end
+content += "\n"
+
+# read change log
+changelog = nil
+if File.exists? options['change_log']
+  File.open(options['change_log']) do |f|
+    changelog = JSON.parse(f.read)
+  end
+else
+  open(options['change_log']) do |file|
+    changelog = JSON.parse(file.read)
+  end
+end
+
+unless changelog
+  $stderr.puts "Cannot retrieve change_log #{options['change_log']}"
+end
+
+class Main
+
+  LostReplaceValues = ['unresolved', 'withdrawn']
+  attr_reader :ttl
+
+  def initialize(nsversion, content, change_log)
+    @change_log = change_log
+    @redefine_section = @change_log['redefine']
+    resource_index = ResourceIndex.openbel_published_index(nsversion)
+    content.each_line do |line|
+      parsed_objects = BEL::Script.parse(line, resource_index).to_a
+
+      if parsed_objects.empty?
+        $stderr.puts "parse failure for '#{line.strip}': outputting original"
+        puts line
+      else
+        parsed_objects.each do |obj|
+          if obj.is_a? Parameter and obj.ns
+            # first try replacing by existing namespace prefix...
+            prefix = obj.ns.prefix.to_s
+            replacements = @change_log[prefix]
+            if replacements
+              replacement_value = replacements[obj.value]
+              if replacement_value
+                if LostReplaceValues.include? replacement_value
+                  $stderr.puts "no replacement value for #{obj.ns} '#{obj.value}' - value '#{replacement_value}'"
+                else
+                  obj.value = replacement_value
+                end
+              end
+            end
+
+            # ...then change namespace if redefined...
+            if @redefine_section
+              redefinition = @redefine_section[prefix]
+              if redefinition
+                new_prefix = redefinition['new_keyword']
+                new_url = redefinition['new_url']
+                obj.ns = NamespaceDefinition.new(new_prefix, new_url)
+
+                # ...and replace value using new namespace prefix
+                replacements = @change_log[new_prefix]
+                if replacements
+                  replacement_value = replacements[obj.value]
+                  if replacement_value
+                    if LostReplaceValues.include? replacement_value
+                      $stderr.puts "no replacement value for #{obj.ns} '#{obj.value}' - value '#{replacement_value}'"
+                    else
+                      obj.value = replacement_value
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # do not print Parameter and Term; they are included in Statement
+          if obj.is_a? Statement
+            puts obj.to_bel
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def error_file(file_name)
+    $stderr.puts "#{file_name} is not readable"
+    exit 1
+  end
+end
+
+Main.new(options[:namespace_version], content, changelog)
+# vim: ts=2 sw=2:
+# encoding: utf-8

data/ext/mri/bel-ast.c

@@ -0,0 +1,221 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "bel-ast.h"
+
+bel_ast_node* bel_new_ast_node_token(bel_ast_token_type type) {
+    bel_ast_node* node;
+    node = malloc(sizeof(bel_ast_node));
+    node->token = malloc(sizeof(bel_ast_node_token));
+    node->token->type  = BEL_TOKEN;
+    node->token->ttype = type;
+    node->token->left  = NULL;
+    node->token->right = NULL;
+    return node;
+};
+
+bel_ast_node* bel_new_ast_node_value(bel_ast_value_type type, char* value) {
+    bel_ast_node* node;
+    char*         copy_value;
+
+    if (value) {
+        copy_value = malloc(strlen(value) + 1);
+        strcpy(copy_value, value);
+    } else {
+        copy_value = NULL;
+    }
+
+    node = malloc(sizeof(bel_ast_node));
+    node->value = malloc(sizeof(bel_ast_node_value));
+    node->value->type  = BEL_VALUE;
+    node->value->vtype = type;
+    node->value->value = copy_value;
+    return node;
+};
+
+bel_ast_node* bel_copy_ast_node(bel_ast_node* node) {
+	bel_ast_node* copy_node;
+    char* copy_value;
+
+    if (!node) {
+        return NULL;
+	}
+
+	copy_node = malloc(sizeof(bel_ast_node));
+
+    if (node->type_info->type == BEL_VALUE) {
+		if (node->value->value) {
+			copy_value = malloc(strlen(node->value->value) + 1);
+			strcpy(copy_value, node->value->value);
+		} else {
+			copy_value = NULL;
+		}
+
+		copy_node->value = malloc(sizeof(bel_ast_node_value));
+		copy_node->value->type  = node->value->type;
+		copy_node->value->vtype = node->value->vtype;
+		copy_node->value->value = copy_value;
+    } else {
+		copy_node->token = malloc(sizeof(bel_ast_node_token));
+		copy_node->token->type  = node->token->type;
+		copy_node->token->ttype = node->token->ttype;
+		copy_node->token->left  = bel_copy_ast_node(node->token->left);
+		copy_node->token->right = bel_copy_ast_node(node->token->right);
+	}
+
+	return copy_node;
+}
+
+bel_ast_node* bel_set_value(bel_ast_node* node, char* value) {
+    char* copy_value;
+
+    if (!node) {
+        // TODO Debug node error to stderr; node is NULL
+        return NULL;
+    }
+
+    if (node->type_info->type != BEL_VALUE) {
+        // TODO Debug node error to stderr; node cannot hold value
+        return NULL;
+    }
+
+    if (value) {
+        copy_value = malloc(strlen(value) + 1);
+        strcpy(copy_value, value);
+    } else {
+        copy_value = NULL;
+    }
+
+	node->value->value = copy_value;
+	return node;
+}
+
+bel_ast* bel_new_ast() {
+    bel_ast* ast;
+    ast = malloc(sizeof(bel_ast));
+    ast->root = NULL;
+    return ast;
+};
+
+void bel_free_ast(bel_ast* ast) {
+    if (!ast) {
+        return;
+    }
+    bel_free_ast_node(ast->root);
+    free(ast);
+};
+
+void bel_free_ast_node(bel_ast_node* node) {
+    if (node->type_info->type == BEL_TOKEN) {
+        if (node->token->left != NULL) {
+            bel_free_ast_node(node->token->left);
+        }
+        if (node->token->right != NULL) {
+            bel_free_ast_node(node->token->right);
+        }
+	free(node->token);
+    } else {
+	free(node->value->value);
+	free(node->value);
+    }
+
+    free(node);
+};
+
+void bel_print_ast_node(bel_ast_node* node, char* tree_flat_string) {
+    char val[1024 * 32];
+    if (node == NULL) {
+        strcat(tree_flat_string, "(null) ");
+        return;
+    }
+
+    switch(node->type_info->type) {
+        case BEL_TOKEN:
+            switch(node->type_info->ttype) {
+                case BEL_TOKEN_ARG:
+                    strcat(tree_flat_string, "ARG ");
+                    break;
+                case BEL_TOKEN_NV:
+                    strcat(tree_flat_string, "NV ");
+                    break;
+                case BEL_TOKEN_TERM:
+                    strcat(tree_flat_string, "TERM ");
+                    break;
+				case BEL_TOKEN_SUBJECT:
+                    strcat(tree_flat_string, "SUBJECT ");
+                    break;
+				case BEL_TOKEN_REL:
+                    strcat(tree_flat_string, "REL ");
+                    break;
+				case BEL_TOKEN_OBJECT:
+                    strcat(tree_flat_string, "OBJECT ");
+                    break;
+                case BEL_TOKEN_STATEMENT:
+                    strcat(tree_flat_string, "STATEMENT ");
+                    break;
+            };
+            bel_print_ast_node(node->token->left, tree_flat_string);
+            bel_print_ast_node(node->token->right, tree_flat_string);
+            break;
+        case BEL_VALUE:
+            switch(node->type_info->vtype) {
+                case BEL_VALUE_FX:
+					if (node->value->value == NULL) {
+						strcat(tree_flat_string, "fx((null)) ");
+					} else {
+						sprintf(val, "fx(%s) ", node->value->value);
+						strcat(tree_flat_string, val);
+					}
+                    break;
+                case BEL_VALUE_REL:
+					if (node->value->value == NULL) {
+						strcat(tree_flat_string, "rel((null)) ");
+					} else {
+						sprintf(val, "rel(%s) ", node->value->value);
+						strcat(tree_flat_string, val);
+					}
+                    break;
+                case BEL_VALUE_PFX:
+					if (node->value->value == NULL) {
+						strcat(tree_flat_string, "pfx((null)) ");
+					} else {
+						sprintf(val, "pfx(%s) ", node->value->value);
+						strcat(tree_flat_string, val);
+					}
+                    break;
+                case BEL_VALUE_VAL:
+					if (node->value->value == NULL) {
+						strcat(tree_flat_string, "val((null)) ");
+					} else {
+						sprintf(val, "val(%s) ", node->value->value);
+						strcat(tree_flat_string, val);
+					}
+                    break;
+            };
+            break;
+    };
+};
+
+void bel_print_ast(bel_ast* ast) {
+    char tree_flat_string[1024 * 32];
+
+    if (!ast) {
+        return;
+    }
+
+    memset(tree_flat_string, '\0', 1024 * 32);
+    bel_print_ast_node(ast->root, tree_flat_string);
+    fprintf(stdout, "%s\n", tree_flat_string);
+};
+
+char* bel_ast_as_string(bel_ast* ast) {
+    char *tree_flat_string;
+
+    if (!ast) {
+        return NULL;
+    }
+
+    tree_flat_string = calloc(1024 * 32, 1);
+    bel_print_ast_node(ast->root, tree_flat_string);
+    return tree_flat_string;
+};