express_admin 1.1.0 → 1.2.0

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

@@ -0,0 +1,86 @@
+module ExpressTemplates
+  module Components
+    #
+    # Create an html <tt>table</tt> or <tt>ol</tt> (ordered list) for
+    # a model object representing a tree of similar objects.
+    #
+    # The objects must respond to <tt>:children</tt>.
+    #
+    # The block is passed a NodeBuilder which may accept field names.
+    #
+    # Example:
+    #
+    # ```ruby
+    # tree_for(:roles) {
+    #   "{{role.name}}"
+    # }
+    # ```
+    #
+    # If the view has an @roles variable with a Role having children,
+    # this will turn into markup such as the following:
+    #
+    #     <ul id="roles" class="roles tree">
+    #       <li>SuperAdmin
+    #         <ul>
+    #           <li>Admin
+    #             <ul>
+    #               <li>Publisher
+    #                 <ul>
+    #                    <li>Author</li>
+    #                 </ul>
+    #               </li>
+    #               <li>Auditor</li>
+    #             </ul>
+    #           </li>
+    #         </ul>
+    #       </li>
+    #     </ul>
+    #
+    class TreeFor < Container
+      def node_renderer
+        return (-> (node, renderer) {
+    ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
+      "#{wsnl}<li>"+
+      _yield +
+      if node.children.any?
+        ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
+          "#{wsnl}<ul>" +
+            node.children.map do |child|
+              renderer.call(child, renderer)
+            end.join +
+          "#{wsnl}</ul>"
+        end +
+        "#{wsnl}</li>"
+      else
+        "</li>"
+      end
+    end
+  }).source.sub(/\W_yield\W/, compile_children.lstrip)
+      end
+
+      def compile
+        collection = if @options[:collection]
+            "#{@options[:collection].source}.call()"
+          else
+            _variablize(@options[:id])
+          end
+        member = @options[:id].to_s.singularize
+        return 'ExpressTemplates::Components::TreeFor.render_in(self) {
+  node_renderer = '+node_renderer.gsub(/node/, member)+'
+  ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
+    "#{ws}<ul id=\"'+@options[:id]+'\" class=\"'+@options[:id]+' tree\">" +
+      '+collection+'.map do |'+member+'|
+        node_renderer.call('+member+', node_renderer)
+      end.join +
+    "#{wsnl}</ul>\n"
+  end
+}'
+      end
+
+      private
+        def _variablize(sym)
+          "@#{sym}"
+        end
+    end
+  end
+end

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

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

data/vendor/gems/express_templates/lib/express_templates/expander.rb

