express_templates 0.5.0 → 0.7.0

data/lib/express_templates/components/forms/form_support.rb

@@ -1,13 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Forms
-      module FormSupport
-
-        def form_action
-          @config[:action] || "{{@#{resource_name}.try(:persisted?) ? #{resource_path(ivar: true)} : #{collection_path}}}"
-        end
-
-      end
-    end
-  end
-end

data/lib/express_templates/components/null_wrap.rb

@@ -1,41 +0,0 @@
-module ExpressTemplates
-  module Components
-    # NullWrap is useful for creating a node in the component tree that does
-    # not produce any markup.  It can be used in a template fragment to
-    # wrap bare text or string content where such would not normally be possible.
-    #
-    # Example:
-    #
-    # ```ruby
-    # div {
-    #   some_component
-    #   null_wrap {
-    #     "Some text"
-    #   }
-    #   other_component
-    # }
-    # ```
-    #
-    # Otherwise you can use it to hold already-complied code meant for
-    # evaluation in the view that needs to be protected from being compiled
-    # again. This use is largely internal to express_templates. It is not
-    # expected that users of this library would need this.
-    #
-    # Example:
-    #
-    # ```ruby
-    # null_wrap("(@collection.map do |member| \"<li>#{member.name}</li>\").join")
-    # ```
-    #
-    class NullWrap < Components::Container
-      def initialize(*args)
-        @already_compiled_stuff = args.shift if args.first.is_a?(String)
-        super(*args)
-      end
-
-      def compile
-        @already_compiled_stuff || compile_children
-      end
-    end
-  end
-end

data/lib/express_templates/components/row.rb

@@ -1,28 +0,0 @@
-module ExpressTemplates
-  module Components
-    # A Row is a Container implemented as a div with
-    # a CSS class "row"
-    #
-    # An optional dom ID may be specified as a symbol.
-    #
-    # Example:
-    #
-    #     row(:main) {
-    #       p "Some content"
-    #     }
-    #
-    # This will render as:
-    #
-    #     <div id="main" class="row"><p>Some content</p></div>
-    #
-    class Row < Container
-      include Capabilities::Configurable
-
-      emits -> {
-        div.row(my[:id]) {
-          _yield
-        }
-      }
-    end
-  end
-end

data/lib/express_templates/components/table_for.rb

@@ -1,163 +0,0 @@
-module ExpressTemplates
-  module Components
-    # Create an html table from a collection of data.
-    #
-    # Typically this will be a collection of models
-    # of the same type.  Each member of the collection must
-    # respond to the column names provided.
-    #
-    # Example:
-    #
-    # ````ruby
-    # table_for(:people) do |t|
-    #   t.column :name
-    #   t.column :email
-    #   t.column :phone
-    #   t.column :hourly_rate, header: "Rate",
-    #                          formatter: -> (amount) {'$%0.2f' % amount rescue 'N/A'}
-    # end
-    # ````
-    #
-    # This assumes that a @people variable will exist in the
-    # view and that it will be a collection whose members respond to
-    # :name, :email, :phone, :hourly_rate
-    #
-    # This will result in markup like the following:
-    #
-    #     <table id="people">
-    #       <thead>
-    #         <tr>
-    #           <th class="name">Name</th>
-    #           <th class="email">Email</th>
-    #           <th class="phone">Phone</th>
-    #           <th class="hourly_rate">Rate</th>
-    #         </tr>
-    #       </thead>
-    #       <tbody>
-    #         <tr id="person-1">
-    #           <td class="name">Steven Talcott Smith</td>
-    #           <td class="email">steve@aelogica.com</td>
-    #           <td class="phone">415-555-1212</td>
-    #           <td class="hourly_rate">$250.00</td>
-    #         </tr>
-    #       </tbody>
-    #     </table>
-    #
-    # Note that column options include :formatter and :header.
-    #
-    # :formatter may be a stabby lambda which is passed the value to be formatted.
-    #
-    # :header may be either a string
-    #
-    class TableFor < Base
-      include Capabilities::Configurable
-      include Capabilities::Building
-
-      def initialize(*args)
-        super(*args)
-        _process_args!(args) # from Configurable
-        yield(self) if block_given?
-      end
-
-      attr :columns
-
-      def column(name, options = {})
-        @columns ||= []
-        @columns << Column.new(name, options)
-      end
-
-      emits -> {
-        table(my[:id]) {
-          thead {
-            tr {
-              columns.each do |column|
-                th.send(column.name) {
-                  column.title
-                }
-              end
-            }
-          }
-          tbody {
-            for_each("@#{my[:id]}".to_sym) {
-
-              tr(id: "#{my[:id].to_s.singularize}-{{#{my[:id].to_s.singularize}.id}}",
-                 class: my[:id].to_s.singularize) {
-
-                columns.each do |column|
-                  if(column.has_actions?)
-                    td(class: column.name) {
-                      column.show_actions(my[:id].to_s)
-                    }
-                  else
-                    td(class: column.name) {
-                      column.format(my[:id].to_s.singularize)
-                    }
-                  end
-                end
-              }
-            }
-          }
-        }
-      }
-
-      def wrap_for_stack_trace(body)
-        "ExpressTemplates::Components::TableFor.render_in(self) {\n#{body}\n}"
-      end
-
-      def compile
-        wrap_for_stack_trace(lookup(:markup))
-      end
-
-      class Column
-        attr :name, :options
-        def initialize(name, options = {})
-          @name = name
-          @options = options
-          @formatter = options[:formatter]
-          @header = options[:header]
-          @actions = options[:actions] || []
-        end
-
-        def has_actions?
-          @actions.any?
-        end
-
-        def format(item_name)
-          if @formatter.nil?
-            "\#\{#{item_name}.#{name}\}"
-          elsif @formatter.kind_of?(Proc)
-            "\#\{(#{@formatter.source}).call(#{item_name}.#{name})\}"
-          end
-        end
-
-        def show_actions(item_name)
-          action_links = StringIO.new
-          @actions.each do |action|
-            action_name = action.to_s
-            if action_name.eql?('edit')
-              action_links.puts "<a href='/#{item_name}/{{#{item_name.singularize}.id}}/edit'>Edit</a>"
-            elsif action_name.eql?('delete')
-              action_links.puts "<a href='/#{item_name}/{{#{item_name.singularize}.id}}' data-method='delete' data-confirm='Are you sure?'>Delete</a>"
-            elsif action_name.eql?('show')
-              action_links.puts "<a href='/#{item_name}/{{#{item_name.singularize}.id}}'>Show</a>"
-            end
-          end
-          action_links.string
-        end
-
-        def title
-          case
-          when @header.nil?
-            @name.to_s.try(:titleize)
-          when @header.kind_of?(String)
-            @header
-          when @header.kind_of?(Proc)
-            "{{(#{@header.source}).call(#{@name})}}"
-          end
-        end
-      end
-
-    end
-
-  end
-end

data/lib/express_templates/components/unless_block.rb

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