rbbt-views 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2011 Miguel Vázquez García
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/rbbt/workflow/rest/auth.rb

@@ -0,0 +1,69 @@
+require 'sinatra/base'
+
+module Sinatra
+  module SessionAuth
+
+    module Helpers
+      def authorized?
+        session[:authorized]
+      end
+
+      def user
+        session[:user]
+      end
+
+      def authorize!
+        redirect '/login' unless authorized?
+      end
+
+      def logout!
+        session[:authorized] = false
+      end
+    end
+
+    def self.registered(app)
+      app.helpers SessionAuth::Helpers
+
+      app.set :users, {}
+
+      app.get '/login' do
+        "<h1>Please enter your login information</h1>" +
+        "<form method='POST' action='/login'>" +
+        "<label>Username</label>" +
+        "<input type='text' name='user'>" +
+        "<label>Password</label>" +
+        "<input type='password' name='pass'>" +
+        "<input type='submit' name='Submit'>" +
+        "</form>"
+      end
+
+      app.post '/login' do
+        if options.users.include? params[:user] and options.users[params[:user]] == params[:pass]
+          session[:authorized] = true
+          session[:user] = params[:user]
+          session[:context] = nil
+          redirect '/'
+        else
+          session[:authorized] = false
+          session[:user] = nil
+          session[:context] = nil
+          redirect '/login'
+        end
+      end
+
+      app.get '/logout' do
+        session[:authorized] = false
+        session[:user] = nil
+        session[:context] = nil
+        redirect '/'
+      end
+
+
+
+    end
+  end
+
+  register SessionAuth
+end
+
+

data/lib/rbbt/workflow/rest/client.rb

@@ -0,0 +1,162 @@
+require 'rest_client'
+require 'json'
+require 'rbbt/workflow'
+require 'rbbt/util/misc'
+
+class RbbtRestClient
+
+  attr_accessor :url, :name
+  def to_s
+    @name
+  end
+
+  def initialize(url, name)
+    @url = url
+    @name = name
+    task_names = JSON.parse(RestClient.get(@url + '?_format=json'))
+
+    extend Workflow
+
+    class << self 
+      alias old_job job
+
+      def job(task_name, name, *args)
+        step = old_job(task_name, name, *args)
+
+        class << step
+          attr_accessor :remote_name
+          attr_accessor :original_name
+          attr_accessor :remote_export
+        end
+
+        step.original_name = name || "RestClient"
+
+        step.remote_export = task_info(task_name)[:export]
+
+        class << step
+          def info
+            if remote_name.nil?
+              {:status => :done}
+            else
+              i = JSON.parse(RestClient.get(File.join(task.url, task.name.to_s, remote_name, 'info') + '?_format=json'))
+              IndiferentHash.setup i
+              i[:status] = i.delete(:status).to_sym if i.include? :status
+              i[:messages] = i.delete(:messages) if i.include? :messages
+              i
+            end
+          end
+
+          def load
+            if task.result_type.to_sym == :string
+              RestClient.get(File.join(task.url, task.name.to_s, @remote_name) + "?_format=raw")
+            else
+              res = JSON.parse(RestClient.get(File.join(task.url, task.name.to_s, @remote_name) + "?_format=json"))
+              res = TSV.setup(res) if task.result_type.to_sym == :tsv
+              res
+            end
+          end
+
+          def exec
+            input_hash = Misc.zip2hash(task.inputs, @inputs)
+            input_str = input_hash.collect{|k,v| 
+              [k, 
+                Array === v ? v.dup.collect{|vv| CGI.escape(vv.to_s)} * "," : CGI.escape(v.to_s)
+              ] * "="
+            } * "&"
+
+            case remote_export.to_s 
+            when "exec"
+              url = File.join(task.url, task.name.to_s)
+              if task.result_type.to_sym == :string
+                res = RestClient.post(url, input_hash.merge(:_format => :raw))
+                res
+              else
+                res = RestClient.post(url, input_hash.merge(:_format => :json))
+                JSON.parse(res)
+              end
+            when "synchronous"
+              @remote_name = RestClient.post(File.join(task.url, task.name.to_s), input_hash.merge(:_format => :json, :jobname => original_name))
+              self.load
+            when "asynchronous"
+              @remote_name = RestClient.post(File.join(task.url, task.name.to_s), input_hash.merge(:_format => :json, :jobname => original_name))
+              while not done?
+                sleep 10
+              end
+              self.load
+            end
+          end
+
+          def run
+            exec
+          end
+
+          def fork
+            input_hash = Misc.zip2hash(task.inputs, @inputs)
+            input_str = input_hash.collect{|p| p * "="} * "&"
+
+            case remote_export.to_s 
+            when "exec"
+              raise "Cannot export a remote function exported as 'exec'"
+            when "synchronous"
+              @remote_name = RestClient.post(File.join(task.url, task.name.to_s), input_hash.merge(:_format => :json, :jobname =>  original_name))
+              self
+            when "asynchronous"
+              @remote_name = RestClient.post(File.join(task.url, task.name.to_s), input_hash.merge(:_format => :json, :jobname =>  original_name))
+              self
+            end
+          end
+
+          def clean
+            return if remote_export.to_s == "exec"
+            RestClient.delete(File.join(task.url, task.name.to_s, remote_name) + '?_format=json')
+          end
+
+          def name
+            remote_name || @name
+          end
+
+        end
+
+        step
+      end
+    end
+
+    task_names.each do |task_name|
+      task_info = JSON.parse(RestClient.get(File.join(@url, task_name, 'info') + '?_format=json'))
+      IndiferentHash.setup(task_info)
+
+      desc task_info[:description] if task_info.include? :description
+
+      task_info[:inputs].each do |input_name|
+        input_info = [input_name.to_sym] 
+        IndiferentHash.setup(input_info)
+        input_info << task_info[:input_types][input_name].to_sym if task_info[:input_types].include? input_name
+        input_info << task_info[:input_descriptions][input_name] if task_info[:input_descriptions].include? input_name
+        input_info << task_info[:input_defaults][input_name] if task_info[:input_defaults].include? input_name
+        self.input *input_info
+      end
+
+      case task_info[:export]
+      when "exec"
+        export_exec task_name.to_sym
+      when "synchronous"
+        export_synchronous task_name.to_sym
+      when "asynchronous"
+        export_asynchronous task_name.to_sym
+      end
+
+      task task_name => task_info[:result_type] do |*inputs|
+        raise "Placeholder, this should not execute"
+      end
+    end
+
+    tasks.each do |name, task|
+      class << task
+        attr_accessor :url
+      end
+      task.url = @url
+    end
+  end
+
+end
+

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

