express_admin 1.1.0 → 1.2.0

data/vendor/gems/express_templates/lib/express_templates/components/forms/option_support.rb

@@ -0,0 +1,65 @@
+module ExpressTemplates
+  module Components
+    module Forms
+      # Provides a form component with knowledge of any association
+      # on the field and an means of loading the collection for supplying
+      # options to the user.
+      module OptionSupport
+
+        def has_many_through_association
+          reflection = resource_class.reflect_on_association(field_name.to_sym)
+          return reflection if reflection && reflection.macro.eql?(:has_many) && reflection.options.keys.include?(:through)
+        end
+
+        # Reflect on any association and return it if the association type
+        # is :belongs_to.  Returns false if the association is not :belongs_to.
+        # Returns nil if there was a problem reflecting.
+        def belongs_to_association
+          # assumes the belongs_to association uses <name>_id
+          reflection = resource_class.reflect_on_association(field_name.gsub(/_id$/, '').to_sym)
+          if reflection && reflection.macro.eql?(:belongs_to)
+            return reflection
+          end
+        end
+
+        # Provide ActiveRecord code to load the associated collection as
+        # options for display.
+        def related_collection
+          reflection = belongs_to_association || has_many_through_association
+          if reflection && !reflection.polymorphic?
+            if cols.detect {|column| column.name.eql?('name') }
+              "#{reflection.klass}.all.select(:#{option_value_method}, :#{option_name_method}).order(:#{option_name_method})"
+            else
+              "#{reflection.klass}.all.sort_by(&:#{option_name_method})"
+            end
+          end
+        end
+
+        protected
+
+          def option_value_method
+            :id
+          end
+
+          def cols
+            @cols ||= (belongs_to_association||has_many_through_association).klass.columns
+          end
+
+          def option_name_method
+            @option_name_method ||=
+              if cols.detect {|column| column.name.eql?('name') } ||
+                 resource_class.instance_methods.include?(:name)
+                :name
+              else
+                if string_col = cols.detect {|column| column.type.eql?(:string) }
+                  string_col.name.to_sym
+                else
+                  :id
+                end
+              end
+          end
+
+      end
+    end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/components/forms/radio.rb

@@ -0,0 +1,84 @@
+module ExpressTemplates
+  module Components
+    module Forms
+      class Radio < FormComponent
+        include OptionSupport
+
+        emits -> {
+          div(class: field_wrapper_class) {
+            label_tag(label_name, label_text)
+            if option_values_specified?
+              generate_options_from_specified_values
+            else
+              use_options_from_collection_radio_buttons_helper
+            end
+          }
+        }
+
+        def use_options_from_collection_radio_buttons_helper
+          # Note {{ }} will get stripped.  This prevents the collection finder string being passed as string.
+          collection_radio_buttons(resource_var, field_name.to_sym, "{{#{collection_from_association}}}",
+                                   option_value_method, option_name_method,
+                                   field_options, html_options) do |b|
+            b.label(class: "radio") {
+              b.radio_button + b.text
+            }
+          end
+        end
+
+        def option_values_specified?
+          [Array, Hash].include?(option_collection.class)
+        end
+
+        def option_collection
+          @args.second
+        end
+
+        def wrapper_class
+          @config[:wrapper_class] || 'wrapper-class'
+        end
+
+        def generate_options_from_specified_values
+          case
+          when option_collection.kind_of?(Array)
+            option_collection.each_with_index do |option, index|
+              label(class: wrapper_class) {
+                radio_button(resource_var, field_name.to_sym, option, class: 'radio')
+                null_wrap { option }
+              }
+            end
+          when option_collection.kind_of?(Hash)
+            option_collection.each_pair do |key, value|
+              label(class: wrapper_class) {
+                radio_button(resource_var, field_name.to_sym, key, class: 'radio')
+                null_wrap { value }
+              }
+            end
+          else
+            raise "Radio collection should be Array or Hash: #{option_collection.inspect}"
+          end
+        end
+
+        def collection_from_association
+          related_collection or raise "No association collection for: #{resource_name}.#{field_name}"
+        end
+
+        def field_options
+          # If field_otions is omitted the Expander will be
+          # in last or 3rd position and we don't want that
+          if @args.size > 3 && @args[2].is_a?(Hash)
+            @args[2]
+          else
+            {}
+          end
+        end
+
+        # TODO: implement
+        def html_options
+          {}
+        end
+
+      end
+    end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/components/forms/select.rb

