rbbt-rest 1.1.0

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

@@ -0,0 +1,76 @@
+require 'rbbt/util/open'
+require 'rbbt/rest/common/render'
+
+require 'haml'
+module EntityRESTHelpers
+
+  def setup_entity(type, entity, params)
+    base_type, format = type.split ":"
+    entity_class = case
+                   when Entity.formats.include?(format)
+                     Entity.formats[format] 
+                   when Entity.formats.include?(base_type)
+                     Entity.formats[base_type] 
+                   else
+                     nil
+                   end
+
+    raise "Unknown entity type: #{ type }" if entity_class.nil?
+
+    entity_annotations = {}
+    entity_class.annotations.each do |annotation|
+      value = consume_parameter annotation, params
+      value = false if value == "false"
+      value = true if value == "true"
+      entity_annotations[annotation] = value
+    end
+
+    entity.extend entity_class
+    entity_class.setup_hash(entity, entity_annotations)
+    entity.format = format if format and entity.respond_to? :format
+
+    entity
+  end
+
+  def entity_render(entity)
+    template_file = locate_entity_template(entity)
+
+    locals = {:entity => entity}
+
+    layout_file = layout ? locate_template("layout") : nil
+
+    render(template_file, locals, layout_file, "Entity: #{ entity }")
+  end
+
+  def entity_action_render(entity, action, params = {})
+    template_file = locate_entity_action_template(entity, action)
+
+    locals = params.merge({:entity => entity})
+
+    layout_file = layout ? locate_template("layout") : nil
+
+    render(template_file, locals, layout_file, "Entity #{ action }: #{ entity }")
+  end
+
+  def entity_list_render(list, id)
+    template_file = locate_entity_list_template(list)
+
+    locals = {:list => list, :list_id => id}
+
+    layout_file = layout ? locate_template("layout") : nil
+
+    render(template_file, locals, layout_file, "Entity list: #{ id }")
+  end
+
+  def entity_list_action_render(list, action, id, params = {})
+    template_file = locate_entity_list_action_template(list, action)
+
+    locals = params.merge({:list => list, :list_id => id})
+
+    layout_file = layout ? locate_template("layout") : nil
+
+    render(template_file, locals, layout_file, "Entity list #{ action }: #{ id }")
+  end
+end
+
+

data/lib/rbbt/rest/entity/rest.rb

