express_templates 0.5.0 → 0.7.0

data/test/components/forms/checkbox_test.rb

@@ -1,43 +1,37 @@
 require 'test_helper'
 
 class CheckboxTest < ActiveSupport::TestCase
-
-  test "Checkbox requires a parent form" do
-    fragment = -> {
-      checkbox :permission_granted
-    }
-    assert_raises(RuntimeError) {
-      ExpressTemplates.compile(&fragment)
-    }
+  def assigns
+    {resource: resource}
   end
 
   test "checkbox places the label before the input" do
-    fragment = -> {
+    html = arbre {
       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)
+    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
-    fragment = -> {
+    html = arbre {
       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)
+    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
 

data/test/components/forms/express_form_test.rb

@@ -1,108 +1,55 @@
 require 'test_helper'
 require 'ostruct'
 
-class ExpressFormTest < ActiveSupport::TestCase
-  class Context
-    def initialize(resource)
-      @resource = resource
-    end
+  class Foo
+    def self.columns ; [] ; 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'
-    )
+class ExpressFormTest < ActiveSupport::TestCase
+
+  def assigns
+    {resource: resource}
   end
 
-  def simplest_form(resource)
-    ctx = Context.new(resource)
-    fragment = -> {
+  def simplest_form
+    arbre {
       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
+    assert 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
+    assert_match "<form", 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
+  test "express_form contents are inside the form" do
+    assert_match /<form.*submit.*\/form>/, simplest_form.gsub("\n",'')
   end
 
-  test "#form_action uses url helpers" do
-    assert_equal "{{@foo.try(:persisted?) ? foo_path(@foo) : foos_path}}", express_form.new(:foo).form_action
+  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 "#form_action uses correct path helper for update/patch" do
-    assert_equal "{{@foo.try(:persisted?) ? foo_path(@foo) : foos_path}}", express_form.new(:foo, method: :put).form_action
+  test "simplest_form contains submit" do
+    assert_match '<input type="submit" name="commit" value="Save" />', simplest_form
   end
 
   test "simplest_form uses form_action for the action" do
-    form_open_tag = compile_simplest_form.match(/<form[^>]*>/)[0]
-    assert_match 'action=\"#{@resource.try(:persisted?) ? resource_path(@resource) : resources_path}\"', form_open_tag
+    form_open_tag = simplest_form.match(/<form[^>]*>/)[0]
+    assert_match 'action="/resources"', 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
+    assert_match 'method="POST"', simplest_form
   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 "express_form has a namespace option with nil default" do
-  #   form = ExpressTemplates::Components::Forms::ExpressForm
-  #   assert_nil form.new(:person).namespace
-  #   assert_equal 'express_engine', form.new(:person, namespace: 'express_engine').namespace
-  # end
-
 end

data/test/components/forms/radio_test.rb

@@ -2,17 +2,20 @@ require 'test_helper'
 
 class RadioTest < ActiveSupport::TestCase
 
+  def assigns
+    {resource: resource}
+  end
+
   test "radio requires a parent component" do
-    fragment = -> {
-      radio :preferred_email_format, ['HTML', 'Text']
-    }
     assert_raises(RuntimeError) {
-      ExpressTemplates.compile(&fragment)
+      html = arbre {
+        radio :preferred_email_format, ['HTML', 'Text']
+      }
     }
   end
 
   def radio_with_array_options
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
         radio :preferred_email_format, ['HTML', 'Text']
       }
@@ -20,18 +23,17 @@ class RadioTest < ActiveSupport::TestCase
   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)
+    assert_match /<label for="person_preferred_email_format"/,
+                  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
+    assert_match /<input.*class="radio"/,
+                 radio_with_array_options
   end
 
   def radio_with_hash_options
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
         radio :subscribed, {1 => 'Yes', 0 => 'No'}, wrapper_class: 'my-wrapper'
       }
@@ -39,34 +41,36 @@ class RadioTest < ActiveSupport::TestCase
   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
+    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
-    fragment = -> {
-      express_form(:person) {
-        radio :subscribed, "Garbage options"
-      }
-    }
     assert_raises(RuntimeError) {
-      ExpressTemplates.compile(&fragment)
+      html = arbre {
+        express_form(:person) {
+          radio :subscribed, "Garbage options"
+        }
+      }
     }
   end
 
   def radio_with_options_omitted
-    fragment = -> {
+    html = arbre {
       express_form(:employee) {
         radio :department_id
       }
     }
   end
 
-  class ::Department
-    def self.columns
-      [OpenStruct.new(name: 'id'), OpenStruct.new(name: 'name')]
+  class ::Department < ::Gender
+    def self.order(*)
+      all
+    end
+    def self.all
+      return [new(1, 'Accounting'), new(2, 'Marketing')]
     end
   end
   class ::Employee
@@ -84,8 +88,8 @@ class RadioTest < ActiveSupport::TestCase
   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)
+    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"

data/test/components/forms/select_test.rb

@@ -2,144 +2,119 @@ require 'test_helper'
 require 'ostruct'
 class SelectTest < ActiveSupport::TestCase
 
