scout-camp 0.1.13 → 0.1.14

data/lib/scout/sinatra/base/assets.rb

@@ -0,0 +1,245 @@
+module SinatraScoutAssets
+  def self.registered(app)
+    app.helpers do
+      def reset_js_css
+        @recorded_js_files = []
+        @recorded_css_files = []
+      end
+
+      def recorded_js_files_global
+        @recorded_js_files ||= []
+      end
+
+      def recorded_css_files_global
+        @recorded_css_files ||= []
+      end
+
+      def recorded_js_files
+        global = recorded_js_files_global
+        return global unless @step
+        (global + (@step.info[:js_files] || [])).uniq
+      end
+
+      def recorded_css_files
+        global = recorded_css_files_global
+        return global unless @step
+        (global + (@step.info[:css_files] || [])).uniq
+      end
+
+      def record_js_global(file)
+        if Array === file
+          recorded_js_files.concat file
+        else
+          recorded_js_files << file
+        end
+      end
+
+      def record_css_global(file)
+        if Array === file
+          recorded_css_files.concat file
+        else
+          recorded_css_files << file
+        end
+      end
+
+      def record_js(js_files)
+        return record_js_global(js_files) unless @step
+        js_files = [js_files] unless Array === js_files
+        current_js_files = @step.info[:js_files] || []
+
+        new_files = js_files - current_js_files
+        @step.set_info :js_files, new_files if new_files.any?
+      end
+
+      def record_css(css_files)
+        return record_css_global(css_files) unless @step
+        css_files = [css_files] unless Array === css_files
+        current_css_files = @step.info[:css_files] || []
+
+        new_files = css_files - current_css_files
+        @step.set_info :css_files, new_files if new_files.any?
+      end
+
+      def link_css(file)
+        file << "?_update=reload" if @debug_css
+        html_tag('link', nil, :rel => 'stylesheet', :type => 'text/css', :href => file)
+      end
+
+      def link_js(file)
+        html_tag('script', " ", :src => file, :type => 'text/javascript')
+      end
+
+      def purge_paths(paths)
+        @served_paths ||= []
+        new = paths - @served_paths
+        @served_paths.concat new
+        new
+      end
+
+      def serve_css
+        md5 = Misc.digest(recorded_css_files * ",")
+        filename = ScoutRender.cache_dir["all_css-#{md5}.css"].find
+
+        paths = recorded_css_files.collect do |file|
+          if Open.remote?(file)
+            path = file
+          else
+            path = ScoutRender.find_js(file)
+            path = ScoutRender.find_js("public/#{file}") unless path.exists?
+          end
+          path
+        end.uniq
+
+        paths = purge_paths paths
+
+        update = _update == :css
+        checks = paths.select{|p| Open.mtime(p) }
+
+        Persist.persist 'all', :text, prefix: 'css', path: filename, other: {files: paths}, check: checks, update: update, no_load: true do
+          Log.debug{ "Regenerating CSS Compressed file: #{ filename }" }
+          paths.collect do |path|
+            TmpFile.with_file do |tmpfile|
+              cmd_str = "-i '#{path}' -o '#{tmpfile}'"
+              CMD.cmd(:tailwindcss, cmd_str)
+              Open.read tmpfile
+            end
+          end * "\n"
+        end
+
+        res = "<link href='/file/#{File.basename(filename)}' rel='stylesheet' type='text/css'/>"
+
+        res
+      end
+
+      def serve_js
+        md5 = Misc.digest(recorded_js_files * ",")
+        filename = ScoutRender.cache_dir["all_js-#{md5}.js"].find
+
+        paths = recorded_js_files.collect do |file|
+          if Open.remote?(file)
+            path = file
+          else
+            path = ScoutRender.find_js(file)
+            path = ScoutRender.find_js("public/#{file}") unless path.exists?
+          end
+          path
+        end.uniq
+
+        paths = purge_paths paths
+
+        update = _update == :js
+
+        minify = false
+        checks = paths.select{|p| Open.mtime(p) }
+
+        Persist.persist 'all', :text, prefix: 'js', path: filename, other: {files: paths}, check: checks, update: update, no_load: true do
+          Log.debug{ "Regenerating JS Compressed file: #{ filename }, from: #{Log.fingerprint paths}" }
+          TmpFile.with_file nil, false do |tmp_file|
+            Open.write tmp_file do |f|
+              paths.each do |path|
+                f.write(Open.read(path) + "\n")
+              end
+            end
+
+            cmd_str = "esbuild ".dup
+            cmd_str << "'#{tmp_file}' "
+            cmd_str << "--outfile='#{filename}' "
+            cmd_str << "--bundle " if paths.length > 1
+            cmd_str << "--minify " if minify
+            cmd_str << "--platform='browser' "
+            CMD.cmd(:npx, cmd_str)
+          end
+        end
+
+        res = "<script src='/file/#{File.basename(filename)}' type='text/javascript' defer></script>"
+
+        recorded_js_files.clear
+
+        res
+      end
+
+      def mime_file(file, content_type = nil)
+        if file.end_with?('.js')
+          content_type = 'text/javascript'
+        elsif file.end_with?('.css')
+          content_type = 'text/css'
+        else
+          content_type = 'text/html'
+        end if content_type.nil?
+
+        Log.debug "Serving #{file} as #{content_type}"
+        content_type content_type if content_type
+        send_file(file)
+      end
+    end
+
+    # helpers for REST-style responses & params
+    # expose method to register a workflow at runtime
+    app.get "/plugins/*" do
+      splat = consume_parameter(:splat)
+
+      splat.unshift 'public/plugins'
+
+      name = splat * "/"
+
+      file = ScoutRender.find_resource(name)
+      status 200
+      mime_file file
+    end
+
+    app.get '/(stylesheets|css)/*' do
+      splat = consume_parameter(:splat)
+
+      splat.unshift 'public/css'
+
+      name = splat * "/"
+
+      file = ScoutRender.find_resource(name)
+
+      if file.exists?
+        content_type 'text/css', :charset => 'utf-8'
+        cache_control :public, :max_age => 360000 if production?
+
+        mime_file file, false
+      else
+        splat.shift
+
+        splat.unshift 'compass'
+
+        name = splat * "/"
+
+        content_type 'text/css', :charset => 'utf-8'
+        cache_control :public, :max_age => 360000 if production?
+
+        render_template(name.sub(/\.css/, '.sass'))
+      end
+    end
+
+    app.get '/js/*' do
+      splat = consume_parameter(:splat)
+
+      splat.unshift 'public/js'
+
+      name = splat * "/"
+
+      file = ScoutRender.find_resource(name)
+      content_type 'application/javascript'
+      status 200
+      mime_file file, false
+    end
+
+    app.get '/file/*' do
+      splat = consume_parameter(:splat)
+
+      name = splat * "/"
+      if ScoutRender.cache_dir[name].exists?
+        mime_file ScoutRender.cache_dir[name].find
+      end
+
+      splat.unshift 'public'
+      name = splat * "/"
+      file = ScoutRender.find_resource(name)
+      mime_file file
+    end
+  end
+end

