templet_rails 0.1.0

data/lib/generators/templet/templates/core/templet/links/bs_btn_class.rb

@@ -0,0 +1,61 @@
+
+module Templet
+  module Links
+    # For Bootstrap link/button HTML classes
+    class BsBtnClass < Struct.new(:type, :size)
+      include Constants
+
+      def call(type: type(), size: size())
+        "#{BS_BUTTON} " +
+          "#{BS_BUTTON}-#{type or default_type} " +
+          "#{BS_BUTTON}-#{size or default_size}"
+      end
+
+      alias to_s call
+
+      # Allows compatibily with an HTML class specifield in a String
+      def +(suffix)
+        suffix = suffix.to_s
+
+        call + (suffix.start_with?(' ') ? '' : ' ') + suffix
+      end
+
+      class << self
+        def call(html_class=nil)
+          case html_class
+          when String, self
+            html_class
+          when Symbol
+            preset html_class
+          when Array
+            new *html_class
+          else
+            new
+          end
+        end
+
+        def preset(name=nil)
+          case name
+          when :default
+            new
+          when :item
+            Constants::BS_LIST_GROUP_ITEM
+          else
+            new name
+          end
+        end
+      end
+
+      private
+
+      def default_type
+        BS_BUTTON_TYPE
+      end
+
+      def default_size
+        BS_BUTTON_SIZE
+      end
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/templet/links/bs_link_set_base.rb

@@ -0,0 +1,168 @@
+
+module Templet
+  module Links
+    # Superclass with utility methods for building a list (Array) of HTML links.
+    # Primarily for REST actions, but any kind of link may be specified.
+    #
+    # Designed to work with any subclass of ActiveRecord.
+    class BsLinkSetBase
+      include Constants
+
+      attr_accessor :renderer, :model, :parent, :backward, :forward
+
+      attr_accessor :scope, :controller, :remote, :html_class,
+                            :selected, :omit_selected,
+                            :default_params, :verify_links,
+                            :wrapper
+
+      def initialize(renderer, model, parent, backward=nil, forward=nil,
+                               scope: nil, controller: nil,
+                               remote: nil, html_class: nil,
+                               selected: nil, omit_selected: false,
+                               default_params: nil,
+                               verify_links: false,
+                               wrapper: nil)
+        self.renderer = renderer
+
+        self.model = model
+        self.parent = parent
+
+        self.backward = backward
+        self.forward = forward
+
+        self.scope = scope
+        self.controller = controller
+
+        self.remote = remote
+
+        self.html_class = BsBtnClass.(html_class)
+
+        self.selected = selected || BS_SELECTED
+
+        self.omit_selected = omit_selected
+
+        self.default_params = default_params
+
+        self.verify_links = verify_links
+
+        self.wrapper = get_wrapper(wrapper)
+      end
+
+      private
+
+      def get_wrapper(wrapper)
+        if wrapper
+          if wrapper.respond_to? :call
+            wrapper
+          else
+            Utils::SelectedWrapper.new(wrapper, selected)
+          end
+        end
+      end
+
+      def push(links, link)
+        links << link if links and link
+      end
+
+      def rest_link_procs(link_class, remote: remote(), controller: controller())
+        RestLinkProcs.new link_class, scope: scope,
+                                      controller: controller,
+                                      remote: remote,
+                                      default_params: default_params,
+                                      verify_path: verify_links
+      end
+
+      def link_procs(is_selected=false)
+        is_selected ? selected_link_procs : unselected_link_procs
+      end
+
+      def unselected_link_procs
+        @unselected_link_procs ||= rest_link_procs(html_class)
+      end
+
+      def selected_link_procs
+        @selected_link_procs ||= rest_link_procs(selected_class)
+      end
+
+      def selected_class
+        html_class + "#{selected.start_with?(' ') ? '' : ' '}#{selected}"
+      end
+
+      def link_proc(action, is_selected=false)
+        link_method = "#{action}_link"
+
+        if wrapper
+          link = link_procs.send(link_method).(renderer, model, parent)
+
+          wrapper.(link, is_selected)
+        else
+          link_procs(is_selected).send(link_method).(renderer, model, parent)
+        end
+      end
+
+      def link_proc_unless(action, current_action, to: nil)
+        is_selected = selected? current_action, action
+
+        if display?(is_selected)
+          link_proc(action, is_selected).tap {|link| push to, link }
+        end
+      end
+
+      def link_proc_by_path_selected(action, current_action, *args)
+        is_selected = selected? current_action, action
+
+        if display?(is_selected)
+          if wrapper
+            link = link_procs.link_by_path(*args).(renderer, model, parent)
+
+            wrapper.(link, is_selected)
+          else
+            link_procs(is_selected).link_by_path(*args)
+                                   .(renderer, model, parent)
+          end
+        end
+      end
+
+      def link_proc_by_action_selected(action, current_action, *args)
+        is_selected = selected? current_action, action
+
+        if display?(is_selected)
+          if wrapper
+            link = link_procs.link_by_action(action, *args)
+                             .(renderer, model, parent)
+
+            wrapper.(link, is_selected)
+          else
+            link_procs(is_selected).link_by_action(action, *args)
+                                   .(renderer, model, parent)
+          end
+        end
+      end
+
+      def parent_link_proc(action)
+        link = rest_link_procs(html_class, controller: nil)
+                 .send("#{action}_parent_link", **grand_parent_options)
+                 .(renderer, nil, parent)
+
+        wrapper ? wrapper.(link) : link
+      end
+
+      def grand_parent_options
+        { grand_parent: backward }
+      end
+
+      def selected?(current_action, action)
+        current_action.to_s == action.to_s
+      end
+
+      def display?(is_selected)
+        not (omit_selected and is_selected)
+      end
+
+      def rest_path(scope: scope(), controller: controller())
+        RestPath.new(model, parent, scope: scope, controller: controller)
+      end
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/templet/links/bs_link_set_collection.rb

