voom-presenters 0.2.0 → 2.0.0

data/lib/voom/presenters/settings.rb

@@ -1,23 +1,22 @@
-include Voom::Trace
-trace {"Loading Presenters Settings"}
-require 'voom/presenters/helpers/route'
+#include Voom::Trace
+#trace {"Loading Presenters Settings"}
+require 'dry-configurable'
 
 unless defined?(Voom::Presenters::Settings)
   module Voom
     module Presenters
       class Settings
-        extend Dry::Configurable
+        extend ::Dry::Configurable
         setting :presenters do
           setting :root, []
           # You can add helpers that will automatically be included
           # For example:
-          # For example:
           # Voom::Presenters::Settings.configure do |config|
           #   config.presenters.helpers << YourHelperModule # Passing a module
           #   config.presenters.helpers << &->{ def foo; :foo; end } # Passing a block
           # end
           setting :helpers, [Voom::Presenters::Helpers::Route]
-          setting :deep_freeze, true
+          setting :deep_freeze, false
           setting :id_generator, ->(node) {"id-#{SecureRandom.hex}"}
           setting :web_client do
             # Add lambda's to modify the context for the presenters
@@ -29,8 +28,11 @@ unless defined?(Voom::Presenters::Settings)
             #   }
             # end
             setting :prepare_context, []
-            setting     :custom_css, 'public/presenters/*.css'
+            # Relative to the root
+            setting :custom_css, '../public/presenters'
+            setting :protect_from_forgery, false
           end
+          setting :plugins, [:google_maps]
           setting :components do
             setting :defaults do
               setting :datetime do
@@ -56,10 +58,18 @@ unless defined?(Voom::Presenters::Settings)
                 setting :level, 6
               end
               setting :rich_text_area do
-                setting :rows, 25
+                setting :rows, 6
               end
             end
           end
+          setting :error_logger, ->(file, e, _params, _presenter_name) {
+            msg = [
+              "#{Time.now.strftime("%Y-%m-%d %H:%M:%S")} - #{e.class} - #{e.message}:",
+              *e.backtrace
+            ].join("\n\t")
+            file.puts(msg)
+          }
+          setting :before_render, [] # an array of `#call`ables
         end
 
         def self.default(type, key)

data/lib/voom/presenters/version.rb

@@ -1,5 +1,5 @@
 module Voom
   module Presenters
-    VERSION = '0.2.0'.freeze
+    VERSION = '2.0.0'
   end
 end

data/lib/voom/presenters/web_client/app.rb

@@ -1,12 +1,8 @@
 require 'sinatra'
+require 'honeybadger' if ENV['HONEYBADGER_API_KEY']
 require 'uri'
 require 'redcarpet'
-require "dry/inflector"
-require 'voom/trace'
-require 'voom/presenters/app'
-require 'voom/presenters/web_client/router'
-require 'voom/presenters/web_client/markdown_render'
-require 'voom/presenters/errors/unprocessable'
+require 'dry/inflector'
 
 module Voom
   module Presenters
@@ -17,11 +13,19 @@ module Voom
         set :router_, WebClient::Router
         set :bind, '0.0.0.0'
         set :views, Proc.new {File.join(root, "views", ENV['VIEW_ENGINE'] || 'mdc')}
+        set :dump_errors, false
+        set :protection, :except => :frame_options
         configure do
           enable :logging
         end
-
+        helpers Helpers::FormHelpers
+        helpers Helpers::PaddingHelpers
+        helpers Helpers::ExpandHash
         helpers do
+          def render_component(scope, comp, components, index)
+            ComponentRenderer.new(comp, render: method(:render), scope: scope, components: components, index: index).render
+          end
+
           def markdown(text)
             unless @markdown
               renderer = CustomRender.new(hard_wrap: false, filter_html: true)
@@ -48,21 +52,43 @@ module Voom
             attrib.to_s == value.to_s
           end
 
+          def h(text)
+            Rack::Utils.escape_html(text)
+          end
+
+          def include?(array, value)
+            array.map(&:to_s).include?(value.to_s)
+          end
+
+          def includes_one?(array1, array2)
+            (array2.map(&:to_sym)-array1.map(&:to_sym)).size != array2.size
+          end
+
           def unique_id(comp)
             "#{comp.id}-#{SecureRandom.hex(4)}"
           end
 
-          def expand_text(text)
-            self.markdown(Array(text).join("\n\n")) #.gsub("\n\n", "<br/>")
+          def expand_text(text, markdown: true)
+            if markdown
+              self.markdown(Array(text).join("\n\n")) #.gsub("\n\n", "<br/>")
+            else
+              Array(text).join('<br/>')
+            end
           end
 
-          def color_classname(comp)
-            return "v-#{comp.type}__primary" if eq(comp.color, :primary)
-            "v-#{comp.type}__secondary" if eq(comp.color, :secondary)
+          def color_classname(comp, affects = nil, color_attr = :color)
+            color = comp&.public_send(color_attr)
+            return unless color
+
+            return "v-#{comp.type}__primary" if eq(color, :primary)
+            return "v-#{comp.type}__secondary" if eq(color, :secondary)
+
+            "v-#{affects}color__#{color}"
           end
 