data/lib/scout/sinatra/base/favicon.rb

@@ -0,0 +1,43 @@
+module SinatraScoutFavicon
+  def self.registered(app)
+    app.get '/favicon.ico' do
+      content_type 'image/svg+xml'
+      cache_control :public, max_age: 86_400 # 1 day
+
+      <<~SVG
+      <?xml version="1.0" encoding="UTF-8"?>
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Compass favicon">
+        <!-- outer circle -->
+        <circle cx="32" cy="32" r="28" fill="none" stroke="currentColor" stroke-width="2" />
+        <!-- ticks for N/E/S/W -->
+        <line x1="32" y1="4"  x2="32" y2="10" fill="none" stroke="currentColor" stroke-width="2" />
+        <line x1="60" y1="32" x2="54" y2="32" fill="none" stroke="currentColor" stroke-width="2" />
+        <line x1="32" y1="60" x2="32" y2="54" fill="none" stroke="currentColor" stroke-width="2" />
+        <line x1="4"  y1="32" x2="10" y2="32" fill="none" stroke="currentColor" stroke-width="2" />
+        <!-- inner degree markers -->
+        <g stroke="currentColor" stroke-width="1">
+          <line x1="32" y1="12" x2="32" y2="14"/>
+          <line x1="45" y1="19" x2="43" y2="21"/>
+          <line x1="52" y1="32" x2="50" y2="32"/>
+          <line x1="45" y1="45" x2="43" y2="43"/>
+          <line x1="32" y1="52" x2="32" y2="50"/>
+          <line x1="19" y1="45" x2="21" y2="43"/>
+          <line x1="12" y1="32" x2="14" y2="32"/>
+          <line x1="19" y1="19" x2="21" y2="21"/>
+        </g>
+        <!-- compass needle (line drawing) -->
+        <g stroke="currentColor" stroke-width="1.8" stroke-linejoin="round" stroke-linecap="round" fill="none">
+          <!-- main spine -->
+          <line x1="32" y1="32" x2="42" y2="12"/>
+          <line x1="32" y1="32" x2="22" y2="52"/>
+          <!-- needle outlines (simple triangular tips) -->
+          <path d="M42 12 L36 20 L32 18 Z" fill="none" stroke="currentColor" stroke-width="1.6"/>
+          <path d="M22 52 L28 44 L32 46 Z" fill="none" stroke="currentColor" stroke-width="1.6"/>
+        </g>
+        <!-- center hub -->
+        <circle cx="32" cy="32" r="2" fill="currentColor" />
+      </svg>
+      SVG
+    end
+  end
+end