@@ -0,0 +1,105 @@
+module ExpressTemplates
+  module Components
+    module Forms
+      # Provides a form Select component based on the Rails *select_tag* helper.
+      # Parameters:
+      # field_name, select_options, helper_options
+      #
+      # Select options may be specified as an Array or Hash which will be
+      # supplied to the *options_for_select* helper.
+      #
+      # If the select_options are omitted, the component attempts to check
+      # whether the field is an association.  If an association exists,
+      # the options will be generated using *options_from_collection_for_select*
+      # with the assumption that :id and :name are the value and name fields
+      # on the collection.  If no association exists, we use all the existing
+      # unique values for the field on the collection to which the resource belongs
+      # as the list of possible values for the select.
+      class Select < FormComponent
+        include OptionSupport
+
+        emits -> {
+          div(class: field_wrapper_class) {
+            label_tag(label_name, label_text)
+            select_tag(*select_tag_args)
+          }
+        }
+
+        def select_tag_args
+          args = [field_name_attribute, select_options, field_options]
+          args << html_options unless html_options.nil? or html_options.empty?
+          args
+        end
+
+        # Returns the options which will be supplied to the select_tag helper.
+        def select_options
+          options_specified = [Array, Hash, Proc].include?(@args.second.class) && @args.size > 2
+          if options_specified
+            if @args.second.respond_to?(:source) # can be a proc
+              options = "#{@args.second.source}.call()"
+            else
+              options = @args.second
+            end
+
+          else
+            options = "@#{resource_var}.class.distinct(:#{field_name}).pluck(:#{field_name})"
+          end
+
+          if belongs_to_association && !options_specified
+            if belongs_to_association.polymorphic?
+              "{{options_for_select([[]])}}"
+            else
+              "{{options_from_collection_for_select(#{related_collection}, :id, :#{option_name_method}, @#{resource_name}.#{field_name})}}"
+            end
+          elsif has_many_through_association
+            "{{options_from_collection_for_select(#{related_collection}, :id, :#{option_name_method}, @#{resource_name}.#{field_name}.map(&:id))}}"
+          else
+            if selection = field_options.delete(:selected)
+              "{{options_for_select(#{options}, \"#{selection}\")}}"
+            else
+              "{{options_for_select(#{options}, @#{resource_name}.#{field_name})}}"
+            end
+          end
+        end
+
+        def field_name_attribute
+          if has_many_through_association
+            "#{resource_name.singularize}[#{field_name.singularize}_ids]"
+          else
+            super
+          end
+        end
+
+        def field_options
+          # If field_otions is omitted the Expander will be
+          # in last or 3rd position and we don't want that
+          defaults = {include_blank: true}
+          defaults.merge(supplied_field_options.reject {|k,v| k.eql?(:select2)})
+        end
+
+        def html_options
+          supplied_html_options
+        end
+
+        protected
+
+          def supplied_field_options
+            if @args.size > 3 && @args[2].is_a?(Hash)
+              @args[2]
+            else
+              {}
+            end
+          end
+
+          def supplied_html_options
+            if @args.size > 4 && @args[3].is_a?(Hash)
+              @args[3]
+            else
+              {}
+            end
+          end
+
+      end
+    end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/components/forms/select_collection.rb

