templet_rails 0.1.0

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

@@ -0,0 +1,39 @@
+
+module Templet
+  module Links
+    # For REST links to a model's parent
+    # Included in RestLinkProcs
+    module RestLinkProcsParent
+      def index_parent_link(**options)
+        link_to_parent :index, **options
+      end
+
+      def show_parent_link(**options)
+        link_to_parent :show, **options
+      end
+
+      def new_parent_link(**options)
+        link_to_parent :new, **options
+      end
+
+      def edit_parent_link(**options)
+        link_to_parent :edit, **options
+      end
+
+      private
+
+      def link_to_parent(action, grand_parent: nil, text: nil, params: nil)
+        -> renderer, _, parent {
+
+          text ||= link_text.parent_text(action, parent)
+
+          grand_parent = grand_parent && parent.send(grand_parent)
+
+          send("#{action}_link", text, params: params)
+              .(renderer, parent, grand_parent)
+        }
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,30 @@
+
+module Templet
+  module Links
+    # For grouping REST links together
+    # Included in RestLinkProcs
+    module RestLinkProcsSets
+      def member_link_hash(field_names=%i(_show _edit _delete),
+                             action_to_text: {})
+        field_names.zip(member_links action_to_text: action_to_text).to_h
+      end
+
+      def collection_link_list(renderer, model_name: nil,
+                                         model: nil, parent: nil)
+        collection_links(model_name).map {|f| f.(renderer, model, parent) }
+      end
+
+      def member_links(params: nil, action_to_text: {})
+        return show_link(action_to_text[:show], params: params),
+               edit_link(action_to_text[:edit], params: params),
+               delete_link(action_to_text[:delete], params: params)
+      end
+
+      def collection_links(name=nil, params: nil)
+        return index_link(name, params: params),
+               new_link(name, params: params)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,102 @@
+
+module Templet
+  module Links
+    # For the text and title on buttons and links
+    class RestLinkText
+      def index(model)
+        model_plural(model)
+      end
+
+      def show(model)
+        'Show'
+      end
+
+      def new(model)
+        'New ' + model_singular(model)
+      end
+
+      def edit(model)
+        'Edit'
+      end
+
+      def delete(model)
+        'Delete'
+      end
+
+      def by_path(path)
+        String === path ? path.tr('/', ' ').strip.capitalize : 'Go'
+      end
+
+      def default_title(action, model)
+        case action
+        when :index
+          title_plural(action, model)
+        when :new
+          title_singular(action, model)
+        when :show, :edit, :delete
+          title_info(action, model)
+        else
+          title_plural(action, model)
+        end
+      end
+
+      def parent_text(action, parent)
+        if action == :index
+          prefix, suffix = parent.model_name.plural
+        else
+          prefix, suffix = action, parent.model_name.singular
+        end
+
+        "#{prefix.to_s.capitalize} #{suffix}"
+      end
+
+      def title_singular(action, model)
+        title action, model_singular(model)
+      end
+
+      def title_plural(action, model)
+        title action, model_plural(model)
+      end
+
+      def title_info(action, model)
+        title action, model_info(model)
+      end
+
+      def title(action, model_text)
+        "#{action_alias action} #{model_text}"
+      end
+
+      private
+
+      def model_plural(model)
+        if model.respond_to?(:model_name)
+          model.model_name.plural
+        else
+          model.to_s.pluralize
+        end.capitalize.tr('_', ' ')
+      end
+
+      def model_singular(model)
+        if model.respond_to?(:model_name)
+          model.model_name.singular
+        else
+          model.to_s
+        end
+      end
+
+      def model_info(model)
+        "#{model.model_name.singular}: #{model}"
+      end
+
+      def action_alias(action)
+        { index: 'List',
+          show: 'See',
+          new: 'Create',
+          edit: 'Update',
+          delete: 'Remove',
+        }[action] || action.to_s.capitalize
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,90 @@
+
+module Templet
+  module Links
+    # Returns REST paths as an Array
+    class RestPath
+      attr_accessor :model, :parent, :scope, :controller
+
+      def initialize(model, parent=nil, scope: nil, controller: nil)
+        self.model = model
+
+        self.parent = parent
+
+        self.scope = scope
+
+        self.controller = controller
+      end
+
+      def action(name, params: nil, on_collection: false)
+        [name] + (on_collection || on_collection? ? index(params) : show(params))
+      end
+
+      def for_form(params=nil)
+        if model.persisted?
+          return show(params), model
+        else
+          return index(params), model
+        end
+      end
+
+      def index(params=nil)
+        [ scope, parent, try_controller(plural), params ].compact
+      end
+
+      def show(params=nil)
+        params = add_model_param(params) if controller
+
+        [ scope, parent, try_controller(model, :singular), params ].compact
+      end
+
+      #def create(params=nil)
+      #  [ scope, parent, try_controller(singular, :singular), params ].compact
+      #end
+
+      def new(params=nil)
+        #%i(new) + create(params)
+        [ :new, scope, parent, try_controller(singular, :singular), params ].compact
+      end
+
+      def edit(params=nil)
+        %i(edit) + show(params)
+      end
+
+      #alias update show
+
+      alias delete show
+      alias destroy show
+
+      private
+
+      def on_collection?
+        String === model || Symbol === model
+      end
+
+      def try_controller(default, inflection=:plural)
+        inflect(controller, inflection) or default
+      end
+      def inflect(word, inflection)
+        word and (inflection == :plural ? word : word.to_s.singularize)
+      end
+
+      def add_model_param(params=nil)
+        (params || {}).merge id: model.to_param
+      end
+
+      def plural
+        singular.to_s.pluralize.to_sym
+      end
+
+      def singular
+        case model
+        when String, Symbol
+          model.to_sym
+        else
+          model.class.name.underscore.to_sym
+        end
+      end
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/templet/mixins.rb

