voom-presenters 0.1.13 → 2.0.3

data/lib/voom/presenters/helpers/route.rb

@@ -2,9 +2,22 @@ module Voom
   module Presenters
     module Helpers
       module Route
-        def presenters_path(presenter, **params)
-          router.url(render: presenter, context: params)
+        include Namespace
+
+        def presenters_path(presenter, host: false, **params)
+          presenter = _expand_namespace_(presenter, namespace)
+          presenter = presenter.gsub(':', '/')
+          router.url(render: presenter, host: host, context: params)
         end
+
+        alias presenter_path presenters_path
+
+        # Full qualified URL
+        def presenters_url(presenter, **params)
+          presenters_path(presenter, host: true, **params)
+        end
+
+        alias presenter_url presenters_url
       end
     end
   end

data/lib/voom/presenters/helpers/time.rb

@@ -7,7 +7,7 @@ module Voom
         LONG_FORMAT='%m/%d/%Y %I:%M:%S %p %Z'
         SHORT_FORMAT='%d %b %H:%M %Z'
 
-        def format_time(time, format: '%m/%d/%Y %I:%M:%S %p %Z', timezone: nil)
+        def format_time(time, format: LONG_FORMAT, timezone: nil)
           return '' unless time
           time = time.in_time_zone(timezone) if timezone
           time.strftime(format)

data/lib/voom/presenters/namespace.rb

@@ -0,0 +1,12 @@
+module Voom
+  module Presenters
+    module Namespace
+      def _expand_namespace_(presenter, namespace)
+        presenter = presenter.to_s
+        return presenter if presenter.split(':').size > 1
+        return presenter if presenter.split('/').size > 1
+        namespace.any? ? namespace.join(':')+':'+presenter : presenter
+      end
+    end
+  end
+end

data/lib/voom/presenters/pluggable.rb

@@ -0,0 +1,37 @@
+include Voom::Trace
+
+module Voom
+  module Presenters
+    module Pluggable
+      def include_plugins(*layers, plugins: [],
+                          plugin_method: method(:include))
+        plugins = Array(plugins) + Array(Voom::Presenters::Settings.config.presenters.plugins)
+        plugins.uniq.each do |plugin|
+          plugin(plugin, *layers, plugin_method: plugin_method)
+        end
+      end
+
+
+      # Returns the module for the specified plugin. If the module is not
+      # defined, the corresponding plugin required.
+      def plugin_module(plugin)
+        module_name = plugin.to_s.gsub(/(^|_)(.)/) {|x| x[-1..-1].upcase}
+        unless Voom::Presenters::Plugins.const_defined?(module_name, false)
+          trace {"Method plugin loading plugin: #{plugin}"}
+          load "voom/presenters/plugins/#{plugin}.rb"
+        end
+        Voom::Presenters::Plugins.const_get(module_name)
+      end
+
+      def plugin(plugin, *layers, plugin_method: method(:include))
+        m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
+        layers.each do |layer|
+          if m.const_defined?(layer, false) && !self.const_defined?(layer, false)
+            trace {"Injecting plugin(#{m.const_get(layer).inspect}) into #{self.inspect}!"}
+            plugin_method.call(m.const_get(layer))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/voom/presenters/plugins.rb

@@ -0,0 +1,7 @@
+module Voom
+  module Presenters
+    module Plugins
+
+    end
+  end
+end

data/lib/voom/presenters/plugins/google_maps.rb

@@ -0,0 +1,24 @@
+module Voom
+  module Presenters
+    module Plugins
+      module GoogleMaps
+          module DSLComponents
+            def google_map(**attributes, &block)
+              self << GoogleMap.new(parent: self, **attributes, &block)
+            end
+          end
+        module WebClientComponents
+          def render_google_map(comp,
+                                render:,
+                                components:,
+                                index:)
+            view_dir = File.join(__dir__, 'google_maps')
+            render.call :erb, :google_map, views: view_dir,
+                        locals: {comp: comp,
+                                 components: components, index: index}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/voom/presenters/plugins/google_maps/google_map.erb

@@ -0,0 +1,10 @@
+<% if comp %>
+  <img id="<%= comp.id %>"
+       class="v-image v-google-map-image <%= comp.events ? 'v-actionable' : nil%>"
+       src="<%= comp.url %>"
+       border="0"
+       height="<%= comp.height %>"
+       width="<%= comp.width %>"
+       alt=""
+       <%= erb :"components/event", :locals => {comp: comp, events: comp.events, parent_id: comp.id} %>>
+<% end %>

data/lib/voom/presenters/plugins/google_maps/google_map.rb

