express_admin 1.2.1 → 1.3.0

data/vendor/gems/express_templates/lib/express_templates/components/capabilities/wrapping.rb

@@ -1,84 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-
-      # Add the ability for a component template to wrap or decorate a fragment
-      # with another fragment.
-      #
-      # The insertion point for the inner fragment is marked with <tt>_yield</tt>
-      #
-      # Example:
-      #
-      #   class MenuComponent < ExpressTemplates::Components::Base
-      #
-      #     fragments :menu_item, -> { li { menu_link(item) } },
-      #               :menu_wrapper, -> { ul { _yield } }
-      #
-      #     for_each -> { menu_items }
-      #
-      #     wrap_with :menu_wrapper
-      #
-      #   end
-      #
-      # Note this example also uses Capabilities::Iterating.
-      #
-      # Provides:
-      #
-      # * Wrapping::ClassMethods
-      #
-      module Wrapping
-        def self.included(base)
-          base.class_eval do
-            extend ClassMethods
-            include InstanceMethods
-          end
-        end
-
-        module InstanceMethods
-          def compile
-            lookup :markup
-          end
-        end
-
-        module ClassMethods
-
-          # Enclose whatever the component would already generate
-          # inside the specified fragment wherever we encounter _yield
-          def wrap_with(fragment, dont_wrap_if: false )
-            wrapper_name(fragment)
-            wrapper_src = _lookup(fragment).source
-            inner_src = _lookup(:markup).source_body
-            wrapped_src = wrapper_src.gsub!(/\W_yield\W/, inner_src)
-
-            fragment_src = if dont_wrap_if
-              %Q(-> {
-  unless_block(Proc.from_source(#{dont_wrap_if.source.inspect}), alt: Proc.from_source(%q(-> {#{inner_src}}))) {
-    #{Proc.from_source(wrapped_src).source_body}
-  }
-})
-            else
-              wrapped_src
-            end
-
-            _store :markup, Proc.from_source(fragment_src)
-
-          end
-
-          def wrapper_name(name = nil)
-            if name.nil?
-              @wrapper_name || :markup
-            else
-              @wrapper_name = name
-            end
-          end
-
-          def _yield(*args)
-            "{{_yield}}"
-          end
-
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module ExpressTemplates
-  module Components
-    class Column < Container
-      include Capabilities::Configurable
-
-      emits -> {
-        div.column(my[:id]) {
-          _yield
-        }
-      }
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-module ExpressTemplates
-  module Components
-    class Container < Base
-      include Capabilities::Parenting
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-module ExpressTemplates
-  module Components
-    # Provide a wrapper for the content_for helper which
-    # accepts a block of express template code.
-    #
-    # Example:
-    #
-    # ```ruby
-    # content_for(:header) {
-    #   h1 "Title"
-    # }
-    # ```
-    # Or:
-    # ```ruby
-    # content_for(:page_title), "People"
-    # ```
-    class ContentFor < Container
-      include Capabilities::Configurable
-      def compile
-        children_markup = compile_children
-        content_label = @args[0]
-        result = %Q|\ncontent_for(:#{content_label}|
-        if children_markup.empty?
-          if @args[1].kind_of?(String)
-            children_markup = @args[1]
-            # append children as argument
-            result << %Q|, "#{children_markup}".html_safe).to_s|
-          else
-            # no markup specified - must be referencing the content
-            result << ").to_s"
-          end
-        else
-          # append children in block form
-          result << %Q|) {
-  (#{children_markup.gsub(/^\s+/, '')}).html_safe
-}.to_s|
-        end
-        result
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-module ExpressTemplates
-  module Components
-    class ForEach < Components::Container
-      attr :collection, :member
-
-      def initialize(*args)
-        iterator = args.shift
-        options = args.first.kind_of?(Hash) ? args.shift : {}
-        expander = args.shift
-        @collection, @member = nil, (options[:as]||"item")
-        if iterator.kind_of?(Symbol)
-          @collection = iterator.to_s
-          @member = collection.sub(/^@/, '').singularize
-        elsif iterator.kind_of?(Proc)
-          @collection = "(#{iterator.source}.call)"
-        elsif iterator.kind_of?(String)
-          @collection = "(#{iterator}.call)"
-        else
-          raise "ForEach unknown iterator: #{iterator}"
-        end
-      end
-
-
-      def compile
-        %Q((#{@collection}.each_with_index.map do |#{@member}, #{@member}_index|#{compile_children}\nend).join)
-      end
-
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Forms
-      module FormSupport
-
-        def form_action
-          @config[:action] || "{{@#{resource_name}.try(:persisted?) ? #{resource_path(ivar: true)} : #{collection_path}}}"
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

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

@@ -1,40 +0,0 @@
-module ExpressTemplates
-  module Components
-    class UnlessBlock < Components::Container
-
-      attr :conditional
-
-      def initialize(*args)
-        @conditional = args.shift
-        @alt = args.shift[:alt] if args.first.kind_of?(Hash)
-        parent = args.shift
-        if @conditional.kind_of?(Symbol)
-          @conditional = @conditional.to_s
-        elsif @conditional.kind_of?(Proc)
-          @conditional = "(#{@conditional.source}.call)"
-        elsif iterator.kind_of?(String)
-          @conditional = "(#{@conditional}.call)"
-        else
-          raise "UnlessBlock unknown conditional: #{@conditional.inspect}"
-        end
-
-        if @alt.kind_of?(Proc)
-          @alt = _compile_fragment @alt
-        elsif @alt.nil?
-          @alt = "''"
-        end
-      end
-
-      def compile
-        s = unless @alt
-          %Q((unless #{@conditional}#{compile_children}\nend))
-        else
-          %Q((unless #{@conditional}#{compile_children}\nelse #{@alt}\nend))
-        end
-        puts s if ENV['DEBUG'].eql?('true')
-        s
-      end
-
-    end
-  end
-end