express_templates 0.5.0 → 0.7.0

data/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/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/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/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/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/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

data/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/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/lib/express_templates/components/container.rb

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

data/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/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