express_admin 1.1.0 → 1.2.0

data/vendor/gems/express_templates/express_templates.gemspec

@@ -0,0 +1,29 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "express_templates/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "express_templates"
+  s.version     = ExpressTemplates::VERSION
+  s.authors     = ["Steven Talcott Smith", "Eumir Gaspar"]
+  s.email       = ["steve@aelogica.com", "eumir@aelogica.com"]
+  s.homepage    = "https://github.com/aelogica/express_templates"
+  s.summary     = "Write HTML templates in declarative Ruby.  Create reusable view components."
+  s.description = "Replace Erb/HAML/Slim with ExpressTemplates and write templates in a declartive style of Ruby.  With ExpressTemplates you may easily create a library of components for use across projects."
+  s.license     = "MIT"
+
+  s.files = Dir["{app,config,db,lib}/**/*", "LICENSE", "Rakefile", "README.md"]
+  s.test_files = Dir["test/**/*"]
+
+  s.add_dependency "activesupport", "~> 4.2" # strictly speaking we only depend on active support
+  s.add_dependency "parslet", "~> 1.6"
+  s.add_development_dependency "rails", "~> 4.2"
+  s.add_development_dependency "pry", "~> 0"
+  s.add_development_dependency "erubis", "~> 2.7"
+  s.add_development_dependency "haml", "~> 4.0"
+  s.add_development_dependency "better_errors", "~> 2.0"
+  s.add_development_dependency "binding_of_caller", "~> 0.7"
+  s.add_development_dependency "pry-stack_explorer", "~> 0.4"
+end

data/vendor/gems/express_templates/lib/core_extensions/proc.rb

@@ -0,0 +1,90 @@
+require 'ripper'
+require 'pp'
+class Proc
+
+  TLAMBEG = [:on_tlambeg, "{"]
+  TLAMBDA = [:on_tlambda, "->"]
+  LBRACE  = [:on_lbrace, '{']
+
+  TOKEN_PAIRS = {LBRACE             => [:on_rbrace, '}'],
+                 [:on_kw, 'do']     => [:on_kw, 'end'],
+                 TLAMBDA            => [:on_rbrace, '}']}
+
+  # Make a best effort to provide the original source for a block
+  # based on extracting a string from the file identified in
+  # Proc#source_location using Ruby's tokenizer.
+  #
+  # This works for first block declared on a line in a source
+  # file.  If additional blocks are specified inside the first block
+  # on the same line as the start of the block, only the outer-most
+  # block declaration will be identified as a the block we want.
+  #
+  # If you require only the source of blocks-within-other-blocks, start them
+  # on a new line as would be best practice for clarity and readability.
+  def source
+    @source ||= begin
+      file, line_no = source_location
+      raise "no line number provided for source_location: #{self}" if line_no.nil?
+      tokens =  Ripper.lex File.read(file)
+      tokens_on_line = tokens.select {|pos, lbl, str| pos[0].eql?(line_no) }
+      starting_token = tokens_on_line.detect do |pos, lbl, str|
+          TOKEN_PAIRS.keys.include? [lbl, str]
+      end
+      starting_token_type = [starting_token[1], starting_token[2]]
+      ending_token_type = TOKEN_PAIRS[starting_token_type]
+      source_str = ""
+      remaining_tokens = tokens[tokens.index(starting_token)..-1]
+      nesting = -1
+      starting_nesting_token_types = if [TLAMBDA, LBRACE].include?(starting_token_type)
+        [TLAMBDA, LBRACE]
+      else
+        [starting_token_type]
+      end
+
+      while token = remaining_tokens.shift
+        token = [token[1], token[2]] # strip position
+        source_str << token[1]
+        nesting += 1 if starting_nesting_token_types.include? token
+        is_ending_token = token.eql?(ending_token_type)
+        break if is_ending_token && nesting.eql?(0)
+        nesting -= 1 if is_ending_token
+      end
+      source_str
+    end
+  end
+
+  # Examines the source of a proc to extract the body by
+  # removing the outermost block delimiters and any surrounding.
+  # whitespace.
+  #
+  # Raises exception if the block takes arguments.
+  #
+  def source_body
+    raise "Cannot extract proc body on non-zero arity" unless arity.eql?(0)
+    tokens = Ripper.lex source
+    body_start_idx = 2
+    body_end_idx = -1
+    if tokens[0][1].eql?(:on_tlambda)
+      body_start_idx = tokens.index(tokens.detect { |t| t[1].eql?(:on_tlambeg) }) + 1
+    end
+    body_tokens = tokens[body_start_idx..-1]
+
+    body_tokens.pop # ending token of proc
+    # remove trailing whitespace
+    whitespace = [:on_sp, :on_nl, :on_ignored_nl]
+    body_tokens.pop while whitespace.include?(body_tokens[-1][1])
+    # remove leading whitespace
+    body_tokens.shift while whitespace.include?(body_tokens[0][1])
+
+    # put them back together
+    body_tokens.map {|token| token[2] }.join
+  end
+
+  def self.from_source(prc_src)
+    raise ArgumentError unless prc_src.kind_of?(String)
+    prc = eval(prc_src)
+    prc.instance_variable_set(:@source, prc_src)
+    prc
+  end
+
+end

