rbbt-util 4.1.0 → 4.2.0

data/bin/run_workflow.rb

@@ -92,12 +92,15 @@ if options[:server]
   require 'compass'
 
   Workflow.require_workflow workflow
-  WorkflowREST.add_workflows Workflow.workflows.last
+  WorkflowREST.add_workflows *Workflow.workflows
 
   WorkflowREST.setup
 
   Sinatra::Application.port = options[:port] || 4567
   Sinatra::Application.run = true
+  if File.exists? workflow
+    Sinatra::Application.views = File.join(File.dirname(workflow), 'www/views')
+  end
 
 else
 

data/lib/rbbt/annotations.rb

@@ -1,9 +1,12 @@
+require 'rbbt/util/misc'
 require 'rbbt/util/chain_methods'
+
 require 'json'
 module Annotated
   attr_accessor :annotation_types
   attr_accessor :context
   attr_accessor :container
+  attr_accessor :container_index
 
   def self.extended(base)
     base.annotation_types ||= []
@@ -30,53 +33,83 @@ module Annotated
 
   def self.load(object, info)
     annotation_types = info[:annotation_types]
+    annotation_types = annotation_types.split("+") if String === annotation_types
+
     annotation_types.each do |mod|
       mod = Misc.string2const(mod) if String === mod
-      mod.setup_info(object, info)
+      mod.setup(object, *info.values_at(*mod.all_annotations))
     end
 
     object
   end
 
   def tsv_values(*fields)
-    fields = fields.flatten
-    info = self.info
-    values = []
-    fields.each do |field|
-      values << case
-      when field == "JSON"
-        info.to_json
-      when field == "literal"
-        self.gsub(/\n|\t/, ' ') 
-      when info.include?(field.to_sym)
-        info.delete(field.to_sym)
-      when self.respond_to?(field)
-        self.send(field)
+    if Array === self and (not AnnotatedArray === self or self.double_array)
+      Misc.zip_fields(self.compact.collect{|e| e.tsv_values(fields)})
+    else
+      fields = fields.flatten
+      info = self.info
+      values = []
+
+      fields.each do |field|
+        values << case
+        when Proc === field
+          field.call(self)
+        when field == "JSON"
+          info.to_json
+        when field == "annotation_types"
+          annotation_types.collect{|t| t.to_s} * "+"
+        when field == "literal array"
+          (self * "|").gsub(/\n|\t/, ' ')
+        when field == "literal"
+          self.gsub(/\n|\t/, ' ')
+        when info.include?(field.to_sym)
+          info.delete(field.to_sym)
+        when self.respond_to?(field)
+          self.send(field)
+        end
       end
+
+      values
     end
-    values
   end
 
   def self.load_tsv_values(id, values, *fields)
     fields = fields.flatten
     info = {}
     literal_pos = fields.index "literal"
+    literal_array_pos = fields.index "literal array"
 
-    object = if literal_pos.nil?
-               id
+    object = case
+             when literal_pos
+               values[literal_pos]
+             when literal_array_pos
+               values[literal_array_pos].split("|").extend AnnotatedArray
              else
-               v = values[literal_pos]
-               v = v.first if Array === v
-               v
+               id.dup
              end
 
-    fields.each_with_index do |field,i|
-      if field == "JSON"
-        JSON.parse(values[i]).each do |key, value|
-          info[key.to_sym] = value
+    if Array === values
+      Misc.zip_fields(values).collect do |list|
+        fields.each_with_index do |field,i|
+          if field == "JSON"
+            JSON.parse(list[i]).each do |key, value|
+              info[key.to_sym] = value
+            end
+          else
+            info[field.to_sym] = list[i]
+          end
+        end
+      end
+    else
+      fields.each_with_index do |field,i|
+        if field == "JSON"
+          JSON.parse(values[i]).each do |key, value|
+            info[key.to_sym] = value
+          end
+        else
+          info[field.to_sym] = values[i]
         end
-      else
-        info[field.to_sym] = values[i]
       end
     end
 
@@ -84,44 +117,71 @@ module Annotated
   end
 
   def self.tsv(annotations, *fields)
+    return nil if annotations.nil?
     fields = case
              when ((fields.compact.empty?) and not annotations.empty?)
-               fields = annotations.first.annotations
+               fields = AnnotatedArray === annotations ? annotations.annotations : annotations.first.annotations
                fields << :annotation_types
              when (fields == [:literal] and not annotations.empty?)
-               fields = annotations.first.annotations
                fields << :literal
              when (fields == [:all] and not annotations.empty?)
