voom-presenters 0.1.12 → 2.0.2

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

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

@@ -0,0 +1,31 @@
+require 'redcarpet'
+
+module Voom::Presenters::WebClient
+  class CustomRender < Redcarpet::Render::Safe
+    # include Redcarpet::Render::SmartyPants
+    BR = '<br/>'
+
+    def initialize(extensions = {})
+      super(extensions)
+    end
+
+    def paragraph(text)
+      text + BR
+    end
+
+    def postprocess(full_document)
+      strip_trailing_br(colorize(full_document))
+    end
+
+    private
+
+    def colorize(doc)
+      doc.gsub(/{c:([#\w]\w+)}([^{]+){\/c}/) {|m| "<span style=\"color:#{$1};\">#{$2}</span>"}
+    end
+
+    def strip_trailing_br(doc)
+      return doc unless doc[-BR.length..-1] == BR
+      doc[0...doc.length-BR.length]
+    end
+  end
+end

data/lib/voom/presenters/web_client/helpers/expand_hash.rb

@@ -0,0 +1,19 @@
+# Expands a hash ensuring all values are hash's
+# POM object models expand to a hash using :to_hash
+# JSON is serialized in as recursive OpenStruct's, they need special expansion logic.
+module Voom::Presenters::WebClient::Helpers
+  module ExpandHash
+    def expand_hash(h)
+      HashExt::Traverse.traverse(h.to_h) do |k,v|
+        if !v.is_a?(Array) && v.respond_to?(:to_h)
+          v = v.is_a?(OpenStruct) ? expand_hash(v.to_h) : v.to_h
+        elsif v.is_a?(Array)
+          v = v.map {|v| v.is_a?(OpenStruct) ? expand_hash(v.to_h) : v}
+        elsif v.respond_to?(:to_hash)
+          v = v.to_hash
+        end
+        [k,v]
+      end
+    end
+  end
+end

data/lib/voom/presenters/web_client/helpers/form_helpers.rb

@@ -0,0 +1,14 @@
+# used used by the form erbs
+module Voom::Presenters::WebClient::Helpers
+  module FormHelpers
+
+    def buttons?(components)
+      buttons(components).any?
+    end
+
+    def buttons(components)
+      components.select {|c| eq(c.type, :button)}
+    end
+
+  end
+end

data/lib/voom/presenters/web_client/helpers/padding_helpers.rb

@@ -0,0 +1,21 @@
+# used used by the grid, content and card erbs
+module Voom::Presenters::WebClient::Helpers
+  module PaddingHelpers
+    def _padding_array_(padding, nesting=0)
+      return (%i(top0 right0 bottom0 left0) - padding.map {|p| "#{p.to_s.gsub(%r(\d),'')}0".to_sym} + padding.map(&:to_sym)).sort if padding
+      nesting > 1 ? %i(top3 right0 bottom3 left0).sort : []
+    end
+
+    def _padding?(padding, nesting=0)
+      _padding_array_(padding, nesting) != %i(top0 right0 bottom0 left0).sort
+    end
+
+    def _padding_classes_(padding, nesting=0)
+      "v-padding-#{_padding_array_(padding, nesting).join('-')}"
+    end
+
+    def _alignment_class_(align)
+      "v-grid-column-align-#{align}"
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'erb'
+
+module Voom
+  module Presenters
+    module WebClient
+      # This class renders headers for the plugins into the default layout.
+      class PluginHeaders
+        extend Pluggable
+        include_plugins(:WebClientComponents)
+
+        def initialize(pom:, render:)
+          @pom = pom
+          @render = render
+          initialize_plugins
+        end
+
+        def render
+          results = ""
+          ((@plugins||[]) + Voom::Presenters::Settings.config.presenters.plugins).each do |plugin|
+            header_method = :"render_header_#{plugin}"
+            results << send(header_method,
+                 @pom,
+                 render: @render) if respond_to?(header_method)
+          end
+          results
+        end
+
+        private
+
+        def initialize_plugins
+          @plugins = @pom.send(:plugins)
+          self.class.include_plugins(:WebClientComponents, plugins: @plugins)
+        end
+      end
+    end
+  end
+end

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

@@ -1,96 +1,10 @@
-require 'rack'
+require 'voom/presenters/router'
 
 module Voom
   module Presenters
     module WebClient
-      class Router
-
-        attr_reader :base_url
-
-        def initialize(base_url: nil)
-          @base_url = base_url
-        end
-
-        def url(command: nil, render: nil, entity: nil, context:)
-          _params_ = context.dup
-          # if it is a local page command
-          # return build_local_render(command, render, entity, _params_) if local_render?(render)
-          return build_render_url(render, entity, _params_) unless command
-          _params_[:redirect]=build_render_url(render, entity, _params_) if render
-          build_command_url(command, entity, _params_)
-        end
-
-        def local_render?(render)
-          return unless render
-          render.to_s.start_with?('#')
-        end
-
-        def build_local_render(command, render, entity, context)
-
-          client_command = render[/(.*?)\(/m, 1]
-
-          start_params = render.index('(')
-          end_params = render.rindex(')')
-          client_params = render[start_params+1..end_params-1]
-          client_params = client_params.split(',')
-
-          client_command += '('
-          client_params.each.with_index do |p, index|
-            client_command += ',' if index > 0
-            url_var = p[/{url\((.*?)\)}/m, 1]
-            client_command += build_client_url(url_var.strip, entity, context) if url_var && command.nil?
-            client_command += p.strip unless url_var
-          end
-          client_command += ')'
-        end
-
-        def join_errors
-          '<br/>'
-        end
-
-        def scrub_params(_params_)
-          # _params_.delete('captures')
-          # _params_.delete('render')
-          # _params_.delete('view')
-          _params_.delete('presenter')
-          # _params_.delete('redirect')
-          _params_.delete('action')
-          _params_.delete('errors')
-          _params_
-        end
-
-        private
-
-        def build_command_url(command, entity, params)
-          return '' unless command
-          seperator = command.include?('?') ? '&' : '?'
-          "#{command}#{seperator}#{build_params(params, entity)}"
-        end
-
-        def build_render_url(render_, entity, params)
-          return '#' unless render_
-          render = render_.to_s
-          return render if render.start_with?('http')
-          seperator = render.start_with?('/') ? '' : '/'
-          url = "#{base_url}#{seperator}#{render}"
-          query_params = build_params(params, entity)
-          if(query_params)
-            query_seperator = render.include?('?') ? '&' : '?'
-            url = "#{url}#{query_seperator}#{query_params}"
-          end
-          url
-        end
-
-        def build_client_url(render, entity, params)
-          return '#' unless render
-          "#{base_url}/web/#{render}?layout=false&#{build_params(params, entity)}"
-        end
-
-        def build_params(params, entity)
-          params = params.merge(entity_key: entity.id) if entity
-          Rack::Utils.build_nested_query(scrub_params(params))
-        end
+      class Router <  Presenters::Router
       end
     end
   end
-end
+end

data/lib/voom/railtie.rb

@@ -0,0 +1,37 @@
+require 'filewatcher'
+
+module Voom
+  class Railtie < ::Rails::Railtie
+    BOOT = -> {
+      Voom::Presenters::App.reset!
+      Voom::Presenters::Settings.configure do |config|
+        config.presenters.root = Rails.root.join('app')
+        config.presenters.deep_freeze = false
+      end
+      Voom::Presenters::App.boot!
+    } unless defined?(BOOT)
+
+    WATCH = -> {
+      return unless Rails.env.development?
+      path = Rails.root.join('app', '**', '*.pom')
+      puts "Watching #{path} for changes..."
+      filewatcher = Filewatcher.new(path)
+      Thread.new(filewatcher) do |fw|
+        fw.watch do |f|
+          puts "Detected updated POM file: #{f}"
+          begin
+            BOOT.call
+          rescue Exception => exc
+            puts exc.backtrace
+            puts exc.message
+          end
+        end
+      end
+    } unless defined?(WATCH)
+
+    config.after_initialize do
+      BOOT.call
+      WATCH.call
+    end
+  end
+end