coprl 0.1.0 → 3.0.0.beta.5

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

@@ -0,0 +1,12 @@
+module Coprl::Presenters::WebClient::Helpers
+  # Sinatra specific helpers
+  module Rails
+    include Coprl::Presenters::WebClient::Helpers::Shared
+    include LocalVariables
+    include Partials
+    include SafeMarkdown
+    include Namespaced
+    include Raw
+    include EscapeHtml
+  end
+end

data/lib/coprl/presenters/web_client/helpers/rails/escape_html.rb

@@ -0,0 +1,9 @@
+module Coprl::Presenters::WebClient::Helpers::Rails
+  module EscapeHtml
+    def h(text)
+      # Rails escapes html already so we don't do it here. It is the opposite as Sinatra.
+      # For the inverse see raw
+      text
+    end
+  end
+end

data/lib/coprl/presenters/web_client/helpers/rails/local_variables.rb

@@ -0,0 +1,11 @@
+module Coprl::Presenters::WebClient::Helpers::Rails
+  module LocalVariables
+    # A rails specific helper to see if a local variable is defined
+    # This passes the binding from the evaluating (erb) context
+    # We don't do this inline, because rails and sintra have different variable names for the same thing
+    def bound_locals_include?(variable, __binding__)
+      locals = __binding__.local_variable_get(:local_assigns)
+      locals.include? variable
+    end
+  end
+end

data/lib/coprl/presenters/web_client/helpers/rails/namespaced.rb

@@ -0,0 +1,12 @@
+module Coprl::Presenters::WebClient::Helpers::Rails
+  module Namespaced
+    def namespaced_presenter(params)
+      scoped_presenter = []
+      scoped_presenter << params.fetch(:namespace1,nil)
+      scoped_presenter << params.fetch(:namespace2,nil)
+      scoped_presenter << params.fetch(:presenter,nil)
+      scoped_presenter.compact!
+      scoped_presenter.any? ? scoped_presenter.join(':') : nil
+    end
+  end
+end

data/lib/coprl/presenters/web_client/helpers/rails/partials.rb

