scout-camp 0.1.13 → 0.1.14

data/lib/scout/sinatra/base.rb

@@ -0,0 +1,253 @@
+require_relative 'base/helpers'
+require_relative 'base/headers'
+require_relative 'base/parameters'
+require_relative 'base/assets'
+require_relative 'base/session'
+require_relative '../render/engine'
+
+module SinatraScoutBase
+  def self.registered(app)
+    class << app
+      def post_get(...)
+        get(...)
+        post(...)
+      end
+    end
+
+    app.helpers ScoutRenderHelpers
+    app.register SinatraScoutHelpers
+
+    app.register SinatraScoutHeaders
+    app.register SinatraScoutParameters
+    app.register SinatraScoutPostProcessing
+    app.register SinatraScoutAssets
+    app.register SinatraScoutSession
+
+    app.helpers do
+      def json_halt(status, object = nil)
+        status, object = 200, status if object.nil? 
+        content_type 'application/json'
+        halt status, (object.is_a?(String) ? {message: object}.to_json : object.to_json)
+      end
+
+      def html_halt(status, text = nil)
+        status, text = 200, status if text.nil? 
+        content_type 'text/html'
+        halt status, text
+      end
+
+      def return_json(object)
+        json_halt 200, object
+      end
+
+      def charset_meta
+        '<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">'
+      end
+
+      def html(content, layout = false, extension: %w(slim haml erb))
+        return charset_meta + content unless _layout
+        return charset_meta + content unless layout
+        layout = 'layout' if TrueClass === layout
+        layout_file = ScoutRender.find_resource('layout', extension: extension )
+        ScoutRender.render(layout_file, exec_context: self) do
+          content
+        end
+      end
+
+      def initiate_step(step, layout = nil, http_status = 200)
+        step.clean if _update == :clean
+        step.recursive_clean if _update == :recursive_clean
+        #step.clean if step.recoverable_error? && _update
+
+
+        return step if step.done?
+
+        case _cache_type
+        when :synchronous, :sync
+          step.run
+        when :asynchronous, :async
+          step.fork unless step.started?
+        when :exec
+          halt http_status, html(step.exec, layout)
+        end
+
+        Open.wait_for(step.path, timeout: 0.5)
+
+        step.join if step.done?
+
+        step
+      end
+
+      def serve_step(step, layout = nil, http_status = 200, &block)
+        layout = _layout if layout.nil?
+        status = step.status
+        step.status = :done if step.done? && ! status == :done
+        status = :done if step.done?
+        case status
+        when :error, 'error'
+          Log.exception step.exception if Exception === step.exception
+          raise step.exception
+        when :done, 'done'
+          step.join
+          if block_given?
+            block.call step
+          else
+            halt http_status || 200, html(step.load, layout)
+          end
+        else
+          render_or('wait', "Waiting on #{step.path}", cache: false, step: step, http_status: 202)
+        end
+      end
+
+      def serve_step_info(step)
+        case step.status
+        when 'done'
+          json_halt 200, step.info
+        when 'error'
+          json_halt 500, step.info
+        else
+          json_halt 202, step.info
+        end
+      end
+
+      def serve_step_json(step)
+        case step.status
+        when 'done'
+          json_halt 200, step.load.to_json
+        when 'error'
+          json_halt 500, step.info
+        else
+          json_halt 202, step.info
+        end
+      end
+
+      def serve_step_raw(step)
+        case step.status
+        when 'done'
+          status 200
+          mime_file step.path.find
+        when 'error'
+          json_halt 500, step.info
+        else
+          json_halt 202, step.info
+        end
+      end
+
+
+      def render_template(template, options = {}, &block)
+        layout, http_status = IndiferentHash.process_options options, :layout, :http_status,
+          layout: _layout
+        options = IndiferentHash.setup(clean_params).merge(options) if defined?(clean_params)
+        options = IndiferentHash.add_defaults options,
+          update: _update,
+          persist_step: _step,
+          cache: _cache_type != :none
+
+        step = ScoutRender.render_template(template, options.merge(exec_context: self, run: false, current_user: current_user), &block)
+        if String === step
+          status http_status if http_status
+          return html step, layout
+        end
+
+        @step = step
+
+        initiate_step step, layout, http_status
+
+        post_processing @step
+
+        serve_step step, layout, http_status
+      end
+
+      def render_partial(template, options = {}, &block)
+        render_template(template, options.merge(layout: false, cache: false), &block)
+      end
+
+      def render_or(template, alt=nil, params = {}, &block)
+        begin
+          render_template(template, params)
+        rescue TemplateNotFoundException
+          if block_given?
+            if block.arity == 0
+              block.call
+            else
+              block.call params
+            end
+          else
+            status = IndiferentHash.process_options params, :http_status, http_status: 200
+            halt status, alt
+          end
+        end
+      end
+    end
+
+    #{{{ HOOKS
+
+    app.before do
+      $script_name = script_name
+
+      if request_method == 'POST' && request.content_type.include?('json')
+        begin
+          post_text = request.body.read
+          post_data = JSON.parse(post_text)
+          params.merge!(post_data)
+        rescue
+          Log.exception $!
+        end
+      end
+
+      method_color = case request_method
+                     when "GET"
+                       :cyan
+                     when "POST"
+                       :yellow
+                     end
+
+      Log.medium{ "#{Log.color method_color, request_method} #{Log.color(:blue, request.ip)}: " << path_info.gsub('/', Log.color(:blue, "/")) << ". Params: " << Log.color(:blue, Log.fingerprint(params))}
+
+      process_common_parameters
+
+      headers 'Access-Control-Allow-Origin' => '*'
+    end
+
+    app.after do
+      if @step
+        headers 'SCOUT_RENDER_STEP' => @step.name
+      end
+
+      if _update == :reload
+        redirect to(fullpath)
+      end
+    end
+
+    app.error  do
+      error = env['sinatra.error']
+      case _format
+      when :json
+        json_halt 500, {class: error.class.to_s, error: error.message, backtrace: error.backtrace}
+      else
+        render_or "error", error: error.message, backtrace: error.backtrace, http_status: 500 do
+          <<-EOF
+<pre>#{error.class}<pre/>
+<pre>#{error.message}<pre/>
+<pre>#{error.backtrace * "\n"}<pre/>
+          EOF
+        end
+      end
+    end
+
+    #{{{ ROUTES
+
+    app.post_get "/" do
+      render_template('main', clean_params)
+    end
+
+    app.post_get "/main/*" do
+      $title = "Scout"
+      splat = consume_parameter :splat
+      splat.unshift 'main'
+      template = splat * "/"
+      render_template(template, clean_params)
+    end
+
+  end
+end

