express_admin 1.2.1 → 1.3.0

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

@@ -1,20 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-      module Adoptable
-        # Adoptable adds the capability for a child to refer
-        # to its parent.  This is used by more complex
-        # components which are intended to work together
-        # such as form components where form elements may need
-        # to use information known only to the parent.
-
-        def self.included(base)
-          base.class_eval do
-            attr_accessor :parent
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-      module Building
-        # commented this out because it's intercepting calls to rails helpers
-        # TODO: fix this... I think the whole buiding approach is broken.
-        #       this class is empty and should probably go away.
-        # def method_missing(name, *args)
-        #   raise "#{self.class.to_s} has no method '#{name}'"
-        # end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-      # Adds the capability for a component to only render
-      # its markup when a condition to be evaluated in the
-      # view is true.
-      #
-      # Example:
-      #
-      #     class PageHeader < ExpressTemplates::Components::Base
-      #       include ExpressTemplates::Components::Capabilities::Conditionality
-      #
-      #         emits {
-      #           h1 { content_for(:page_header) }
-      #         }
-      #
-      #         only_if -> { content_for?(:page_header) }
-      #
-      #       end
-      #     end
-      #
-      # The condition supplied to only if in the form of a proc
-      # is evaluated in the view context.
-      #
-      # The component will render an empty string if the proc returns false.
-      module Conditionality
-        def self.included(base)
-          base.class_eval do
-            extend ClassMethods
-          end
-        end
-
-        module ClassMethods
-
-          def condition_proc
-            @condition_proc
-          end
-
-          def only_if condition_proc
-            @condition_proc = Proc.from_source "-> {!(#{condition_proc.source_body})}"
-            inner_src = self[:markup]
-            fragment_src = %Q(-> {
-  unless_block(Proc.from_source(#{@condition_proc.source.inspect})) {
-    #{inner_src.source_body}
-  }
-})
-            _store :markup, Proc.from_source(fragment_src)
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-
-      # Configurable components accept options which they can use to alter
-      # their markup each time they are invoked within a template.
-      #
-      # They do not compile their markup fragments at load time as simpler
-      # components do for efficiency.  Rather they compile their fragments
-      # when they are themselves undergoing compilation.  This facilitates
-      # access to arguments which were passed to the component at initialization.
-      #
-      # For example, if we have a Row component that is Configurable:
-      #
-      #     row(:main)
-      #
-      # might process to:
-      #
-      #     <div id="main" class="row" />
-      #
-
-      module Configurable
-        def self.included(base)
-          base.class_eval do
-            extend ClassMethods
-            include InstanceMethods
-
-            # Stores arguments for later processing, eg., compile time
-            def initialize(*args)
-              @args = args.dup
-              _process_args!(args)
-              super(*args)
-            end
-          end
-        end
-
-        module ClassMethods
-
-          protected
-
-            # Override Templating._compile_fragment to delay compilation
-            def _compile_fragment(block, options = {})
-              if options.delete(:force_compile)
-                super(block, options)
-              else
-                block
-              end
-            end
-
-            def _lookup(name, options = {})
-              super(name, options.merge(force_compile: true))
-            end
-
-        end
-
-        module InstanceMethods
-
-          def config
-            @config ||= {}
-          end
-
-          alias :my :config
-
-          def expand_locals
-            {my: config}
-          end
-
-          # Override Templating#lookup to pass locals
-          def lookup(fragment_name, options = {})
-            super(fragment_name, options.merge(expand_locals))
-          end
-
-
-          private
-
-            def _process_args!(args)
-              if args.first.kind_of?(Symbol)
-                config.merge!(id: args.shift)
-              end
-              while arg = args.shift
-                if arg.kind_of?(Hash)
-                  config.merge!(arg)
-                end
-              end
-            end
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-      #
-      # Adds the capability to iterate over a collection repeating a markup
-      # fragment for each member.
-      #
-      # Example:
-      #
-      #   class ParagraphsComponent < ExpressTemplates::Components::Base
-      #
-      #     emits -> { p { item } }     # item is the default local variable name
-      #
-      #     for_each -> { paragraphs }  # evaluated in view context
-      #
-      #   end
-      #
-      # Must specify an <tt>iterator</tt> either as a proc to be evaluated in the
-      # view context or else as a variable name in the form of a symbol which is
-      # assumed to be available in the view context.
-      #
-      # Provides:
-      #
-      # * Iterating::ClassMethods (for_each)
-      #
-      module Iterating
-        def self.included(base)
-          base.class_eval do
-            extend ClassMethods
-          end
-        end
-
-        module ClassMethods
-          # Sets the component up to use iterating logic to reproduce a fragment
-          # for a collection.
-          #
-          # Parameters include an iterator that may be :@variable assumed to be
-          # available in context or a proc that when evaluated in the context
-          # should return a collection.
-          #
-          # An <tt>:emit</tt> option may specify a fragment to emit.
-          # Defaults to <tt>:markup</tt>
-          #
-          # An <tt>:as</tt> option specifies the local variable name for each
-          # item in the collection for use in the fragment.  Defaults to: <tt>item</tt>
-          #
-          # An <tt>:empty</tt> option specifies a fragment to use for the
-          # empty state when the iterator returns an empty collection.
-          def for_each(iterator, as: :item, emit: :markup, empty: nil)
-            as = as.to_sym
-            emit = emit.to_sym
-            iterator = iterator.kind_of?(Proc) ? iterator.source : iterator
-            fragment_src = if empty
-%Q(-> {
-  unless_block(Proc.from_source("-> {#{iterator}.call.empty?}"), alt: #{self[empty].source}) {
-    for_each(Proc.from_source("#{iterator}"), as: #{as.inspect}) {
-      #{self[emit].source_body}
-    }
-  }
-})
-            else
-%Q(-> {
-  for_each(Proc.from_source("#{iterator}"), as: #{as.inspect}) {
-    #{self[emit].source_body}
-  }
-})
-            end
-            fragment = Proc.from_source(fragment_src)
-            _store :markup, fragment
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-      module Parenting
-
-        # Parenting adds the capability for a component to have and render
-        # children that may be specified in the template fragment which
-        # includes the component.
-        #
-        # Example parenting component:
-        #
-        #   class Line < ExpressTemplates::Components::Base
-        #     include Capabilities::Parenting
-        #
-        #     emits { p.line { _yield } }
-        #   end
-        #
-        # You might then use this component like so:
-        #
-        #   line "In", "Xanadu", "did", "Kubla", "Khan"
-        #   line { "A stately pleasure-dome decree :" }
-        #   line { "Where Alph, the sacred river, ran" }
-        #   line %q(Through caverns measureless to man)
-        #   line %q|Down to a sunless sea.|
-        #
-        # Provides
-        #
-        # * ClassMethods for rendering
-        # * InstanceMethods for managing children
-        #
-        def self.included(base)
-          base.class_eval do
-            include InstanceMethods
-          end
-        end
-
-        module InstanceMethods
-          def children
-            @children ||= []
-          end
-
-          def children=(children)
-            @children = children
-            children.each do |child|
-              if child.kind_of?(Adoptable)
-                child.parent = self
-              end
-            end
-          end
-
-          def compile
-            null_wrapped_children = "null_wrap(%q(#{compile_children}))"
-            wrap_children_src = self.class[:markup].source.gsub(/(\s)_yield(\s)/, '\1'+null_wrapped_children+'\2')
-            _compile_fragment(Proc.from_source(wrap_children_src))
-          end
-
-          def compile_children
-            compiled_children = nil
-            Indenter.for(:compile) do |indent, indent_with_newline|
-              compiled_children = children.map do |child|
-                indent_with_newline +
-                (child.respond_to?(:compile) ? child.compile : child.inspect) # Bare strings may be children
-              end.join("+\n")
-              compiled_children.gsub!('"+"', '') # avoid unnecessary string concatenation
-            end
-            return compiled_children
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-
-      # Adds the capability for a component to render itself in a context.
-      #
-      # Provides both:
-      #
-      # * Rendering::ClassMethods
-      # * Rendering::InstanceMethods
-      #
-      # Used in ExpressTemplates::Components::Base.
-      #
-      module Rendering
-        def self.included(base)
-          base.class_eval do
-            extend ClassMethods
-          end
-        end
-
-        module ClassMethods
-          def render_in(context, &view_code)
-            context.instance_eval(&view_code)
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,198 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-
-      # The Templating capability module provides Components with the ability
-      # to store, reference and compile template fragments.
-      #
-      # It extends the including class with Templating::ClassMethods.
-      #
-      # It also provides helpers which are snippets of code in the form of
-      # lambdas that may be evaluated in the view context.
-      #
-      module Templating
-        def self.included(base)
-          base.class_eval do
-            extend ClassMethods
-            include InstanceMethods
-          end
-          class << base
-            alias_method :fragments, :emits
-            alias_method :has_markup, :emits
-          end
-        end
-
-        module ClassMethods
-
-          # Store fragments of ExpressTemplate style markup for use in
-          # generating the HTML representation of a component.
-          #
-          # For example in your class, simply place the following:
-          #
-          #     class MyComponent < ET::Components::Base
-          #       emits {
-          #         ul {
-          #           li "one"
-          #           li "two"
-          #           li "three"
-          #         }
-          #       }
-          #
-          #     end
-          #
-          # By default this template code is stored under the label :markup
-          # 
-          # You may specify several fragments with a hash containing lambdas:
-          #
-          #       emits body:     -> { li "item" },
-          #             wrapper:  -> { ul { _yield } }
-          #
-          # This method is aliased as <tt>fragments</tt> and <tt>has_markup</tt>
-          # 
-          def emits(*args, &template_code)
-            if args.first.respond_to?(:call) or template_code
-              fragment = (args.first||template_code)
-              raise "must use stabby lambda" unless fragment.lambda?
-              _store :markup, fragment# default fragment is named :markup
-            else
-              args.first.to_a.each do |name, block|
-                raise ArgumentError unless name.is_a?(Symbol) and block.is_a?(Proc)
-                _store(name, block)
-              end
-            end
-          end
-
-          def [](label)
-            _lookup(label)
-          end
-
-          # Stores a block given for later evaluation in context.
-          #
-          # Example:
-          #
-          #       class TitleComponent < ECB
-          #         helper :title_helper do
-          #           @resource.name
-          #         end
-          #
-          #         emits {
-          #           h1 {
-          #             title_helper
-          #           }
-          #         }
-          #
-          #       end
-          #
-          # In this example <tt>@resource.name</tt> is evaluated in the
-          # provided context during page rendering and not during template
-          # expansion or compilation.
-          #
-          # This is the recommended for encapsulation of "helper" type
-          # functionality which is of concern only to the component and
-          # used only in its own markup fragments.
-          def helper(name, &block)
-            _helpers[name] = block
-            _define_helper_methods name
-          end
-
-          def special_handlers
-            {insert: self, _yield: self}.merge(Hash[*(_helpers.keys.map {|k| [k, self] }.flatten)])
-          end
-
-          protected
-
-            # Stores a fragment for use during compilation and rendering
-            # of a component.
-            def _store(name, fragment)
-              @fragments ||= Hash.new
-              @fragments[name] = fragment
-            end
-
-            # Looks up a template fragment for this component and returns
-            # compiled template code.
-            #
-            # If the template fragment is not already compiled, it compiles it
-            # with the supplied options as locals.  Locals may be used within
-            # the template during expansion.
-            #
-            # Returns a string containing ruby code which evaluates to markup.
-            def _lookup(name, options = {})
-              @fragments ||= Hash.new
-              @fragments[name] or raise "no template fragment supplied for: #{name}"
-            end
-
-          private
-
-
-            def _helpers
-              @helpers ||= Hash.new
-            end
-
-            def _define_helper_methods(name)
-              method_definition= <<-RUBY
-                class << self
-
-                  # called during expansion
-                  define_method(:#{name}) do |*args|
-                    helper_args = %w(self)
-                    helper_args += args.map(&:inspect)
-                    '{{#{self.to_s}._#{name}('+_interpolate(helper_args).join(', ')+')}}'
-                  end
-
-                  # called during rendering in view context
-                  define_method(:_#{name}) do |context, *args|
-                    begin
-                      helper_proc = _helpers[:#{name}]
-                      helper_args = args.take(helper_proc.arity)
-                      context.instance_exec *helper_args, &helper_proc
-                    rescue => e
-                      raise "#{name} raised: \#\{e.to_s\}"
-                    end.to_s
-                  end
-                end
-              RUBY
-              eval(method_definition)
-            end
-
-            def _interpolate(args)
-              args.map do |arg|
-                if arg.kind_of?(String) && match = arg.match(/"\{\{(.*)\}\}"/)
-                  match[1]
-                else
-                  arg
-                end
-              end
-            end
-
-        end
-
-        module InstanceMethods
-
-          def lookup(fragment_name, options={})
-            fragment = self.class[fragment_name]
-            if fragment.kind_of?(Proc)
-              _compile_fragment(fragment, options)
-            else
-              fragment
-            end
-          end
-
-          # Expands and compiles the supplied block representing a
-          # template fragment.
-          #
-          # Any supplied options are passed as locals for use during expansion.
-          #
-          # Returns a string containing ruby code which evaluates to markup.
-          def _compile_fragment(block, options = {})
-            initialize_expander(nil, self.class.special_handlers, options)
-            expand(&block).map(&:compile).join("+").gsub('"+"', '')
-          end
-
-
-        end
-
-
-      end
-    end
-  end
-end