data/vendor/gems/express_templates/lib/core_extensions/string.rb

@@ -0,0 +1,25 @@
+# We use Hash#inspect in ExpressTemplates::Markup::Wrapper to reproduce arguments
+# to helpers in the Rails view.
+#
+# Hash#inspect calls #inspect on values and keys.  This allows us to
+# place the resulting string into the view code with a simple substitution
+# or concatenation.
+#
+# In special cases, however, we might want the argument or one of its keys
+# or values to be the result of evaluating of a ruby expression in the view
+# that does not itself return a String.  The result of #inspect
+# is normally a quoted and escaped string which would evaluate to a string
+# in the view.  What we want is a simple string of code.  Here we provide
+# a method that overrides #inspect in the strings eigenclass to strip off
+# enclosing quotes or unwanted escapes.  It shouldn't bother anybody and
+# it keeps us from doing messy things elsewhere for now.
+class String
+  def to_view_code
+    class << self
+      def inspect
+        super.gsub(/^"(.*)"$/,'\1')
+      end
+    end
+    return self
+  end
+end

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

@@ -0,0 +1,19 @@
+module ExpressTemplates
+  require 'core_extensions/proc'
+  require 'core_extensions/string'
+  require 'express_templates/indenter'
+  require 'express_templates/macro'
+  require 'express_templates/markup'
+  require 'express_templates/components'
+  require 'express_templates/template/handler'
+  require 'express_templates/renderer'
+  require 'express_templates/expander'
+  require 'express_templates/compiler'
+  require 'express_templates/interpolator'
+  extend Renderer
+  extend Compiler
+  if defined?(Rails)
+    ::ActionView::Template.register_template_handler :et, ExpressTemplates::Template::Handler
+  end
+
+end

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

@@ -0,0 +1,36 @@
+module ExpressTemplates
+  module Compiler
+    def compile(template_or_src=nil, &block)
+
+      if block
+        begin
+          block.source
+        rescue
+          raise "block must have source - did you do compile(&:label) ?"
+        end
+      end
+
+      template, src = _normalize(template_or_src)
+
+      expander = Expander.new(template)
+
+      compiled = expander.expand(src, &block).map(&:compile)
+
+      return Interpolator.transform(compiled.join("+").gsub('"+"', '')).tap do |s|
+        puts("\n"+template.inspect+"\nSource:\n#{template.try(:source)}\nInterpolated:\n#{s}\n") if ENV['DEBUG'].eql?('true')
+      end
+    end
+
+    private
+      def _normalize(template_or_src)
+        template, src = nil, nil
+        if template_or_src.respond_to?(:source)
+          template = template_or_src
+          src = template_or_src.source
+        else
+          src = template_or_src
+        end
+        return template, src
+      end
+  end
+end

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

@@ -0,0 +1,18 @@
+module ExpressTemplates
+  module Components
+  end
+end
+
+require 'express_templates/expander'
+require 'express_templates/components/base'
+require 'express_templates/components/container'
+require 'express_templates/components/null_wrap'
+require 'express_templates/components/for_each'
+require 'express_templates/components/unless_block'
+require 'express_templates/components/row'
+require 'express_templates/components/column'
+require 'express_templates/components/form_rails_support'
+require 'express_templates/components/content_for'
+require 'express_templates/components/table_for'
+require 'express_templates/components/tree_for'
+require 'express_templates/components/forms'

data/vendor/gems/express_templates/lib/express_templates/components/base.rb

@@ -0,0 +1,54 @@
+capabilities = Dir.glob(File.join(File.dirname(__FILE__), 'capabilities', '*.rb'))
+capabilities.each {|capability| require capability}
+
+module ExpressTemplates
+  # Components provide self-contained reusable view code meant to be shared
+  # within a project or across many projects through a library of components
+  #
+  # Components gain their functionality through inclusion of Capabilities.
+  #
+  # Most Components are descendents of Components::Base.
+  #
+  module Components
+
+    # Components::Base is the base class for ExpressTemplates view components.
+    #
+    # View components are available as macros in ExpressTemplates and may be
+    # used to encapsulate common view patterns, behavior and functionality in
+    # reusable classes that can be shared within and across projects.
+    #
+    # Components intended to provide a base framework for a library of reusable
+    # components to cut development time across a multitude of projects.
+    #
+    # Components gain their functionality through including Capabilities.
+    #
+    # Example capabilities include:
+    #
+    # * Managing related ExpressTemplate fragments
+    # * Compiling template fragments for evaluation in a View Context
+    # * Specifying rendering logic to be executed in the View Context
+    # * Potentially referencing external assets that may be required
+    #   for the component to work.
+    #
+    # Components::Base includes the following capabilities:
+    #
+    # * Capabilities::Templating
+    # * Capabilities::Rendering
+    # * Capabilities::Wrapping
+    # * Capabilities::Iterating
+    #
+    class Base < Expander
+      include ExpressTemplates::Macro
+      include Capabilities::Templating
+      include Capabilities::Rendering
+      include Capabilities::Wrapping
+      include Capabilities::Iterating
+
+      def self.inherited(klass)
+        ExpressTemplates::Expander.register_macros_for klass
+      end
+
+    end
+
+  end
+end

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

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

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

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

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