-          def color_style(comp, affects = nil)
-            "#{affects}color: #{comp.color};" unless %w(primary secondary).include?(comp.color.to_s) || comp.color.nil?
+          def color_style(comp, affects = nil, color_attr = :color)
+            color = comp.public_send(color_attr)
+            "#{affects}color: #{color};" unless %w(primary secondary).include?(color.to_s) || color.nil?
           end
 
           def snake_to_camel(hash, except: [])
@@ -91,20 +117,29 @@ module Voom
             end
           end
 
-          def custom_css
-            custom_css_path = Presenters::Settings.config.presenters.web_client.custom_css
-            Dir.glob(custom_css_path).map do |file|
-              _build_css_link_(file)
-            end.join("\n") if custom_css_path
+          def plugin_headers(pom)
+            PluginHeaders.new(pom: pom, render: method(:render)).render
+          end
+
+          def custom_css(path, host=nil)
+            CustomCss.new(path, root: Presenters::Settings.config.presenters.root, host: host).render
           end
 
-          def _build_css_link_(path)
-            (<<~CSS)
-              <link rel="stylesheet" href="#{env['SCRIPT_NAME']}#{path.sub('public/','')}">
-            CSS
+          def custom_js
+            custom_js_path = Presenters::Settings.config.presenters.web_client.custom_js
+            Dir.glob(custom_js_path).map do |file|
+              _build_script_tag_(file)
+            end.join("\n") if custom_js_path
+          end
+
+          def _build_script_tag_(path)
+            (<<~JS)
+            <script defer src="#{env['SCRIPT_NAME']}#{path.sub('public/','')}"></script>
+            JS
           end
         end
 
+
         get '/' do
           pass unless Presenters::App.registered?('index')
           presenter = Presenters::App['index'].call
@@ -137,20 +172,42 @@ module Voom
         post '/__post__/:presenter' do
           @pom = JSON.parse(request.body.read, object_class: OpenStruct)
           @grid_nesting = Integer(params[:grid_nesting] || 0)
+          @base_url = request.base_url
           layout = !(request.env['HTTP_X_NO_LAYOUT'] == 'true')
           erb :web, layout: layout
         end
 
         private
 
+        # analogous to Voom::Presenters::Api::App#render_presenter
         def render_presenter(presenter)
           @grid_nesting = Integer(params[:grid_nesting] || 0)
 
           begin
-            @pom = presenter.expand(router: router, context: prepare_context)
+            before_render = Presenters::Settings.config.presenters.before_render
+            render_instead, ctx = before_render
+                                    .lazy
+                                    .map { |p| p.call(request) }
+                                    .detect(&:itself)
+
+            if Presenters::App.registered?(render_instead)
+              presenter = Presenters::App[render_instead].call
+            end
+
+            p = params.merge(ctx || {})
+            @pom = presenter.expand(router: router, context: prepare_context(p))
+            @base_url = request.base_url
             layout = !(request.env['HTTP_X_NO_LAYOUT'] == 'true')
-            response.headers['X-Frame-Options'] = 'ALLOWALL' if ENV['ALLOWALL_FRAME_OPTIONS']
+            response.headers['X-Frame-Options'] = ENV['ALLOWALL_FRAME_OPTIONS'] || presenter.options.fetch(:allow_all_frame_options, false) ? 'ALLOWALL' : 'SAMEORIGIN'
             erb :web, layout: layout
+          rescue StandardError => e
+            Presenters::Settings.config.presenters.error_logger.call(
+              @env['rack.errors'],
+              e,
+              params,
+              presenter.name
+            )
+            raise e
           rescue Presenters::Errors::Unprocessable => e
             content_type :json
             status 422
@@ -159,13 +216,13 @@ module Voom
         end
 
         def router
-          settings.router_.new(base_url: "#{request.script_name}")
+          settings.router_.new(base_url: "#{request.base_url}")
         end
 
-        def prepare_context
+        def prepare_context(base_params = params)
           prepare_context = Presenters::Settings.config.presenters.web_client.prepare_context.dup
           prepare_context.push(method(:scrub_context))
-          context = params.dup
+          context = base_params.dup
           prepare_context.reduce(context) do |params, context_proc|
             context = context_proc.call(params, session, env)
           end
@@ -173,7 +230,7 @@ module Voom
         end
 
         def scrub_context(params, _session, _env)
-          %i(splat captures _presenter_ grid_nesting input_tag _namespace1_ _namespace2_).each do |key|
+          %i(splat captures  grid_nesting input_tag).each do |key|
             params.delete(key) {params.delete(key.to_s)}
           end
           params

data/lib/voom/presenters/web_client/component_decorator_factory.rb

@@ -0,0 +1,27 @@
+require "dry/inflector"
+
+module Voom
+  module Presenters
+    module WebClient
+      class ComponentDecoratorFactory
+
+        def self.build(component)
+          comp_class = "#{inflector.camelize(component.type)}HtmlDecorator"
+          klass = if const_defined?(comp_class)
+                    const_get(comp_class)
+                  else
+                    ComponentHtmlDecorator
+                  end
+          klass.new(component)
+        end
+
+        private
+
+        def self.inflector
+          @inflector ||= Dry::Inflector.new
+        end
+
+      end
+    end
+  end
+end