data/lib/scout/sinatra/base/headers.rb

@@ -0,0 +1,77 @@
+module SinatraScoutHeaders
+  def self.registered(app)
+    app.helpers do
+      def environment
+        settings.environment 
+      end
+
+      def production?
+        environment == :production
+      end
+
+      def development?
+        environment == :development
+      end
+
+      def script_name
+        request.script_name ||= request.env["HTTP_SCRIPT_NAME"]
+      end
+
+      def xhr?
+        request.xhr?
+      end
+
+      def ajax?
+        request.xhr?
+      end
+
+      def request_method
+        request.env["REQUEST_METHOD"]
+      end
+
+      def post?
+        request_method.to_s.downcase == 'post'
+      end
+
+      def clean_uri(uri)
+        return nil if uri.nil?
+        remove_GET_param(uri, ["_update", "_"])
+      end
+
+      def original_uri
+        clean_uri(request.env["REQUEST_URI"])
+      end
+
+      def post_uri
+        new_params = {}
+        params.each do |k,v|
+          if m = k.match(/(.*)__param_file/)
+            new_params[m[1]] = v['filename']
+          else
+            new_params[k] = v
+          end
+        end
+        hash = Misc.digest(new_params)
+        params[:_layout]
+      end
+
+      def path_info
+        @path_info ||= request.env["PATH_INFO"]
+      end
+
+      def query
+        @query ||= request.env["QUERY_STRING"]
+      end
+
+      def fullpath
+        @fullpath ||= (query && ! query.empty?) ? clean_uri(path_info + "?" + query) : path_info
+      end
+
+      alias url fullpath
+
+      def script_name
+        @script_name ||= request.script_name = request.env["HTTP_SCRIPT_NAME"]
+      end
+    end
+  end
+end

data/lib/scout/sinatra/base/helpers.rb

@@ -0,0 +1,14 @@
+require_relative 'post_processing'
+module SinatraScoutHelpers
+  def self.registered(app)
+
+    app.helpers do
+      def format_name(name)
+        parts = name.split("_")
+        hash = parts.pop
+        clean_name = parts * "_"
+        "<span class='name' jobname='#{ name }'>#{ clean_name }</span> <span class='hash'>#{ hash }</span>"
+      end
+    end
+  end
+end

data/lib/scout/sinatra/base/parameters.rb

