express_templates 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30791598c725b41c362d6f436e51342db19abea2
-  data.tar.gz: 139fc021df9d57161f27240a020826f203aebc40
+  metadata.gz: 7e3c4b0da15f9c3a8e15afd1cd406974c6a77830
+  data.tar.gz: 4fcaadfa00a739490b71b7a9539778aa3a7019e8
 SHA512:
-  metadata.gz: 4889d57691fbb9a2f787381e42f89bcba50dd084381721003520e2aed39a11514befe3899587ffcab4192f7f2e333f39277681c30ee9c7cdd998c19dea4913d4
-  data.tar.gz: 6d4623073cf1f498a4d542637f8a54331cfe7fda2088e33cf9cf05907835875175751a7a19e71adc9965f18f604b5cd450e753d6b4e2824fe5e810bdcea46717
+  metadata.gz: 4ad45dd634f82597ad578c21047556a4770ad76f05b7b92e344fbbde27993dc69a7ff1d53dd3c0c116e9dadc0f444633ea6dc325cf1a7cbcb596179946bea615
+  data.tar.gz: 1a67f14a59f8eac2b61a840376c0ff2ab1607a2e41533c6fa1543c5caa1ce7811a3d2d0b7b4ca3a66b745d8d38e2cfd99efafbf94d78a056284b187b163ea72b

data/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/lib/express_templates/components/capabilities/resourceful.rb

@@ -0,0 +1,135 @@
+module ExpressTemplates
+  module Components
+    module Capabilities
+
+      module Resourceful
+        def namespace
+          @config[:namespace] || infer_namespace
+        end
+
+        def path_prefix
+          @config[:path_prefix] || infer_path_prefix
+        end
+
+        def resource_class
+          resource_class = @config[:resource_class] || _namespaced_resource_class
+          resource_class.constantize
+        end
+
+        private
+
+        def _namespaced_resource_class
+          if namespace
+            "#{namespace}/#{resource_name}".classify
+          else
+            resource_name.classify
+          end
+        end
+
+        def infer_namespace
+          expander = @args.last
+          if expander.try(:template)
+            path_parts = expander.template.virtual_path.split('/')
+
+            case
+            when path_parts.size == 4
+              path_parts.first
+            when path_parts.size == 3
+              mod = path_parts.first.classify.constantize
+              if mod.const_defined?(:Engine)
+                path_parts.first
+              else
+                nil
+              end
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+        def infer_path_prefix
+          expander = @args.last
+          if expander.try(:template)
+            path_parts = expander.template.virtual_path.split('/')
+
+            case
+            when path_parts.size == 4
+              path_parts[1]
+            when path_parts.size == 3
+              mod = path_parts.first.classify.constantize
+              if mod.const_defined?(:Engine)
+                nil
+              else
+                path_parts.first
+              end
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+        # TODO: this can now be inferred from the template.virtual_path
+        # if not supplied...
+        def resource_name
+          @config[:id].to_s.singularize
+        end
+
+        def collection_member_name
+          resource_name
+        end
+
+        def collection_name
+          collection_member_name.pluralize
+        end
+
+        def collection_var
+          "@#{collection_name}".to_sym
+        end
+
+        def collection
+          @config[:collection] || collection_var
+        end
+
+        def collection_path
+          if @config[:collection_path]
+            @config[:collection_path]
+          else
+            "#{collection_name_with_prefix}_path"
+          end
+        end
+
+        def collection_name_with_prefix
+          if path_prefix
+            "#{path_prefix}_#{collection_name}"
+          else
+            collection_name
+          end
+        end
+
+        def resource_path(ivar=false)
+          if @config[:resource_path]
+            @config[:resource_path]
+          else
+            "#{resource_name_with_path_prefix}_path(#{ivar ? '@' : ''}#{resource_name})"
+          end
+        end
+
+        def resource_name_with_path_prefix
+          if path_prefix
+            "#{path_prefix}_#{resource_name}"
+          else
+            resource_name
+          end
+        end
+
+        def attributes
+          resource_class.columns
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,8 @@ module ExpressTemplates
       class ExpressForm < Base
         include Capabilities::Configurable
         include Capabilities::Parenting