@@ -0,0 +1,57 @@
+module ExpressTemplates
+  module Components
+    module Forms
+      # Provides a form Select component based on the Rails *select_tag* helper.
+      # Parameters:
+      # field_name, select_options, helper_options
+      #
+      # Select options may be specified as an Array or Hash which will be
+      # supplied to the *options_for_select* helper.
+      #
+      class SelectCollection < Select
+
+        emits -> {
+          div(class: field_wrapper_class) {
+            label_tag(label_name, label_text)
+
+            # need this because the collection_select helper does not provide
+            # the hidden_field_tag trick (see rails api docs for select)
+            hidden_field_tag(multi_field_name, '')
+
+            collection_select(*collection_select_tag_args)
+          }
+        }
+
+        def collection_select_tag_args
+          [ resource_name,
+            multi_field_name,
+            select_options, :id, :name,
+            field_options,
+            html_options ]
+        end
+
+        def field_options
+          selected_options_ruby = "@#{resource_name}.#{multi_field_name}".to_view_code
+          super.merge(include_blank: false, selected: selected_options_ruby)
+        end
+
+        def html_options
+          (super||{}).merge(multiple: true)
+        end
+
+        def multi_field_name
+          if has_many_through_association
+            "#{field_name.singularize}_ids"
+          else
+            raise "Only use select_collection for has_many :through.  #{field_name} is not has_many :through"
+          end
+        end
+
+
+        def select_options
+          "{{#{related_collection}}}"
+        end
+      end
+    end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/components/forms/submit.rb

@@ -0,0 +1,26 @@
+module ExpressTemplates
+  module Components
+    module Forms
+      class Submit < FormComponent
+
+        emits -> {
+          div(class: field_wrapper_class) {
+            submit_tag(value, html_options)
+          }
+        }
+
+        def value
+          if @args.first.is_a?(String)
+            @args.first
+          else
+            'Save'
+          end
+        end
+
+        def html_options
+          @config
+        end
+      end
+    end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/components/null_wrap.rb

@@ -0,0 +1,41 @@
+module ExpressTemplates
+  module Components
+    # NullWrap is useful for creating a node in the component tree that does
+    # not produce any markup.  It can be used in a template fragment to
+    # wrap bare text or string content where such would not normally be possible.
+    #
+    # Example:
+    #
+    # ```ruby
+    # div {
+    #   some_component
+    #   null_wrap {
+    #     "Some text"
+    #   }
+    #   other_component
+    # }
+    # ```
+    #
+    # Otherwise you can use it to hold already-complied code meant for
+    # evaluation in the view that needs to be protected from being compiled
+    # again. This use is largely internal to express_templates. It is not
+    # expected that users of this library would need this.
+    #
+    # Example:
+    #
+    # ```ruby
+    # null_wrap("(@collection.map do |member| \"<li>#{member.name}</li>\").join")
+    # ```
+    #
+    class NullWrap < Components::Container
+      def initialize(*args)
+        @already_compiled_stuff = args.shift if args.first.is_a?(String)
+        super(*args)
+      end
+
+      def compile
+        @already_compiled_stuff || compile_children
+      end
+    end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/components/row.rb

@@ -0,0 +1,28 @@
+module ExpressTemplates
+  module Components
+    # A Row is a Container implemented as a div with
+    # a CSS class "row"
+    #
+    # An optional dom ID may be specified as a symbol.
+    #
+    # Example:
+    #
+    #     row(:main) {
+    #       p "Some content"
+    #     }
+    #
+    # This will render as:
+    #
+    #     <div id="main" class="row"><p>Some content</p></div>
+    #
+    class Row < Container
+      include Capabilities::Configurable
+
+      emits -> {
+        div.row(my[:id]) {
+          _yield
+        }
+      }
+    end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/components/table_for.rb

