templet_rails 0.1.0 → 0.2.0

data/app/helpers/templet/viewer/meta_model_defaults.rb

@@ -0,0 +1,56 @@
+
+module Templet
+  module Viewer
+    # Provides controls for scaffolding defaults for index, show, and forms
+    module MetaModelDefaults
+      private
+
+      # Html default display controls - for overriding
+
+      def index_controls(*args)
+        procs_by_name = args.pop if Hash === args.last
+
+        link_procs = args.pop || default_rest_link_procs
+
+        procs_by_name ||= hash_field_name_by_proc_call_method_default
+
+        forward_link(link_procs, to: procs_by_name)
+
+        procs_by_name.merge(link_procs.member_link_hash)
+      end
+
+      def default_rest_link_procs
+        rest_link_procs(%i(default sm), remote?)
+      end
+
+      def hash_field_name_by_proc_call_method_default
+        hash_field_name_by_proc_call_method(meta_model.listing_names)
+      end
+
+      def forward_link(link_procs=rest_link_procs(:link), to: nil)
+        if forward
+          text = forward.to_s.capitalize
+
+          link = link_procs.index_link(text, name: forward)
+
+          (block_given? ? yield(link) : link).tap do |link_proc|
+            to[:"_#{forward}"] = link_proc if to
+          end
+        end
+      end
+
+      def show_controls(field_names=meta_model.names)
+        hash_field_name_by_value_proc field_names
+      end
+
+      def form_inputs(field, group=nil)
+        meta_model.input_names.map do |field_name|
+          input_method_name = meta_model.input(field_name)
+
+          field.send(input_method_name, field_name)
+        end
+      end
+    end
+  end
+end
+

data/app/helpers/templet/viewer/presenters.rb

@@ -0,0 +1,44 @@
+
+module Templet
+  module Viewer
+    # For rendering HTML tables and forms
+    # Shortcuts to method calls in Templet::Mixins:HtmlPresenters
+    # Supports Kaminari paging - as long as the gem's installed
+    module Presenters
+      def list(renderer)
+        html_definition_list(renderer, show_controls, model)
+      end
+
+      def form(renderer)
+        path = Links::RestPath.new model, parent, scope: controllers_path,
+                                                  controller: controllers_name
+
+        html_form(renderer, url: path, height: form_height)
+      end
+
+      def table(renderer, records=models, footer: nil)
+        footer ||= pagination(renderer, records)
+
+        html_table(renderer, index_controls, records, opaque_heading: model,
+                                                      opaque_row: parent,
+                                                      footer: footer)
+      end
+
+      private
+
+      def pagination(renderer, records)
+        if pagination? and records.respond_to? :current_page
+          renderer.call do
+            [ paginate(records),
+              em(page_entries_info(records), 'small pull-right') ]
+          end
+        end
+      end
+
+      def pagination?
+        defined? Kaminari
+      end
+    end
+  end
+end
+

data/app/helpers/templet/viewer/rest_actions.rb

@@ -0,0 +1,24 @@
+
+module Templet
+  module Viewer
+    # Dispatches REST actions
+    module RestActions
+      def index(records=models, action=nil)
+        wrap_action(action || __method__) {|renderer| table renderer, records }
+      end
+
+      def show
+        wrap_action(__method__) {|renderer| list renderer }
+      end
+
+      def new
+        wrap_action(__method__) {|renderer| form renderer }
+      end
+
+      def edit
+        wrap_action(__method__) {|renderer| form renderer }
+      end
+    end
+  end
+end
+

data/app/helpers/templet/viewer_base.rb

@@ -0,0 +1,111 @@
+
+module Templet
+  # An abstract superclass, either of *ViewerRest*
+  # Or of your own custom class if you're not using a REST-based interface
+  class ViewerBase
+    include Mixins
+
+    attr_accessor :contexts, :locals
+
+    attr_accessor :action, :wrapper
+
+    def initialize(contexts, *, **locals)
+      self.contexts = [ contexts ].flatten
+
+      self.locals = locals
+
+      self.wrapper = locals[:wrapper] || :layout
+    end
+
+    private
+
+    # Layout and panel
+
+    # Called within a method that adds or overrides an action
+    def wrap_action(action=nil)
+      self.action = (action || caller_locations(1, 1)[0].label).to_sym
+
+      wrap_around {|renderer| yield renderer }
+    end
+
+    # For rendering e.g. JS - use a layout or a panel or have nothing surrounding
+    def wrap_around(&block)
+      case wrapper
+      when :none, :inner
+        new_renderer.call {|renderer| yield renderer }
+      when :panel, :outer
+        panel(new_renderer, &block)
+      else
+        layout(&block)
+      end
+    end
+
+    # The layout surrounds everything
+    def layout(action=nil, &block)
+      self.action ||= action
+
+      layout_class.new(*contexts, **locals).call(*layout_args) do |renderer|
+        panel renderer, &block
+      end
+    end
+
+    # A panel is a sub-layout within the main layout (just above)
+    def panel(renderer)
+      panel_class.new(renderer).(*panel_args(renderer)) do |renderer|
+        yield renderer
+      end
+    end
+
+    def new_renderer
+      Templet::Renderer.new(*contexts, **locals)
+    end
+
+    # Used chiefly in menus to check if a link is active
+    def action?(current_action)
+      current_action.to_sym == action.to_sym
+    end
+
+    # Defaults - for overriding
+
+    def layout_class
+      Layouts::HtmlRails
+    end
+
+    def layout_args
+      return page_title, ''
+    end
+
+    def page_title
+      Rails.app_class.name.split(/::/).first.titlecase
+    end
+
+    def panel_class
+      Templet::Component::Partial
+    end
+
+    def panel_args(renderer)
+      return action, panel_options(renderer)
+    end
+
+    def panel_options(renderer=nil, **options)
+      options.reverse_merge panel_options_default
+    end
+
+    def panel_options_default
+      { title: panel_title, subtitle: panel_subtitle }
+    end
+
+    def panel_subtitle
+      action.to_s.capitalize
+    end
+
+    def panel_title
+      if controller
+        controller.to_s
+      else
+        self.class.name.sub('Viewer', '').split(/::/).last
+      end.titleize
+    end
+  end
+end
+