@@ -0,0 +1,21 @@
+
+module Templet
+  module Links
+    # Returns a list of REST links when there's no model instance.
+    # For the buttons: back, index & new
+    class BsLinkSetCollection < BsLinkSetBase
+      def call(action=nil)
+        links = []
+
+        links << parent_link_proc(:index) if parent
+
+        link_proc_unless(:index, action, to: links)
+
+        link_proc_unless(:new, action, to: links)
+
+        links
+      end
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/templet/links/bs_link_set_navigation.rb

@@ -0,0 +1,62 @@
+
+module Templet
+  module Links
+    # Returns a list of links for a model instance.
+    # Has all the main buttons for REST actions.
+    class BsLinkSetNavigation < BsLinkSetBase
+      # Returns a list of 3 lists of REST links.
+      #   The first is for parent links
+      #   The second are links for the current model
+      #   The third is a link pointing to an index of hildren
+      # Note that this list is usually flattened.
+      def call(action=nil)
+        parents, current, children = [ [], [], [] ]
+
+        # Ancestors
+        if parent
+          push parents, parent_link_proc(:index)
+
+          push parents, parent_link_proc(:show)
+        end
+
+        # Current model
+
+        link_proc_unless(:new, action, to: current)
+
+        if have_instance?
+          link_proc_unless(:edit, action, to: current)
+
+          link_proc_unless(:show, action, to: current)
+
+          push current, link_proc(:delete)
+        end
+
+        link_proc_unless(:index, action, to: current)
+
+        # Descendants
+        if have_instance?
+          if forward
+            push children, link_procs.index_link.(renderer, forward, model)
+
+            singular = forward.to_s.singularize
+
+            push children, link_procs.new_link.(renderer, singular, model)
+          end
+        end
+
+        Array.new << parents << current << children
+      end
+
+      private
+
+      def push_in(links, link, at: 1)
+        links[at].push link if link
+      end
+
+      def have_instance?
+        not (Symbol === model or String === model or model.new_record?)
+      end
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/templet/links/rest_link_procs.rb