@@ -0,0 +1,147 @@
+module SinatraScoutParameters
+  def self.registered(app)
+    app.set :common_parameters, []
+
+    app.define_singleton_method(:register_common_parameter) do |name,type=:string,default=nil,&block|
+      settings.common_parameters << name
+      app.helpers do
+        attr_accessor name
+
+        define_method(name) do
+          value = self.instance_variable_get(:"@#{name}")
+          return value unless value.nil?
+          value = consume_parameter(name)
+          if value.nil?
+            value = if default
+                      default
+                    elsif block
+                      self.instance_eval &block
+                    else
+                      nil
+                    end
+          end
+
+          value = case type
+                  when :string
+                    value.to_s if value
+                  when :symbol
+                    if String === value
+                      value.to_sym
+                    else
+                      value
+                    end
+                  when :integer
+                    value.to_i
+                  when :float
+                    value.to_f 
+                  when :boolean
+                    value.to_s.downcase == "true" unless value.nil?
+                  when :escaped
+                    restore_element(value) if value
+                  when :array
+                    value = case value
+                            when Array
+                              value
+                            when String
+                              value.split(",")
+                            else
+                              value
+                            end
+                  end
+
+          self.instance_variable_set(:"@#{name}", value)
+        end
+      end
+    end
+
+    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 consume_parameter(name, source = params)
+        return nil if source.nil?
+        val = IndiferentHash.process_options source, name
+        val = nil if val == ''
+        val
+      end
+
+      def clean_params
+        @clean_params ||= begin
+                            params = IndiferentHash.setup(self.params)
+                            params.keys.each do |param|
+                              if param =~ /(.*)_checkbox_false$/
+                                params[$1] = false if params[$1].nil?
+                                params.delete param
+                              elsif param =~ /(.*)_upload_file$/
+                                file = params[param]
+                                params[$1] = file['tempfile'].read
+                                params[$1 + "_upload_filename"] = file['filename']
+                              elsif param.to_s.start_with? '_'
+                                params.delete param
+                              end
+                            end
+                            params
+                          end
+      end
+
+      def process_common_parameters
+        settings.common_parameters.each{|name,*_| self.send(name) }
+      end
+
+      def form(**kwgars, &block)
+        inputs = []
+        input_types = {}
+        input_descriptions = {}
+        input_defaults = {}
+        input_options = {}
+
+        self.define_singleton_method :input do |name, type=nil, description=nil, default=nil, options=nil|
+          inputs << name
+          input_types[name] = type
+          input_descriptions[name] = description
+          input_defaults[name] = default
+          input_options[name] = options
+        end
+        self.instance_exec &block
+
+        self.singleton_class.remove_method(:input)
+
+
+        render_partial 'partial/form', kwgars.merge( inputs: inputs, types: input_types, descriptions: input_descriptions, defaults: input_defaults, options: input_options)
+      end
+    end
+
+    app.register_common_parameter(:splat, :array)
+    app.register_common_parameter(:_layout, :boolean) do ! ajax?  end
+    app.register_common_parameter(:_format, :symbol) do :html end
+    app.register_common_parameter(:_update, :symbol) do 
+      if development? && ! _step
+        :development  
+      elsif request_method != 'GET'
+        request_method
+      end
+    end
+    app.register_common_parameter(:_cache_type, :symbol, :asynchronous)
+    app.register_common_parameter(:_debug_js, :boolean)
+    app.register_common_parameter(:_debug_css, :boolean)
+    app.register_common_parameter(:_step, :string)
+    app.register_common_parameter(:_)
+  end
+end

data/lib/scout/sinatra/base/post_processing.rb

@@ -0,0 +1,18 @@
+module SinatraScoutPostProcessing
+  def self.registered(app)
+    app.set :post_processing_blocks, []
+
+    app.define_singleton_method(:register_post_processing) do |&block|
+      settings.post_processing_blocks << block
+    end
+
+    app.helpers do
+      def post_processing(step)
+        return unless settings.post_processing_blocks
+        settings.post_processing_blocks.each do |block|
+          self.instance_exec step, &block
+        end
+      end
+    end
+  end
+end

data/lib/scout/sinatra/base/session.rb

@@ -0,0 +1,72 @@
+require "sinatra"
+
+module SinatraScoutSession
+  def self.registered(app)
+    secret = Scout::Config.get :secret, :sinatra_session, :sinatra, :session, env:"SESSION_SECRET", default: "scout_and_rbbt_super_secret"
+
+    app.configure do
+      app.enable :sessions
+      app.set :sessions, true
+      app.set :session_secret, secret
+    end
+
+    app.use Rack::Session::Cookie, secret: secret
+
+    app.get '/debug_session' do
+      "Session contents: #{session.inspect}"
+    end
+
+    app.post_get '/preference/:key' do
+      key = consume_parameter :key
+      value = consume_parameter :value
+
+      if value.nil?
+        consume_parameter :key
+        case _format
+        when :json
+          content_type 'application/json'
+          get_preference(key).to_json
+        else
+          get_preference(key)
+        end
+      else
+
+        case _format
+        when :json
+          value = JSON.parse(value)
+        else
+          record_preference(key, value)
+        end
+        halt 200
+      end
+    end
+
+    app.helpers do
+
+      def csrf_token
+        session[:csrf] ||= SecureRandom.hex(16)
+      end
+
+      def preferences
+        session['preferences'] ||= {}
+      end
+
+      def record_preference(key, value)
+        preferences[key] = value
+      end
+
+      def get_preference(key)
+        preferences[key]
+      end
+
+      def preference_url(key, value=nil, params = {})
+        url = "/preference/#{key}"
+        if value
+          add_GET_params("/preference/#{key}", params.merge(value: value))
+        else
+          add_GET_params("/preference/#{key}", params)
+        end
+      end
+    end
+  end
+end