@@ -0,0 +1,181 @@
+require 'rbbt/util/misc'
+require 'rbbt/rest/entity/list'
+
+module Entity
+  module REST
+    USE_ENSEMBL = true
+
+    REST_ENTITIES = []
+
+    def self.included(base)
+      REST_ENTITIES << base
+    end
+
+    #{{{ MISC
+    
+    def self.clean_element(elem)
+      elem.gsub('/', '--')
+    end
+ 
+    def self.restore_element(elem)
+      CGI.unescape(elem.gsub('--', '/'))
+    end
+
+    def entity_link_params
+      info = self.info
+      info.delete :format
+      info.delete :annotation_types
+      info.delete :annotated_array
+      info
+    end
+
+    def base_type
+      annotation_types.select{|mod| mod.include? Entity::REST }.first.to_s
+    end
+
+    def klasses
+      klasses = []
+      klasses << base_type.to_s if base_type
+      klasses << format if self.respond_to? :format and format
+      klasses.collect{|klass| klass.gsub(/\s/, '_') }
+    end
+    
+    def entity_type
+      entity_type = self.respond_to?(:format) ? [base_type, format].compact.join(":") : base_type
+    end
+
+    def process_link_options(options = {}, include_entity_params = true)
+      attributes = {}
+      link_params = include_entity_params ? entity_link_params : {}
+
+      %w(class style title).each do |at|
+        attributes[at.to_sym] = options.delete(at.to_sym) || 
+          options.delete(at.to_s) || 
+          nil
+      end
+
+      attributes[:class] = attributes[:class].split(" ") if String === attributes[:class]
+
+      attributes[:class] = [] if attributes[:class].nil?
+
+      link_params = link_params.merge(options)
+
+      [attributes, link_params]
+    end
+
+    #{{{ URLS
+    
+    def self.entity_url(entity, type, params = {})
+      url = File.join('/', 'entity', Entity::REST.clean_element(type.to_s), entity) 
+      url << "?" << Misc.hash2GET_params(params) if params.any?
+      url
+    end
+
+    def self.entity_action_url(entity, type, action, params = {})
+      url = File.join('/', 'entity_action', Entity::REST.clean_element(type.to_s), action.to_s, entity)
+      url << "?" << Misc.hash2GET_params(params) if params.any?
+      url
+    end
+
+    def self.entity_list_url(list, type)
+      File.join('/', 'entity_list', Entity::REST.clean_element(type.to_s), Entity::REST.clean_element(list))
+    end
+
+    def self.entity_list_action_url(list, type, action, params)
+      url = File.join('/', 'entity_list_action', Entity::REST.clean_element(type.to_s), action.to_s, Entity::REST.clean_element(list))
+      url << "?" << Misc.hash2GET_params(params) if params.any?
+      url
+    end
+
+
+    #{{{ LINKS
+
+    def link(text = nil, options = {})
+      #return self.tap{|a| a.extend AnnotatedArray}.collect{|e| e.link(text, options) } if Array === self
+      return self.collect{|e| e.link(text, options) } if Array === self
+
+      klasses = self.klasses
+      klasses <<  'entity'
+
+      attributes, link_params = process_link_options(options)
+
+      attributes[:class] << klasses
+      attributes[:href] = Entity::REST.entity_url(self, entity_type.to_s, link_params)
+
+      text = self.respond_to?(:name)? self.name || self : self if text.nil?
+      attributes[:title] = text if attributes[:title].nil?
+
+      Misc.html_tag('a', text, attributes)
+    end
+
+
+    def action_link(action, text = nil, options = {})
+      return self.collect{|e| e.link(action, text) } if Array === self
+
+      klasses = self.klasses
+      klasses << 'entity_action'
+
+      attributes, link_params = process_link_options({:title => [action, self] * ": " }.merge(options))
+
+      attributes[:class] << klasses
+      attributes[:href] = Entity::REST.entity_action_url(self, entity_type.to_s, action, link_params)
+
+      if text.nil? or (String === text and text.empty?)
+        text = self.respond_to?(:name)? self.name || self : self if text.nil?
+        text = [text, action] * "&rarr;"
+      end
+      Misc.html_tag('a', text, attributes)
+    end
+
+    def list_link(text = nil, id = nil, options = {})
+      options = Misc.add_defaults options, :ensembl => USE_ENSEMBL
+      ensembl = Misc.process_options options, :ensembl
+
+      if ensembl and self.respond_to? :ensembl and self.format !~ /^Ensembl /
+        return self.ensembl.compact.uniq.list_link(text, id, options.merge({:ensembl => false}))
+      end
+
+      text = self.length if text.nil? or text == :length or (String === text and text.strip.empty?)
+      id = options[:id] || Misc.digest((self * "|").inspect) if id.nil? or (String === id and id.empty?)
+
+      reuse = options.delete(:reuse)
+      reuse = options.delete("reuse") if reuse.nil?
+      reuse = true if reuse.nil?
+
+      Entity::List.save_list(entity_type.to_s, id, self) unless reuse and File.exists? Entity::List.list_file(entity_type.to_s, id, self)
+
+      klasses = self.klasses
+      klasses << 'entity_list'
+
+      attributes, link_params = process_link_options(options)
+
+      attributes[:class] = klasses
+      attributes[:href] = Entity::REST.entity_list_url(id, entity_type.to_s)
+
+      attributes[:title] = id
+      Misc.html_tag('a', text, attributes)
+    end
+
+    def list_action_link(action, text = nil, id = nil, options = {})
+      text = [id, action] * "&rarr;" if text.nil? or (String === text and text.strip.empty?)
+      id = options[:id] || Misc.digest((self * "|").inspect) if id.nil? or (String === id and id.empty?)
+
+      reuse = options.delete(:reuse)
+      reuse = options.delete("reuse") if reuse.nil?
+      reuse = true if reuse.nil?
+
+      Entity::List.save_list(entity_type.to_s, id, self) unless reuse and File.exists? Entity::List.list_file(entity_type.to_s, id, self)
+
+      klasses = self.klasses
+      klasses << 'entity_list_action'
+
+      attributes, link_params = process_link_options({:title => [action, id] * ": " }.merge(options), false)
+
+      attributes[:class] = klasses
+      attributes[:href] = Entity::REST.entity_list_action_url(id, entity_type.to_s, action, link_params)
+
+      attributes[:title] = id if attributes[:title].nil?
+      Misc.html_tag('a', text, attributes)
+    end
+  end
+end

