templet_rails 0.1.0

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

@@ -0,0 +1,82 @@
+
+module Templet
+  module Mixins
+    # Helper methods for rendering HTML tables, forms and lists
+    module HtmlPresenters
+      include Constants
+
+      # Html table
+
+      # +controls+:: Is a Hash of field name by Proc which is passed a record
+      def html_table(renderer, controls, records, **options)
+        unless options.key? :html_class
+          options[:html_class] = default_table_class
+        end
+
+        Templet::Html::Table.new(renderer).(controls, records, **options)
+      end
+
+      def default_table_class
+        BS_TABLE
+      end
+
+      # Renders the outside of an HTML form.
+      # Usually you feed it a block to specify the various fields.
+      def html_form(renderer, form_opts, **group_opts)
+        if not form_opts.key?(:remote) and respond_to?(:remote?) and remote?
+          form_opts[:remote] = true
+        end
+
+        height = form_opts.delete(:height) || group_opts[:height]
+        group_opts[:height] = height
+
+        Forms::BsForm.new(renderer).(**form_opts) do |renderer|
+          field, group = Forms::BsForm.(renderer, model, **group_opts)
+
+          if block_given?
+            yield field, group
+          else
+            form_inputs(field, group) << field.submit
+          end
+        end
+      end
+
+      # Html lists
+
+      # +controls+:: A Hash of field name by Proc which is paassed a model
+      def html_definition_list(renderer, controls, record=nil)
+        Templet::Html::DefinitionList.new(renderer)
+          .(controls, record, html_class: 'dl-horizontal')
+      end
+
+       # +items+ is an Array of (literal) list elements
+      def html_list(renderer, items, html_class: nil, item_class: nil)
+        html_class = get_list_class(html_class)
+
+        Templet::Html::List.new(renderer).(items, html_class: html_class,
+                                                  item_class: item_class)
+      end
+
+      def get_list_class(html_class)
+        case html_class
+        when nil, :default, :inline
+          default_list_class
+        when true, :stacked
+          stacked_list_class
+        when false, :none
+        else
+          html_class
+        end
+      end
+
+      def default_list_class
+        BS_LIST_INLINE
+      end
+
+      def stacked_list_class
+        BS_LIST_UNSTYLED
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,45 @@
+
+# Requires the whole framework - in case the framework is placed outside of
+# the Rails autoload paths, e.g. under the directory lib/
+=begin
+require 'templet'
+#require 'templet/component'
+#require 'templet/html'
+
+require 'templet/viewer_base'
+require 'templet/viewer_rest'
+require 'templet/constants'
+
+require 'templet/forms/bs_form_errors'
+require 'templet/forms/bs_form_field'
+require 'templet/forms/bs_form_group'
+require 'templet/forms/bs_form'
+
+require 'templet/links/rest_link_text'
+require 'templet/links/bs_btn_class'
+require 'templet/links/rest_link_procs_sets'
+require 'templet/links/rest_link_procs_parent'
+require 'templet/links/rest_link_procs'
+require 'templet/links/bs_link_set_base'
+require 'templet/links/bs_link_set_collection'
+require 'templet/links/bs_link_set_navigation'
+require 'templet/links/bs_btn_class'
+require 'templet/links/rest_link_text'
+
+require 'templet/mixins'
+require 'templet/mixins/bs'
+require 'templet/mixins/html_presenters'
+require 'templet/mixins/bs/lists'
+require 'templet/mixins/bs/grid'
+
+require 'templet/utils/html_search_form'
+require 'templet/utils/list_model_parents'
+
+require 'templet/viewer'
+require 'templet/viewer/presenters'
+require 'templet/viewer/rest_actions'
+require 'templet/viewer/meta_model_defaults'
+require 'templet/viewer/meta_model'
+require 'templet/viewer/rest_actions'
+=end
+

data/lib/generators/templet/templates/core/templet/utils/html_search_form.rb