@@ -0,0 +1,77 @@
+module EntityOLD
+  ENTITIES = {}
+  METHODS = {}
+  SYNONYMS = {}
+
+  def self.tsv_sort(&block)
+    METHODS[:tsv_sort] = block
+  end
+
+  def self.sort(&block)
+    METHODS[:sort] = block
+  end
+
+  def self.sort_by(&block)
+    METHODS[:sort_by] = block
+  end
+
+  def self.html(&block)
+    METHODS[:html] = block
+  end
+
+  def self.filter(&block)
+    METHODS[:filter] = block
+  end
+
+  def self.link(entity, type, params = {}, text = nil, html_class= nil)
+    if entity.nil?
+      ""
+    else
+      text ||= entity
+      "<a class='entity #{ type.sub(/\s/,'_') }#{html_class.nil? ? "" : " " << html_class}' href='#{File.join('/entity', type, entity)}#{
+        if params.nil? or params.empty?
+          ""
+        else
+          "?" + params.collect{|*p| p * "="} * "&"
+        end
+      }'>#{ text }</a>"
+    end
+  end
+
+  def self.define(name, *synonyms, &block)
+    Log.debug "Defining entity #{ name }"
+    Misc.lock(Rbbt.tmp.sinatra_rbbt.find) do
+      self.instance_exec &block
+      ENTITIES[name] = METHODS.dup
+      METHODS.clear
+    end
+    synonyms.each do |syn|
+      SYNONYMS[syn] = name
+    end
+  end
+end
+
+module Entity
+  module REST
+    def link(text = nil, options = {})
+      return nil if self.nil?
+      if Array === self
+        text ||= self.name if self.respond_to? :name
+        if Array === text
+          translations = Misc.zip2hash(self, text)
+          self.collect{|e| e.link(translations[e])}
+        else
+          self.collect{|e| e.link(text)}
+        end
+      else
+        text ||= self.name if self.respond_to? :name 
+        text = self if text.nil? or text == :literal
+        klass = self.respond_to?(:format)? self.format : annotation_types.collect{|t| t.to_s} * " "
+        klass += " " << options[:extra_classes] if options.include? :extra_classes
+        type = self.respond_to?(:format)? annotation_types.last.to_s + ":" + self.format : annotation_types.last.to_s
+        annotations_str = self.info.reject{|k,v| [:annotation_types, :format].include? k}.collect{|k,v| [k, CGI.escape(v)] * "="} * "&"
+        "<a class='entity #{klass}' href='#{File.join("/entity", type, self) + '?' + annotations_str}'>#{text}</a>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+require 'rbbt/workflow/rest/entity'
+
+module Sinatra
+  module SinatraRbbt
+
+    PAGESIZE = 25
+
+    def parse_page(page)
+      field, num, size = page.split("~").values_at 0, 1, 2
+      if num.nil?
+        num = field
+        field = "key"
+      end
+      size ||= PAGESIZE
+      [field, num, size]
+    end
+
+    def paginate(object, page = nil, just_keys = false)
+      return object unless TSV === object and not page.nil?
+
+      page = "key~1~#{PAGESIZE}" if page.nil? and object.size > 100
+      return object if page.nil? or page == "all"
+      field, num, size = parse_page(page)
+
+      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, entity.method(:tsv_sort))
+      else
+        object.page(num, size, field, just_keys)
+      end
+    end
+    
+    def process_result(result, options)
+      rows = result
+
+      if options.include? :_filter and not options[:_filter].nil?
+        field, query = options[:_filter].split("~")
+
+        entity = Entity.formats[field]
+
+        if entity and entity.respond_to?(:filter)
+          filter_proc = entity.method :filter
+          if filter_proc.respond_to? :curry
+            curried_proc = filter_proc.curry(query, type, options.merge(:tsv => result, :field => field))
+          else
+            curried_proc = Proc.new{|entity|
+              filter_proc.call(query, type, options.merge(:tsv => result, :field => field), entity)
+            }
+          end
+          rows = rows.select field => curried_proc
+        else
+          rows = rows.select field => Regexp.new(query)
+        end
+      end
+
+      total = rows.size
+
+      if options.include? :_page and not options[:_page].nil?
+        keys = paginate(rows, options[:_page], true)
+        
+        if keys
+          rows = keys.zip(rows.values_at *keys)
+        end
+
+      end
+
+      [rows, total]
+    end
+
+    def workflow_render(workflow, task, file, locals = {}, &block)
+      size = locals["_size"] || :normal
+
+      case size.to_sym
+      when :normal
+        path = locate_file(workflow, task, file)
+      when :small
+        begin
+          path = locate_file(workflow, task, file + '.small')
+        rescue
+          Log.debug $!.message
+          path = locate_file(workflow, task, file)
+        end
+      end
+
+      layout = locals[:_layout]
+      layout = false if request.xhr? and layout.nil?
+
+      headers "AJAX-URL" => request.env["REQUEST_URI"]
+
+      locals = Misc.add_defaults locals, :workflow => workflow, :task => task
+
+      renderer = Haml::Engine.new(path.read)
+
+      case
+      when (not layout)
+        renderer.render(self, locals, &block)
+      when (not block_given?)
+        workflow_render(workflow, task, "layout", locals) do 
+          renderer.render(self, locals) 
+        end
+      else
+        renderer.render(self, locals, &block)
+      end
+    end
+
+    def workflow_partial(workflow, task, file, locals = {})
+      workflow_render(workflow, task, file, locals.merge(:_layout => false))
+    end
+
+    def workflow_render_result(workflow, task_name, result, options = {})
+      format = options[:_format]
+      page = options[:_page]
+
+      case 
+      when format.to_sym == :raw
+        content_type "text/plain"
+        if Array === result
+          result * "\n"
+        else
+          result.to_s
+        end
+      when format.to_sym == :json
+        content_type "application/json"
+        if TSV === result
+          result = paginate(result, page)
+          result.to_json
+        else
+          result.to_json
+        end
+      when format.to_sym == :html
+        content_type "text/html"
+        options = Misc.add_defaults options, workflow.task_info(task_name)
+        options = Misc.add_defaults options, :result => result, :workflow => workflow, :task_name => task_name
+        workflow_render(workflow, task_name, "result", options)
+      else
+        raise "Unkonwn format: #{format}"
+      end
+    end
+
+    def entity_render(type, locals, &block)
+      type, format = type.split ":"
+
+      size = locals["_size"] || :normal
+
+      if Entity.formats.include?(format) and not Entity.formats[format].template.nil? or
+        Entity.formats.include?(type) and not Entity.formats[type].template.nil?
+
+        path = Entity.formats[format || type].template
+      else
+        path = nil
+
+        [format, type].each do |file|
+          begin
+            case size.to_sym
+            when :normal
+              file = File.join('entity', file + '.haml')
+              path = locate_file(nil, nil, file)
+            when :small
+              begin
+                file_small = File.join('entity', file + 'small.haml')
+                path = locate_file(nil, nil, file_small)
+              rescue
+                Log.debug $!.message
+                file = File.join('entity', file + '.haml')
+                path = locate_file(nil, nil, file)
+              end
+            end
+          rescue
+            next
+          end
+        end
+
+        raise "Template not found for type, format: #{[type, format] * ", "}" if path.nil?
+      end
+
+      if (Entity.formats.include?(format) or Entity.formats.include?(type)) and locals[:entity]
+        entity = Entity.formats[format || type]
+        entity.setup(locals[:entity], *locals.values_at(*entity.annotations))
+      end
+
+      layout = locals[:_layout]
+      layout = false if request.xhr? and layout.nil?
+
+      headers "AJAX-URL" => request.env["REQUEST_URI"]
+
+      renderer = Haml::Engine.new(path.read)
+
+      case
+      when (not layout)
+        renderer.render(self, locals, &block)
+      when (not block_given?)
+        entity_render(workflow, task, "layout", locals) do 
+          renderer.render(self, locals) 
+        end
+      else
+        renderer.render(self, locals, &block)
+      end
+    end
+
+  end
+end