express_admin 1.1.0 → 1.2.0

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

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

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

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

@@ -0,0 +1,135 @@
+module ExpressTemplates
+  module Components
+    module Capabilities
+
+      module Resourceful
+        def namespace
+          @config[:namespace] || infer_namespace
+        end
+
+        def path_prefix
+          @config[:path_prefix] || infer_path_prefix
+        end
+
+        def resource_class
+          resource_class = @config[:resource_class] || _namespaced_resource_class
+          resource_class.constantize
+        end
+
+        private
+
+        def _namespaced_resource_class
+          if namespace
+            "#{namespace}/#{resource_name}".classify
+          else
+            resource_name.classify
+          end
+        end
+
+        def infer_namespace
+          expander = @args.last
+          if expander.try(:template)
+            path_parts = expander.template.virtual_path.split('/')
+
+            case
+            when path_parts.size == 4
+              path_parts.first
+            when path_parts.size == 3
+              mod = path_parts.first.classify.constantize
+              if mod.const_defined?(:Engine)
+                path_parts.first
+              else
+                nil
+              end
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+        def infer_path_prefix
+          expander = @args.last
+          if expander.try(:template)
+            path_parts = expander.template.virtual_path.split('/')
+
+            case
+            when path_parts.size == 4
+              path_parts[1]
+            when path_parts.size == 3
+              mod = path_parts.first.classify.constantize
+              if mod.const_defined?(:Engine)
+                nil
+              else
+                path_parts.first
+              end
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+        # TODO: this can now be inferred from the template.virtual_path
+        # if not supplied...
+        def resource_name
+          @config[:id].to_s.singularize
+        end
+
+        def collection_member_name
+          resource_name
+        end
+
+        def collection_name
+          collection_member_name.pluralize
+        end
+
+        def collection_var
+          "@#{collection_name}".to_sym
+        end
+
+        def collection
+          @config[:collection] || collection_var
+        end
+
+        def collection_path
+          if @config[:collection_path]
+            @config[:collection_path]
+          else
+            "#{collection_name_with_prefix}_path"
+          end
+        end
+
+        def collection_name_with_prefix
+          if path_prefix
+            "#{path_prefix}_#{collection_name}"
+          else
+            collection_name
+          end
+        end
+
+        def resource_path(ivar=false)
+          if @config[:resource_path]
+            @config[:resource_path]
+          else
+            "#{resource_name_with_path_prefix}_path(#{ivar ? '@' : ''}#{resource_name})"
+          end
+        end
+
+        def resource_name_with_path_prefix
+          if path_prefix
+            "#{path_prefix}_#{resource_name}"
+          else
+            resource_name
+          end
+        end
+
+        def attributes
+          resource_class.columns
+        end
+      end
+    end
+  end
+end

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

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