express_templates 0.3.6 → 0.4.0

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

@@ -0,0 +1,61 @@
+module ExpressTemplates
+  module Components
+    module Forms
+      # Provides a form Select component based on the Rails *select_tag* helper.
+      # Parameters:
+      # field_name, select_options, helper_options
+      #
+      # Select options may be specified as an Array or Hash which will be
+      # supplied to the *options_for_select* helper.
+      #
+      # If the select_options are omitted, the component attempts to check
+      # whether the field is an association.  If an association exists,
+      # the options will be generated using *options_from_collection_for_select*
+      # with the assumption that :id and :name are the value and name fields
+      # on the collection.  If no association exists, we use all the existing
+      # unique values for the field on the collection to which the resource belongs
+      # as the list of possible values for the select.
+      class Select < FormComponent
+        include OptionSupport
+
+        emits -> {
+          div(class: field_wrapper_class) {
+            label_tag(label_name, label_text)
+            select_tag(field_name_attribute, select_options, field_options)
+          }
+        }
+
+        # Returns the options which will be supplied to the select_tag helper.
+        def select_options
+          options_specified = [Array, Hash].include?(@args.second.class)
+          if options_specified
+            options = @args.second
+          else
+            options = "@#{resource_name}.pluck(:#{field_name}).distinct"
+          end
+
+          if belongs_to_association && !options_specified
+            "{{options_from_collection_for_select(#{related_collection}, :id, :name, @#{resource_name}.#{field_name})}}"
+          else
+            if selection = field_options.delete(:selected)
+              "{{options_for_select(#{options}, \"#{selection}\")}}"
+            else
+              "{{options_for_select(#{options}, @#{resource_name}.#{field_name})}}"
+            end
+          end
+        end
+
+        def field_options
+          # If field_otions is omitted the Expander will be
+          # in last or 3rd position and we don't want that
+          if @args.size > 3 && @args[2].is_a?(Hash)
+            @args[2]
+          else
+            {}
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ExpressTemplates
+  module Components
+    module Forms
+      class Submit < FormComponent
+
+        emits -> {
+          div(class: field_wrapper_class) {
+            submit_tag(value, html_options)
+          }
+        }
+
+        def value
+          if @args.first.is_a?(String)
+            @args.first
+          else
+            'Save'
+          end
+        end
+
+        def html_options
+          @config
+        end
+      end
+    end
+  end
+end

data/lib/express_templates/components/null_wrap.rb

@@ -1,8 +1,40 @@
 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
-        compile_children
+        @already_compiled_stuff || compile_children
       end
     end
   end

data/lib/express_templates/expander.rb

@@ -76,6 +76,7 @@ module ExpressTemplates
     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)

data/lib/express_templates/version.rb

@@ -1,3 +1,3 @@
 module ExpressTemplates
-  VERSION = "0.3.6"
+  VERSION = "0.4.0"
 end

data/test/components/container_test.rb

@@ -22,6 +22,8 @@ class ContainerTest < ActiveSupport::TestCase
     child1, child2 = Minitest::Mock.new, Minitest::Mock.new
     child1.expect(:compile, '"one"')
     child2.expect(:compile, '"two"')
+    child1.expect(:kind_of?, false, [ExpressTemplates::Components::Capabilities::Adoptable])
+    child2.expect(:kind_of?, false, [ExpressTemplates::Components::Capabilities::Adoptable])
     return child1, child2
   end
 

data/test/components/forms/basic_fields_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class BasicFieldsTest < ActiveSupport::TestCase
+
+  BASIC_FIELDS = %w(email phone text password color date datetime
+                    datetime_local number range
+                    search telephone time url week)
+
+  test "text requires parent" do
+    fragment = -> {
+      text :name
+    }
+    assert_raises(RuntimeError) {
+      ExpressTemplates.compile(&fragment)
+    }
+  end
+
+  test "all fields work" do
+    BASIC_FIELDS.each do |type|
+      fragment = -> {
+        express_form(:foo) {
+          send(type, :bar)
+        }
+      }
+      assert_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
+      assert_match "#{type}_field(:foo, :bar)", ExpressTemplates.compile(&fragment)
+    end
+  end
+
+  test "textarea uses rails text_area helper" do
+    fragment = -> {
+      express_form(:foo) {
+        textarea :bar
+      }
+    }
+    assert_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
+    assert_match "text_area(:foo, :bar)", ExpressTemplates.compile(&fragment)
+  end
+
+
+  test "hidden uses rails hidden_tag helper" do
+    fragment = -> {
+      express_form(:foo) {
+        hidden :bar
+      }
+    }
+    assert_no_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
+    assert_match "hidden_field(:foo, :bar)", ExpressTemplates.compile(&fragment)
+  end
+
+end
+