@@ -0,0 +1,140 @@
+require 'express_templates/components'
+module ExpressTemplates
+  class Expander
+
+    cattr_accessor :module_search_space
+
+    attr_accessor :stack, :handlers, :locals, :template
+
+    def initialize(*args)
+      initialize_expander(*args)
+    end
+
+    def initialize_expander(template, handlers = {}, locals = {})
+      @template = template
+      @stack = Stack.new
+      @handlers = handlers
+      @locals = locals
+      self
+    end
+
+    def expand(source=nil, &block)
+      case
+      when block.nil? && source
+        modified = _replace_yield_with_yielder(source)
+        instance_eval(modified, @template.inspect)
+      when block
+        instance_exec &block
+      else
+        raise ArgumentError
+      end
+      stack.current
+    end
+
+    def process_children!(parent, &block)
+      begin
+        stack.descend!
+        result = instance_exec &block
+        if stack.current.empty? && result.is_a?(String)
+          stack << result
+        end
+        parent.children += stack.current
+        stack.ascend!
+      end
+      stack.current
+    end
+
+    # define a "macro" method for a component
+    # these methods accept args which are passed to the
+    # initializer for the component
+    # blocks supplied are evaluated and children added to the "stack"
+    # are added as children to the component
+    def self.register_macros_for(*components)
+      components.each do |component|
+        define_method(component.macro_name.to_sym) do |*args, &block|
+            new_component = nil
+            # this is a code smell here.
+            if component.ancestors.include?(Components::Capabilities::Building)
+              new_component = component.new(*(args.push(self)), &block)
+            else
+              new_component = component.new(*(args.push(self)))
+              process_children!(new_component, &block) unless block.nil?
+            end
+            stack << new_component
+        end
+      end
+    end
+
+
+    @module_search_space = [ExpressTemplates::Markup, ExpressTemplates::Components]
+
+    @module_search_space.each do |mod|
+      register_macros_for(*
+        mod.constants.map { |const| [mod.to_s, const.to_s].join("::").constantize }.
+          select { |klass| klass.ancestors.include? (ExpressTemplates::Markup::Tag) }
+      )
+    end
+
+    def method_missing(name, *args, &block)
+      raise "#{self.class} unexpected macro: \"#{name}\"." if locals.nil?
+      return locals[name] if locals.keys.include?(name)
+
+      if handlers.keys.include?(name)
+        stack << handlers[name].send(name, *args, &block)
+      else
+        stack << ExpressTemplates::Markup::Wrapper.new(name.to_s, *args, &block)
+      end
+      nil
+    end
+
+    private
+
+      def _replace_yield_with_yielder(source)
+        source.gsub(/(\W)(yield)(\([^\)]*\))?/, '\1 (stack << ExpressTemplates::Markup::Yielder.new\3)')
+      end
+
+    class Stack
+      def initialize
+        @stack = [[]]
+        @frame = 0
+      end
+
+      def all
+        @stack
+      end
+
+      def dump
+        puts "Current frame: #{@frame}"
+        require 'pp'
+        pp all
+      end
+
+      def <<(child)
+        current << child
+        child
+      end
+
+      def current
+        @stack[@frame]
+      end
+
+      def next
+        @stack[@frame+1] ||= []
+      end
+
+      def descend!
+        @frame += 1
+        @stack[@frame] ||= []
+        @stack[@frame].clear
+        @frame
+      end
+
+      def ascend!
+        raise "Cannot ascend" if @frame <= 0
+        current.clear ;
+        self.next.clear
+        @frame -= 1
+      end
+    end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/indenter.rb

@@ -0,0 +1,47 @@
+module ExpressTemplates
+
+  # Tracks current indent level scoped to the current thread.
+  #
+  # May be used to track multiple indents simultaneously through
+  # namespacing.
+  class Indenter
+
+    DEFAULT = 2
+    WHITESPACE = " "*DEFAULT
+
+    # Returns whitespace for the named indenter or yields to a block
+    # for the named indentor.
+    #
+    # The block is passed the current whitespace indent.
+    #
+    # For convenience an optional second parameter is passed to the block
+    # containing a newline at the beginning of the indent.
+    def self.for name
+      if block_given?
+        current_indenters[name] += 1
+        begin
+          indent = WHITESPACE * current_indenters[name]
+          yield indent, "\n#{indent}"
+        ensure
+          if current_indenters[name].eql?(-1)
+            # if we have long-lived threads for some reason
+            # we want to clean up after ourselves
+            current_indenters.delete(name)
+          else
+            current_indenters[name] -= 1
+          end
+        end
+      else
+        return WHITESPACE * current_indenters[name]
+      end
+    end
+
+    private
+      # For thread safety, scope indentation to the current thread
+      def self.current_indenters
+        Thread.current[:indenters] ||= Hash.new {|hsh, key| hsh[key] = -1 }
+      end
+
+  end
+
+end

data/vendor/gems/express_templates/lib/express_templates/interpolator.rb

@@ -0,0 +1,36 @@
+require 'parslet'
+
+module ExpressTemplates
+  class Interpolator < Parslet::Parser
+    rule(:lbrace)         { str('{{') }
+    rule(:rbrace)         { str('}}') }
+    rule(:delim)          { lbrace | rbrace }
+    rule(:lpart)          { (lbrace.absnt? >> any).repeat.as(:lpart) }
+    rule(:rpart)          { (rbrace.absnt? >> any).repeat.as(:rpart) }
+    rule(:expression)     { (text_with_interpolations).as(:expression) }
+    rule(:interpolation)  { (lbrace>>expression>>rbrace).as(:interpolation) }
+    rule(:text)           { (delim.absnt? >> any).repeat(1) }
+    rule(:text_with_interpolations) { (text.as(:text) | interpolation).repeat }
+    root(:text_with_interpolations)
+
+    def self.transform(s)
+      begin
+        Transformer.new.apply(new.parse(s)).flatten.join
+      rescue Parslet::ParseFailed => failure
+        puts s
+        puts failure.cause.ascii_tree
+        raise failure
+      end
+    end
+  end
+
+  class Transformer < Parslet::Transform
+    rule(:interpolation => simple(:expression)) {
+      '#{'+expression+'}'
+    }
+    rule(:expression => sequence(:exp))      do
+      exp.map(&:to_s).join.gsub('\\"', '"')
+    end
+    rule(:text => simple(:s)) { s.to_s }
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/macro.rb