-               fields = [:annotation_types] + annotations.first.annotations
+               fields = [:annotation_types] + (Annotated === annotations ? annotations.annotations : annotations.first.annotations)
                fields << :literal
              else
                fields.flatten
              end
+
     fields = fields.collect{|f| f.to_s}
 
-    tsv = TSV.setup({}, :key_field => "ID", :fields => fields, :type => :list )
+    fields = fields.collect{|f| ((f == "literal" and AnnotatedArray === annotations) ? "literal array" : f)}
 
-    annotations.each do |annotation|
-      tsv[annotation.id] = annotation.tsv_values(fields)
+    case
+    when (Annotated === annotations and not annotations.double_array)
+      tsv = TSV.setup({}, :key_field => "Single", :fields => fields, :type => :list, :unnamed => true)
+      tsv[annotations.id] = annotations.tsv_values(*fields)
+    when Array === annotations 
+      tsv = TSV.setup({}, :key_field => "ID", :fields => fields, :type => :list, :unnamed => true)
+      annotations.compact.each do |annotation|
+        tsv[annotation.id] = annotation.tsv_values(*fields)
+      end
+    else
+      raise "Annotations need to be an Array to create TSV"
     end
 
     tsv
   end
 
   def self.load_tsv(tsv)
-    tsv.collect do |id, values|
-      Annotated.load_tsv_values(id, values, tsv.fields)
+    tsv.with_unnamed do
+      annotated_entities = tsv.collect do |id, values|
+        Annotated.load_tsv_values(id, values, tsv.fields)
+      end
+
+      if tsv.key_field == "Single"
+        annotated_entities.first
+      else
+        annotated_entities[0].annotate annotated_entities unless annotated_entities.empty?
+      end
     end
   end
 
   def make_list
     new = [self]
     annotation_types.each do |mod|
-      mod.setup(new, *info.values_at(*mod.annotations))
+      mod.setup(new, *info.values_at(*mod.all_annotations))
     end
     new.context = self.context
     new
   end
+
+  def annotate(object)
+    annotation_types.each do |mod|
+      mod.setup(object, *info.values_at(*mod.annotations))
+    end
+    object.context = self.context
+    object.container = self.container
+    object
+  end
 end
 
 
@@ -145,12 +205,12 @@ module Annotation
 
         def self.extended(object)
           self.send(:prev_annotation_extended, object)
-          object.extend Annotated
-          if not object.annotation_types.include? self
-            object.annotation_types.concat self.inheritance 
-            object.annotation_types << self
-            object.annotation_types.uniq!
-          end
+            object.extend Annotated unless Annotated == object
+            if not object.annotation_types.include? self
+              object.annotation_types.concat self.inheritance 
+              object.annotation_types << self
+              object.annotation_types.uniq!
+            end
         end
 
         def self.included(base)
@@ -166,7 +226,7 @@ module Annotation
   end
 
   def update_annotations
-    @all_annotations = all_inheritance.inject([]){|acc,mod| acc.concat mod.annotations}.concat(@annotations)
+    @all_annotations = all_inheritance.inject([]){|acc,mod| acc.concat mod.all_annotations}.concat(@annotations)
   end
 
   def annotation(*values)
@@ -179,14 +239,14 @@ module Annotation
   end
 
  def setup_info(object, info)
-    object.extend self
+    object.extend self unless self === object
     all_annotations.each do |annotation|
       object.send(annotation.to_s + '=', info[annotation])
     end
   end
 
   def setup(object, *values)
-    object.extend self
+    object.extend self unless self === object
 
     inputs = Misc.positional2hash(all_annotations, *values)
     inputs.each do |name, value|
@@ -195,29 +255,47 @@ module Annotation
 
     object
   end
+
 end
 
 module AnnotatedArray
   extend ChainMethods
   self.chain_prefix = :annotated_array
 
+  def double_array
+    AnnotatedArray === self.first
+  end
+
+  def annotated_array_first
+    self[0]
+  end
+
+  def annotated_array_last
+    self[-1]
+  end
+
   def annotated_array_get_brackets(pos)
     value = annotated_array_clean_get_brackets(pos)
     annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.annotations))
+      mod.setup(value, *info.values_at(*mod.all_annotations))
     end
     value.context = self.context
     value.container = self
+    value.container_index = pos
     value
   end
 
   def annotated_array_each
+    i = 0
     annotated_array_clean_each do |value|
+      value = value.dup if value.frozen?
       annotation_types.each do |mod|
         mod.setup(value, info)
       end
       value.context = self.context
       value.container = self
+      value.container_index = i
+      i += 1
       yield value
     end
   end
