voom-presenters 0.1.13 → 2.0.3

data/config.ru

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-if ENV['VOOM_ENV']=='integration_testing'
+if ENV['VOOM_ENV'] == 'integration_testing'
   require 'simplecov'
   if ENV['CIRCLE_ARTIFACTS']
     dir = File.join(ENV['CIRCLE_ARTIFACTS'], "coverage")
@@ -9,22 +9,33 @@ if ENV['VOOM_ENV']=='integration_testing'
 end
 
 ENV['VOOM_ROOT'] = File.expand_path(__dir__)
-libdir = File.join(ENV['VOOM_ROOT'], 'lib')
-$:.unshift(libdir) unless $:.include?(libdir)
-require 'voom/presenters/api/app'
-require 'voom/presenters/web_client/app'
-require 'voom/presenters/demo/search'
-require 'voom/presenters/demo/echo'
+ENV['GOOGLE_API_KEY'] = 'AIzaSyDhSgj9XSBLY5E9Rx5pP2ILQ7IXnD4uX2Q'
+require 'voom'
 
+require 'rack/cors'
+use Rack::Cors do
+  allow do
+    origins '*'
+    resource '*', headers: :any, methods: [:get, :post, :options]
+  end
+end
+
+Voom::Presenters::Settings.configure do |config|
+  config.presenters.root = File.join(ENV['VOOM_ROOT'], 'app')
+  config.presenters.web_client.prepare_context << ->(context, session, _env) {
+    context.merge(session: session)
+  }
+end
 
 use Voom::Presenters::Demo::Search
 use Voom::Presenters::Demo::Echo
+use Voom::Presenters::Demo::Slow
+use Voom::Presenters::Demo::DragonDrop
 
 use Voom::Presenters::WebClient::App
 run Voom::Presenters::Api::App
 
-Voom::Presenters::Settings.configure do |config|
-  config.presenters.root = File.join(ENV['VOOM_ROOT'], 'app')
-end
+
 Voom::Presenters::App.boot!
 
+

data/docs/settings.md