data/test/components/forms/checkbox_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class CheckboxTest < ActiveSupport::TestCase
+
+  test "Checkbox requires a parent form" do
+    fragment = -> {
+      checkbox :permission_granted
+    }
+    assert_raises(RuntimeError) {
+      ExpressTemplates.compile(&fragment)
+    }
+  end
+
+  test "checkbox places the label before the input" do
+    fragment = -> {
+      express_form(:account) {
+        checkbox :eula
+      }
+    }
+    compiled = ExpressTemplates.compile(&fragment)
+    label_helper = '#{label_tag("account_eula", "Eula")}'
+    field_helper = '#{check_box(:account, :eula, {}, "1", "0")}'
+    assert_match label_helper, compiled
+    assert_match field_helper, compiled
+    label_idx = compiled.index(label_helper)
+    field_idx = compiled.index(field_helper)
+    assert (field_idx > label_idx), "label must come first"
+  end
+
+  test "checkbox respects label_after: true " do
+    fragment = -> {
+      express_form(:account) {
+        checkbox :eula, label_after: true
+      }
+    }
+    compiled = ExpressTemplates.compile(&fragment)
+    label_helper = '#{label_tag("account_eula", "Eula")}'
+    field_helper = '#{check_box(:account, :eula, {}, "1", "0")}'
+    label_idx = compiled.index(label_helper)
+    field_idx = compiled.index(field_helper)
+    assert (field_idx < label_idx), "label must come after when label_after: true"
+  end
+
+end

data/test/components/forms/express_form_test.rb

@@ -0,0 +1,120 @@
+require 'test_helper'
+require 'ostruct'
+
+class ExpressFormTest < ActiveSupport::TestCase
+  class Context
+    def initialize(resource)
+      @resource = resource
+    end
+  end
+
+  def resource
+    OpenStruct.new(
+      id: 1,
+      name: 'Foo',
+      body: 'Hello world',
+      email: 'some@email.com',
+      phone: '123123123',
+      url: 'http://someurl.com',
+      number: 123,
+      dropdown: 'yes',
+      gender: 'Male'
+    )
+  end
+
+  def simplest_form(resource)
+    ctx = Context.new(resource)
+    fragment = -> {
+      express_form(:resource) {
+        submit value: 'Save it!'
+      }
+    }
+    return ctx, fragment
+  end
+
+  def express_form
+    "ExpressTemplates::Components::Forms::ExpressForm".constantize
+  end
+
+  test "express_form component exists" do
+    assert express_form
+  end
+
+  def compile_simplest_form
+    ctx, fragment = simplest_form(resource)
+    ExpressTemplates.compile(&fragment)
+  end
+
+  test "simplest form renders" do
+    assert compile_simplest_form
+  end
+
+  test "simplest form contains form tag" do
+    assert_match "<form", compile_simplest_form
+  end
+
+  test "simplest form contains rails form helpers" do
+    compiled_src = compile_simplest_form
+    assert_match "utf8_enforcer_tag", compiled_src
+    assert_match "method_tag(", compiled_src
+    assert_match "token_tag", compiled_src
+  end
+
+  test "simplest_form contains submit" do
+    assert_match 'submit_tag', compile_simplest_form
+  end
+
+  test "simplest_form adopts children (submit has reference to parent)" do
+    ctx, fragment = simplest_form(resource)
+    expanded_nodes = ExpressTemplates::Expander.new(nil).expand(fragment.source_body)
+    assert_instance_of ExpressTemplates::Components::Forms::ExpressForm,
+                       expanded_nodes.first.children.last.parent
+  end
+
+  test "#form_action uses url helpers" do
+    assert_equal "{{foos_path}}", express_form.new(:foo).form_action
+  end
+
+  test "#form_action uses correct path helper for update/patch" do
+    assert_equal "{{foo_path(@foo)}}", express_form.new(:foo, method: :put).form_action
+  end
+
+  test "simplest_form uses form_action for the action" do
+    form_open_tag = compile_simplest_form.match(/<form[^>]*>/)[0]
+    assert_match 'action=\"#{resources_path}\"', form_open_tag
+  end
+
+  test "express_form default method is POST" do
+    form_open_tag = compile_simplest_form.match(/<form[^>]*>/)[0]
+    assert_match 'method=\"POST\"', form_open_tag
+  end
+
+  test "express_form accepts :resource_name for removing namespace" do
+    fragment = -> {
+      express_form(:admin_foo, resource_name: 'foo') {
+        submit "Save!"
+      }
+    }
+    expanded_nodes = ExpressTemplates::Expander.new(nil).expand(fragment.source_body)
+    assert_equal 'foo', expanded_nodes.first.resource_name
+  end
+
+
+#   test "simplest form compiled source is legible " do
+#     @example_compiled = -> {
+# "<form action=\"/resources/#{@resource.id}\" method=\"post\">
+#   <div style=\"display:none\">
+# "+%Q(#{utf8_enforcer_tag})+%Q(#{method_tag(:post)})+%Q(#{token_tag})+"
+#   </div>
+#   <div class=\"form-group widget-buttons\">
+# "+%Q(#{submit_tag("Save it!", class: "submit primary")})+"</div>
+# </form>
+# "
+#     }.source_body
+#     ExpressTemplates::Markup::Tag.formatted do
+#       ctx, fragment = simplest_form(resource)
+#       assert_equal @example_compiled, ExpressTemplates.compile(&fragment)
+#     end
+#   end
+
+end

