rbbt-rest 1.1.0

data/lib/rbbt/rest/common/render.rb

@@ -0,0 +1,150 @@
+require 'rbbt/util/misc'
+require 'rbbt/rest/common/cache'
+
+module RbbtRESTHelpers
+  def error_for(job, layout = nil)
+    layout = @layout if layout.nil?
+    layout_file = (layout ? locate_template('layout') : nil)
+    template_file = locate_template('error')
+
+    result = render template_file, {:job => job}, layout_file
+
+    job.clean
+
+    status 500
+    result
+  end
+
+  def wait_on(job, layout = nil)
+    3.times do
+      sleep 1
+      raise RbbtRESTHelpers::Retry if job.done? or job.error?
+    end
+
+    layout = @layout if layout.nil?
+
+    layout_file = (layout ? locate_template('layout') : nil)
+    template_file = locate_template('wait')
+
+    status 202
+    render template_file, {:job => job}, layout_file
+  end
+
+  def render(template_file, locals = {}, layout_file = nil, cache = nil, cache_options = {})
+    if layout_file
+      Haml::Engine.new(Open.read(layout_file), :filename => layout_file).render(self) do
+        cache(cache, locals.merge(:_template_file => template_file, :user => user).merge(cache_options)) do
+          Log.debug("Rendering #{template_file} with layout")
+          Haml::Engine.new(Open.read(template_file), :filename => template_file).render(self, locals)
+        end
+      end
+    else
+      cache(cache, locals.merge(:_template_file => template_file, :user => user).merge(cache_options)) do
+        Log.debug("Rendering #{template_file} without layout")
+        Haml::Engine.new(Open.read(template_file), :filename => template_file).render(self, locals)
+      end
+    end
+  end
+
+  def render_partial(template_file, locals = {}, cache = nil, cache_options = {})
+    render(template_file, locals, nil, cache, cache_options)
+  end
+
+  def template_render(template, locals = {}, cache = nil, cache_options = {})
+    template_file = locate_template(template)
+    layout_file = layout ? locate_template("layout") : nil
+
+    render(template_file, locals, layout_file, cache, cache_options)
+  end
+
+  def partial_render(template, locals = {}, cache = nil, cache_options = {})
+    template_file = locate_template(template)
+    render(template_file, locals, nil, cache, cache_options)
+  end
+
+  def fragment(link = nil,&block)
+    if block_given?
+      if defined? @step and cache_type == :asynchronous or cache_type == :async
+        fragment_code = (rand * 100000).to_i.to_s
+        fragment_file = @step.file(fragment_code)
+
+        pid = @step.child {
+          begin
+            res = capture_haml &block
+            Open.write(fragment_file, res)
+          rescue Exception
+            Open.write(fragment_file + '.error', $!.message)
+            Open.write(fragment_file + '.backtrace', $!.backtrace * "\n") if $!.backtrace
+            raise $!.message
+          end
+        }
+
+        url = request.fullpath
+        url = remove_GET_param(url, "_update")
+        fragment_url = add_GET_param(url, "_fragment", fragment_code)
+        if link.nil?
+          html_tag('a', " ", :href => fragment_url, :class => 'fragment')
+        else
+          if link =~ / href=/
+            link.sub(/ href=('|")/," href='#{fragment_url}'")
+          else
+            link.sub(/<a /,"<a href='#{fragment_url}' ")
+          end
+        end
+      else
+        yield
+        nil
+      end
+    else
+      if link =~ / class=/
+        link.sub(/ class=('|")/,' class=\1fragment ')
+      else
+        link.sub(/<a /,'<a class="fragment" ')
+      end
+    end
+  end
+
+  def modal_fragment(text, &block)
+    link = "<a class='modal_fragment'>#{text}</a>"
+    fragment(link, &block)
+  end
+
+  def resource(filename = nil, text = nil, type = nil, options = {})
+    case
+    when filename.nil?
+      filename = File.basename(TmpFile.tmp_file)
+    when filename[0] == "."[0]
+      extension = filename
+      filename = File.basename(TmpFile.tmp_file) + extension
+    end
+
+    text ||= filename
+
+    filename = Misc.sanitize_filename(filename)
+    f = File.join(settings.file_dir, filename)
+    FileUtils.mkdir_p(File.dirname(f))
+    yield(f)
+
+    type ||= :link
+    case type
+    when :image
+      "<img src='/files/#{ filename }' class='file_resource'/>"
+    when :link
+      "<a href='/files/#{ filename }' class='file_resource'>#{ text }</a>"
+    when :linked_image
+      "<a href='/files/#{ filename }' class='file_resource' target='_blank'><img src='/files/#{ filename }' class='file_resource'/></a>"
+    when :zoomable_image
+      id = options[:id] || Misc.digest(filename)
+      width, height= [600, 600]
+      "<div class='zoomable_image'><img id='#{id}' style='width:#{width}px; height:#{height}px' rel='/files/#{ filename }' src='/files/#{ filename }' class='file_resource'/></div>"
+    when :mapped_image
+      mapid = options[:mapid] || options[:id] + '_map'
+      width, height= [300, 300]
+      mapfile = f.sub(/\.[^.]+$/, '.html')
+      "<div class='mapped_image'>#{Open.read(mapfile)}<img class='has_map' usemap='##{mapid}' rel='/files/#{ filename }' src='/files/#{ filename }' class='file_resource'/></div>"
+    else
+      raise "Type not understood: #{ type }"
+    end
+  end
+end
+ 

data/lib/rbbt/rest/common/resources.rb

@@ -0,0 +1,80 @@
+require 'sass'
+#require 'yui/compressor'
+require 'uglifier'
+
+module RbbtRESTHelpers
+  def recorded_js_files
+    @recorded_js_files ||= []
+  end
+
+  def recorded_css_files
+    @recorded_css_files ||= []
+  end
+
+
+  def record_js(file)
+    recorded_js_files << file
+  end
+
+  def record_css(file)
+    recorded_css_files << file
+  end
+
+  def link_css(file)
+    file += '.css' unless file =~ /.css$/
+    html_tag('link', nil, :rel => 'stylesheet', :type => 'text/css', :href => file)
+  end
+
+  def link_js(file)
+    file += '.js' unless file =~ /.js$/
+    html_tag('script', " ", :src => file, :type => 'text/javascript')
+  end
+
+  def serve_js(compress = true)
+    if production? and compress and not @debug_js 
+      md5 = Misc.digest(recorded_js_files * ",")
+      filename = File.join(settings.file_dir, "all_js-#{md5}.js")
+
+      if not File.exists?(filename)
+        Log.debug("Regenerating JS Compressed file: #{ filename }")
+
+        text = recorded_js_files.collect{|file| 
+          begin
+            path = locate_javascript(file)
+          rescue
+            path = locate_javascript(File.basename(file))
+          end
+
+          Open.read(path)
+        } * "\n"
+
+        FileUtils.mkdir_p File.dirname(filename) unless File.exists? File.dirname(filename)
+        #Open.write(filename, YUI::JavaScriptCompressor.new(:munge => false).compress(text))
+        Open.write(filename, Uglifier.compile(text))
+      end
+
+      res = "<script src='/files/#{File.basename(filename)}' type='text/javascript'></script>"
+    else
+      res = recorded_js_files.collect{|file|
+        link_js(file)
+      } * "\n"
+
+    end
+
+    recorded_js_files.clear
+
+    res
+  end
+
+  def serve_css
+    res = recorded_css_files.collect{|file|
+      link_css(file)
+    } * "\n"
+
+    recorded_css_files.clear
+
+    res
+  end
+
+end
+ 

data/lib/rbbt/rest/common/table.rb

@@ -0,0 +1,169 @@
+require 'rbbt/entity'
+
+module NumericValue
+  extend Entity
+
+  self.format =(<<-EOF
+p-value
+p.value
+P-value
+P.value
+p-values
+p.values
+P-values
+P.values
+score
+scores
+ratio
+ratios
+t.value
+t.values
+adjusted.p.value
+adjusted.p.values
+                EOF
+               ).split("\n")
+
+  def <=>(other)
+    self.to_f <=> other.to_f
+  end
+
+  def self.tsv_sort(v)
+    value = v.last
+    if Array === value
+      value.first.to_f
+    else
+      value.to_f
+    end
+  end
+end
+
+module RbbtRESTHelpers
+  def tsv_rows_full(tsv)
+    case tsv.type 
+    when :single
+      tsv.collect{|id, value| [id, value]}
+    when :list
+      key_field = tsv.key_field
+      tsv.collect{|id, values| values = NamedArray.setup([id].concat(values), values.fields, id, values.entity_options, values.entity_templates); values.fields = [key_field].concat values.fields if values.respond_to? :fields; values }
+    when :flat
+      key_field = tsv.key_field
+      tsv.collect{|id, values| [id, values]}
+    when :double
+      key_field = tsv.key_field
+      tsv.collect{|id, value_lists|  value_lists = NamedArray.setup([id].concat(value_lists), value_lists.fields, id, value_lists.entity_options, value_lists.entity_templates); value_lists.fields = ([key_field].concat value_lists.fields) if value_lists.respond_to? :fields; value_lists }
+    end
+  end
+
+  def parse_page(page)
+    num, size, field = page.split("~").values_at 0, 1, 2
+
+    field, size = size, nil if field.nil?
+
+    field = "key" if field.nil? or field.empty?
+    size = PAGE_SIZE if size.nil? or size.empty?
+
+    [num, size, field]
+  end
+
+  def paginate(object, page = nil, just_keys = false)
+    return object unless TSV === object and not page.nil?
+
+    return object if page == "all" or page.nil?
+    num, size, field = parse_page(page)
+
+    if field and field[0] == "-"[0]
+      field = field[1..-1]
+      reverse = true
+    else
+      reverse = false
+    end
+
+    entity = Entity.formats[field]
+
+    num = num.to_i
+    size = size.to_i
+    max = object.size / size + 1
+
+    num = max if num > max
+    num = - max if num < - max
+
+    if entity and entity.respond_to? :tsv_sort
+      object.page(num, size, field, just_keys, reverse, &entity.method(:tsv_sort))
+    else
+      object.page(num, size, field, just_keys, reverse)
+    end
+  end
+
+  def tsv_rows(tsv, page = nil)
+    page = @page if page.nil?
+    if page.nil? or page.to_s == "false"
+      tsv_rows_full(tsv)
+    else
+      tsv_rows_full(paginate(tsv, page))
+    end
+  end
+
+
+  def table_value(value, type = nil, options = {})
+    options = {} if options.nil?
+    return value.list_link :length, options[:list_id] if Array === value and options[:list_id] 
+
+    entity_options = options[:entity_options]
+
+    Misc.prepare_entity(value, type, entity_options) if Entity.formats.include? type
+
+    value = value.link if value.respond_to? :link
+
+    Array === value ? value * ", " : value
+  end
+
+  def header(field, entity_type, entity_options = {})
+    @table_headers ||= {}
+    @table_headers[field] = [entity_type, entity_options]
+  end
+
+  def table(options = {})
+    options = {} if options.nil?
+
+    tsv = yield
+
+    table_code = (rand * 100000).to_i.to_s
+    table_file = @step.file(table_code)
+
+    url = add_GET_param(@fullpath, "_fragment", File.basename(table_file))
+    url = remove_GET_param(url, "_update")
+    url = remove_GET_param(url, "_")
+
+    table_class = []
+    table_class << 'wide' if tsv.fields.length > 4
+
+    options[:url] = url
+    options[:table_class] = table_class
+    options[:tsv_entity_options] = tsv.entity_options
+
+    if @table_headers and @table_headers.any?
+      options[:headers] = @table_headers
+      @table_headers = {}
+    end
+
+    Open.write table_file, tsv.to_s
+    Open.write table_file + '.table_options', options.to_yaml if defined? options.any?
+
+    total_size = tsv.size
+    if options[:page].nil?  and total_size > PAGE_SIZE * 1.2
+        page = "1"
+    end
+
+    partial_render('partials/table', {:page => page, :total_size => total_size, :rows => tsv_rows(tsv, page), :header => tsv.all_fields, :url => url, :table_class => table_class * " ", :table_options => options.dup})
+  end
+
+  def tsv2html(file)
+    tsv = TSV.open(Open.open(file))
+    table_options = YAML.load_file(file + '.table_options') if File.exists? file + '.table_options'
+    tsv.entity_options = table_options[:tsv_entity_options]
+    headers = table_options[:headers]
+    headers.each{|field,p| tsv.entity_templates[field] = Misc.prepare_entity("TEMPLATE", p.first, p.last) } unless headers.nil?
+    content_type "text/html"
+    halt 200, partial_render('partials/table', {:total_size => tsv.size, :rows => tsv_rows(tsv), :header => tsv.all_fields, :table_options => table_options})
+  end
+end

data/lib/rbbt/rest/common/users.rb

@@ -0,0 +1,68 @@
+require 'rbbt/util/misc'
+
+require 'sinatra/base'
+
+module Sinatra
+  module RbbtAuth
+
+    module Helpers
+      def authorized?
+        session[:authorized]
+      end
+
+      def authorize!
+        return true if authorized?
+        target_url = request.env["REQUEST_URI"]
+        Log.warn("Unauthorized access to #{target_url}")
+        session[:target_url] = target_url
+        redirect '/login' 
+      end
+
+      def logout!
+        session[:authorized] = false
+      end
+
+      def user
+        session[:user]
+      end
+    end
+
+    def self.registered(app)
+      app.helpers RbbtAuth::Helpers
+
+      app.set :users, Rbbt.etc.web_users.yaml
+
+      app.get '/login' do
+        "<form class='login' method='POST' action='/login'>" +
+          "<label for='login_name'>Name: </label>" +
+          "<input id='login_name' type='text' name='user'>" +
+          "<label for='login_pass'>Pass: </label>" +
+          "<input id 'login_pass' type='password' name='pass'>" +
+          "<input type='submit'>" +
+        "</form>"
+      end
+
+      app.post '/login' do
+        user = params[:user]
+        pass = params[:pass]
+
+        if settings.users.include?(user) and settings.users[user] == pass
+          Log.warn("Successful login #{[user, pass] * ": "}")
+          session[:authorized] = true
+          session[:user] = user
+          if session[:target_url]
+            url = session.delete :target_url
+            redirect url
+          else
+            redirect '/'
+          end
+        else
+          Log.warn("Failed login attempt #{[user, pass] * ": "}")
+          session[:authorized] = false
+          redirect '/login'
+        end
+      end
+    end
+  end
+
+end