coprl 0.1.0 → 3.0.0.beta.1

data/lib/coprl/presenters/version.rb

@@ -0,0 +1,7 @@
+module Coprl
+  module Presenters
+    module Version
+      VERSION = '3.0.0.beta.1'
+    end
+  end
+end

data/lib/coprl/presenters/views.rb

@@ -0,0 +1,17 @@
+module Coprl
+  module Presenters
+    class Views
+      def self.view_path
+        File.expand_path('../../../../views/mdc', __FILE__)
+      end
+
+      def self.web_erb_path
+        File.join(view_path, web_erb)
+      end
+
+      def self.web_erb
+        'web.erb'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require 'sinatra'
+require 'honeybadger' if ENV['HONEYBADGER_API_KEY']
+require 'uri'
+require 'redcarpet'
+require 'dry/inflector'
+
+module Coprl
+  module Presenters
+    module WebClient
+      class App < Sinatra::Base
+        include Trace
+        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 :dump_errors, false
+        set :protection, :except => :frame_options
+        configure do
+          enable :logging
+        end
+        helpers Helpers::Sinatra
+
+        get '/' do
+          pass unless Presenters::App.registered?('index')
+          presenter = Presenters::App['index'].call
+          render_presenter(presenter)
+        end
+
+        get '/:_presenter_' do
+          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
+
+        # Forms engine demo
+        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 Coprl::Presenters::Api::App#render_presenter
+        def render_presenter(presenter)
+          @grid_nesting = Integer(params[:grid_nesting] || 0)
+
+          begin
+            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'] = 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
+            JSON.dump({error: e.message})
+          end
+        end
+
+        def router
+          settings.router_.new(base_url: "#{request.base_url}")
+        end
+
+        def prepare_context(base_params = params)
+          prepare_context = Presenters::Settings.config.presenters.web_client.prepare_context.dup
+          prepare_context.push(method(:scrub_context))
+          context = base_params.dup
+          prepare_context.reduce(context) do |params, context_proc|
+            context = context_proc.call(params, session, env)
+          end
+          context
+        end
+
+        def scrub_context(params, _session, _env)
+          %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

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

@@ -0,0 +1,27 @@
+require "dry/inflector"
+
+module Coprl
+  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/coprl/presenters/web_client/component_html_decorator.rb

@@ -0,0 +1,50 @@
+require 'delegate'
+
+module Coprl
+  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/coprl/presenters/web_client/component_renderer.rb

@@ -0,0 +1,49 @@
+require 'erb'
+
+module Coprl
+  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/coprl/presenters/web_client/custom_css.rb

@@ -0,0 +1,66 @@
+module Coprl
+  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
+        include Coprl::Presenters::WebClient::Helpers::HtmlSafe
+
+        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)
+          html_safe (<<~CSS)
+            <link rel="stylesheet" type="text/css" href="#{host}/#{path.sub('public/', '')}">
+          CSS
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'redcarpet'
+
+module Coprl::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/coprl/presenters/web_client/helpers/color.rb

@@ -0,0 +1,18 @@
+module Coprl::Presenters::WebClient::Helpers
+  module Color
+    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, color_attr = :color)
+      color = comp.public_send(color_attr)
+      "#{affects}color: #{color};" unless %w(primary secondary).include?(color.to_s) || color.nil?
+    end
+  end
+end

data/lib/coprl/presenters/web_client/helpers/drag_and_drop.rb

@@ -0,0 +1,21 @@
+module Coprl::Presenters::WebClient::Helpers
+  module DragAndDrop
+    def draggable_attributes(comp)
+      draggable_attributes = ''
+      if comp.draggable
+        draggable_attributes = "draggable=true data-drag_params='#{comp.draggable.to_h.to_json}'"
+      end
+      draggable_attributes
+    end
+
+    def drop_zone_attributes(comp)
+      drop_zone_attributes = ''
+      if comp.drop_zone
+        zone = comp.drop_zone[:zone]
+        drop_zone_attributes = "data-dropzone='#{zone}' data-drop_params='#{comp.drop_zone.to_h.to_json}'"
+      end
+      drop_zone_attributes
+    end
+  end
+end
+

data/lib/coprl/presenters/web_client/helpers/equal.rb

@@ -0,0 +1,7 @@
+module Coprl::Presenters::WebClient::Helpers
+  module Equal
+    def eq(attrib, value)
+      attrib.to_s == value.to_s
+    end
+  end
+end

data/lib/coprl/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 Coprl::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