@@ -0,0 +1,53 @@
+
+module Templet
+  module Utils
+    # Renders a form (inline) for string searches, primarily for index actions.
+    class HtmlSearchForm < Templet::Component::Partial
+      include Constants
+
+      include Mixins::Bs
+
+      def call(url, field_name: 'q', submit_text: 'Search',
+                    label: nil, remote: false)
+        label ||= submit_text.underscore
+
+        super() do
+          Forms::BsForm.new(renderer).(**form_opts(url, remote)) do |renderer|
+            group = Forms::BsFormGroup.(renderer)
+
+            btn_class = "#{BS_BUTTON_SUBMIT_SEARCH} #{BS_BUTTON}-#{group.height}"
+            submit = button(submit_text, btn_class, type: 'submit')
+
+            [
+              group.(field_name, label_name: label) do |renderer, record_name|
+                renderer.call do
+                  text_field record_name, field_name, value: params[field_name],
+                                                      class: group.field_class
+                end
+              end,
+              submit
+            ]
+          end
+        end
+      end
+
+      def self.call(renderer, model, parent=nil, scope: nil,
+                                                 action: nil,
+                                                 remote: nil)
+        rest_path = Links::RestPath.new(model, parent, scope: scope)
+
+        path = action ? rest_path.action(action) : rest_path.index
+
+        new(renderer).(path, remote: remote)
+      end
+
+      private
+
+      def form_opts(url, remote=nil)
+        { url: url, inline: true, method: 'get' }.tap do |options|
+          options.merge!(remote: true) if remote
+        end
+      end
+    end
+  end
+end

data/lib/generators/templet/templates/core/templet/utils/link_set_factory.rb

@@ -0,0 +1,46 @@
+
+module Templet
+  module Utils
+    # Creates lists of HTML links for REST actions
+    class LinkSetFactory < Struct.new(:renderer, :action, :klass, :options)
+      def call(**extra_options)
+        create extra_options
+      end
+
+      private
+
+      def create(**extra_options)
+        get_class.new(*link_set_args(extra_options)).(action)
+      end
+
+      def link_set_args(**extra_options)
+        renderer.link_set_args_proc.(renderer, get_options(extra_options))
+      end
+
+      def get_class
+        case klass
+        when Class
+          klass
+        when String
+          klass.constantize
+        when :navigation, :nav
+          Templet::Links::BsLinkSetNavigation
+        else
+          Templet::Links::BsLinkSetCollection
+        end
+      end
+
+      def get_options(**extra_options)
+        { html_class: %i(default md) }
+          .merge(options || {})
+          .merge(extra_options)
+      end
+
+=begin
+      def class_name_defined?(class_name)
+        class_name.constantize rescue false
+      end
+=end
+    end
+  end
+end

data/lib/generators/templet/templates/core/templet/utils/link_set_factory_wrapper.rb

@@ -0,0 +1,53 @@
+
+module Templet
+  module Utils
+    # Creates HTML links for REST actions in Bootstrap containers
+    class LinkSetFactoryWrapper < LinkSetFactory
+      include Mixins::Bs::Lists
+
+      def call(type=nil, **options)
+        stacked = options.delete(:stacked) || false
+
+        wrap type, create(link_set_options(type).merge options), stacked: stacked
+      end
+
+      private
+
+      def link_set_options(type)
+        case type
+        when :pills, :tabs
+          { html_class: '', wrapper: nav_li_wrapper }
+        when :buttons, :toolbar
+          { html_class: %i(default md) }
+        when :links
+          { html_class: %i(link sm), selected: 'disabled' }
+        else
+          { html_class: :item }
+        end
+      end
+
+      def wrap(type, links, stacked: false)
+        case type
+        when :pills
+          in_nav renderer, links.flatten, stacked: stacked
+        when :tabs
+          in_nav renderer, links.flatten, tabs: true, stacked: stacked
+        when :buttons
+          in_button_group renderer, links.flatten, stacked: stacked
+        when :toolbar
+          in_button_toolbar renderer, links, stacked: stacked
+        when :links
+          in_list_group_links renderer, links.flatten
+        else
+          in_list_group_buttons renderer, links.flatten
+        end
+      end
+
+      def nav_li_wrapper
+        { regular: '<li role="presentation">%s</li>',
+          selected: '<li role="presentation" class="active">%s</li>' }
+      end
+    end
+  end
+end
+

