express_admin 1.7.5 → 1.7.7

data/vendor/gems/express_templates/Gemfile

@@ -1,16 +0,0 @@
-source "https://rubygems.org"
-
-# Declare your gem's dependencies in express_templates.gemspec.
-# Bundler will treat runtime dependencies like base dependencies, and
-# development dependencies will be added by default to the :development group.
-gemspec
-
-# Declare any dependencies that are still in development here instead of in
-# your gemspec. These might include edge Rails or gems from your path or
-# Git. Remember to move these dependencies to your gemspec before releasing
-# your gem to rubygems.org.
-
-# To use debugger
-# gem 'debugger'
-gem 'pry-byebug'
-gem 'minitest-reporters'

data/vendor/gems/express_templates/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 ÆLOGICA | Build it better here.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/vendor/gems/express_templates/README.md

@@ -1,133 +0,0 @@
-# ExpressTemplates
-
-Provides a DSL for HTML templates using a declarative style of Ruby as an alternative to Erb or HAML.
-
-Although originally we implemented our own DSL and used a code generation approach,
-this gem now uses [ActiveAdmin's arbre](https://github.com/activeadmin/arbre).  Arbre is widely
-used as part of ActiveAdmin, has a long history and many contributors and is conceptually much simpler.
-
-## Usage
-
-Add this to your gemfile:
-
-```ruby
-gem 'express_templates'
-```
-
-Rename your application.html.erb to application.html.et.
-
-Change your template to look like this.
-
-```ruby
-html(lang: "en") {
-  head {
-    meta charset: 'utf-8'
-    meta name: 'viewport', content: "width=device-width, initial-scale=1.0"
-    title {
-      content_for(:title)
-    }
-    stylesheet_link_tag "application", media: 'all', 'data-turbolinks-track' => true
-    csrf_meta_tags
-  }
-  body {
-    current_arbre_element.add_child yield
-    javascript_include_tag "application"
-  }
-}
-```
-
-Everything should work as you would expect.
-
-Set your editor syntax for .et files to Ruby.
-
-You can now utilize components which are found with documentation and examples in <tt>ExpressTemplates::Components</tt>.
-
-Components are the real strength of both arbre and express_templates.
-
-express_templates now *is* arbre + some components + some conventions.  ExpressTemplates::Components::Base provides a little syntactic sugar in the form of the emits class method.
-
-In terms of conventions, we use brace blocks { } to indicate html structure and do/end blocks to indicate control flow.
-
-Control flow should only be used in Components.  This is currently not enforced but it will be in the future.
-
-The purpose of express_templates is to provide a foundation for a library of reusable UX components which we can enhance for drag-and-drop style UX construction and template editing.
-
-
-## Block Structure
-
-ExpressTemplates use Ruby's block structure and execution order to indicate parent-child relationships and to build the tree structure that ultimately results in nodes in the DOM.
-
-Example:
-
-```ruby
-ul {
-  li { "one" }
-  li "two"
-  li %Q(#{@three})
-}
-```
-
-Let us suppose that an @three variable exists in the view context with the value "three".  This would yield the following markup:
-
-```html
-<ul>
-  <li>one</li>
-  <li>two</li>
-  <li>three</li>
-</ul>
-```
-
-## Components
-
-Given the constraint that logic must not go in the template, where does one put it?  The answer is we make a component!
-
-ExpressTemplates provide a framework for construction of components by encapsulating common logic patterns found in view code into Capabilities which Components may include.  These Capabilities form a DSL which allows Components to be built in a declarative fashion.  This makes them "low-cost" entities to construct in terms of developer time.
-
-A common need is for a list items such as in the above example to be generated from a collection or array of data.   Let us suppose we expect the view context to have:
-
-```ruby
-@list = %w(one two three)
-```
-
-We can make a simple component like so:
-
-```ruby
-class ListComponent < ExpressTemplates::Components::Base
-  emits -> {
-    ul {
-      # assumes view provides list
-      list.each do |item|
-        li {
-          item
-        }
-      end
-    }
-  }
-end
-```
-
-This would be used in a view template just as if it were a tag, like so:
-
-```ruby
-div(class: "active") {
-  list_component
-}
-```
-
-Now when the template renders, it will yield:
-
-```html
-<div class="active">
-  <ul>
-    <li>one</li>
-    <li>two</li>
-    <li>three</li>
-  </ul>
-</div>
-```
-
-## Background
-
-ExpressTemplates is a key part of the AppExpress platform at [appexpress.io](http://appexpress.io).
-
-This project rocks and uses MIT-LICENSE.

data/vendor/gems/express_templates/Rakefile

@@ -1,32 +0,0 @@
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'ExpressTemplates'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-
-
-
-Bundler::GemHelper.install_tasks
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
-
-
-task default: :test

data/vendor/gems/express_templates/express_templates.gemspec

@@ -1,32 +0,0 @@
-$:.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/**/*"] - Dir["test/log/*", "test/tmp/*", "test/dummy/tmp/**/*", "test/dummy/log/*"]
-
-  s.add_dependency "activesupport", "~> 4.2" # strictly speaking we only depend on active support
-  s.add_dependency "parslet", "~> 1.6"
-  s.add_dependency "arbre", "~> 1.0"
-
-  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"
-  s.add_development_dependency "minitest-line"
-end

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

@@ -1,76 +0,0 @@
-module Arbre
-  class Context
-    def resource
-      helpers.resource
-    end
-  end
-
-  class Element
-
-    module BuilderMethods
-
-      # we do not want to check the arity of the
-      # block in express templates because components
-      # are expected to be able to contain other components or template code
-      # without use of a builder style syntax
-      def build_tag(klass, *args, &block)
-        tag = klass.new(arbre_context)
-        tag.parent = current_arbre_element
-
-        with_current_arbre_element tag do
-          tag.build(*args, &block)
-        end
-
-        tag
-      end
-    end
-
-    def possible_route_proxy(name)
-      if helpers.controller.class.parent &&
-        helpers.respond_to?(namespace = helpers.controller.class.parent.to_s.underscore)
-        if (route_proxy = helpers.send(namespace)).respond_to?(name)
-          return route_proxy
-        end
-      end
-      return nil
-    end
-
-    # Implements the method lookup chain. When you call a method that
-    # doesn't exist, we:
-    #
-    #  1. Try to call the method on the current DOM context
-    #  2. Return an assigned variable of the same name
-    #  3. Call the method on the helper object
-    #  4. Call super
-    #
-    def method_missing(name, *args, &block)
-      if current_arbre_element.respond_to?(name)
-        current_arbre_element.send name, *args, &block
-      elsif assigns && assigns.has_key?(name.to_sym)
-        assigns[name.to_sym]
-      elsif helpers.respond_to?(name)
-        helper_method(name, *args, &block)
-      elsif route_proxy = possible_route_proxy(name)
-        route_proxy.send(name, *args, &block)
-      else
-        super
-      end
-    end
-
-    # In order to not pollute our templates with helpers. prefixed
-    # everywhere we want to try to distinguish helpers that are almost
-    # always used as parameters to other methods such as path helpers
-    # and not add them as elements
-    def helper_method(name, *args, &block)
-      if name.match /_path$/
-        helpers.send(name, *args, &block)
-      elsif (const_get([name, 'engine'].join('/').classify) rescue nil)
-        helpers.send(name, *args, &block)
-      else
-        current_arbre_element.add_child helpers.send(name, *args, &block)
-      end
-    end
-
-  end
-
-end

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

@@ -1,103 +0,0 @@
-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 file provided by source_location: #{self}" if file.nil?
-      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]) &&
-          _actually_starting_a_proc?(tokens, [pos, 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
-
-  def _actually_starting_a_proc?(tokens, tok)
-    return true if tokens.index(tok).eql?(0)
-    look_back = tokens.slice(0..tokens.index(tok)-1)
-    look_back.pop if look_back.last.try(:[], 1).eql? :on_sp
-    if [:on_tlambeg, :on_tlambda].include?(tok[1])
-      true
-    else
-      ![:on_comma, :on_lparen, :on_label].include?(look_back.last.try(:[], 1))
-    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

@@ -1,25 +0,0 @@
-# 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/compiler.rb

@@ -1,22 +0,0 @@
-module ExpressTemplates
-  module Compiler
-    def compile(template_or_src=nil, &block)
-
-      template, src = _normalize(template_or_src)
-
-      %Q[assigns.merge!(template_virtual_path: @virtual_path) ; Arbre::Context.new(assigns, self) { #{src || block.source_body} }.to_s]
-    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/all.rb

@@ -1,28 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Presenters
-      class All < Container
-
-        has_argument :id, "Name of the collection", as: :collection_name, type: :symbol
-
-        contains -> (&block) {
-          prepended
-          collection.each do |item|
-            assigns[member_name.to_sym] = item
-            block.call(self) if block
-          end
-          appended
-        }
-
-        def member_name
-          config[:collection_name].to_s.singularize.to_sym
-        end
-
-        def collection
-          self.send(config[:collection_name])
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,156 +0,0 @@
-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
-  #
-  module Components
-
-    # Components::Base is the base class for ExpressTemplates view components.
-    #
-    #
-    class Base < Arbre::Component
-
-      class_attribute :before_build_hooks
-      self.before_build_hooks = []
-
-      class_attribute :builder_method_name
-
-      # mark a component as abstract ie. can't be used
-      # in Express Designer
-      #
-      @is_abstract = false
-
-      def self.abstract_component(value = true)
-        @is_abstract = value
-      end
-
-      def self.abstract_component?
-        @is_abstract
-      end
-
-      abstract_component
-
-      # define the parent componennt ie. can't be used
-      # in Express Designer unless parent is present
-      #
-      @parent_component = nil
-
-      def self.require_parent(component)
-        raise "must pass a sublcass of ExpressTemplates::Components::Base" if !component.kind_of? ExpressTemplates::Components::Base
-        @parent_component = component
-      end
-
-      def self.required_parent
-        @parent_component
-      end
-
-      def self.builder_method_and_class(method_name, klass)
-        Arbre::Element::BuilderMethods.class_eval <<-EOF, __FILE__, __LINE__
-          def #{method_name}(*args, &block)
-            insert_tag ::#{klass.name}, *args, &block
-          end
-        EOF
-        self.builder_method_name = method_name
-        # puts "added #{method_name} -> #{klass.name}"
-      end
-
-      def initialize(*)
-        super
-        _default_attributes.each do |name, value|
-          set_attribute(name, value)
-        end
-        add_class _default_classes
-      end
-
-      def self.contains(proc = nil, &block)
-        define_method(:_build_body, &(proc || block))
-      end
-
-      # Override the tag_name method for other than <div>
-      def self.tag(tag)
-        define_method(:tag_name) { tag }
-      end
-
-      # Provide default attributes for the enclosing tag
-      # of the component
-      def self.has_attributes(attribs)
-        self._default_classes = attribs.delete(:class)
-        _default_attributes.merge!(attribs)
-      end
-
-      def self.before_build(proc_or_symbol = nil, exclusive: false, &block)
-        hook = (proc_or_symbol || block)
-        unless hook.kind_of?(Symbol) or hook.respond_to?(:call)
-          raise "before_build requires symbol (method_name), proc or block"
-        end
-        if exclusive
-          self.before_build_hooks = [hook]
-        else
-          self.before_build_hooks += [hook]
-        end
-      end
-
-      def build(*args, &block)
-        _extract_class!(args)
-        _run_before_build_hooks
-        super(*args) {
-          _build_body(&block) if respond_to?(:_build_body)
-        }
-      end
-
-      def resource
-        helpers.resource
-      end
-
-      def self.inherited(subclass)
-        subclass.builder_method_and_class subclass.to_s.demodulize.underscore, subclass
-      end
-
-      def self.builder_method(name)
-        builder_method_and_class name, self
-      end
-
-      def self.descendants
-        ObjectSpace.each_object(Class).select { |klass| klass < self }
-      end
-
-      protected
-        def default_class_name
-          self.class.name.demodulize.underscore.dasherize
-        end
-
-
-      private
-        def _run_before_build_hooks
-          before_build_hooks.each do |hook|
-            if hook.kind_of?(Symbol)
-              self.send(hook)
-            else
-              instance_exec &hook
-            end
-          end
-        end
-        def _extract_class!(args)
-          add_class args.last.delete(:class) if args.last.try(:kind_of?, Hash)
-        end
-        def _default_attributes
-          self.class._default_attributes
-        end
-        def self._default_attributes
-          @default_attributes ||= {}
-        end
-        def _default_classes
-          self.class._default_classes
-        end
-        def self._default_classes
-          @default_classes ||= ''
-        end
-        def self._default_classes=(classes)
-          @default_classes = classes
-        end
-
-    end
-  end
-end