@@ -0,0 +1,9 @@
+
+module Templet
+  module Mixins
+    include FieldProcs
+
+    include HtmlPresenters
+  end
+end
+

data/lib/generators/templet/templates/core/templet/mixins/bs.rb

@@ -0,0 +1,11 @@
+
+module Templet
+  module Mixins
+    module Bs
+      include Lists
+
+      include Grid
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/templet/mixins/bs/grid.rb

@@ -0,0 +1,53 @@
+
+module Templet
+  module Mixins
+    module Bs
+      # For the Bootstrap grid system
+      module Grid
+        include Constants
+
+        # For arranging a row into columns. Divided into twelfths.
+        # +columns+ is a Hash. For example: { 2 => menu, 10 => table }
+        def in_cols(renderer, columns)
+          inner_self = self
+
+          renderer.call do
+            div :row do
+              columns.to_h.reduce [] do |acc, (count, content)|
+                acc << div(inner_self.col_class count) { content }
+              end
+            end
+          end
+        end
+
+        # For arranging content into stacked rows.
+        # +rows+ is an Array of separate elements, e.g. [ menu, table ]
+        def in_rows(renderer, *rows, cols: nil, offset: nil)
+          rows += yield(renderer) if block_given?
+
+          inner_self = self
+
+          renderer.call do
+            rows.flatten.compact.map do |row|
+              div :row do
+                html_class = inner_self.col_offset_class(offset) +
+                             inner_self.col_class(cols)
+
+                div(html_class) { row }
+              end
+            end
+          end
+        end
+
+        def col_class(cols=nil)
+          "#{BS_COL}#{cols || 12} "
+        end
+
+        def col_offset_class(offset)
+          offset ? "#{BS_COL_OFFSET}#{offset} " : ''
+        end
+      end
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/templet/mixins/bs/lists.rb

@@ -0,0 +1,77 @@
+
+module Templet
+  module Mixins
+    module Bs
+      # Renders various listing and Bootstrap grouping components
+      module Lists
+        include Constants
+
+        include HtmlPresenters
+
+        def in_html_list(renderer, items=nil, **opts)
+          items = yield(renderer) if block_given?
+
+          html_list(renderer, items, **opts)
+        end
+
+        def in_list_group_links(renderer, links)
+          in_html_list renderer, links, html_class: BS_LIST_GROUP,
+                                        item_class: BS_LIST_GROUP_ITEM
+        end
+
+        def in_list_group_buttons(renderer, links)
+          renderer.call do
+            div(links, BS_LIST_GROUP)
+          end
+        end
+
+        def in_nav(renderer, links, tabs: false, stacked: false)
+          html_class = tabs ? BS_NAV_TABS : BS_NAV_PILLS
+
+          html_class += " #{BS_NAV_PILLS_STACKED}" if stacked
+
+          in_html_list(renderer, links, html_class: html_class)
+        end
+
+        def in_button_group(renderer, links, stacked: false, justified: false)
+          renderer.call do
+            html_class = stacked ? BS_BUTTON_GROUP_VERTICAL : BS_BUTTON_GROUP
+
+            html_class += ' ' + BS_BUTTON_GROUP_JUSTIFIED if justified
+
+            div(links, html_class, role: 'group')
+          end
+        end
+
+        def in_button_toolbar(renderer, toolbar_links, **options)
+          this = self
+
+          renderer.call do
+            div BS_BUTTON_TOOLBAR, role: BS_TOOLBAR do
+              toolbar_links.map do |links|
+                this.in_button_group(renderer, links, **options)
+              end
+            end
+          end
+        end
+
+        def button_group_dropdown(renderer, links, text, btn_class='btn-default')
+          list = in_html_list(renderer, links, html_class: BS_BUTTON_DROPDOWN)
+
+          atts = { type: "button",
+                   class: "btn #{btn_class} dropdown-toggle",
+                   data_toggle: "dropdown",
+                   aria_haspopup: true,
+                   aria_expanded: false }
+
+          caret = " <span class='caret'></span>"
+
+          renderer.call do
+            div(:btn_group) { [ button(text + caret, atts), *list ] }
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/templet/mixins/field_procs.rb

