voom-presenters 0.1.0

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

@@ -0,0 +1,11 @@
+module Voom
+  module Presenters
+    module Helpers
+      module Route
+        def presenters_path(presenter, **params)
+          router.url(render: presenter, context: params)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'tzinfo'
+
+module Voom
+  module Presenters
+    module Helpers
+      module Time
+        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)
+          return '' unless time
+          time = time.in_time_zone(timezone) if timezone
+          time.strftime(format)
+        end
+
+        def format_time_long(time, format: nil, timezone: nil)
+          format_time(time, format: format||LONG_FORMAT, timezone: timezone)
+        end
+
+        def format_time_short(time, format: nil, timezone: nil)
+          format_time(time, format: format||SHORT_FORMAT, timezone: timezone)
+        end
+      end
+    end
+  end
+end
+

data/lib/voom/presenters/settings.rb

@@ -0,0 +1,35 @@
+include Voom::Trace
+trace {"Loading Presenters Settings"}
+require_relative 'helpers/route'
+
+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
+          # 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, []
+        end
+      end
+    end
+  end
+end

data/lib/voom/presenters/version.rb

@@ -0,0 +1,5 @@
+module Voom
+  module Presenters
+    VERSION = '0.1.0'.freeze
+  end
+end

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

@@ -0,0 +1,128 @@
+require 'sinatra'
+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'
+
+module Voom
+  module Presenters
+    module WebClient
+      class App < Sinatra::Base
+        include Trace
+        set :root, File.expand_path('../../../../..', __FILE__)
+        set :router_, Router
+        set :bind, '0.0.0.0'
+        set :views, Proc.new {File.join(root, "views", ENV['VIEW_ENGINE']||'mdc')}
+
+        helpers do
+          def markdown(text)
+            unless @markdown
+              renderer = CustomRender.new(hard_wrap: false, filter_html: true)
+              options = {
+                  autolink: false,
+                  no_intra_emphasis: true,
+                  fenced_code_blocks: true,
+                  lax_html_blocks: true,
+                  strikethrough: true,
+                  superscript: true,
+                  disable_indented_code_blocks: true
+              }
+              @markdown = Redcarpet::Markdown.new(renderer, options)
+            end
+
+            @markdown.render(text)
+          end
+
+          def inflector
+            @inflector ||= Dry::Inflector.new
+          end
+
+          def eq(attrib, value)
+            attrib.to_s == value.to_s
+          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/>")
+          end
+
+          def color_classname(comp)
+            return "v-#{comp.type}__primary" if eq(comp.color, :primary)
+            "v-#{comp.type}__secondary" if eq(comp.color, :secondary)
+          end
+
+          def color_style(comp, affects=nil)
+            "#{affects}color: #{comp.color};" unless %w(primary secondary).include?(comp.color.to_s) || comp.color.nil?
+          end
+
+        end
+
+        get '/' do
+          pass unless Presenters::App.registered?('index')
+          presenter = Presenters::App['index'].call
+          render_presenter(presenter)
+        end
+
+        get '/:_presenter_' do
+          pass unless Presenters::App.registered?(params[:_presenter_])
+          presenter = Presenters::App[params[:_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)
+          layout = !(request.env['HTTP_X_NO_LAYOUT'] == 'true')
+          erb :web, layout: layout
+        end
+
+        private
+
+        def render_presenter(presenter)
+          @grid_nesting = Integer(params[:grid_nesting] || 0)
+
+          begin
+            @pom = presenter.expand(router: router, context: prepare_context)
+            layout = !(request.env['HTTP_X_NO_LAYOUT'] == 'true')
+            response.headers['X-Frame-Options'] = 'ALLOWALL' if ENV['ALLOWALL_FRAME_OPTIONS']
+            erb :web, layout: layout
+          rescue 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}#{env['SCRIPT_NAME']}")
+        end
+
+        def prepare_context
+          prepare_context = Presenters::Settings.config.presenters.web_client.prepare_context.dup
+          prepare_context.push(method(:scrub_context))
+          context = params.dup
+          prepare_context.reduce(context) do |params, context_proc|
+            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)
+          end
+          params
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+class CustomRender < Redcarpet::Render::Safe
+  include Redcarpet::Render::SmartyPants
+
+  def initialize(extensions = {})
+    super(extensions)
+  end
+  
+  def paragraph(text)
+      text + '<br/>'
+    end
+
+  def postprocess(full_document)
+    full_document.
+        gsub(/{c:([#\w]\w+)}([^{]+){\/c}/) {|m| "<span style=\"color:#{$1};\">#{$2}</span>"} # color
+  end
+end

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

@@ -0,0 +1,96 @@
+require 'rack'
+
+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
+      end
+    end
+  end
+end

data/lib/voom/serializer.rb

@@ -0,0 +1,43 @@
+require_relative 'parameters'
+require_relative 'trace'
+
+module Voom
+  # 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/voom/symbol/to_str.rb

@@ -0,0 +1,29 @@
+require "dry/inflector"
+
+module Voom
+  # Helper module for converting symbol naming to string.
+  # It provides common conversions for variable naming (snake_case) and class naming (class_name)
+  module Symbol
+    # 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/voom/trace.rb

@@ -0,0 +1,19 @@
+require_relative 'logger_methods'
+
+module Voom
+  module Trace
+    include Voom::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

data/presenters.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'voom/presenters/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'voom-presenters'
+  spec.version = Voom::Presenters::VERSION
+  spec.authors = ['Russell Edens']
+  spec.email = ["russell@voomify.com\n"]
+
+  spec.summary = 'Presenters Gem.'
+  spec.homepage = 'http://github.com/rx/presenters'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'ice_nine', '~>0.11'
+  spec.add_runtime_dependency 'dry-container', '~>0.6'
+  spec.add_runtime_dependency 'dry-configurable', '~>0.7'
+  spec.add_runtime_dependency 'dry-inflector', '~>0.1'
+  spec.add_runtime_dependency 'sinatra', '~>2.0'
+  spec.add_runtime_dependency  'tzinfo', '~>1.2'
+  spec.add_runtime_dependency  'tzinfo-data', '~>1.2018'
+  spec.add_runtime_dependency  'redcarpet', '~>3.4'
+  
+  spec.add_development_dependency 'rack-test', '~>0.8'
+  spec.add_development_dependency 'pry', '~>0.10'
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 11.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end