@@ -0,0 +1,81 @@
+# Configuration
+Presenters can be configured via settings set in e.g. Rails initializers.
+
+## Overview
+Configuration is handled via [dry-configurable](https://github.com/dry-rb/dry-configurable).
+
+```ruby
+Voom::Presenters::Settings.configure do |config|
+  config.presenters.helpers << SomeHelperClass
+end
+```
+
+## Table of Contents
+* [`before_render`](#before_render)
+
+## Settings
+### `before_render`
+`before_render` is an array of things which respond to `#call/1`. The items in
+the array are lazily invoked with the current request prior to a Presenter
+being rendered.
+
+If an item returns a non-`nil` Presenter name, this Presenter will be rendered
+instead of the Presenter that was about to be rendered. In this case, subsequent
+`before_render` items will not be invoked.
+
+```ruby
+# request: /foos/foo?id=1
+
+Voom::Presenters::Settings.configure do |config|
+  config.presenters.before_render << lambda do |req|
+    if some_predicate?
+      return :render_me_instead
+      # /render_me_instead?id=1 will be rendered instead of /foos/foo?id=1.
+    end
+
+    # return nil will not intercept rendering and the next lambda will be
+    # invoked.
+  end
+
+  # this lambda will be invoked only if all previous lambdas returned nil.
+  config.presenters.before_render << lambda do |req|
+    puts 'if you see me, some_predicate? returned true'
+
+    # return nil will not intercept rendering and the next lambda will be
+    # invoked.
+  end
+end
+```
+
+If all items return `nil`, the original Presenter is rendered unintercepted.
+
+#### Returning context
+
+A `before_render` item may optionally return a context hash. This hash will be
+passed to the rendered presenter and merged with existing context at render
+time. **Key names in a returned context hash will overwrite the request's
+context, so use with caution.**
+
+```ruby
+# request: /foos/foo?id=1
+
+class AuthenticationCheck
+  def initialize; end
+
+  def call(req)
+    unless authenticated?(req)
+      return ['auth:login', { timestamp: Time.current.to_i }]
+      # /auth/login?id=1&timestamp=1579535489 will be rendered instead of
+      # /foos/foo?id=1.
+      # /auth/login will have context { id: 1, timestamp: 1579535489 }
+    end
+
+    # return nil will not intercept rendering and the next lambda will be
+    # invoked.
+  end
+end
+
+Voom::Presenters::Settings.configure do |config|
+  config.presenters.before_render << AuthenticationCheck.new
+end
+```

data/exe/presenters

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require_relative '../lib/voom/presenters/cli'
+Voom::Presenters::Cli.start(ARGV)

data/lib/hash_ext/traverse.rb

@@ -0,0 +1,14 @@
+module HashExt
+  module Traverse
+    def self.traverse(hash, &block)
+      hash.inject({}) do |h,(k,v)|
+        if Hash === v
+          v = traverse(v,&block)
+        end
+        nk, nv = block.call(k,v)
+        h[nk] = nv unless nk.nil?
+        h
+      end
+    end
+  end
+end

data/lib/voom.rb

@@ -0,0 +1,25 @@
+require 'zeitwerk'
+
+class MyInflector < Zeitwerk::GemInflector
+  def camelize(basename, _abspath)
+    case basename
+    when "dsl"
+      "DSL"
+    else
+      super
+    end
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector = MyInflector.new(__FILE__)
+#loader.logger = Logger.new($stderr)
+loader.setup
+
+module Voom
+end
+
+if defined?(::Rails)
+  # We need this class's file to be parsed, but we want to let Zeitwerk load it
+  Voom::Railtie
+end

data/lib/voom/container_methods.rb

@@ -1,8 +1,8 @@
-require_relative 'symbol/to_str'
+require 'dry-container'
 
 module Voom
   module ContainerMethods
-    include Voom::Symbol
+    include Voom::Symbol::ToStr
 
     def registered_keys
       @registered_keys ||= []

data/lib/voom/engine.rb

@@ -0,0 +1,5 @@
+module Voom
+  class Engine < ::Rails::Engine
+    config.eager_load_paths += Dir["#{config.root}/lib"]
+  end
+end

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

@@ -1,7 +1,6 @@
 require 'sinatra'
+require 'honeybadger' if ENV.fetch('HONEYBADGER_API_KEY'){false}
 require 'json'
-require_relative '../../presenters'
-require_relative 'router'
 
 module Voom
   module Presenters
@@ -13,28 +12,62 @@ module Voom
         set :bind, '0.0.0.0'
 
         get '/:_presenter_.pom' do
-          render_presenter
+          render_presenter(params[:_presenter_])
         end
 
+        get '/:_namespace1_/:_presenter_.pom' do
+          fq_presenter = [params[:_namespace1_], params[:_presenter_]].join(':')
+          pass unless Presenters::App.registered?(fq_presenter)
+          render_presenter(fq_presenter)
+        end
+
+        get '/:_namespace1_/:_namespace2_/:_presenter_.pom' do
+          fq_presenter = [params[:_namespace1_], params[:_namespace2_], params[:_presenter_]].join(':')
+          pass unless Presenters::App.registered?(fq_presenter)
+          render_presenter(fq_presenter)
+        end
+
+
         private
 
-        def render_presenter
-          # puts "/presenters/api/#{params[:version]}/#{params[:presenter]}/"
-          # puts "Parameters: #{params.inspect}"
-          presenter = Voom::Presenters::App[params[:_presenter_]].call
-          pom = presenter.expand(router: router, context: prepare_context)
-          content_type :json
-          JSON.dump(pom.to_hash)
+        # analogous to Voom::Presenters::WebClient::App#render_presenter
+        def render_presenter(presenter)
+          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 = render_instead
+            end
+
+            p = params.merge(ctx || {})
+            presenter = Voom::Presenters::App[presenter].call
+            pom = presenter.expand(router: router, context: prepare_context(p))
+            content_type :json
+            JSON.dump(pom.to_hash)
+          rescue StandardError => e
+            presenter_name = presenter.respond_to?(:name) ? presenter.name : '(unknown)'
+            Presenters::Settings.config.presenters.error_logger.call(
+              @env['rack.errors'],
+              e,
+              params,
+              presenter_name
+            )
+            raise e
+          end
         end
 
         def router
           settings.router_.new(base_url: "#{request.base_url}#{env['SCRIPT_NAME']}")
         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)
           end
@@ -50,4 +83,4 @@ module Voom
       end
     end
   end
-end
+end

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

@@ -1,94 +1,10 @@
-require 'rack'
+require 'voom/presenters/router'
 
 module Voom
   module Presenters
     module Api
-      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
-          "#{command}?#{build_params(params, entity)}"
-        end
-
-        def build_render_url(render_, entity, params)
-          return '#' unless render_
-          render = render_.to_s
-          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/presenters/app.rb

@@ -34,13 +34,13 @@ module Voom
         def load(dir='app', root=ENV['VOOM_ROOT']||File.expand_path("../../../", __FILE__))
           path = File.expand_path(dir, root)
           trace {"Loading Presenters from: #{path}"}
-          Presenters::DSL.load(File.expand_path(dir, root))
-          Presenters::DSL.finalize
+          Presenters::Registry.load(File.expand_path(dir, root))
+          Presenters::Registry.finalize
         end
 
         def reset!
           super
-          Presenters::DSL.reset!
+          Presenters::Registry.reset!
         end
 
         private

data/lib/voom/presenters/cli.rb

@@ -0,0 +1,28 @@
+require 'thor'
+require_relative 'generators/plugin'
+
+module Voom
+  module Presenters
+    class SubCommandBase < Thor
+      def self.banner(command, namespace = nil, subcommand = false)
+        "#{basename} #{subcommand_prefix} #{command.usage}"
+      end
+
+      def self.subcommand_prefix
+        self.name.gsub(%r{.*::}, '').gsub(%r{^[A-Z]}) { |match| match[0].downcase }.gsub(%r{[A-Z]}) { |match| "-#{match[0].downcase}" }
+      end
+    end
+
+      class Generate < SubCommandBase
+        desc "plugin", "generates a plugin"
+        def plugin(name)
+          Generators::Plugin.start([name])
+        end
+      end
+      class Cli < Thor
+        desc "generate", "generate a plugin"
+        subcommand "generate", Generate
+      end
+    end
+  end
+

data/lib/voom/presenters/demo/dragon_drop.rb

@@ -0,0 +1,48 @@
+require 'sinatra/base'
+
+module Voom
+  module Presenters
+    module Demo
+      class DragonDrop < Sinatra::Base
+        include Voom::Presenters::WebClient::Helpers::ExpandHash
+
+        configure do
+          enable :sessions
+          set :session_secret, '0e53ba1da13aa8eb8cf3d361e67b70d79265edca'
+        end
+
+        post('/_dragon_drop_change_order_') do
+          content_type :json
+          source_id = JSON.parse(params[:source_id]) if params[:source_id]
+          target_id = JSON.parse(params[:target_id]) if params[:target_id]
+          dragons = fetch_dragons
+          unless source_id == target_id
+            source = dragons.select {|d| d.id == source_id}.first
+            target = dragons.select {|d| d.id == target_id}.first
+
+            if source && target
+              starting_sort = target.sort
+              source.sort = starting_sort
+              dragons.each do |dragon|
+                next if dragon.id == source.id || dragon.sort < starting_sort
+                dragon.sort += 1
+              end
+            end
+            save(dragons)
+          end
+        end
+
+        def fetch_dragons
+          JSON.parse(session[:dragons], object_class: OpenStruct)
+        end
+
+        def save(dragons)
+          session[:dragons] = dragons.map {|d| expand_hash(d)}.to_json
+        end
+
+        # start the server if ruby file executed directly
+        run! if app_file == $0
+      end
+    end
+  end
+end