data/app/helpers/templet/viewer_rest.rb

@@ -0,0 +1,144 @@
+
+#require 'app/panel/main'
+
+module Templet
+  # The principal class which carries out the default HTML rendering
+  # It is an entry point, even though it's mostly is used as a superclass
+  class ViewerRest < ViewerBase
+    include Viewer
+
+    include Mixins
+    include Mixins::Bs
+
+    include Templet::Constants
+
+    attr_accessor :model, :parent, :grand_parent, :controller, :models
+
+    attr_accessor :meta_model
+
+    def initialize(contexts, model=nil, parent=nil, **locals)
+      self.model = model
+
+      self.parent = parent || locals[:parent]
+
+      self.controller = locals[:controller]&.to_s
+
+      self.grand_parent = locals[:grand_parent] || backward
+
+      self.models = locals[:models] || []
+
+      self.meta_model = Viewer::MetaModel.new(model)
+
+      locals.merge!(view_variables)
+
+      super contexts, **locals
+    end
+
+    private
+
+    # These values become global methods for accessing inside the view
+    def view_variables
+      { model: model,
+        parent: parent,
+        controllers_name: controllers_name,
+        controllers_path: controllers_path,
+        grand_parent: grand_parent,
+        forward: forward,
+        link_set_args_proc: link_set_args_proc }
+    end
+
+    def controllers_name
+      if controller
+        controller_name = controller.split('/').last.to_s
+
+        if controller_name != plural_model
+          return controller_name
+        end
+      end
+    end
+
+    def controllers_path
+      if controller
+        paths = controller.split('/').tap {|paths| paths.pop }
+
+        if paths.any?
+          paths.join('/')
+        end
+      end
+    end
+
+    def plural_model
+      if model.respond_to?(:model_name)
+        model.model_name.plural
+      else
+        model.to_s.pluralize
+      end
+    end
+
+    # Returns the arguments used to construct Templet::Links::BsLinkSetBase
+    # whose subclasses render REST links in menus and button groups
+    def link_set_args_proc
+      -> (renderer, options) {
+        options.reverse_merge! scope: namespace,
+                               controller: controllers_name,
+                               remote: remote?,
+                               verify_links: verify_rest_links?
+
+        [ renderer, model, parent, grand_parent, forward, **options ]
+      }
+    end
+
+    def namespace
+      scope or controllers_path
+    end
+
+    # The remaining methods are for overriding, there are more in the superclass
+
+    # Layouts
+
+    def panel_title
+      if model
+        case model
+        when String, Symbol
+          model.to_s
+        else
+          model.class.name
+        end
+      else
+        super.sub('Rest', '')
+      end.humanize.pluralize
+    end
+
+    # General
+
+    # Height of form fields
+    def form_height
+      'md'
+    end
+
+    # Use JS (AJAX) for form submissions, and REST links of the index table
+    def remote?
+    end
+
+    # Name of model's grand parent (underscored)
+    # Used for 'Back' buttons
+    def backward
+    end
+
+    # Name (underscored) of model's child
+    # Used for (index) links that list children
+    def forward
+    end
+
+    # For use in specifying a namespace in links
+    def scope
+    end
+
+    # Set to true if the controller does not support all REST actions,
+    # for example, if just index and show are available
+    def verify_rest_links?
+      false
+    end
+  end
+end
+

data/app/helpers/templet_helper.rb

@@ -0,0 +1,10 @@
+
+#require 'templet/require_all'
+#require 'app'
+
+module TempletHelper
+  def icon(name)
+     "<span class='glyphicon glyphicon-#{name}'></span>".html_safe
+  end
+end
+

data/app/helpers/templet_rails/application_helper.rb

@@ -0,0 +1,4 @@
+module TempletRails
+  module ApplicationHelper
+  end
+end

data/app/jobs/templet_rails/application_job.rb

@@ -0,0 +1,4 @@
+module TempletRails
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/templet_rails/application_mailer.rb

@@ -0,0 +1,6 @@
+module TempletRails
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/templet_rails/application_record.rb

@@ -0,0 +1,5 @@
+module TempletRails
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/layouts/templet_rails/application.html.erb

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Templet rails</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag    "templet_rails/application", media: "all" %>
+  <%= javascript_include_tag "templet_rails/application" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+TempletRails::Engine.routes.draw do
+end