data/lib/rbbt/rest/file_server.rb

@@ -0,0 +1,64 @@
+require 'rbbt'
+require 'sinatra/base'
+
+module Sinatra
+  module RbbtRESTFileServer
+    
+    def self.registered(base)
+      base.module_eval do
+
+        get '/resource/:resource/get_directory' do
+          directory, resource, create = params.values_at :directory, :resource, :create
+
+          create = true unless create.nil? or create.empty? or %w(no false).include? create.downcase
+
+          raise "The Rbbt resource may not be used since it has access to seccurity sensible files" if resource == "Rbbt"
+
+          resource = Kernel.const_get(resource)
+
+          path = resource.root[directory]
+
+          raise "For security reasons the file path must not leave the resource root directory" unless Misc.path_relative_to(resource.root, path)
+
+          Log.debug("Serving resource: #{[resource, directory, path, path.find] * " | "}")
+
+          raise "Directory does not exist" unless path.exists? or create
+          raise "Directory does not exist and can not create it" unless path.exists? or path.produce.exists?
+
+          stream(:binmode => true) do |out|
+
+            io = Misc.in_dir path.find do
+              CMD.cmd("tar cfz - '.'", :pipe => true)
+            end
+
+            while not io.closed? and block = io.read(4096) 
+              out << block
+            end
+          end
+        end
+
+        get '/resource/:resource/get_file' do
+          file, resource, create = params.values_at :file, :resource, :create
+
+          create = true unless create.nil? or create.empty? or %w(no false).include? create.downcase
+
+          raise "The Rbbt resource may not be used since it has access to seccurity sensible files" if resource == "Rbbt"
+
+          resource = Kernel.const_get(resource)
+
+          path = resource.root[file]
+
+          raise "For security reasons the file path must not leave the resource root directory" unless Misc.path_relative_to(resource.root, path)
+
+          Log.debug("Resource: #{[resource, file, path, path.find] * " | "}")
+
+          raise "File does not exist" unless path.exists? or create
+          raise "File does not exist and can not create it" unless path.exists? or path.produce.exists?
+
+          send_file path.find, :filename => path
+        end
+
+      end
+    end
+  end
+end

data/lib/rbbt/rest/helpers.rb