@@ -0,0 +1,140 @@
+
+module Templet
+  module Mixins
+    # Various procs/lambdas for displaying a model's field values
+    # For general purpose components that deal with models of any type
+    module FieldProcs
+      # For retrieving a model's field value (in table rows)
+      # 1st arg will be a renderer instance
+      def proc_call_method(name)
+        Proc.new {|_, model| model.send name }
+      end
+
+      # Returns a formatted field value
+      def proc_call_method_format(name)
+        value_proc = proc_call_method(name)
+
+        Proc.new {|*args| format_field_by_type value_proc.(*args) }
+      end
+
+      # To pass parameters to a REST index link
+      def proc_index_link_with_params(link_procs, link_text, params)
+        link_procs.index_link(link_text, params: params)
+      end
+
+      # To pass parameters to an arbitrarily named link
+      def proc_action_link_with_params(link_procs, action, link_text, params)
+        link_procs.link_by_action(action, params: params,
+                                          text: link_text, #title: nil,
+                                          on_collection: true)
+      end
+
+      # Used in html definition list controls
+      # Returns a Hash of field names by Procs
+      # The Proc returns a field value of a model passed as 1st arg
+      def hash_field_name_by_value_proc(field_names)
+        hash_yield_value(field_names, &:to_proc)
+      end
+      alias show_controls_hash hash_field_name_by_value_proc
+
+      # Used in html table controls
+
+      # Returns a Hash of names by Procs
+      # The Proc returns a field value of a model passed as 2nd arg
+      def hash_field_name_by_proc_call_method(field_names)
+        hash_yield_value(field_names) {|name| proc_call_method name }
+      end
+      alias index_controls_hash hash_field_name_by_proc_call_method
+
+      # To pass the same parameter to a list of index links
+      # Used in html table headings for sorting by field name
+      # Returns a Hash with a html link as the key and a Proc
+      # The Proc returns a field value of a model passed as 2nd arg
+      def hash_proc_link_with_params_by_proc_call_method(field_names,
+                                                         param_name,
+                                                         link_class='',
+                                                         action: nil,
+                                                         formatted: true)
+        link_procs = rest_link_procs(link_class)
+
+        field_names.inject Hash.new do |hash, field_name|
+          params = { param_name => field_name }
+
+          link_text = field_name.to_s.titleize
+
+          link_proc = if action
+                        proc_action_link_with_params(link_procs, action,
+                                                     link_text, params)
+                      else
+                        proc_index_link_with_params(link_procs, link_text, params)
+                      end
+
+          value_proc = if formatted
+                         proc_call_method_format(field_name)
+                       else
+                         proc_call_method(field_name)
+                       end
+
+          hash.merge link_proc => value_proc
+        end
+      end
+      alias index_controls_sortable_hash hash_proc_link_with_params_by_proc_call_method
+
+      private
+
+      # Returns a Hash for use in html tables and lists
+      # The key is used in the heading
+      # The value is a Proc that is called for each row
+      def hash_yield_value(keys)
+        keys.inject Hash.new do |acc, key|
+          acc.merge key => yield(key.to_sym)
+        end
+      end
+
+      def format_field_by_type(value)
+        case value
+        when true, false
+          #value ? 'Yes' : 'No'
+          value ? icon('ok') : icon('remove')
+        when Integer
+          pull_right value.to_s + '  ' * 3
+        when Date
+          value.to_s :rfc822
+        when Time, DateTime
+          value.strftime '%c'
+        else
+          value
+        end
+      end
+
+      def pull_right(content=nil)
+        "<span class='pull-right'>#{content}</span>".html_safe
+      end
+      def pull_right_proc(function)
+        Proc.new {|*args| pull_right function.(*args) }
+      end
+
+      # For displaying REST links as icons (on tables, for example)
+
+      def icon(name)
+        "<span class='glyphicon glyphicon-#{name}'></span>".html_safe
+      end
+      def actions_to_icons
+        { show: icon('camera'), edit: icon('pencil'), delete: icon('trash') }
+      end
+      def member_links_hash_as_icons(size=:md)
+        rest_link_procs([:link, size])
+            .member_link_hash(action_to_text: actions_to_icons)
+      end
+
+      # This is a factory that produces Procs for rendering html links
+      # The Proc is passed the current model and parent
+      def rest_link_procs(html_class=nil, remote=remote?)
+        Templet::Links.rest_link_procs html_class, scope: controllers_path,
+                                                   controller: controllers_name,
+                                                   remote: remote
+      end
+    end
+  end
+end
+