data/lib/generators/templet/templates/core/templet/utils/list_model_parents.rb

@@ -0,0 +1,27 @@
+
+module Templet
+  module Utils
+    # To list info on a model's parents, and optionally in HTML.
+    class ListModelParents
+      def call(model, parent_names, out=[])
+        if model
+          if parent_name = parent_names&.shift
+            parent = model.send(parent_name)
+
+            call(parent, parent_names, out)
+          end
+
+          out << [ model.model_name.to_s, model.to_s ]
+        end
+
+        out
+      end
+
+      def in_html(*args)
+        call(*args).map do |(name, value)|
+          "<b>#{name}</b>: <em class='small'>#{value[0, 25]}</em>"
+        end
+      end
+    end
+  end
+end

data/lib/generators/templet/templates/core/templet/utils/navbar_form.rb

@@ -0,0 +1,26 @@
+
+module Templet
+  module Utils
+    # Renders a Bootstrap navbar form for string searches.
+    class NavbarForm < Templet::Component::Partial
+      include Constants
+
+      include Mixins::Bs
+
+      def call(url, field_name: 'q', submit_text: 'Search', remote: false)
+        super() do
+          form action: url, class: "navbar-form navbar-left", role: "search" do
+            div class: "form-group" do
+              [ input(name: field_name, type: "text", value: params[field_name],
+                      class: "form-control", placeholder: "Name"),
+                button(submit_text, type: "submit", class: "btn btn-default") ]
+            end
+          end
+        end
+      end
+
+      private
+
+    end
+  end
+end

data/lib/generators/templet/templates/core/templet/utils/selected_wrapper.rb

@@ -0,0 +1,40 @@
+
+module Templet
+  module Utils
+    # Wraps (in a tag) some given content according to a condition.
+    class SelectedWrapper
+      attr_accessor :wrapper, :selected_class
+
+      def initialize(wrapper, selected_class)
+        self.selected_class = selected_class
+
+        self.wrapper = get_wrapper wrapper
+      end
+
+      def call(content, is_selected=false)
+        if wrapper
+          wrapper[is_selected ? :selected : :regular] % content
+        else
+          content
+        end
+      end
+
+      private
+
+      def get_wrapper(wrapper)
+        if wrapper
+          if Hash === wrapper
+            wrapper
+          else
+            { regular: tag(wrapper),
+              selected: tag(wrapper, " class='#{selected_class}'") }
+          end
+        end
+      end
+
+      def tag(name, atts_string='')
+         "<#{name}#{atts_string}>%s</#{name}>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+
+module Templet
+  module Viewer
+    include Presenters
+
+    include RestActions
+
+    include MetaModelDefaults
+  end
+end
+

data/lib/generators/templet/templates/core/templet/viewer/meta_model.rb

@@ -0,0 +1,66 @@
+
+module Templet
+  module Viewer
+    # Model introspection
+    class MetaModel < Struct.new(:model_proto)
+      def names
+        #dictionary {|column| column.name.to_sym }
+        field_info.map(&:name).map(&:to_sym)
+      end
+
+      def listing_names
+        names.reject do |name|
+          %i(id created_at updated_at).include?(name) or name.to_s =~ /_id$/
+        end
+      end
+
+      def input_names
+        listing_names
+      end
+
+      def type(name)
+        (@types ||= types)[name]
+      end
+
+      def types
+        dictionary &:type
+      end
+
+      def input(name)
+        type = type(name)
+
+        inputs[type] or type
+      end
+
+      def inputs
+        { string: :text, text: :text_area, boolean: :check_box, integer: :text }
+      end
+
+      def field_info
+        model_class.content_columns
+      end
+
+      private
+
+      def dictionary
+        field_info.inject Hash.new do |acc, column|
+          acc[column.name.to_sym] = yield column
+
+          acc
+        end
+      end
+
+      def model_class
+        case model_proto
+        when Class
+          model_proto
+        when String, Symbol
+          model_proto.to_s.classify.constantize
+        else
+          model_proto.class
+        end
+      end
+    end
+  end
+end
+