express_admin 1.7.5 → 1.7.7

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

@@ -1,67 +0,0 @@
-require 'test_helper'
-
-class BaseTest < ActiveSupport::TestCase
-
-  class Context
-    def assigns
-      {}
-    end
-  end
-
-  def render(&block)
-    ExpressTemplates.render(Context.new, &block)
-  end
-
-  class UnorderedList < ExpressTemplates::Components::Base
-    tag :ul
-
-    has_attributes :class       => 'something',
-                   'data-foo'   => 'something-else'
-
-    contains {
-      li { "Some stuff" }
-    }
-  end
-
-  test ".tag_name determines the enclosing tag" do
-    assert_match /^\<ul/, render { unordered_list }
-  end
-
-  test ".has_attributes creates default attributes" do
-    assert_match /class="[^"]*something[^"]*"/, render { unordered_list }
-    assert_match /data-foo="[^"]*something-else[^"]*"/, render { unordered_list }
-  end
-
-  test ".contains places fragment inside the enclosing tag" do
-    markup = render { unordered_list }
-    assert_match /\<ul.*\<li.*\/li\>.*\/ul\>/, markup.gsub("\n", '')
-  end
-
-  test "class name is dasherized instead of underscored" do
-    assert_match /class="[^"]*unordered-list[^"]*"/, render { unordered_list }
-  end
-
-  test "options are passed to html attributes" do
-    assert_match /rows="5"/, render { unordered_list(rows: 5) }
-  end
-
-  test "class option adds a class, does not override" do
-    markup = render { unordered_list(class: 'extra') }
-    assert_match /class="[^"]*something[^"]*"/, markup
-    assert_match /class="[^"]*unordered-list[^"]*"/, markup
-    assert_match /class="[^"]*extra[^"]*"/, markup
-  end
-
-  class BeforeBuildHook < ExpressTemplates::Components::Base
-    before_build :add_my_foo
-
-    def add_my_foo
-      set_attribute('data-foo', 'bar')
-    end
-  end
-
-  test "before_build hook runs before build" do
-    assert_match /data-foo="bar"/, render { before_build_hook }
-  end
-
-end

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

@@ -1,63 +0,0 @@
-require 'test_helper'
-
-module AdminModule
-  module Engine
-  end
-  class SmartThing < ExpressTemplates::Components::Configurable
-    include ExpressTemplates::Components::Capabilities::Resourceful
-
-    attr_accessor :virtual_path, :config
-
-    def initialize(virtual_path, config = {})
-      @virtual_path = virtual_path
-      @config = config
-      @args = [self]
-    end
-
-    def template_virtual_path
-      @virtual_path
-    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/configurable_test.rb

@@ -1,140 +0,0 @@
-require 'test_helper'
-
-class ConfigurableTest < ActiveSupport::TestCase
-
-  class Context
-    def assigns
-      {}
-    end
-  end
-
-  def render(&block)
-    ExpressTemplates.render(Context.new, &block)
-  end
-
-  ETCC = ExpressTemplates::Components::Configurable
-
-  class ConfigurableComponent < ETCC
-  end
-
-  test "renders first argument as dom id" do
-    assert_match /id="foo"/, render { configurable_component(:foo) }
-  end
-
-  test "has no id attribute if not specified" do
-    assert_no_match /id="foo"/, render { configurable_component }
-  end
-
-  class ConfigWithOption < ETCC
-    has_option :thing, 'Something about things'
-  end
-
-  test "supports option declaration" do
-    markup = render { config_with_option }
-    assert_equal %Q(<div class="config-with-option"></div>\n), markup
-  end
-
-  test "does not pass declared options as html attributes" do
-    markup = render { config_with_option(thing: 'whatever') }
-    assert_equal %Q(<div class="config-with-option"></div>\n), markup
-  end
-
-  test "unrecognized options raises an exception" do
-    assert_raises(ArgumentError) do
-      class ConfigWithUnrecognizedOptions < ETCC
-        has_option :title, 'asdfasdf', something_unrecognized: 'whatever'
-      end
-    end
-  end
-
-  class ConfigWithDefaultOption < ETCC
-    has_option :rows, 'Number of rows', type: :integer, default: 5, attribute: true
-  end
-
-  test "default values are supported" do
-    markup = render { config_with_default_option }
-    assert_equal %Q(<div class="config-with-default-option" rows="5"></div>\n), markup
-  end
-
-  test "default values for attributes can be overridden" do
-    markup = render { config_with_default_option(rows: 999) }
-    assert_equal %Q(<div class="config-with-default-option" rows="999"></div>\n), markup
-  end
-
-  class ConfigWithRequiredOptions < ETCC
-    has_option :title, 'adds a title', required: true
-  end
-
-  test "required options are required" do
-    assert_raises(RuntimeError) do
-      render { config_with_required_options }
-    end
-    assert render { config_with_required_options(title: 'foo') }
-  end
-
-  class ConfigWithOptionValues < ETCC
-    has_option :virtual, 'gets the virtual_attributes of a resource', values: -> (*) { resource_class.virtual_attributes }
-
-    def resource_class
-      OpenStruct.new(virtual_attributes: [:password, :password_confirmation])
-    end
-  end
-
-  test "values can be set for options" do
-    component = ConfigWithOptionValues.new
-    assert_equal [:password, :password_confirmation], component.instance_eval(&ConfigWithOptionValues.new.supported_options[:virtual][:values])
-  end
-
-  class ConfigSubclass < ConfigWithRequiredOptions
-    has_option :status, 'something'
-  end
-
-  test "options are inherited" do
-    assert_equal [:title, :status], ConfigSubclass.supported_options.keys
-  end
-
-  class ConfigArgument < ETCC
-    has_argument :name, "The name.", type: :string
-
-    has_option :something, "else"
-
-    contains {
-      text_node config[:name]
-    }
-  end
-
-  test ".has_argument adds a positional configuration argument" do
-    assert_equal :name, ConfigArgument.new.supported_arguments.keys.last
-    assert_equal "The name.", ConfigArgument.new.supported_arguments.values.last[:description]
-  end
-
-  test ".has_argument makes builder arguments accessible by name according to position" do
-    html = render &-> {
-      config_argument :bar, 'Foo'
-    }
-    assert_match />Foo</, html
-  end
-
-  class ConfigAnotherArgument < ConfigArgument
-    has_argument :title, "comes after name", type: :string
-  end
-
-  test ".has_argument appends supported arguments in order of inheritence" do
-    assert_equal [:id, :name, :title], ConfigAnotherArgument.new.supported_arguments.keys
-  end
-
-  class ConfigOverwriteId < ConfigArgument
-    has_argument :id, 'Should overwrite :id',
-                      as: :foo, type: :symbol
-    contains -> {
-      text_node config[:foo]
-    }
-  end
-
-  test ".has_argument as: allows overwrite of inherited argument" do
-    html = render {
-      config_overwrite_id(:whatever, 'Ignore me')
-    }
-    assert_match /div.*>whatever/, html
-  end
-end

data/vendor/gems/express_templates/test/components/forms/basic_fields_test.rb

@@ -1,158 +0,0 @@
-require 'test_helper'
-require 'active_model'
-
-class BasicFieldsTest < ActiveSupport::TestCase
-
-  BASIC_FIELDS = %w(email phone text password color file date datetime
-                    datetime_local number range
-                    search telephone time url week)
-
-  def assigns
-    {foo: resource}
-  end
-
-  def helpers
-    mock_action_view do
-      def foos_path
-        '/foos'
-      end
-    end
-  end
-
-  def field_type_map
-    Hash[BASIC_FIELDS.map {|f| [f, f]}].merge(
-      {'phone'          => 'tel',
-       'telephone'          => 'tel',
-       'datetime_local' => 'datetime-local' })
-  end
-
-  def label_html
-    '<label for="foo_bar">Bar</label>'
-  end
-
-  test "all fields work" do
-    BASIC_FIELDS.each do |type|
-      fragment = -> (ctx) {
-        express_form(:foo) {
-          send(type, :bar)
-        }
-      }
-      html = arbre(&fragment)
-      assert_match label_html, html
-      assert_match(/input.*type="#{field_type_map[type]}"/, html)
-      # assert_match "#{type}_field(:foo, :bar, {})", arbre(&fragment)
-    end
-  end
-
-  test "passing html options to fields work" do
-    options = {style: 'width: 10em;'}
-    ['email'].each do |type|
-      html = arbre {
-        express_form(:foo) {
-          send(type, :bar, options)
-        }
-      }
-      assert_match label_html, html
-      assert_match /input.*type="#{field_type_map[type]}"/, html
-      assert_match /input.*style="width: 10em;"/, html
-    end
-  end
-
-  test "textarea uses rails text_area helper" do
-    html = arbre {
-      express_form(:foo) {
-        textarea :bar
-      }
-    }
-    assert_match label_html, html
-    assert_match /<textarea name="foo\[bar\]" id="foo_bar"><\/textarea>/, html.gsub("\n", '')
-  end
-
-  test "textarea passes additional html options to rails helper" do
-    html = arbre {
-      express_form(:foo) {
-        textarea :bar, rows: 5, class: 'tinymce form-field'
-      }
-    }
-    assert_match label_html, html
-    assert_match /<textarea name="foo\[bar\]" id="foo_bar" rows="5" class="tinymce form-field"><\/textarea>/, html.gsub("\n", '')
-  end
-
-  test "hidden uses rails hidden_tag helper" do
-    html = arbre {
-      express_form(:foo) {
-        hidden :bar
-      }
-    }
-    assert_no_match label_html, html
-    assert_match '<input type="hidden"', html
-  end
-
-  test "hidden field passes additional html options to rails helper" do
-    html = arbre {
-      express_form(:foo) {
-        hidden :bar, class: 'hidden form-field', value: 'ninja'
-      }
-    }
-    assert_no_match label_html, html
-    assert_match /<input type="hidden" name="foo\[bar\]" id="foo_bar" value="ninja" class="hidden form-field"/, html
-  end
-
-  def resource_with_errors
-    mock_resource = resource
-    class << mock_resource
-      def errors
-        errors = ActiveModel::Errors.new(self)
-        errors.add(:name, "Can't be Foo")
-        errors
-      end
-    end
-    mock_resource
-  end
-
-  def has_error_class
-    /div[^>]*class="[^"]*error[^"]*"/
-  end
-
-  def has_error_class_on(field, html)
-    md = html.match(/(<div[^>]*id="[^"]*#{field}_wrapper[^"]*"[^>]*>)/)
-    assert md, "field has no wrapper"
-    return !!md[1].match(has_error_class)
-  end
-
-  test "adds error class if there are errors on a field with no input attributes" do
-    html_with_error = arbre(foo: resource_with_errors) {
-      express_form(:foo) {
-       text :name
-       text :body
-      }
-    }
-    assert resource_with_errors.errors.any?
-    assert assigns[:foo].errors.any?
-    assert has_error_class_on(:name, html_with_error), "name field has no error when expected"
-    refute has_error_class_on(:body, html_with_error), "body field has error class when it should not"
-  end
-
-    test "adds error class if there are errors on a field with no class set" do
-    html_with_error = arbre(foo: resource_with_errors) {
-      express_form(:foo) {
-       text :name, value: 'ninja'
-      }
-    }
-    assert resource_with_errors.errors.any?
-    assert assigns[:foo].errors.any?
-    assert_match has_error_class, html_with_error
-  end
-
-    test "adds error to class if there are errors on a field with existing class" do
-    html_with_error = arbre(foo: resource_with_errors) {
-      express_form(:foo) {
-       text :name, value: 'ninja', class: 'slug'
-      }
-    }
-    assert resource_with_errors.errors.any?
-    assert assigns[:foo].errors.any?
-    assert_match has_error_class, html_with_error
-  end
-
-end

data/vendor/gems/express_templates/test/components/forms/checkbox_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-class Account
-end
-
-class CheckboxTest < ActiveSupport::TestCase
-
-  def assigns
-    {account: resource}
-  end
-
-  def helpers
-    mock_action_view do
-      def accounts_path
-        '/accounts'
-      end
-    end
-  end
-
-
-  test "checkbox places the label before the input" do
-    html = arbre(account: resource) {
-      express_form(:account) {
-        checkbox :eula
-      }
-    }
-    label = '<label for="account_eula"'
-    field = 'input type="checkbox" value="1" name="account\[eula\]"'
-    assert_match /#{label}/, html
-    assert_match /#{field}/, html
-    label_idx = html.index(label)
-    field_idx = html.index(field.gsub('\\', ''))
-    assert (field_idx > label_idx), "label must come first"
-  end
-
-  test "checkbox respects label_after: true " do
-    html = arbre(account: resource) {
-      express_form(:account) {
-        checkbox :eula, label_after: true
-      }
-    }
-    label = '<label for="account_eula"'
-    field = 'input type="checkbox" value="1" name="account\[eula\]"'
-    assert_match /#{label}/, html
-    assert_match /#{field}/, html
-    label_idx = html.index(label)
-    field_idx = html.index(field.gsub('\\', ''))
-    assert (field_idx < label_idx), "label must come after when label_after: true"
-  end
-
-end

data/vendor/gems/express_templates/test/components/forms/express_form_test.rb

@@ -1,62 +0,0 @@
-require 'test_helper'
-
-  class Foo
-    def self.columns ; [] ; end
-  end
-
-class ExpressFormTest < ActiveSupport::TestCase
-
-  def simplest_form
-    arbre(foo: resource) {
-      express_form(:foo) {
-        submit value: 'Save it!'
-      }
-    }
-  end
-
-  def helpers
-    mock_action_view do
-      def foos_path
-        '/foos'
-      end
-    end
-  end
-
-  test "simplest form renders" do
-    assert simplest_form
-  end
-
-  test "simplest form will have the proper id" do
-    assert_match /<form.*id="foo_1"/, simplest_form
-  end
-
-  test "simplest form contains form tag" do
-    assert_match "<form", simplest_form
-  end
-
-  test "express_form contents are inside the form" do
-    assert_match /<form.*submit.*\/form>/, simplest_form.gsub("\n",'')
-  end
-
-  test "simplest form contains rails form helpers" do
-    compiled_src = simplest_form
-    assert_match "input name=\"utf8\" type=\"hidden\"", compiled_src
-    assert_match "input type=\"hidden\" name=\"_method\"", compiled_src
-    assert_match "name=\"authenticity_token\" value=\"AUTH_TOKEN\"", compiled_src
-    assert_match /<form.*authenticity_token.*\/form>/, compiled_src.gsub("\n",'')
-  end
-
-  test "simplest_form contains submit" do
-    assert_match '<input type="submit" name="commit" value="Save it!" />', simplest_form
-  end
-
-  test "simplest_form uses form_action for the action" do
-    form_open_tag = simplest_form.match(/<form[^>]*>/)[0]
-    assert_match 'action="/foos"', form_open_tag
-  end
-
-  test "express_form default method is POST" do
-    assert_match 'method="POST"', simplest_form
-  end
-
-end

data/vendor/gems/express_templates/test/components/forms/radio_test.rb

@@ -1,112 +0,0 @@
-require 'test_helper'
-
-class RadioTest < ActiveSupport::TestCase
-
-  def assigns
-    {person: ::Person.new}
-  end
-
-  def helpers
-    mock_action_view do
-      def people_path
-        '/people'
-      end
-
-      def employees_path
-        '/employees'
-      end
-    end
-  end
-
-  test "radio requires a parent component" do
-    assert_raises(RuntimeError) {
-      html = arbre {
-        radio :preferred_email_format, options: ['HTML', 'Text']
-      }
-    }
-  end
-
-  def radio_with_array_options
-    html = arbre {
-      express_form(:person) {
-        radio :preferred_email_format, options: ['HTML', 'Text']
-      }
-    }
-  end
-
-  test "radio has correct label field name and text" do
-    assert_match /<label for="person_preferred_email_format"/,
-                  radio_with_array_options
-  end
-
-  test "radio options present with class 'radio'" do
-    assert_match /<input.*class="radio"/,
-                 radio_with_array_options
-  end
-
-  def radio_with_hash_options
-    html = arbre {
-      express_form(:person) {
-        radio :subscribed, options: {1 => 'Yes', 0 => 'No'}, label_wrapper_class: 'my-wrapper'
-      }
-    }
-  end
-
-  test "radio options may be specified with a hash" do
-    compiled = radio_with_hash_options
-    assert_match '<label class="my-wrapper">', compiled
-    assert_match 'input class="radio" type="radio" value="0" name="person[subscribed]" id="person_subscribed_0" />No', compiled
-    assert_match 'input class="radio" type="radio" value="1" name="person[subscribed]" id="person_subscribed_1" />Yes', compiled
-  end
-
-  test "radio throws error if given improper options" do
-    assert_raises(RuntimeError) {
-      html = arbre {
-        express_form(:person) {
-          radio :subscribed, "Garbage options"
-        }
-      }
-    }
-  end
-
-  def radio_with_options_omitted
-    html = arbre(employee: resource) {
-      express_form(:employee) {
-        radio :department_id
-      }
-    }
-  end
-
-  class ::Department < ::Gender
-    def self.order(*)
-      all
-    end
-    def self.all
-      return [new(1, 'Accounting'), new(2, 'Marketing')]
-    end
-  end
-  class ::Employee
-    def self.reflect_on_association(name)
-      if name.eql? :department
-        dummy_association = Object.new
-        class << dummy_association
-          def macro ; :belongs_to ; end
-          def klass ; ::Department ; end
-          def polymorphic? ; false ; end
-        end
-        return dummy_association
-      end
-    end
-  end
-
-  test "radio options from collection when options omitted" do
-    assert_match /input type="radio" value="1" name="employee\[department_id\]" id="employee_department_id_1"/,
-                  radio_with_options_omitted
-  end
-
-  # test "radio supports html options"
-
-  # test "html_options passed correctly when collection is omitted"
-
-  # test "radio helper options passed to collection_radio_buttons"
-end