data/lib/voom/presenters/web_client/component_html_decorator.rb

@@ -0,0 +1,50 @@
+require 'delegate'
+
+module Voom
+  module Presenters
+    module WebClient
+      class ComponentHtmlDecorator < SimpleDelegator
+
+        def _plugins_
+          __getobj__.send(:_plugins_)
+        end
+
+        def method_missing(meth, *args, &block)
+          if respond_to?(meth)
+            super
+          else
+            nil
+          end
+        end
+
+        private
+
+        HTML_ESCAPED_ATTRIBUTES = %i(
+          id
+          type
+        )
+
+        def self.html_escape_attribute(attr)
+          define_method(attr) do
+            self.class.html_escape(super())
+          end
+        end
+
+        HTML_ESCAPED_ATTRIBUTES.each do |attr|
+          html_escape_attribute(attr)
+        end
+
+        def self.inherited(subclass)
+          subclass::HTML_ESCAPED_ATTRIBUTES.each do |attr|
+            html_escape_attribute(attr)
+          end
+        end
+
+        def self.html_escape(text)
+          Rack::Utils.escape_html(text)
+        end
+
+      end
+    end
+  end
+end

data/lib/voom/presenters/web_client/component_renderer.rb

@@ -0,0 +1,49 @@
+require 'erb'
+
+module Voom
+  module Presenters
+    module WebClient
+      # This class renders a given component.
+      # First it looks for plugins that override default behavior
+      # If they don't exist then it renders the base components
+      class ComponentRenderer
+        extend Pluggable
+        include_plugins(:WebClientComponents)
+
+        def initialize(comp,
+                       render:,
+                       components:,
+                       index:,
+                       scope: nil)
+          @comp = comp
+          @index = index
+          @components = components
+          @scope = scope
+          @render = render
+          initialize_plugins
+        end
+
+        def render
+          comp = ComponentDecoratorFactory.build(@comp)
+          components = @components.map { |c| ComponentDecoratorFactory.build(c) }
+
+          return public_send(:"render_#{@scope ? "_#{@scope}_" : nil}#{@comp.type}",
+                      comp,
+                      components: components,
+                      index: @index,
+                      render: @render) if respond_to?(:"render_#{@comp.type}")
+
+          @render.call :erb, :"components#{@scope ? "/#{@scope}" : nil}/#{@comp.type}",
+                       :locals => {comp: comp,
+                                   components: components, index: @index}
+        end
+
+        private
+
+        def initialize_plugins
+          self.class.include_plugins(:WebClientComponents, plugins: @comp.send(:_plugins_))
+        end
+      end
+    end
+  end
+end

data/lib/voom/presenters/web_client/custom_css.rb

@@ -0,0 +1,65 @@
+module Voom
+  module Presenters
+    module WebClient
+      # This class renders custom CSS for the layout
+      # It looks for public/presenters/global.css first
+      # It then looks for public/presenters/#{env['REQUEST_PATH']}.css
+      class CustomCss
+
+        attr_reader :path, :root, :host
+        private :path, :root, :host
+
+        def initialize(path, root:, host:)
+          @path = path
+          @root = root
+          @host = host
+        end
+
+        def render
+          return unless custom_css_path
+          [global_css, global_namespace_css(path), presenter_css(path)].join
+        end
+
+        private
+
+        def custom_css_path
+          Presenters::Settings.config.presenters.web_client.custom_css
+        end
+
+        # loads a global css file - by default located at `public/presenters/global.css`
+        def global_css
+          css_file = File.join(custom_css_path, 'global.css')
+          full_path = File.join(root, css_file)
+          _build_css_link_(css_file) if File.exists?(full_path)
+        end
+
+        def global_namespace_css(path)
+          return unless custom_css_path && path
+          namespace_path = path.split('/').reject { |c| c.empty? }.first
+          css_file = File.join(custom_css_path, namespace_path ? namespace_path : '')
+          css_file = File.join(css_file, 'global.css')
+          full_path = File.join(root, css_file)
+          trace {"Loading global namespace: #{full_path}"}
+          _build_css_link_(css_file) if File.exists?(full_path)
+        end
+
+        # loads a custom css file that matches the presenter namespace/presenter.css
+        # by default located at public/presenters/#{namespace}/#{presenter}.css
+        def presenter_css(path)
+          return unless custom_css_path && path
+          css_file = File.join(custom_css_path, path)
+          css_file = File.join(css_file, 'index') if path == '/'
+          css_file = "#{css_file}.css"
+          full_path = File.join(root, css_file)
+          _build_css_link_(css_file) if File.exists?(full_path)
+        end
+
+        def _build_css_link_(path)
+          (<<~CSS)
+            <link rel="stylesheet" type="text/css" href="#{host}/#{path.sub('public/', '')}">
+          CSS
+        end
+      end
+    end
+  end
+end