+  def assigns
+    {resource: ::Person.new}
+  end
+
+
   test "select requires a parent component" do
-    fragment = -> {
-      select :gender, ['Male', 'Female'], selected: 'Male'
-    }
     assert_raises(RuntimeError) {
-      ExpressTemplates.compile(&fragment)
+      html = arbre {
+        select :gender, options: ['Male', 'Female'], selected: 'Male'
+      }
     }
   end
 
   test "select comes with a label" do
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
         select :gender
       }
     }
-    assert_match '#{label_tag("person_gender", "Gender")}', ExpressTemplates.compile(&fragment)
+    assert_match /<label.*for="person_gender"/, html
   end
 
-  test "select uses options_for_select when values are specified" do
-    fragment = -> {
+  test "select generates correct options when values are specified" do
+    html = arbre {
       express_form(:person) {
-        select :gender, ['Male', 'Female'], selected: 'Male'
+        select :gender, options: ['Male', 'Female'], selected: 'Male'
       }
     }
-    assert_match 'options_for_select(["Male", "Female"], "Male")', ExpressTemplates.compile(&fragment)
+    assert_match /<option.*selected="selected" value="Male"/, html
+    assert_match /<option.*value="Female"/, html
   end
 
   test "selected option is omitted selection is taken from model" do
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
-        select :gender, ['Male', 'Female']
+        select :gender, options: ['Male', 'Female']
       }
     }
-    assert_match 'options_for_select(["Male", "Female"], @person.gender)', ExpressTemplates.compile(&fragment)
+    assert_match /<option.*selected="selected" value="Male"/, html
+    assert_match /<option.*value="Female"/, html
   end
 
   test "select generates options from data when options omitted" do
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
         select :city
       }
     }
-    assert_match 'options_for_select(@person.class.distinct(:city).pluck(:city), @person.city)', ExpressTemplates.compile(&fragment)
-  end
-
-  class ::Gender
-    def self.columns
-      [OpenStruct.new(name: 'id'), OpenStruct.new(name: 'name')]
-    end
-  end
-  class ::Tagging
-    def self.columns
-      [OpenStruct.new(name: 'id'), OpenStruct.new(name: 'name')]
-    end
-  end
-  class ::Person
-    def self.reflect_on_association(name)
-      if name.eql? :gender
-        dummy_belongs_to_association = Object.new
-        class << dummy_belongs_to_association
-          def macro ; :belongs_to ; end
-          def klass ; ::Gender ; end
-          def polymorphic? ; false ; end
-        end
-        return dummy_belongs_to_association
-      end
-      if name.eql? :taggings
-        dummy_has_many_through_association = Object.new
-        class << dummy_has_many_through_association
-          def macro ; :has_many ; end
-          def klass ; ::Tagging ; end
-          def options ; {:through => :peron_tags} ; end
-          def polymorphic? ; false ; end
-        end
-        return dummy_has_many_through_association
-      end
-    end
+    assert_match /<option.*selected="selected" value="San Francisco"/, html
+    assert_match /<option.*value="Hong Kong"/, html
   end
 
   test "select uses options_from_collect... when field is relation" do
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
-        select :gender
+        select :gender_id
       }
     }
 
-    assert_match 'options_from_collection_for_select(Gender.all.select(:id, :name).order(:name), :id, :name, @person.gender)',
-                  ExpressTemplates.compile(&fragment)
+    assert_match /<option.*selected="selected" value="1"/, html
+    assert_match /<option.*value="2"/, html
   end
 
   test "select defaults to include_blank: true" do
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
         select :gender
       }
     }
-    assert_match 'include_blank: true', ExpressTemplates.compile(&fragment)
+    assert_match '<option value=""></option>', html
   end
 
 
   test "select defaults can be overridden" do
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
-        select :gender, nil, include_blank: false
+        select :gender, include_blank: false
       }
     }
-    assert_no_match 'include_blank: true', ExpressTemplates.compile(&fragment)
+    assert_no_match 'include_blank: true', html
   end
 
   test "select multiple: true if passed multiple true" do
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
-        select :taggings, nil, include_blank: false, multiple: true
+        select :taggings, include_blank: false, multiple: true
       }
     }
-    assert_match 'multiple: true', ExpressTemplates.compile(&fragment)
+    assert_match 'multiple="multiple"', html
   end
 
   test "select multiple gets options from associated has_many_through collection" do
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
-        select :taggings, nil, include_blank: false, multiple: true
+        select :taggings, include_blank: false, multiple: true
       }
     }
-    assert_match 'tagging_ids', ExpressTemplates.compile(&fragment)
-    assert_match 'options_from_collection_for_select(Tagging.all.select(:id, :name).order(:name), :id, :name, @person.taggings.map(&:id))',
-                 ExpressTemplates.compile(&fragment)
+    assert_match 'tagging_ids', html
+    assert_match /<option selected="selected" value="1">Friend<\/option>/, html
+    assert_match /<option selected="selected" value="2">Enemy<\/option>/, html
+    assert_match /<option value="3">Frenemy<\/option>/, html
   end
 