@@ -0,0 +1,41 @@
+require 'uri'
+
+module Voom
+  module Presenters
+    module Plugins
+      module GoogleMaps
+        class GoogleMap < DSL::Components::EventBase
+
+          attr_reader :url, :google_api_key, :height, :width
+
+          def initialize(**attribs_, &block)
+            super(type: :google_map, **attribs_, &block)
+            @address = attribs.delete(:address)
+            @latitude = attribs.delete(:latitude)
+            @longitude = attribs.delete(:longitude)
+            @width = attribs.delete(:width) { 640 }
+            @height = attribs.delete(:height) { 640 }
+            @zoom = attribs.delete(:zoom) { 14 }
+            @scale = attribs.delete(:scale) { 1 }
+            @google_api_key = attribs.delete(:google_api_key) { ENV['GOOGLE_API_KEY'] }
+            @url = build_static_map_image_url
+            expand!
+          end
+
+          private
+
+          def build_static_map_image_url
+            return @img_url if locked?
+            @img_url = "https://maps.googleapis.com/maps/api/staticmap?center=#{query_string}&zoom=#{@zoom}&scale=#{@scale}&size=#{@width}x#{@height}&markers=|#{query_string}&key=#{@google_api_key}"
+          end
+
+          def query_string
+            return "#{@latitude},#{@longitude}" if @latitude && @longitude
+            URI.escape(@address)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/voom/presenters/{dsl.rb → registry.rb}

@@ -1,12 +1,6 @@
-require 'voom/trace'
-
 module Voom
   module Presenters
-    def self.define(name, &block)
-      DSL.define(name, &block)
-    end
-
-    module DSL
+    class Registry
       class << self
         include Voom::Trace
       end
@@ -17,8 +11,10 @@ module Voom
         @registry
       end
 
-      def self.define(name, &block)
-        registry[name] = Voom::Presenters::DSL::Definition.new(&block)
+      def self.define(name, namespace, options, &block)
+        namespace = Array(namespace).map(&:to_s)
+        fq_name = namespace.any? ? namespace.join(':') + ':' + name.to_s : name.to_s
+        registry[fq_name] = Voom::Presenters::DSL::Definition.new(name, namespace, options, &block)
       end
 
       def self.load(directory)
@@ -49,12 +45,20 @@ module Voom
 
       def self.register(name, definition)
         return Voom::Presenters::App.register(name: name, presenter: definition) unless Voom::Presenters::App.registered?(name)
-        logger.warn {"Warning attempted to redefine the presenter: #{name}!"}
       end
 
       def self.build(definition)
         definition.build
       end
     end
+
+    def self.define(name, namespace: nil, options: {}, &block)
+      unless namespace
+        namespace = name.to_s.split(':')
+        name = namespace.pop
+      end
+      Registry.define(name, namespace, options, &block)
+    end
+
   end
 end

data/lib/voom/presenters/router.rb

@@ -0,0 +1,59 @@
+require 'rack'
+
+module Voom
+  module Presenters
+      class Router
+
+        attr_reader :base_url
+
+        def initialize(base_url: nil)
+          @base_url = base_url
+        end
+
+        def url(command: nil, render: nil, host: false, context:)
+          _params_ = context.dup
+          return build_render_url(render, _params_, host: host) unless command
+          _params_[:redirect]=build_render_url(render, _params_) if render
+          build_command_url(command, _params_)
+        end
+
+        def scrub_params(_params_)
+          _params_.delete('captures')
+          _params_.delete('presenter')
+          _params_.delete('action')
+          _params_.delete('errors')
+          _params_
+        end
+
+        private
+
+        def build_command_url(command, params)
+          return '' unless command
+          add_query_params(command, params)
+        end
+
+        def build_render_url(render_, params, host:)
+          return '#' unless render_
+          render = render_.to_s
+          return render if render.start_with?('http')
+          render = render.gsub(':', '/')
+          seperator = render.start_with?('/') ? '' : '/'
+          url = "#{host ? base_url : nil}#{seperator}#{render}"
+          add_query_params(url, params)
+        end
+
+        def add_query_params(url, params)
+          query_params = build_params(params)
+          if (!query_params.nil? && !query_params.empty?)
+            query_seperator = url.include?('?') ? '&' : '?'
+            url = "#{url}#{query_seperator}#{query_params}"
+          end
+          url
+        end
+
+        def build_params(params)
+          Rack::Utils.build_nested_query(scrub_params(params))
+        end
+      end
+    end
+  end

data/lib/voom/presenters/settings.rb

@@ -1,48 +1,79 @@
-include Voom::Trace
-trace {"Loading Presenters Settings"}
-require_relative 'helpers/route'
+#include Voom::Trace
+#trace {"Loading Presenters Settings"}
+require 'dry-configurable'
 
-module Voom
-  module Presenters
-    class Settings
-      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 :id_generator, ->(node) {"id-#{SecureRandom.hex}"}
-        setting :web_client do
-          # Add lambda's to modify the context for the presenters
+unless defined?(Voom::Presenters::Settings)
+  module Voom
+    module Presenters
+      class Settings
+        extend ::Dry::Configurable
+        setting :presenters do
+          setting :root, []
+          # You can add helpers that will automatically be included
           # For example:
           # Voom::Presenters::Settings.configure do |config|
