voom-presenters 0.1.0

data/config.ru

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+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'
+
+
+use Voom::Presenters::Demo::Search
+use Voom::Presenters::Demo::Echo
+
+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/lib/voom-presenters.rb

@@ -0,0 +1,9 @@
+module Voom
+  module Presenters
+    if defined?(Rails)
+      require 'voom/presenters-engine'
+    else
+      require 'voom/presenters'
+    end
+  end
+end

data/lib/voom/container_methods.rb

@@ -0,0 +1,40 @@
+require_relative 'symbol/to_str'
+
+module Voom
+  module ContainerMethods
+    include Voom::Symbol
+
+    def registered_keys
+      @registered_keys ||= []
+    end
+
+    def registered?(presenter)
+      container.key?(sym_to_str(presenter))
+    end
+
+    def [](name)
+      resolve(name)
+    end
+
+    def resolve(name)
+      container.resolve(sym_to_str(name))
+    end
+
+    def list
+      container.keys
+    end
+    alias keys list
+
+    def container
+      @container ||= Dry::Container.new
+    end
+
+    # This method empties out the container
+    # It should ONLY be used for testing purposes
+    def reset!
+      registered_keys.each { |key| ClassConstants.new(key).deconstantize }
+      @registered_keys = []
+      container._container.clear
+    end
+  end
+end

data/lib/voom/logger_methods.rb

@@ -0,0 +1,11 @@
+require 'logger'
+
+module Voom
+  module LoggerMethods
+    private
+    
+    def logger
+      Logger.new(STDOUT)
+    end
+  end
+end

data/lib/voom/parameters.rb

@@ -0,0 +1,73 @@
+module Voom
+  # Provides a query interface for the ruby parameters method
+  class Parameters
+    def initialize(parameters)
+      @params = parameters
+    end
+
+    def args
+      @params.select {|p| p.first == :req || p.first == :opt}
+    end
+
+    def required_args
+      @params.select {|p| p.first == :req}
+    end
+
+    def required_args?
+      required_args.any?
+    end
+
+    def optional_args
+      @params.select {|p| p.first == :opt}
+    end
+
+    def optional_args?
+      optional_args.any?
+        end
+
+    def splats_args
+      @params.select {|p| p.first == :rest}
+    end
+
+    def splats_args?
+      splats_args.any?
+    end
+    
+    def options
+      @params.select {|p| p.first == :keyreq || p.first == :key}
+    end
+
+    def options?
+      options.any?
+    end
+
+    def required_options
+      @params.select {|p| p.first == :keyreq}
+    end
+
+    def required_options?
+      required_options.any?
+    end
+    
+
+    def optional_options
+      @params.select {|p| p.first == :key}
+    end
+
+    def optional_options?
+      optional_options.any?
+    end
+
+    def spalts_options
+      @params.select {|p| p.first == :keyrest}
+    end
+
+    def splats_options?
+      spalts_options.any?
+    end
+
+    def names(args_or_options)
+      args_or_options.map(&:last)
+    end
+  end
+end

data/lib/voom/presenters-engine.rb

@@ -0,0 +1,40 @@
+if Rails.version =~ /^4/
+  require_dependency 'voom/presenters'
+else
+  require 'voom/presenters'
+end
+
+module Voom
+  module Presenter
+    class Engine < ::Rails::Engine
+      config.autoload_paths += Dir["#{config.root}/lib/**/"]
+    end
+  end
+end
+
+
+module Voom
+  module Presenter
+    class Railtie < ::Rails::Railtie
+      BOOT = ->{
+        Voom::Presenters::Settings.configure do |config|
+          config.presenters.root = Rails.root.join('app')
+          # config.presenters.deep_freeze = false
+        end
+        Voom::Presenters::App.boot!
+      }
+      RELOADER = ActiveSupport::FileUpdateChecker.new([], {"app" => ["pom"]}) do
+        Voom::Presenters::App.reset!
+        BOOT.call
+      end
+
+      initializer 'voom-presenters' do |app|
+        app.reloaders << RELOADER
+      end
+
+      config.to_prepare do
+        RELOADER.execute
+      end
+    end
+  end
+end

data/lib/voom/presenters.rb

@@ -0,0 +1,13 @@
+require 'dry-container'
+require 'voom/container_methods'
+require 'voom/logger_methods'
+require 'voom/trace'
+require_relative 'presenters/version'
+require_relative 'presenters/settings'
+require_relative 'presenters/container_item'
+require_relative 'presenters/dsl'
+require_relative 'presenters/dsl/definer'
+require_relative 'presenters/dsl/definition'
+require_relative 'presenters/helpers'
+require_relative 'presenters/app'
+

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

@@ -0,0 +1,53 @@
+require 'sinatra'
+require 'json'
+require_relative '../../presenters'
+require_relative 'router'
+
+module Voom
+  module Presenters
+    module Api
+      # This is the Rest API for voom services/component commands
+      class App < Sinatra::Base
+        set :root, File.expand_path('../../../..', __FILE__)
+        set :router_, Router
+        set :bind, '0.0.0.0'
+
+        get '/:_presenter_.pom' do
+          render_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)
+        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/api/router.rb

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

data/lib/voom/presenters/app.rb

@@ -0,0 +1,55 @@
+module Voom
+  module Presenters
+    class App
+      class << self
+        include Voom::ContainerMethods
+        include Voom::LoggerMethods
+        include Voom::Trace
+        include Voom::Symbol
+
+        def boot!
+          logger.warn(no_roots_message) if presenter_paths.empty?
+          presenter_paths.each do |load_path|
+            Voom::Presenters::App.load('.', load_path) unless ENV['VOOM_ENV']=='testing'
+          end
+        end
+
+        def no_roots_message
+          <<~MESSAGE
+            No root defined to load presenters!
+            Add the following to your initializer/boot process:
+
+              Voom::Presenters::Settings.configure do |config|
+                config.presenters.root = Rails.root.join('app')
+              end
+          MESSAGE
+        end
+
+        def register(name:, presenter: nil, &block)
+          raise Errors::MissingArgument,
+                'A presenter class, proc, lambda or a block must be provided!' unless block_given? || presenter
+          container.register(sym_to_str(name), Voom::Presenters::ContainerItem.new(ui: block || presenter), {})
+        end
+
+        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
+        end
+
+        def reset!
+          super
+          Presenters::DSL.reset!
+        end
+
+        private
+
+        def presenter_paths
+          Array(Voom::Presenters::Settings.config.presenters.root)
+        end
+      end
+    end
+  end
+end
+

data/lib/voom/presenters/container_item.rb

@@ -0,0 +1,16 @@
+module Voom
+  module Presenters
+    # Presenters are registered in the container with this class
+    # You can replace this using the presenter container_item setting
+    class ContainerItem
+      def initialize(ui:)
+        @ui = ui
+      end
+
+      # Resolves the ui to an instance that can be rendered
+      def call
+        @ui
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'sinatra/base'
+
+module Voom
+  module Presenters
+    module Demo
+      # Echo's back post, delete and put
+      # Used to demonstrate how the posts(updates), deletes and modifies actions work.
+      class Echo < Sinatra::Base
+        post('/_echo_') do
+          content_type :json
+          JSON.dump(params)
+        end
+
+        delete('/_echo_') do
+          content_type :json
+          JSON.dump(params)
+        end
+
+        put('/_echo_') do
+          content_type :json
+          JSON.dump(params)
+        end
+
+        # start the server if ruby file executed directly
+        run! if app_file == $0
+      end
+    end
+  end
+end