express_admin 1.1.0 → 1.2.0

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

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

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

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

@@ -0,0 +1,21 @@
+module ExpressTemplates
+  module Markup
+    class Yielder
+      def initialize(*args)
+        @arg = args.first
+      end
+
+      def compile
+        if @arg
+          "yield(#{@arg.inspect})" # usually a symbol but may be string
+        else
+          "yield"
+        end
+      end
+
+      def to_template
+        compile
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module ExpressTemplates
+  module Renderer
+    # render accepts source or block, expands to macros
+    # compiles the resulting macros 
+    # and then evaluates the resulting string of ruby in the context provided
+    def render context=nil, template_or_src=nil, &block
+      compiled_template = compile(template_or_src, &block)
+      context.instance_eval compiled_template
+    end
+  end
+end

data/vendor/gems/express_templates/lib/express_templates/template/handler.rb

@@ -0,0 +1,15 @@
+module ExpressTemplates
+  module Template
+    class Handler
+      def self.call(template)
+        new.call(template)
+      end
+
+      def call(template)
+        # returns a string to be eval'd
+        "(#{ExpressTemplates.compile(template)}).html_safe"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module ExpressTemplates
+  VERSION = "0.5.0"
+end

data/vendor/gems/express_templates/lib/tasks/express_templates.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :express_templates do
+#   # Task goes here
+# end

data/vendor/gems/express_templates/test/compiler_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class CompilerTest < ActiveSupport::TestCase
+  test ".compile returns a string"  do
+    source = "h1"
+    result = ExpressTemplates.compile(source)
+    assert_kind_of String, result
+  end
+end

data/vendor/gems/express_templates/test/components/base_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class BaseTest < ActiveSupport::TestCase
+
+  class NoLogic < ExpressTemplates::Components::Base
+    has_markup -> {
+      h1 { span "Some stuff" }
+    }
+  end
+
+  test ".has_markup makes compile return the block passed through express compiled" do
+    assert_equal %Q("<h1><span>Some stuff</span></h1>"), NoLogic.new.compile
+  end
+
+  test "components register themselves as macros" do
+    assert ExpressTemplates::Expander.instance_methods.include?(:no_logic)
+  end
+
+  class Context
+    def initialize ; @foo = ['bar', 'baz'] ; end
+  end
+
+  test "fragments and has_markup are synonyms for emits" do
+    assert_equal NoLogic.method(:emits), NoLogic.method(:fragments)
+    assert_equal NoLogic.method(:emits), NoLogic.method(:has_markup)
+  end
+
+  class Helpers < ECB
+    helper :title_helper, &-> { @foo.first }
+
+    emits -> {
+      h1 {
+        title_helper
+      }
+    }
+
+  end
+
+  test "helpers defined in component are evaluated in context" do
+    compiled = Helpers.new.compile
+    assert_equal "<h1>bar</h1>", Context.new.instance_eval(Interpolator.transform(compiled))
+  end
+
+end

data/vendor/gems/express_templates/test/components/capabilities/resourceful_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+module AdminModule
+  module Engine
+  end
+  class SmartThing
+    include ExpressTemplates::Components::Capabilities::Resourceful
+
+    attr_accessor :virtual_path
+
+    def initialize(virtual_path, config = {})
+      @virtual_path = virtual_path
+      @config = config
+      @args = [self]
+    end
+
+    def template
+      self
+    end
+  end
+end
+
+module Admin; end
+
+class FooBar; end
+
+class Something; end
+
+module ExpressTemplates
+
+  class ResourcefulTest < ActiveSupport::TestCase
+    test 'infers namespace and path prefix within an engine and scope' do
+      smart_thing = AdminModule::SmartThing.new('admin_module/admin/something/index')
+      assert_equal 'admin_module', smart_thing.namespace
+      assert_equal 'admin', smart_thing.path_prefix
+    end
+
+    test 'infers a namespace and no prefix within an engine' do
+      # if defined? ExpressFoo::Engine
+      smart_thing = AdminModule::SmartThing.new('admin_module/something/index')
+      assert_equal 'admin_module', smart_thing.namespace
+      assert_equal nil, smart_thing.path_prefix
+    end
+
+    test 'no namespace, infers prefix within a scope within an app' do
+      # else of case above
+      smart_thing = AdminModule::SmartThing.new('admin/something/index')
+      assert_equal nil, smart_thing.namespace
+      assert_equal 'admin', smart_thing.path_prefix
+    end
+
+    test 'no namespace, no prefix within an app' do
+      smart_thing = AdminModule::SmartThing.new('somethings/index')
+      assert_equal nil, smart_thing.namespace
+      assert_equal nil, smart_thing.path_prefix
+    end
+
+    test "#resource_class returns resource_class option if specified" do
+      assert_equal FooBar, AdminModule::SmartThing.new('somethings/index', resource_class: 'FooBar').resource_class
+      assert_equal Something, AdminModule::SmartThing.new('somethings/index', id: :something).resource_class
+    end
+  end
+end

data/vendor/gems/express_templates/test/components/column_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class ColumnTest < ActiveSupport::TestCase
+
+  ETC = ExpressTemplates::Components
+
+  test "a column is configurable" do
+    assert ETC::Column.ancestors.include?(ETC::Capabilities::Configurable)
+  end
+
+end

data/vendor/gems/express_templates/test/components/conditionality_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class ConditionalityTest < ActiveSupport::TestCase
+
+  def empty_title_context
+    ctx = Object.new
+    ctx.instance_variable_set(:@title, '')
+    ctx
+  end
+
+  def present_title_context
+    ctx = Object.new
+    ctx.instance_variable_set(:@title, 'Something')
+    ctx
+  end
+
+  class ConditionalRenderer < ExpressTemplates::Components::Base
+    include ExpressTemplates::Components::Capabilities::Conditionality
+
+      emits -> {
+        h1 "{{@title}}"
+      }
+
+      only_if -> { !@title.empty? }
+  end
+
+  test "when supplied condition is false, renders empty string" do
+    compiled_src = ConditionalRenderer.new.compile
+    assert_equal '', empty_title_context.instance_eval(compiled_src)
+  end
+
+  test "when supplied condition is true, renders the component" do
+    compiled_src = Interpolator.transform(ConditionalRenderer.new.compile)
+    assert_equal '<h1>Something</h1>', present_title_context.instance_eval(compiled_src)
+  end
+
+end