@@ -0,0 +1,20 @@
+module Coprl::Presenters::WebClient::Helpers::Rails
+  module Partials
+    # Called by built in views
+    def partial(template, *args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.merge!(partial: template)
+      # Rails does not support the views parameter ... but sinatra does so we clean it up here
+      options.delete(:views)
+      render options
+    end
+
+    # Called by plugins
+    def render_partial(_engine, template, options = {}, locals = {}, &block)
+      # Rails does not support the views parameter ... but sinatra does so we clean it up here
+      options.delete(:views)
+      options.merge!(partial: template.to_s)
+      render options
+    end
+  end
+end

data/lib/coprl/presenters/web_client/helpers/rails/raw.rb

@@ -0,0 +1,9 @@
+module Coprl::Presenters::WebClient::Helpers::Rails
+  module Raw
+    def raw(html_js_string)
+      # Note Rails escapes by default ... Sinatra is the opposite
+      # For the inverse see escape_html
+      html_js_string.to_s.html_safe
+    end
+  end
+end

data/lib/coprl/presenters/web_client/helpers/rails/safe_markdown.rb

@@ -0,0 +1,9 @@
+module Coprl::Presenters::WebClient::Helpers::Rails
+  module SafeMarkdown
+    include Coprl::Presenters::WebClient::Helpers::Markdown
+    # Called by built in views
+    def markdown(string)
+      base_markdown(string).html_safe
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Coprl::Presenters::WebClient::Helpers
+  module RenderComponent
+    def render_component(scope, comp, components, index)
+      Coprl::Presenters::WebClient::ComponentRenderer.new(comp,
+                                                          render: method(:render_partial),
+                                                          scope: scope,
+                                                          components: components,
+                                                          index: index).render
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Coprl::Presenters::WebClient::Helpers
+  # Helpers used in both rails and sinatra
+  module Shared
+    include FormHelpers
+    include PaddingHelpers
+    include ExpandHash
+    include RenderComponent
+    include Inflector
+    include Color
+    include Headers
+    include Equal
+    include Includes
+    include UniqueId
+    include SnakeToCamel
+    include DragAndDrop
+    include TransformHash
+  end
+end

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

@@ -0,0 +1,11 @@
+module Coprl::Presenters::WebClient::Helpers
+  # Sinatra specific helpers
+  module Sinatra
+    include Coprl::Presenters::WebClient::Helpers::Shared
+    include LocalVariables
+    include Partials
+    include SafeMarkdown
+    include Raw
+    include EscapeHtml
+  end
+end

data/lib/coprl/presenters/web_client/helpers/sinatra/escape_html.rb

@@ -0,0 +1,9 @@
+module Coprl::Presenters::WebClient::Helpers::Sinatra
+  module EscapeHtml
+    def h(text)
+      # Note: Rails escapes html already. It is the opposite as Sinatra.
+      # For the inverse see raw
+      Rack::Utils.escape_html(text)
+    end
+  end
+end

data/lib/coprl/presenters/web_client/helpers/sinatra/local_variables.rb

@@ -0,0 +1,11 @@
+module Coprl::Presenters::WebClient::Helpers::Sinatra
+  module LocalVariables
+    # A sinatra specific helper to see if a local variable is defined
+    # This passes the binding from the evaluating (erb) context
+    # We don't do this inline, because rails and sintra have different variable names for the same thing
+    def bound_locals_include?(variable, __binding__)
+      locals = __binding__.local_variable_get(:locals)
+      locals.include? variable
+    end
+  end
+end

data/lib/coprl/presenters/web_client/helpers/sinatra/partials.rb

@@ -0,0 +1,27 @@
+module Coprl::Presenters::WebClient::Helpers::Sinatra
+  module Partials
+    # Called by built in views
+    def partial(template, *args)
+      template = _add_underscore(template)
+      template = _add_application_dir(template) unless template.start_with?("components/") || template.start_with?("body/")
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.merge!(:layout => false)
+      erb(:"#{template}", options)
+    end
+
+    # Called by plugins
+    def render_partial(engine, template, options = {}, locals = {}, &block)
+      partial(template, options)
+    end
+
+    def _add_underscore(template)
+      template_array = template.to_s.split('/')
+      template_array[0..-2].join('/') + "/_#{template_array[-1]}"
+    end
+
+    def _add_application_dir(template)
+      "application/#{template}"
+    end
+
+  end
+end

data/lib/coprl/presenters/web_client/helpers/sinatra/raw.rb

@@ -0,0 +1,9 @@
+module Coprl::Presenters::WebClient::Helpers::Sinatra
+  module Raw
+    def raw(html_js_string)
+      # Sinatra is raw/unsafe by default - this is the opposite of rails
+      # For the inverse see escape_html
+      html_js_string
+    end
+  end
+end

data/lib/coprl/presenters/web_client/helpers/sinatra/safe_markdown.rb

@@ -0,0 +1,10 @@
+module Coprl::Presenters::WebClient::Helpers::Sinatra
+  module SafeMarkdown
+    include Coprl::Presenters::WebClient::Helpers::Markdown
+    # Called by built in views
+    def markdown(string)
+      # Sinatra does not need a safe_html call it defaults to safe_html
+      base_markdown(string)
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Coprl::Presenters::WebClient::Helpers
+  module SnakeToCamel
+    def snake_to_camel(hash, except: [])
+      Hash[hash.map {|k, v|
+        next [k, v] if except.include?(k)
+        new_key = k.to_s.split('_').collect(&:capitalize).join
+        new_key[0] = new_key[0].downcase
+        [new_key, v]}
+      ]
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Coprl::Presenters::WebClient::Helpers
+  module TransformHash
+    def to_hash(ostruct_or_hash)
+      {}.tap do |h|
+        ostruct_or_hash.to_h.each {|key, value| h[key.to_sym] = transform(value)}
+      end
+    end
+
+    def transform(thing)
+      case thing
+      when OpenStruct
+        to_hash(thing)
+      when Array
+        thing.map {|v| transform(v)}
+      else
+        thing
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Coprl::Presenters::WebClient::Helpers
+  module UniqueId
+    def unique_id(comp)
+      "#{comp.id}-#{SecureRandom.hex(4)}"
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'erb'
+
+module Coprl
+  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||[]) + Coprl::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/coprl/presenters/web_client/plugin_views_path.rb