@@ -0,0 +1,163 @@
+
+module Templet
+  module Links
+    # For rendering REST links for any type of model.
+    # The methods return lambdas that take as parameters a model
+    # and its (optional) parent.
+    # These lambdas are also given a Renderer instance,
+    # with which they call the Rails helper method +link_to+, as used in views.
+    class RestLinkProcs
+      include RestLinkProcsSets
+      include RestLinkProcsParent
+
+      attr_accessor :link_class, :scope, :controller,
+                    :remote, :link_text, :default_params,
+                    :verify_path
+
+      def initialize(link_class=nil, remote: nil,
+                                     scope: nil,
+                                     controller: nil,
+                                     default_params: nil,
+                                     link_text: nil,
+                                     verify_path: false)
+        self.link_class = BsBtnClass.(link_class)
+
+        self.remote = remote
+
+        self.scope = scope
+
+        self.controller = controller
+
+        self.default_params = default_params
+
+        self.link_text ||= RestLinkText.new
+
+        self.verify_path = verify_path
+      end
+
+      def index_link(text=nil, name: nil, params: nil, title: nil)
+        -> renderer, model, parent {
+          parent, model = model, name if name
+
+          text ||= link_text.index(model)
+
+          link_to(renderer, :index, model, parent, text, params, title)
+        }
+      end
+
+      def show_link(text=nil, params: nil, title: nil)
+        -> renderer, model, parent {
+          text ||= link_text.show(model)
+
+          link_to(renderer, :show, model, parent, text, params, title)
+        }
+      end
+
+      def new_link(text=nil, name: nil, params: nil, title: nil)
+        -> renderer, model, parent {
+          parent, model = model, name if name
+
+          text ||= link_text.new(model)
+
+          link_to(renderer, :new, model, parent, text, params, title)
+        }
+      end
+
+      def edit_link(text=nil, params: nil, title: nil)
+        -> renderer, model, parent {
+          text ||= link_text.edit(model)
+
+          link_to(renderer, :edit, model, parent, text, params, title)
+        }
+      end
+
+      def delete_link(text=nil, params: nil, title: nil)
+        -> renderer, model, parent {
+          text ||= link_text.delete(model)
+
+          link_to(renderer, :delete, model, parent, text,
+                  params, title, delete_options)
+        }
+      end
+
+      alias destroy_link delete_link
+
+      # For additional REST controller links
+      def link_by_action(name, params: nil, text: nil, title: nil,
+                               on_collection: false, opts: {})
+        text ||= name.to_s.capitalize
+
+        -> renderer, model, parent {
+          path = rest_path(model, parent)
+                   .action(name, params: parameters(params),
+                                 on_collection: on_collection)
+
+          title ||= link_text.default_title(name, model)
+
+          link_options = link_to_options title
+
+          renderer.call { link_to text, path, link_options.merge(opts) }
+        }
+      end
+
+      # For arbitrary explicitly given links - REST or otherwise
+      def link_by_path(path, text=nil, title=nil, opts={})
+        -> renderer, model, parent {
+          link_options = link_to_options title
+
+          path = path.(renderer, model, parent) if path.respond_to? :call
+
+          text ||= link_text.by_path(path)
+
+          renderer.call { link_to text, path, link_options.merge(opts) }
+        }
+      end
+
+      private
+
+      def link_to(renderer, action, model, parent, text, params, title, opts={})
+        path = rest_path(model, parent).send(action, parameters(params))
+
+        return if verify_path and not path_exists?(renderer, path)
+
+        title ||= link_text.default_title(action, model)
+
+        link_options = link_to_options title
+
+        renderer.call { link_to text, path, link_options.merge(opts) }
+      end
+
+      def path_exists?(renderer, path)
+        !! renderer.url_for(path) rescue false
+      end
+
+      def delete_options
+        { method: :delete, data: confirm }
+      end
+      def confirm
+        { confirm: 'Delete this record?' }
+      end
+
+      def parameters(params)
+        if default_params
+           default_params.merge(params || {})
+        else
+          params
+        end
+      end
+
+      def link_to_options(title)
+        opts = link_class ? { class: link_class.to_s, role: 'button' } : {}
+
+        opts[:remote] = true if remote
+
+        opts.merge title: title || ''
+      end
+
+      def rest_path(model, parent=nil)
+        RestPath.new(model, parent, scope: scope, controller: controller)
+      end
+    end
+  end
+end
+