@@ -0,0 +1,45 @@
+module ExpressTemplates
+  module Macro
+
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+          include InstanceMethods
+        end
+      end
+
+      module ClassMethods
+        def macro_name
+          to_s.split('::').last.underscore
+        end
+      end
+      module InstanceMethods
+        def macro_name ; self.class.macro_name end
+
+        def initialize(*children_or_options)
+          @children = []
+          @options = {}.with_indifferent_access
+          # expander passes itself as last arg
+          @expander = children_or_options.pop if children_or_options.last.kind_of?(ExpressTemplates::Expander)
+          _process(*children_or_options)
+        end
+
+        private
+
+          def _process(*children_or_options)
+            children_or_options.each do |child_or_option|
+              case
+              when child_or_option.kind_of?(Hash)
+                @options.merge!(child_or_option)
+              when child_or_option.kind_of?(Symbol)
+                @options.merge!(id: child_or_option.to_s)
+              when child_or_option.nil?
+              else
+                @children << child_or_option
+              end
+            end
+          end
+
+      end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/markup.rb

@@ -0,0 +1,9 @@
+module ExpressTemplates
+  module Markup
+  end
+end
+
+require 'express_templates/markup/tag'
+require 'express_templates/markup/html_tag'
+require 'express_templates/markup/wrapper'
+require 'express_templates/markup/yielder'

data/vendor/gems/express_templates/lib/express_templates/markup/html_tag.rb

@@ -0,0 +1,62 @@
+module ExpressTemplates
+  module Markup
+    class HtmlTag < Tag
+      NON_VOID_TAGS = [:a, :abbr, :address, :article, :aside, :audio,
+                       :b, :bdi, :bdo, :blockquote, :body, :button,
+                       :canvas, :caption, :cite, :code, :colgroup,
+                       :data, :datalist, :dd, :del, :details, :dfn, :div, :dl, :dt,
+                       :em,
+                       :fieldset, :figcaption, :figure, :footer, :form,
+                       :h1, :h2, :h3, :h4, :h5, :h6, :head, :header, :html,
+                       :i, :iframe, :ins,
+                       :kbd,
+                       :label, :legend, :li,
+                       :main, :map, :mark, :math, :menu, :menuitem, :meter,
+                       :nav, :noscript,
+                       :object, :ol, :optgroup, :option, :output,
+                       :p, :pre, :progress,
+                       :q,
+                       :rp, :rt, :ruby,
+                       :s, :samp, :script, :section, :select, :small,
+                       :span, :strong, :style, :sub, :sup, :summary, :svg,
+                       :table, :tbody, :td, :textarea, :tfoot, :th, :thead, :time, :title, :tr,
+                       :u, :ul,
+                       :var, :video]
+
+      VOID_TAGS =     [:area, :base, :br, :col, :command, :doctype, :embed, :hr, :img, :input,
+                       :keygen, :link, :meta, :param, :source, :track, :wbr]
+
+      ALL_TAGS = NON_VOID_TAGS + VOID_TAGS
+    end
+
+    HtmlTag::ALL_TAGS.each do |tag|
+      klass = tag.to_s.titleize
+      ExpressTemplates::Markup.module_eval "class #{klass} < ExpressTemplates::Markup::HtmlTag ; end"
+    end
+
+    HtmlTag::VOID_TAGS.each do |tag|
+      klass = "ExpressTemplates::Markup::#{tag.to_s.titleize}"
+      klass.constantize.class_eval do
+        def close_tag
+          ''
+        end
+
+        def transform_close_tag?
+          false
+        end
+      end
+    end
+
+    Doctype.class_eval do
+      def start_tag
+        "<!DOCTYPE html>"
+      end
+    end
+
+    I.class_eval do
+      def should_not_abbreviate?
+        true
+      end
+    end
+  end
+end