@@ -0,0 +1,35 @@
+require 'erb'
+
+module Coprl
+  module Presenters
+    module WebClient
+      # This class renders headers for the plugins into the default layout.
+      class PluginViewsPath
+        extend Pluggable
+        include_plugins(:WebClientComponents)
+
+        def initialize(pom:)
+          @pom = pom
+          initialize_plugins
+        end
+
+        def render
+          results = []
+          ((@plugins||[]) + Coprl::Presenters::Settings.config.presenters.plugins).each do |plugin|
+            view_dir_method = :"view_dir_#{plugin}"
+            results << send(view_dir_method,
+                 @pom) if respond_to?(view_dir_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/coprl/presenters/web_client/router.rb

@@ -0,0 +1,10 @@
+require 'coprl/presenters/router'
+
+module Coprl
+  module Presenters
+    module WebClient
+      class Router <  Presenters::Router
+      end
+    end
+  end
+end

data/lib/coprl/serializer.rb

@@ -0,0 +1,43 @@
+require 'coprl/parameters'
+require 'coprl/trace'
+
+module Coprl
+  # Simple serializer that will build add a to_hash method to an object by inspecting
+  # the intersection of its instance variables and public accessor methods.
+  module Serializer
+    include Trace
+
+    def to_hash(serializer=true)
+      trace {self.class.to_s}
+      return build_hash unless serializer
+      begin
+        serializer_name = "#{self.class.to_s}Serializer"
+        serializer = Module.const_get(serializer_name)
+        serializer.new(self).to_hash
+      rescue NameError
+        build_hash
+      end
+    end
+
+    private
+    def build_hash
+      accessable = instance_variables.map {|i| i.to_s.gsub('@', '').to_sym} & methods
+      accessable.reduce({}) do |hash, v|
+        trace {"#{v}:#{params.inspect}"}
+        params = Parameters.new(method(v).parameters)
+        unless params.required_args? || params.required_options?
+          value = self.send(v)
+          value = if value.kind_of?(Array)
+                    value.map {|v_| v_.respond_to?(:to_hash) ? v_.to_hash : v_}
+                  elsif value.kind_of?(Hash)
+                    value.map {|k, v_| v_.respond_to?(:to_hash) ? [k, v_.to_hash] : [k, v_]}.to_h
+                  else
+                    value.respond_to?(:to_hash) ? value.to_hash : value
+                  end
+          hash[v]= value
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/coprl/symbol/to_str.rb

@@ -0,0 +1,29 @@
+require "dry/inflector"
+
+module Coprl::Symbol
+  # Helper module for converting symbol naming to string.
+  # It provides common conversions for variable naming (snake_case) and class naming (class_name)
+  module ToStr
+    # Maps symbols to strings
+    def sym_to_str(name)
+      return name if name.is_a? ::String
+      name.to_s
+    end
+
+    # Converts a namespaced string or symbol to snake_case
+    def snake_case(str)
+      inflector.underscore(sym_to_str(str).tr('.', '_'))
+    end
+
+    # Converts a namespaced symbol or string to a proper class name with modules
+    def class_name(classname)
+      classname = sym_to_str(classname)
+      classname.split('.').map { |m| inflector.camelize(m) }.join('::')
+    end
+
+    private
+    def inflector
+      @_inflector_ ||= Dry::Inflector.new
+    end
+  end
+end

data/lib/coprl/trace.rb

@@ -0,0 +1,17 @@
+module Coprl
+  module Trace
+    include Coprl::LoggerMethods
+
+    private
+    # Use a regex on your classes to enable debug logging
+    # For example:
+    # In your .env
+    # export VOOM_TRACE_LOG_REGEX="^.*$"
+    # In your code
+    # trace {"What is it doing?" }
+    def trace(&block)
+      return unless ENV['VOOM_TRACE_LOG_REGEX']
+      logger.info {"T:#{self.class}:#{block.call}"} if /#{ENV['VOOM_TRACE_LOG_REGEX']}/.match(self.class.name)
+    end
+  end
+end