templet_rails 0.1.0

data/lib/generators/templet/templates/core/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/lib/generators/templet/templates/core/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/lib/generators/templet/templates/core/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/lib/generators/templet/templates/core/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
+    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.titleize
+      else
+        self.class.name.sub('Viewer', '').split(/::/).last
+      end
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/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/lib/generators/templet/viewer/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Generates a single Viewer subclass, which is called by the controller
+    to actually render the view. In this class you may add your own
+    modifications that alter the default behaviour.
+
+Example:
+    rails generate templet:viewer user --child kid --actions index show
+
+    This will create:
+        app/helpers/app/user_viewer.rb

data/lib/generators/templet/viewer/viewer_generator.rb

@@ -0,0 +1,86 @@
+
+require_relative '../shared/child_option'
+require_relative '../shared/actions_option'
+
+class Templet::ViewerGenerator < Rails::Generators::NamedBase
+  include Shared::ChildOption
+  include Shared::ActionsOption
+
+  source_root File.expand_path('./', __FILE__)
+  desc
+
+  def create_viewer_subclass
+    create_file "app/helpers/app/#{file_path}_viewer.rb", class_definition
+  end
+
+  private
+
+  def have_actions?
+    actions
+  end
+
+  def index_controls_method
+    return unless have_actions?
+
+    %Q[
+    # For showing links to member actions (show edit destroy) in table rows
+    def index_controls
+      links = default_rest_link_procs.member_link_hash %i(#{member_actions})
+
+      hash_field_name_by_proc_call_method_default.merge links
+    end
+]
+  end
+
+  def member_actions
+    (%w(show edit delete destroy) & actions).map {|action| "_#{action}" }
+        .join(' ')
+  end
+
+  def forward_method
+    return unless child
+
+    %Q[
+    # Used in button groups for links to a model's children
+    def forward
+#{child? ? '      :' + child.pluralize : ''}
+    end
+]
+  end
+
+  def verify_rest_links_method
+    return unless have_actions?
+
+    %Q[
+    # Checks whether a REST link is actually defined before displaying it
+    def verify_rest_links?
+      true
+    end
+]
+  end
+
+  def class_definition
+    %Q[
+module App
+  class #{class_name}Viewer < BaseViewer
+#{index_controls_method}
+    private
+#{forward_method}
+#{verify_rest_links_method}
+    # You can override the following methods:
+    #
+    # remote?     For AJAX links and forms
+    # form_height For the field height on the form (sm md lg)
+    # forward     For the model's principal has_many relationship
+    # backward    For the model's grand-parent
+    #             This can be overriden in the controller
+    #
+    # There are also a number of others, mostly to do with the layout
+    #
+    # For more info see: app/helpers/templet/viewer_base.rb
+    #                    app/helpers/templet/viewer_rest.rb
+  end
+end
+]
+  end
+end