@@ -0,0 +1,44 @@
+module Sinatra
+  module RbbtMiscHelpers
+    def OR_matrices(m1, m2)
+      samples = m1.fields
+      new = TSV.setup({}, :key_field => "Ensembl Gene ID", :fields => samples)
+
+      m1.each do |gene, values|
+        new[gene] = values
+      end
+
+      m2.each do |gene, values|
+        if new.include? gene
+          new[gene] = new[gene].zip(values).collect do |old, new|
+            case
+            when old == new
+              old
+            else
+              "TRUE"
+            end
+          end
+        else
+          new[gene] = values
+        end
+      end
+
+      new
+    end
+
+    def exome_bed_file_for_genes(genes)
+      bed = TSV.setup({}, :key_field => "Ensembl Exon ID", :fields => %w(chr start end gene), :type => :list)
+      organism = genes.organism
+      exon_info = Organism.exons(organism).tsv :fields => ["Chromosome Name", "Exon Chr Start", "Exon Chr End"], :persist => true
+      exons_for = Organism.exons(organism).tsv :key_field => "Ensembl Gene ID", :fields => ["Ensembl Exon ID"], :persist => true, :merge => true, :type => :flat
+      genes.each do |gene|
+        exons = exons_for[gene.ensembl]
+        exons.each do |exon|
+          chr, start, eend = exon_info[exon]
+          bed[exon] = [chr, start, eend, gene]
+        end
+      end
+      bed
+    end
+  end
+end

data/lib/rbbt/rest/main.rb

@@ -0,0 +1,100 @@
+require 'rbbt/rest/common/locate'
+require 'rbbt/rest/common/resources'
+require 'rbbt/rest/common/users'
+require 'ruby-prof'
+
+require 'sinatra/base'
+require 'json'
+
+module Sinatra
+  module RbbtRESTMain
+    def add_sass_load_path(path)
+      Sass::Engine::DEFAULT_OPTIONS[:load_paths].unshift path
+    end
+
+    def self.registered(base)
+      base.module_eval do
+        helpers RbbtRESTHelpers
+        register Sinatra::RbbtAuth
+
+        set :cache_dir, Rbbt.var.sinatra.cache.find unless settings.respond_to? :cache_dir and settings.cache_dir != nil
+        set :file_dir, Rbbt.var.sinatra.files.find unless settings.respond_to? :file_dir and settings.file_dir != nil
+
+        set :public_folder, Rbbt.share.views.public.find 
+
+        attr_accessor :ajax, :layout, :format, :size, :update, :cache_type, :_, :profile
+
+        set :haml, { :ugly => true }
+        if production?
+          set :haml, { :ugly => true }
+          set :clean_trace, true
+          set :static_cache_control , [:public, {:max_age => 360000}]
+        end
+
+        before do
+          Log.debug("IP #{request.ip}: " << request.path_info << ". Params: " << params.inspect)
+          process_common_parameters
+
+          if profile
+            RubyProf.start 
+          end
+        end
+
+        after do
+
+          if profile
+            result = RubyProf.stop
+            printer = RubyProf::MultiPrinter.new(result)
+            dir = TmpFile.tmp_file
+            FileUtils.mkdir_p dir unless File.exists? dir
+            printer.print(:path => dir, :profile => 'profile')
+            Log.info("Profile saved at #{ dir }")
+          end
+
+          request
+        end
+
+        add_sass_load_path Rbbt.views.compass.find
+
+        get '/files/:filename' do
+          cache_control :public, :max_age => 360000 if production?
+          file = File.join(settings.file_dir, params[:filename])
+          send_file file
+        end
+
+        get %r{/js/(.*)(.js)?} do
+          name = consume_parameter(:captures).first
+
+          script_file = locate_javascript(name)
+
+          cache_control :public, :max_age => 360000 if production?
+          send_file script_file
+        end
+
+        get '/stylesheets/:name.css' do
+          name = consume_parameter :name
+
+          file = locate_sass(name)
+
+          content_type 'text/css', :charset => 'utf-8'
+          cache_control :public, :max_age => 360000 if production?
+
+          @cache_type = production? ? :synchronous : :none
+          cache('css', :_template_file => file, :_send_file => true) do
+            Log.debug("Rendering stylesheets")
+            renderer = Sass::Engine.new(Open.read(file), :filename => file, 
+                                        :style => production? ? :compressed : nil, 
+                                        :debug_info => production? ? false : true)
+            renderer.render
+          end
+        end
+
+        get '/' do
+          template_render('main', params)
+        end
+
+      end
+    end
+  end
+end
+