data/lib/scout/sinatra/entity.rb

@@ -0,0 +1,259 @@
+require 'sinatra/base'
+require_relative 'base'            # SinatraScoutHelpers: requested_format, consume_parameter
+require_relative 'knowledge_base'            # SinatraScoutHelpers: requested_format, consume_parameter
+
+module SinatraScoutEntity
+  def self.registered(app)
+    app.register SinatraScoutKnowledgeBase
+
+    # utilities local to the component
+    app.helpers do
+      def clean_element(elem)
+        elem.to_s.gsub('&', '--AND--').
+          gsub('/', '-..-').
+          gsub("|", '-...-').
+          gsub('%', 'o-o').
+          gsub('[','(.-(').
+          gsub(']',').-)')
+      end
+
+      def restore_element(elem)
+        CGI.unescape(CGI.unescape(
+          elem.gsub('--AND--', '&').
+          gsub('-..-', '/').
+          gsub('-...-', '|').
+          gsub('o-o', '%').
+          gsub('(.-(','[').
+          gsub(').-)',']')
+        ))
+      end
+
+      def setup_entity(type, entity, params)
+        return Entity.prepare_entity entity, type, params
+
+        base_type, format = type.split ":"
+        entity_class = case
+                       when Entity.formats.include?(base_type)
+                         Entity.formats[base_type] 
+                       when Entity.formats.include?(format)
+                         Entity.formats[format] 
+                       else
+                         nil
+                       end
+
+        raise "Unknown entity type: #{ type }" if entity_class.nil?
+
+        entity_class.setup(entity, params)
+        entity_class.annotations.each{|annotation| params.delete annotation }
+
+        entity.format = format if format and entity.respond_to? :format
+
+        entity
+      end
+
+      def entity_template(entity, type = :entity, other = nil)
+        file = case type
+               when :entity
+                 File.join('entity', entity.base_type.to_s)
+               when :action, :property
+                 File.join('entity', entity.base_type.to_s, other.to_s)
+               end 
+        return file if ScoutRender.exists?(file)
+
+        file = case type
+               when :entity
+                 File.join('entity', "Default")
+               when :action, :property
+                 File.join('entity', "Default", other.to_s)
+               end 
+        return file if ScoutRender.exists?(file)
+
+        raise TemplateNotFoundException, "Template not found for entity type #{entity.base_type} action #{other}" if other
+        raise TemplateNotFoundException, "Template not found for entity type #{entity.base_type}"
+      end
+
+      def entity_list_template(list, type = :entity, other = nil)
+        file = case type
+               when :entity
+                 File.join('entity_list', list.base_type.to_s)
+               when :action
+                 File.join('entity_list', list.base_type.to_s, other.to_s)
+               end 
+        return file if ScoutRender.exists?(file)
+
+        file = case type
+               when :entity
+                 File.join('entity_list', 'Default')
+               when :action
+                 File.join('entity_list', 'Default', other.to_s)
+               end 
+        return file if ScoutRender.exists?(file)
+
+        raise "Template not found for entity list type #{list.base_type} action #{other}" if other
+        raise "Template not found for entity list type #{list.base_type}"
+      end
+
+      def render_entity_template(entity, type = :entity, other = nil, params = {})
+        template = entity_template(entity, type, other)
+        render_template(template, params.merge(entity: entity))
+      end
+
+      def entity_list_template(list, type = :entity, other = nil, params = {})
+        template = entity_list_template(list, type, other)
+        render_template(template, params.merge(list: list))
+      end
+
+      def render_entity_partial(entity, type = :entity, other = nil, params = {})
+        template = entity_template(entity, type, other)
+        render_partial(template, params.merge(entity: entity))
+      end
+
+      def entity_list_partial(list, type = :entity, other = nil, params = {})
+        template = entity_list_template(list, type, other)
+        render_partial(template, params.merge(list: list))
+      end
+
+      def entity_url(entity, type = :entity, other = nil, params = {})
+        url = '/' + case type
+        when :entity
+          File.join('entity', entity.base_type.to_s, clean_element(entity))
+        when :action
+          File.join('entity_action', entity.base_type.to_s, clean_element(other), clean_element(entity))
+        when :property
+          File.join('entity_property', entity.base_type.to_s, clean_element(other), clean_element(entity))
+        end 
+        url = add_GET_params(url, params)
+        url
+      end
+
+      def entity_list_url(list, type = :list, other = nil, params = {})
+        url = '/' + case type
+        when :list
+          File.join('entity_list', list.base_type.to_s, clean_element(list))
+        when :action
+          File.join('entity_list_action', list.base_type.to_s, clean_element(other), clean_element(list))
+        when :property
+          File.join('entity_list_property', list.base_type.to_s, clean_element(other), clean_element(list))
+        end
+        url = add_GET_params(url, params)
+        url
+      end
+
+      def entity_link(entity, type = :entity, other = nil, params = {})
+        link_options = IndiferentHash.pull_keys params, :link
+        url = entity_url(entity, type, other)
+        link_options = IndiferentHash.add_defaults link_options, class: "entity_#{type}", href: url
+        text = IndiferentHash.process_options link_options, :text,
+          text: entity.respond_to?(:name) ? entity.name : entity
+
+        html_tag('a', text, link_options)
+      end
+
+      def entity_list_link(list, type = :entity, other = nil, params = {})
+        link_options = IndiferentHash.pull_keys params, :link
+        url = entity_list_url(entity, type, other)
+        link_options = IndiferentHash.add_defaults link_options, class: "entity_list_#{type}", href: url
+        text = IndiferentHash.process_options link_options, :text,
+          text: list
+
+        html_tag('a', text, link_options)
+      end
+
+      def entity
+        return nil unless entity_type
+        return nil unless splat
+        @entity ||= begin
+                      entity_id = restore_element(splat*"/")
+
+                      if entity_type
+                        setup_entity(entity_type, entity_id, params)
+                      else
+                        entity_id
+                      end
+                    end
+      end
+
+      def entity_render(entity, type = :entity, other = nil, params = {})
+        template = entity_template(entity, type, other)
+
+        params = params.merge(entity: entity)
+        params = params.merge(check: entity.check) if entity.respond_to?(:check)
+        render_template(template, params)
+      end
+
+      def entity_list_render(list, list_id, type = :entity, other = nil, params = {})
+        template = entity_template(list, type, other)
+        render_template(template, params.merge(list: list, list_id: list_id))
+      end
+    end
+
+    #{{{ SINGLE ENTITIES
+
+    # Entity report
+    app.post_get '/entity/:entity_type/*' do
+      if _format == :json
+        json_halt(200, { id: entity.to_s, info: entity.annotation_hash })
+      else
+        entity_render(entity, :entity, nil, params)
+      end
+    end
+
+    app.post_get '/entity_action/:entity_type/:entity_action/*' do
+      if _format == :json
+        json_halt(501, message: "Action JSON not implemented yet")
+      else
+        entity_render(entity, :action, entity_action, params)
+      end
+    end
+
+    app.post_get '/entity_property/:entity_type/:entity_property/*' do
+      entity
+      entity_property
+      args = consume_parameter(:args)
+
+      if args
+        prop_params = JSON.parse(args) rescue [args]
+      else
+        param_names = consume_parameter(:params)
+        if param_names
+          prop_params = param_names{|param| consume_parameter(param) }
+        else
+          prop_params = params.values
+        end
+      end
+
+      value = entity.send(entity_property, *prop_params)
+
+      if Step === value
+        job = value
+        initiate_step job, _layout
+
+        case _format
+        when :job
+          redirect to(add_GET_params(job_url(job), _layout: _layout))
+        when :json
+          serve_step_json job
+        else
+          serve_step job, _layout do
+            entity_render(entity, :property, entity_property, params)
+          end
+        end
+      end
+
+      if _format == :json
+        json_halt(200, value)
+      else
+        begin
+          entity_render(entity, :property, entity_property, params)
+        rescue TemplateNotFoundException
+          json_halt(200, value)
+        end
+      end
+    end
+
+    app.register_common_parameter(:entity_type, :escaped)
+    app.register_common_parameter(:entity_action, :escaped)
+    app.register_common_parameter(:entity_property, :escaped)
+    app.register_common_parameter(:_format, :symbol) do entity_property ? :json : :html end
+  end
+end

data/lib/scout/sinatra/finder.rb

@@ -0,0 +1,9 @@
+module SinatraScoutFinder
+  def self.registered(app)
+    app.helpers do
+      def finder
+        nil
+      end
+    end
+  end
+end