@@ -237,7 +315,7 @@ module AnnotatedArray
     annotated_array_each do |value|
       res << value if yield(value)
     end
- 
+
     annotation_types.each do |mod|
       mod.setup(res, *info.values_at(*mod.annotations))
     end
@@ -252,7 +330,7 @@ module AnnotatedArray
     annotated_array_each do |value|
       res << value unless yield(value)
     end
- 
+
     annotation_types.each do |mod|
       mod.setup(res, *info.values_at(*mod.annotations))
     end
@@ -265,7 +343,7 @@ module AnnotatedArray
   def annotated_array_subset(list)
     value = (self & list)
     annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.annotations))
+      mod.setup(value, *info.values_at(*mod.all_annotations))
     end
     value.context = self.context
     value.container = self.container
@@ -282,6 +360,18 @@ module AnnotatedArray
     value
   end
 
+  def annotated_array_compact
+    value = self.annotated_array_clean_compact
+
+    annotation_types.each do |mod|
+      mod.setup(value, *info.values_at(*mod.annotations))
+    end
+
+    value.context = self.context
+    value.container = self.container
+    value
+  end
+ 
   def annotated_array_uniq
     value = self.annotated_array_clean_uniq
 
@@ -353,11 +443,6 @@ module AnnotatedArray
       value << e if method.shift
     end
 
-    #annotation_types.each do |mod|
-    #  mod.setup(value, *info.values_at(*mod.annotations))
-    #end
-    #value.context = self.context
-    #value.container = self.container
     value
   end
 end

data/lib/rbbt/persist.rb

@@ -10,6 +10,8 @@ module Persist
   CACHEDIR="/tmp/tsv_persistent_cache"
   FileUtils.mkdir CACHEDIR unless File.exist? CACHEDIR
 
+  MEMORY = {}
+
   def self.cachedir=(cachedir)
     CACHEDIR.replace cachedir
     FileUtils.mkdir_p CACHEDIR unless File.exist? CACHEDIR
@@ -62,7 +64,11 @@ module Persist
     persistence_dir = Misc.process_options(persist_options, :dir) || CACHEDIR
 
     filename = perfile.gsub(/\s/,'_').gsub(/\//,'>')
-    options_md5 = Misc.hash2md5 options
+    clean_options = options
+    clean_options.delete :unnamed
+    clean_options.delete "unnamed"
+
+    options_md5 = Misc.hash2md5 clean_options
     filename  << ":" << options_md5 unless options_md5.empty?
 
     File.join(persistence_dir, filename)
@@ -75,6 +81,8 @@ module Persist
       nil
     when :boolean
       TRUE_STRINGS.include? Open.read(path).chomp.strip
+    when :annotations
+      Annotated.load_tsv TSV.open(path)
     when :tsv
       TSV.open(path)
     when :marshal_tsv
@@ -104,7 +112,7 @@ module Persist
 
   def self.save_file(path, type, content)
 
-    return if (content.nil? and File.exists? path)
+    return if content.nil?
     
     case (type || "nil").to_sym
     when :nil
@@ -116,6 +124,8 @@ module Persist
       Open.write(path, content.file.read)
     when :tsv
       Open.write(path, content.to_s)
+    when :annotations
+      Open.write(path, Annotated.tsv(content, :all).to_s)
     when :string, :text
       Open.write(path, content)
     when :array
@@ -140,19 +150,27 @@ module Persist
   def self.persist(name, type = nil, persist_options = {})
     type ||= :marshal
     persist_options = Misc.add_defaults persist_options, :persist => true
+    other_options = Misc.process_options persist_options, :other
 
     if persist_options[:persist]
-      path = persistence_path(name, persist_options)
-      Misc.lock(path) do
-        if is_persisted?(path, persist_options)
-          Log.debug "Persist up-to-date: #{ path } - #{persist_options.inspect}"
-          return load_file(path, type) 
-        else
-          Log.debug "Persist create: #{ path } - #{persist_options.inspect}"
+      path = persistence_path(name, persist_options, other_options || {})
+
+      case type
+      when :memory
+        Persist::MEMORY[path] ||= yield
+      else
+        Misc.lock(path) do
+          if is_persisted?(path, persist_options)
+            Log.debug "Persist up-to-date: #{ path } - #{persist_options.inspect[0..100]}"
+            return nil if persist_options[:no_load]
+            return load_file(path, type) 
+          else
+            Log.debug "Persist create: #{ path } - #{persist_options.inspect[0..100]}"
+          end
+          res = yield
+          save_file(path, type, res)
+          res
         end
-        res = yield
-        save_file(path, type, res)
-        res
       end
     else
       yield