-          #   config.presenters.web_client.prepare_context << ->(context, session, _env){
-          #     identity_id = session[:aaa_identity]
-          #     context.merge(aaa_identity: identity_id)
-          #   }
+          #   config.presenters.helpers << YourHelperModule # Passing a module
+          #   config.presenters.helpers << &->{ def foo; :foo; end } # Passing a block
           # end
-          setting :prepare_context, []
-        end
-        setting :components do
-          setting :defaults do
-            setting :datetime do
-              setting :format, 'F j, Y h:i K'
-              setting :time_24hr, false
-            end
-            setting :date do
-              setting :format, 'F j, Y'
-            end
-            setting :time do
-              setting :format, 'h:i K'
-              setting :time_24hr, false
+          setting :helpers, [Voom::Presenters::Helpers::Route]
+          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
+            # For example:
+            # Voom::Presenters::Settings.configure do |config|
+            #   config.presenters.web_client.prepare_context << ->(context, session, _env){
+            #     identity_id = session[:aaa_identity]
+            #     context.merge(aaa_identity: identity_id)
+            #   }
+            # end
+            setting :prepare_context, []
+            # 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
+                setting :format, 'M j, y h:i K'
+                setting :time_24hr, false
+              end
+              setting :date do
+                setting :format, 'F j, Y'
+              end
+              setting :time do
+                setting :format, 'h:i K'
+                setting :time_24hr, false
+              end
+              setting :text_area do
+                setting :rows, 3
+                setting :cols, 80
+              end
+              # Typography
+              setting :headline do
+                setting :level, 5
+              end
+              setting :title do
+                setting :level, 6
+              end
+              setting :rich_text_area do
+                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)
+          config.presenters.components.defaults&.public_send(type)&.public_send(key)
         end
       end
     end

data/lib/voom/presenters/version.rb

@@ -1,5 +1,7 @@
 module Voom
   module Presenters
-    VERSION = '0.1.13'.freeze
+    module Version
+      VERSION = '2.0.3'
+    end
   end
 end

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

@@ -1,13 +1,8 @@
 require 'sinatra'
+require 'honeybadger' if ENV['HONEYBADGER_API_KEY']
 require 'uri'
 require 'redcarpet'
-require 'voom/trace'
-require 'voom/presenters/app'
-require "dry/inflector"
-
-require_relative 'router'
-require_relative 'markdown_render'
-require_relative '../errors/unprocessable'
+require 'dry/inflector'
 
 module Voom
   module Presenters
@@ -17,9 +12,20 @@ module Voom
         set :root, File.expand_path('../../../../..', __FILE__)
         set :router_, WebClient::Router
         set :bind, '0.0.0.0'
-        set :views, Proc.new {File.join(root, "views", ENV['VIEW_ENGINE']||'mdc')}
-
+        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)
@@ -46,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: [])
@@ -80,17 +108,38 @@ module Voom
 
           def transform(thing)
             case thing
-              when OpenStruct
-                to_hash(thing)
-              when Array
-                thing.map {|v| transform(v)}
-              else
-                thing
+            when OpenStruct
+              to_hash(thing)
+            when Array
+              thing.map {|v| transform(v)}
+            else
+              thing
             end
           end
 
+          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 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
@@ -98,8 +147,24 @@ module Voom
         end
 
         get '/:_presenter_' do
-          pass unless Presenters::App.registered?(params[:_presenter_])
-          presenter = Presenters::App[params[:_presenter_]].call
+          fq_presenter = [params[:_presenter_], 'index'].join(':')
+          pass unless Presenters::App.registered?(params[:_presenter_]) || Presenters::App.registered?(fq_presenter)
+          presenter = (Presenters::App.registered?(fq_presenter) ? Presenters::App[fq_presenter] :
+                           Presenters::App[params[:_presenter_]]).call
+          render_presenter(presenter)
+        end
+
+        get '/:_namespace1_/:_presenter_' do
+          fq_presenter = [params[:_namespace1_], params[:_presenter_]].join(':')
+          pass unless Presenters::App.registered?(fq_presenter)
+          presenter = Presenters::App[fq_presenter].call
+          render_presenter(presenter)
+        end
+
+        get '/:_namespace1_/:_namespace2_/:_presenter_' do
+          fq_presenter = [params[:_namespace1_], params[:_namespace2_], params[:_presenter_]].join(':')
+          pass unless Presenters::App.registered?(fq_presenter)
+          presenter = Presenters::App[fq_presenter].call
           render_presenter(presenter)
         end
 
@@ -107,21 +172,43 @@ 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 Errors::Unprocessable => e
+          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
             JSON.dump({error: e.message})
@@ -129,26 +216,26 @@ 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_proc.call(params, session, env)
+            context = context_proc.call(params, session, env)
           end
           context
         end
 
         def scrub_context(params, _session, _env)
-          %i(splat captures _presenter_ grid_nesting).each do |key|
-            params.delete(key)
+          %i(splat captures  grid_nesting input_tag).each do |key|
+            params.delete(key) {params.delete(key.to_s)}
           end
           params
         end
       end
     end
   end
-end
+end