express_admin 1.2.1 → 1.3.0

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

@@ -1,140 +0,0 @@
-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/macro.rb

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

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

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

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

@@ -1,150 +0,0 @@
-module ExpressTemplates
-  module Markup
-    class Tag
-      include ExpressTemplates::Macro
-
-      attr_accessor :children
-
-      INDENT = '  '
-
-      # These come from Macro but must remain overridden here for performance reasons.
-      # To verify, comment these two methods and
-      # run rake test and observe the performance hit.  Why?
-      def self.macro_name
-        @macro_name ||= to_s.split('::').last.underscore
-      end
-
-      def macro_name ; self.class.macro_name end
-
-
-      def html_options
-        @options.each_pair.map do |name, value|
-          case
-          when name.to_sym.eql?(:data) && value.kind_of?(Hash)
-            value.each_pair.map {|k,v| %Q(data-#{k}=\\"#{v}\\") }.join(" ")
-          when value.kind_of?(Proc)
-            %Q(#{name}=\\"\#{(#{value.source}).call}\\")
-          else
-            %Q(#{name}=\\"#{value}\\")
-          end
-        end.join(" ")
-      end
-
-      def start_tag
-        "<#{macro_name}#{html_options.empty? ? '' : ' '+html_options}>"
-      end
-
-      def close_tag
-        "</#{macro_name}>"
-      end
-
-      def add_css_class(css_class)
-        @options['class'] ||= ''
-        css_class = css_class.to_s.gsub('_', '-').gsub(/^-/,'') if css_class.to_s.match /^_.*_/
-        @options['class'] = (@options['class'].split + [css_class]).uniq.join(" ")
-      end
-
-      def method_missing(name, *args, &children)
-        add_css_class(name)
-        _process(*args) unless args.empty?
-        if children # in the case where CSS classes are specified via method
-          unless @expander.nil?
-            @expander.process_children! self, &children
-          else
-            raise "block passed without expander"
-          end
-        end
-        return self
-      end
-
-      def should_not_abbreviate?
-        false
-      end
-
-      def transform_close_tag?
-        true
-      end
-
-      def compile
-        ExpressTemplates::Indenter.for(:markup) do |whitespace|
-          ruby_fragments = @children.map do |child|
-            if child.respond_to?(:compile)
-              child.compile
-            else
-              %Q("#{child}")
-            end
-          end
-          unless ruby_fragments.empty?
-            _wrap_with_tags(ruby_fragments, whitespace)
-          else
-            if should_not_abbreviate?
-              _wrap_with_tags(ruby_fragments, whitespace)
-            elsif transform_close_tag?
-              %Q("#{start_tag.gsub(/>$/, ' />')}")
-            else
-              %Q("#{start_tag}")
-            end
-          end
-        end
-      end
-
-      def to_template
-        # ExpressTemplates::Indenter.for(:template) do
-          template_fragments = @children.map do |child|
-            if child.respond_to?(:to_template)
-              child.to_template
-            else
-              child
-            end
-          end
-          macro_name + _blockify(template_fragments.join("\n"))
-        # end
-      end
-
-      def self.formatted
-        old_setting = Thread.current[:formatted]
-        begin
-          Thread.current[:formatted] = true
-          yield if block_given?
-        ensure
-          Thread.current[:formatted] = old_setting
-        end
-      end
-
-      private
-
-        def _wrap_with_tags(ruby_fragments, whitespace)
-          opening, closing = nil, nil
-          if !ENV['ET_NO_INDENT_MARKUP'].eql?('true') || #TODO: change to setting
-              Thread.current[:formatted]
-            child_code = ruby_fragments.join
-            should_format = ruby_fragments.size > 1 ||
-                            (child_code.size > 40 && !child_code.match(/^"\#\{.*\}"$/)) ||
-                            child_code.match(/\n/)
-
-            nl = should_format ? "\n" : nil
-            nl_after_start = !ruby_fragments.first.try(:match, /^"\n/) ? nl : nil
-            # binding.pry
-            nl_before_end = !ruby_fragments.last.try(:match, /\n"$/) ? nl : nil
-            opening = %Q("\n#{whitespace}#{start_tag}#{nl_after_start}")
-            closing = %Q("#{nl_before_end}#{should_format && whitespace}#{close_tag}#{nl}")
-          else
-            opening = %Q("#{start_tag}")
-            closing = %Q("#{close_tag}")
-          end
-          ruby_fragments.unshift opening
-          ruby_fragments.push closing
-          ruby_fragments.reject {|frag| frag.empty? }.join("+")
-        end
-
-        def _indent(code)
-          code.split("\n").map {|line| ExpressTemplates::Indenter::WHITESPACE + line }.join("\n")
-        end
-
-        def _blockify(code)
-          code.empty? ? code : " {\n#{_indent(code)}\n}\n"
-        end
-
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-module ExpressTemplates
-  module Markup
-    # wrap locals and helpers for evaluation during render
-    class Wrapper
-
-      attr_accessor :name, :args
-
-      def initialize(name, *args, &block)
-        @name = name
-        @args = args
-        @block_src = block ? block.source : nil
-      end
-
-      def compile
-        # insure nils do not blow up view
-        %Q(%Q({{#{_compile}}}))
-      end
-
-      def to_template
-        _compile
-      end
-
-      def children
-        []
-      end
-
-      private
-        def _compile
-          string = "#{name}"
-
-          if !@args.empty?
-
-            args_string = args.slice(0..-2).map do |arg|
-              if arg.respond_to?(:gsub) && arg.match(/^\{\{(.*)\}\}$/)
-                # strip double braces because otherwise these will be converted
-                # to "#{arg}" during final interpolation which is generally not
-                # the intention for arguments to helpers as these are ruby expressions
-                # not necessarily returning strings
-                $1
-              else
-                arg.inspect # 'value' or :value or ['a', 'b', 'c'] or {:key => 'value'}
-              end
-            end.join(', ')
-
-            last_arg = ''
-            if args.last.is_a?(Hash) # expand a hash
-              last_arg = _convert_hash_to_argument_string(args.last)
-            else
-              last_arg = args.last.inspect
-            end
-            args_string << (args_string.empty? ? last_arg : ", #{last_arg}")
-            string << "(#{args_string})"
-          end
-
-          if @block_src
-            string << " #{@block_src}"
-          end
-
-          return string
-        end
-
-        def _convert_hash_to_argument_string(hash)
-          use_hashrockets = hash.keys.any? {|key| key.to_s.match /-/}
-          unless hash.empty?
-            return hash.map do |key, value|
-              s = if use_hashrockets
-                if key.to_s.match /-/
-                  "'#{key}' => "
-                else
-                  ":#{key} => "
-                end
-              else
-                "#{key}: "
-              end
-
-              case
-              when value.is_a?(String)
-                s << '"'+value+'"'
-              when value.is_a?(Hash)
-                s << value.inspect
-              when value.is_a?(Proc)
-                s << "(#{value.source}).call"
-              else
-                s << value.inspect  # immediate values 1, 2.0, true etc
-              end
-              s
-            end.join(", ")
-          else
-            "{}" # empty hash
-          end
-        end
-    end
-  end
-end