@@ -0,0 +1,163 @@
+module ExpressTemplates
+  module Components
+    # Create an html table from a collection of data.
+    #
+    # Typically this will be a collection of models
+    # of the same type.  Each member of the collection must
+    # respond to the column names provided.
+    #
+    # Example:
+    #
+    # ````ruby
+    # table_for(:people) do |t|
+    #   t.column :name
+    #   t.column :email
+    #   t.column :phone
+    #   t.column :hourly_rate, header: "Rate",
+    #                          formatter: -> (amount) {'$%0.2f' % amount rescue 'N/A'}
+    # end
+    # ````
+    #
+    # This assumes that a @people variable will exist in the
+    # view and that it will be a collection whose members respond to
+    # :name, :email, :phone, :hourly_rate
+    #
+    # This will result in markup like the following:
+    #
+    #     <table id="people">
+    #       <thead>
+    #         <tr>
+    #           <th class="name">Name</th>
+    #           <th class="email">Email</th>
+    #           <th class="phone">Phone</th>
+    #           <th class="hourly_rate">Rate</th>
+    #         </tr>
+    #       </thead>
+    #       <tbody>
+    #         <tr id="person-1">
+    #           <td class="name">Steven Talcott Smith</td>
+    #           <td class="email">steve@aelogica.com</td>
+    #           <td class="phone">415-555-1212</td>
+    #           <td class="hourly_rate">$250.00</td>
+    #         </tr>
+    #       </tbody>
+    #     </table>
+    #
+    # Note that column options include :formatter and :header.
+    #
+    # :formatter may be a stabby lambda which is passed the value to be formatted.
+    #
+    # :header may be either a string
+    #
+    class TableFor < Base
+      include Capabilities::Configurable
+      include Capabilities::Building
+
+      def initialize(*args)
+        super(*args)
+        _process_args!(args) # from Configurable
+        yield(self) if block_given?
+      end
+
+      attr :columns
+
+      def column(name, options = {})
+        @columns ||= []
+        @columns << Column.new(name, options)
+      end
+
+      emits -> {
+        table(my[:id]) {
+          thead {
+            tr {
+              columns.each do |column|
+                th.send(column.name) {
+                  column.title
+                }
+              end
+            }
+          }
+          tbody {
+            for_each("@#{my[:id]}".to_sym) {
+
+              tr(id: "#{my[:id].to_s.singularize}-{{#{my[:id].to_s.singularize}.id}}",
+                 class: my[:id].to_s.singularize) {
+
+                columns.each do |column|
+                  if(column.has_actions?)
+                    td(class: column.name) {
+                      column.show_actions(my[:id].to_s)
+                    }
+                  else
+                    td(class: column.name) {
+                      column.format(my[:id].to_s.singularize)
+                    }
+                  end
+                end
+              }
+            }
+          }
+        }
+      }
+
+      def wrap_for_stack_trace(body)
+        "ExpressTemplates::Components::TableFor.render_in(self) {\n#{body}\n}"
+      end
+
+      def compile
+        wrap_for_stack_trace(lookup(:markup))
+      end
+
+      class Column
+        attr :name, :options
+        def initialize(name, options = {})
+          @name = name
+          @options = options
+          @formatter = options[:formatter]
+          @header = options[:header]
+          @actions = options[:actions] || []
+        end
+
+        def has_actions?
+          @actions.any?
+        end
+
+        def format(item_name)
+          if @formatter.nil?
+            "\#\{#{item_name}.#{name}\}"
+          elsif @formatter.kind_of?(Proc)
+            "\#\{(#{@formatter.source}).call(#{item_name}.#{name})\}"
+          end
+        end
+
+        def show_actions(item_name)
+          action_links = StringIO.new
+          @actions.each do |action|
+            action_name = action.to_s
+            if action_name.eql?('edit')
+              action_links.puts "<a href='/#{item_name}/{{#{item_name.singularize}.id}}/edit'>Edit</a>"
+            elsif action_name.eql?('delete')
+              action_links.puts "<a href='/#{item_name}/{{#{item_name.singularize}.id}}' data-method='delete' data-confirm='Are you sure?'>Delete</a>"
+            elsif action_name.eql?('show')
+              action_links.puts "<a href='/#{item_name}/{{#{item_name.singularize}.id}}'>Show</a>"
+            end
+          end
+          action_links.string
+        end
+
+        def title
+          case
+          when @header.nil?
+            @name.to_s.try(:titleize)
+          when @header.kind_of?(String)
+            @header
+          when @header.kind_of?(Proc)
+            "{{(#{@header.source}).call(#{@name})}}"
+          end
+        end
+      end
+
+    end
+
+  end
+end