-  test "select_collection uses collection_select" do
-    fragment = -> {
+  test "select_collection works using collection_select" do
+    html = arbre {
       express_form(:person) {
         select_collection :taggings
       }
     }
-    assert_match 'tagging_ids', ExpressTemplates.compile(&fragment)
-    assert_match 'collection_select("person", "tagging_ids", Tagging.all.select(:id, :name).order(:name), :id, :name, {:include_blank=>false, :selected=>@person.tagging_ids}, multiple: true)',
-                 ExpressTemplates.compile(&fragment)
+    assert_match 'tagging_ids', html
+    assert_match /<option value="1">Friend<\/option>/, html
+    assert_match /<option value="2">Enemy<\/option>/, html
+    assert_match /<option value="3">Frenemy<\/option>/, html
   end
 
 

data/test/components/forms/submit_test.rb

@@ -1,12 +1,17 @@
 require 'test_helper'
 
+class Stuff
+  def self.columns
+    []
+  end
+end
+
 class SubmitTest < ActiveSupport::TestCase
   test "submit takes string param for value" do
-    fragment = -> {
-      express_form(:stuff) {
-        submit "Save it!"
-      }
+    fragment = -> (ctx) {
+      submit "Save it!"
     }
-    assert_match '#{submit_tag("Save it!", {})}', ExpressTemplates.compile(&fragment)
+    assert_match '<div class="field-wrapper"><input type="submit" name="commit" value="Save it!" /></div>', 
+                 arbre(&fragment)
   end
 end

data/test/components/tree_for_test.rb

@@ -24,43 +24,16 @@ class TreeForTest < ActiveSupport::TestCase
              Role.new('Auditor')])])]
   end
 
-  EXAMPLE_COMPILED = -> {
-ExpressTemplates::Components::TreeFor.render_in(self) {
-  node_renderer = -> (role, renderer) {
-    ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
-      "#{wsnl}<li>"+
-     "#{role.name}"+
-      if role.children.any?
-        ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
-          "#{wsnl}<ul>" +
-            role.children.map do |child|
-              renderer.call(child, renderer)
-            end.join +
-          "#{wsnl}</ul>"
-        end +
-        "#{wsnl}</li>"
-      else
-        "</li>"
-      end
-    end
-  }
-  ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
-    "#{ws}<ul id=\"roles\" class=\"roles tree\">" +
-      @roles.map do |role|
-        node_renderer.call(role, node_renderer)
-      end.join +
-    "#{wsnl}</ul>\n"
-  end
-}
-}
-
   EXAMPLE_MARKUP = <<-HTML
 <ul id="roles" class="roles tree">
-  <li>SuperAdmin
+  <li>
+SuperAdmin
     <ul>
-      <li>Admin
+      <li>
+Admin
         <ul>
-          <li>Publisher
+          <li>
+Publisher
             <ul>
               <li>Author</li>
             </ul>
@@ -73,31 +46,30 @@ ExpressTemplates::Components::TreeFor.render_in(self) {
 </ul>
 HTML
 
-  def simple_tree_for(roles)
-    ctx = Context.new(roles)
-    fragment = -> {
-                    tree_for(:roles) {
-                      "{{role.name}}"
-                    }
-                  }
-    return ctx, fragment
+  def assigns
+    {roles: roles}
   end
 
+  def simple_tree_for
+    arbre {
+      tree_for(:roles)
+    }.to_s
+  end
 
-  test "example view code renders example markup" do
-    assert_equal EXAMPLE_MARKUP, Context.new(roles).instance_eval(EXAMPLE_COMPILED.source_body)
+  test "tree_for renders correct markup with node.name as default" do
+    assert_equal EXAMPLE_MARKUP, simple_tree_for
   end
 
-  test "compiled source is legible and transparent" do
-    ctx, fragment = simple_tree_for(roles)
-    assert_equal EXAMPLE_COMPILED.source_body, ExpressTemplates.compile(&fragment)
+  def custom_tree_for
+    arbre {
+      tree_for(:roles) { |node|
+        text_node node.name.upcase
+      }
+    }
   end
 
-  test "rendered component matches desired markup" do
-    ExpressTemplates::Markup::Tag.formatted do
-      ctx, fragment = simple_tree_for(roles)
-      assert_equal EXAMPLE_MARKUP, ExpressTemplates.render(ctx, &fragment)
-    end
+  test "tree_for accepts block with custom content" do
+    assert_match 'AUTHOR', custom_tree_for
   end
 
-end
+end

data/test/dummy/app/views/hello/show.html.et

@@ -1,5 +1,6 @@
-
 content_for :title, "Dummy Show"
 
-h1 '{{@hello}}'
-p 'Find me in app/views/hello/show.html.express_templates'
+div {
+  h1 "#{hello}"
+  p 'Find me in app/views/hello/show.html.express_templates'
+}

data/test/dummy/app/views/layouts/application.html.et

@@ -10,6 +10,6 @@ html(lang: "en") {
   }
   body {
     yield
-    javascript_include_tag "application"
   }
+  javascript_include_tag "application"
 }