data/test/components/forms/radio_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+class RadioTest < ActiveSupport::TestCase
+
+  test "radio requires a parent component" do
+    fragment = -> {
+      radio :preferred_email_format, ['HTML', 'Text']
+    }
+    assert_raises(RuntimeError) {
+      ExpressTemplates.compile(&fragment)
+    }
+  end
+
+  def radio_with_array_options
+    fragment = -> {
+      express_form(:person) {
+        radio :preferred_email_format, ['HTML', 'Text']
+      }
+    }
+  end
+
+  test "radio has correct label field name and text" do
+    assert_match '#{label_tag("person_preferred_email_format", "Preferred Email Format")}',
+                  ExpressTemplates.compile(&radio_with_array_options)
+  end
+
+  test "radio options present with class 'radio'" do
+    compiled = ExpressTemplates.compile(&radio_with_array_options)
+    assert_match 'radio_button(:person, :preferred_email_format, "Text", class: "radio"', compiled
+    assert_match '_format, "HTML", class: "radio"', compiled
+  end
+
+  def radio_with_hash_options
+    fragment = -> {
+      express_form(:person) {
+        radio :subscribed, {1 => 'Yes', 0 => 'No'}, wrapper_class: 'my-wrapper'
+      }
+    }
+  end
+
+  test "radio options may be specified with a hash" do
+    compiled = ExpressTemplates.compile(&radio_with_hash_options)
+    assert_match '<label class=\"my-wrapper\">', compiled
+    assert_match 'radio_button(:person, :subscribed, 0, class: "radio"', compiled
+    assert_match 'radio_button(:person, :subscribed, 1, class: "radio"', compiled
+  end
+
+  test "radio throws error if given improper options" do
+    fragment = -> {
+      express_form(:person) {
+        radio :subscribed, "Garbage options"
+      }
+    }
+    assert_raises(RuntimeError) {
+      ExpressTemplates.compile(&fragment)
+    }
+  end
+
+  def radio_with_options_omitted
+    fragment = -> {
+      express_form(:employee) {
+        radio :department_id
+      }
+    }
+  end
+
+  class ::Department ; end
+  class ::Employee
+    def self.reflect_on_association(field)
+      if field.eql? :department_id
+        dummy_association = Object.new
+        class << dummy_association
+          def macro ; :belongs_to ; end
+          def klass ; ::Department ; end
+        end
+        return dummy_association
+      end
+    end
+  end
+
+  test "radio options from collection when options omitted" do
+    assert_match 'collection_radio_buttons(:employee, :department_id, Department.all.select(:id, :name).order(:name), :id, :name, {}, {}',
+                  ExpressTemplates.compile(&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