+        include Capabilities::Resourceful
+        include Forms::FormSupport
 
         emits -> {
           form( form_args ) {
@@ -20,16 +22,6 @@ module ExpressTemplates
           @config[:method]
         end
 
-        def form_action
-          if _modifying_resource?
-            "{{#{resource_name_for_path}_path(@#{resource_name})}}"
-          else # posting a new to a collection
-            # We also have to take in to account singular resources 
-            # e.g. resource :config -> will throw an unknown method error of configs_path
-            "{{#{resource_name_for_path.pluralize}_path}}"
-          end
-        end
-
 
         def form_args
           # there are no put/patch emthods in HTML5, so we have to enforce post
@@ -52,11 +44,6 @@ module ExpressTemplates
           (@config[:resource_name] || @config[:id]).to_s
         end
 
-        def namespace
-          @config[:namespace]
-        end
-
-
         private
 
           def _modifying_resource?

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

@@ -20,11 +20,7 @@ module ExpressTemplates
         end
 
         def resource_class
-          if namespace = parent_form.namespace
-            "#{namespace}/#{resource_name}".classify
-          else
-            resource_name.classify
-          end
+          parent_form.resource_class
         end
 
         # Return the name attribute for the lable
@@ -34,7 +30,7 @@ module ExpressTemplates
 
         # Return the text content for the label
         def label_text
-          @options[:label] || field_name.titleize
+          @config[:label] || field_name.titleize
         end
 
         # Return the field_name as a string.  This taken from the first argument

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

@@ -0,0 +1,13 @@
+module ExpressTemplates
+  module Components
+    module Forms
+      module FormSupport
+
+        def form_action
+          @config[:action] || "{{@#{resource_name}.try(:persisted?) ? #{resource_path(ivar: true)} : #{collection_path}}}"
+        end
+
+      end
+    end
+  end
+end

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

@@ -5,12 +5,18 @@ module ExpressTemplates
       # on the field and an means of loading the collection for supplying
       # options to the user.
       module OptionSupport
+
+        def has_many_through_association
+          reflection = resource_class.reflect_on_association(field_name.to_sym)
+          return reflection if reflection && reflection.macro.eql?(:has_many) && reflection.options.keys.include?(:through)
+        end
+
         # Reflect on any association and return it if the association type
         # is :belongs_to.  Returns false if the association is not :belongs_to.
         # Returns nil if there was a problem reflecting.
         def belongs_to_association
           # assumes the belongs_to association uses <name>_id
-          reflection = resource_class.constantize.reflect_on_association(field_name.gsub(/_id$/, '').to_sym)
+          reflection = resource_class.reflect_on_association(field_name.gsub(/_id$/, '').to_sym)
           if reflection && reflection.macro.eql?(:belongs_to)
             return reflection
           end
@@ -19,9 +25,13 @@ module ExpressTemplates
         # Provide ActiveRecord code to load the associated collection as
         # options for display.
         def related_collection
-          reflection = belongs_to_association
+          reflection = belongs_to_association || has_many_through_association
           if reflection && !reflection.polymorphic?
-            "#{reflection.klass}.all.select(:#{option_value_method}, :#{option_name_method}).order(:#{option_name_method})"
+            if cols.detect {|column| column.name.eql?('name') }
+              "#{reflection.klass}.all.select(:#{option_value_method}, :#{option_name_method}).order(:#{option_name_method})"
+            else
+              "#{reflection.klass}.all.sort_by(&:#{option_name_method})"
+            end
           end
         end
 
@@ -31,10 +41,14 @@ module ExpressTemplates
             :id
           end
 
+          def cols
+            @cols ||= (belongs_to_association||has_many_through_association).klass.columns
+          end
+
           def option_name_method
-            cols = belongs_to_association.klass.columns
             @option_name_method ||=
-              if cols.detect {|column| column.name.eql?('name') }
+              if cols.detect {|column| column.name.eql?('name') } ||
+                 resource_class.instance_methods.include?(:name)
                 :name
               else
                 if string_col = cols.detect {|column| column.type.eql?(:string) }

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

@@ -21,15 +21,26 @@ module ExpressTemplates
         emits -> {
           div(class: field_wrapper_class) {
             label_tag(label_name, label_text)
-            select_tag(field_name_attribute, select_options, field_options)
+            select_tag(*select_tag_args)
           }
         }
 
+        def select_tag_args
+          args = [field_name_attribute, select_options, field_options]
+          args << html_options unless html_options.nil? or html_options.empty?
+          args
+        end
+
         # Returns the options which will be supplied to the select_tag helper.
         def select_options
-          options_specified = [Array, Hash].include?(@args.second.class) && @args.size > 2
+          options_specified = [Array, Hash, Proc].include?(@args.second.class) && @args.size > 2
           if options_specified
-            options = @args.second
+            if @args.second.respond_to?(:source) # can be a proc
+              options = "#{@args.second.source}.call()"
+            else
+              options = @args.second
+            end
+
           else
             options = "@#{resource_var}.class.distinct(:#{field_name}).pluck(:#{field_name})"
           end
@@ -40,6 +51,8 @@ module ExpressTemplates
             else
               "{{options_from_collection_for_select(#{related_collection}, :id, :#{option_name_method}, @#{resource_name}.#{field_name})}}"
             end
+          elsif has_many_through_association
+            "{{options_from_collection_for_select(#{related_collection}, :id, :#{option_name_method}, @#{resource_name}.#{field_name}.map(&:id))}}"
           else
             if selection = field_options.delete(:selected)
               "{{options_for_select(#{options}, \"#{selection}\")}}"
@@ -49,18 +62,43 @@ module ExpressTemplates
           end
         end
 
+        def field_name_attribute
+          if has_many_through_association
+            "#{resource_name.singularize}[#{field_name.singularize}_ids]"
+          else
+            super
+          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
           defaults = {include_blank: true}
-          field_options = if @args.size > 3 && @args[2].is_a?(Hash)
-            @args[2]
-          else
-            {}
-          end
-          defaults.merge(field_options)
+          defaults.merge(supplied_field_options.reject {|k,v| k.eql?(:select2)})
         end
 
+        def html_options
+          supplied_html_options
+        end
+
+        protected
+
+          def supplied_field_options
+            if @args.size > 3 && @args[2].is_a?(Hash)
+              @args[2]
+            else
+              {}
+            end
+          end
+
+          def supplied_html_options
+            if @args.size > 4 && @args[3].is_a?(Hash)
+              @args[3]
+            else
+              {}
+            end
+          end
+
       end
     end
   end

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

@@ -0,0 +1,57 @@
+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.
+      #
+      class SelectCollection < Select
+
+        emits -> {
+          div(class: field_wrapper_class) {
+            label_tag(label_name, label_text)
+
+            # need this because the collection_select helper does not provide
+            # the hidden_field_tag trick (see rails api docs for select)
+            hidden_field_tag(multi_field_name, '')
+
+            collection_select(*collection_select_tag_args)
+          }
+        }
+
+        def collection_select_tag_args
+          [ resource_name,
+            multi_field_name,
+            select_options, :id, :name,
+            field_options,
+            html_options ]
+        end
+
+        def field_options
+          selected_options_ruby = "@#{resource_name}.#{multi_field_name}".to_view_code
+          super.merge(include_blank: false, selected: selected_options_ruby)
+        end
+
+        def html_options
+          (super||{}).merge(multiple: true)
+        end
+
+        def multi_field_name
+          if has_many_through_association
+            "#{field_name.singularize}_ids"
+          else
+            raise "Only use select_collection for has_many :through.  #{field_name} is not has_many :through"
+          end
+        end
+
+
+        def select_options
+          "{{#{related_collection}}}"
+        end
+      end
+    end
+  end
+end

data/lib/express_templates/components/forms.rb

@@ -5,11 +5,13 @@ module ExpressTemplates
   end
 end
 
+require 'express_templates/components/forms/form_support'
 require 'express_templates/components/forms/express_form'
 require 'express_templates/components/forms/form_component'
 require 'express_templates/components/forms/option_support'
 require 'express_templates/components/forms/submit'
 require 'express_templates/components/forms/select'
+require 'express_templates/components/forms/select_collection'
 require 'express_templates/components/forms/radio'
 require 'express_templates/components/forms/checkbox'
-require 'express_templates/components/forms/basic_fields'
+require 'express_templates/components/forms/basic_fields'

data/lib/express_templates/components/tree_for.rb

@@ -11,9 +11,9 @@ module ExpressTemplates
     # Example:
     #
     # ```ruby
-    # tree_for(:roles) do |role|
-    #   role.name
-    # end
+    # tree_for(:roles) {
+    #   "{{role.name}}"
+    # }
     # ```
     #
     # If the view has an @roles variable with a Role having children,
@@ -59,12 +59,16 @@ module ExpressTemplates
       end
 
       def compile
-        collection = _variablize(@options[:id])
+        collection = if @options[:collection]
+            "#{@options[:collection].source}.call()"
+          else
+            _variablize(@options[:id])
+          end
         member = @options[:id].to_s.singularize
         return 'ExpressTemplates::Components::TreeFor.render_in(self) {
   node_renderer = '+node_renderer.gsub(/node/, member)+'
   ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
-    "#{ws}<ul id=\"roles\" class=\"roles tree\">" +
+    "#{ws}<ul id=\"'+@options[:id]+'\" class=\"'+@options[:id]+' tree\">" +
       '+collection+'.map do |'+member+'|
         node_renderer.call('+member+', node_renderer)
       end.join +

data/lib/express_templates/version.rb

@@ -1,3 +1,3 @@
 module ExpressTemplates
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

data/lib/express_templates.rb

@@ -1,5 +1,6 @@
 module ExpressTemplates
   require 'core_extensions/proc'
+  require 'core_extensions/string'
   require 'express_templates/indenter'
   require 'express_templates/macro'
   require 'express_templates/markup'

data/test/components/capabilities/resourceful_test.rb

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

@@ -72,16 +72,16 @@ class ExpressFormTest < ActiveSupport::TestCase
   end
 
   test "#form_action uses url helpers" do
-    assert_equal "{{foos_path}}", express_form.new(:foo).form_action
+    assert_equal "{{@foo.try(:persisted?) ? foo_path(@foo) : 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
+    assert_equal "{{@foo.try(:persisted?) ? foo_path(@foo) : foos_path}}", 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
+    assert_match 'action=\"#{@resource.try(:persisted?) ? resource_path(@resource) : resources_path}\"', form_open_tag
   end
 
   test "express_form default method is POST" do
@@ -99,10 +99,10 @@ class ExpressFormTest < ActiveSupport::TestCase
     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
+  # 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
+end

data/test/components/forms/select_test.rb

@@ -52,16 +52,31 @@ class SelectTest < ActiveSupport::TestCase
       [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_association = Object.new
-        class << dummy_association
+        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_association
+        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
   end
@@ -96,4 +111,36 @@ class SelectTest < ActiveSupport::TestCase
     assert_no_match 'include_blank: true', ExpressTemplates.compile(&fragment)
   end
 
+  test "select multiple: true if passed multiple true" do
+    fragment = -> {
+      express_form(:person) {
+        select :taggings, nil, include_blank: false, multiple: true
+      }
+    }
+    assert_match 'multiple: true', ExpressTemplates.compile(&fragment)
+  end
+
+  test "select multiple gets options from associated has_many_through collection" do
+    fragment = -> {
+      express_form(:person) {
+        select :taggings, nil, 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)
+  end
+
+  test "select_collection uses collection_select" do
+    fragment = -> {
+      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)
+  end
+
+
 end