express_admin 1.4.5 → 1.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4e4c3c080c9d417ad96cec7a4f482d681998e89
-  data.tar.gz: 39e8700c94d154d98d25930090d3794c81d16aa0
+  metadata.gz: 50d6a3fea68da45a25497be729e3f4122d3073ec
+  data.tar.gz: 1ffe48826b7a7a330a6adf849bcfd92b20562de0
 SHA512:
-  metadata.gz: 64e004b1571753b064868e753d29035a198b079316b12745ac77d1ce2856a0030562a70fe8a34805bfdcb6eec65c1e3fbc650a13333d3dd57646c2569dbc9265
-  data.tar.gz: 886a1812ab705290b6cf3a97a242495371b46e56e8b3b6fdd1e7a8469d84e957137b33f0d2963bd6c39e127ee13571131c554d8e48bb46c05c19b167ea6a2021
+  metadata.gz: 5de456daa50c148a1eff7f6119f3edb0213589fb4111ae344fd9e70b9630c436a51d0c9cfa2b068ab7576beb8873b7f4ae0b2276fbfee9469144853646910961
+  data.tar.gz: 7c543198ff8aabf901bc459cb48bde95afede6f011e3c4507e7e6936daf74ce68ccd995e83ae1658470ed470eea30fcf8bbd42cc337835f4b0eff1422ce81d08

data/app/components/express_admin/smart_form.rb

@@ -4,9 +4,10 @@ module ExpressAdmin
   class SmartForm < ExpressTemplates::Components::Forms::ExpressForm
     TIMESTAMPS = %w(updated_at created_at)
 
-    has_option :virtual, 'Override the list of virtual attributes of the resource to be displayed'
-    has_option :exclude, 'Attributes not to be included in the form'
-    has_option :only, 'Respects the order the attributes are listed in'
+    has_option :virtual, 'Override the list of virtual attributes of the resource to be displayed', type: :array,
+      values: -> (*) { resource_class.respond_to?(:virtual_attributes) ? resource_class.virtual_attributes : [] }
+    has_option :exclude, 'Attributes not to be included in the form', type: :array
+    has_option :only, 'Respects the order the attributes are listed in', type: :array
     has_option :show_timestamps, 'Set to true to show timestamps as labels'
 
     contains {

data/app/components/express_admin/smart_table.rb

@@ -69,10 +69,6 @@ module ExpressAdmin
       !!config[:show_actions]
     end
 
-    def resource_path(item)
-      helpers.send(resource_path_helper, item.to_param)
-    end
-
     def should_show_delete?(item)
       if item.respond_to?(:can_delete?) && item.can_delete?
         true

data/app/controllers/express_admin/standard_controller.rb

@@ -0,0 +1,13 @@
+require 'express_admin/standard_actions'
+
+module ExpressAdmin
+  class StandardController < ::ApplicationController
+
+    include StandardActions
+
+    def initialize(*args)
+      raise "StandardController must be subclassed" if self.class.eql?(StandardController)
+    end
+
+  end
+end

data/lib/express_admin/standard_actions.rb

@@ -0,0 +1,155 @@
+module ExpressAdmin
+  module StandardActions
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+        helper_method :collection
+        helper_method :resource
+
+        class_attribute :defaults
+        self.defaults = {layout: 'layouts/express_admin/admin'}
+      end
+    end
+
+    module ClassMethods
+      def inherited(base)
+        base.class_eval <<-RUBY
+          def #{base.resource_name}_params
+            params.require(:#{base.resource_name}).permit!
+          end
+        RUBY
+      end
+
+      def resource_name
+        self.to_s.demodulize.gsub(/Controller$/, '').singularize.underscore
+      end
+    end
+
+    module InstanceMethods
+      def index
+        build_resource
+        load_collection
+        respond_to do |format|
+          format.html { render :index, layout: defaults[:layout] }
+        end
+      end
+
+      def new
+        build_resource
+        respond_to do |format|
+          format.html { render :new, layout: defaults[:layout] }
+        end
+      end
+
+      def create
+        build_resource(resource_params)
+        if resource.save
+          respond_to do |format|
+            format.html { redirect_to resource_path }
+          end
+        else
+          respond_to do |format|
+            format.html { render :new, layout: defaults[:layout] }
+          end
+        end
+      end
+
+      def show
+        load_resource
+        load_collection
+        respond_to do |format|
+          format.html { render :show, layout: defaults[:layout] }
+        end
+      end
+
+      def edit
+        load_resource
+        respond_to do |format|
+          format.html { render :edit, layout: defaults[:layout] }
+        end
+      end
+
+      def update
+        load_resource
+        if resource.update_attributes(resource_params)
+          respond_to do |format|
+            format.html { redirect_to resource_path }
+          end
+        else
+          respond_to do |format|
+            format.html { render :edit, layout: defaults[:layout] }
+          end
+        end
+      end
+
+      def destroy
+        load_resource
+        resource.destroy!
+        respond_to do |format|
+          format.html { redirect_to :index }
+        end
+      end
+
+      protected
+        def resource_path
+          namespace_route_proxy.send("#{resource_name}_path", resource)
+        end
+
+        def namespace_route_proxy
+          if parent_namespace = self.class.to_s.match(/(\w+)::/).try(:[], 1)
+            self.send(parent_namespace.underscore)
+          else
+            self
+          end
+        end
+
+        def resource_params
+          self.send("#{resource_name}_params")
+        end
+
+        def load_collection
+          self.instance_variable_set(collection_ivar, resource_class.all)
+        end
+
+        def collection_ivar
+          "@#{collection_name}".to_sym
+        end
+
+        def collection
+          self.instance_variable_get(collection_ivar)
+        end
+
+        def collection_name
+          self.class.to_s.demodulize.gsub(/Controller$/, '').pluralize.underscore
+        end
+
+        def resource
+          self.instance_variable_get(resource_ivar)
+        end
+
+        def build_resource(*args)
+          self.instance_variable_set(resource_ivar, resource_class.new(*args))
+        end
+
+        def load_resource
+          self.instance_variable_set(resource_ivar, resource_class.find(params[:id]))
+        end
+
+        def resource_ivar
+          "@#{resource_name}".to_sym
+        end
+
+        def resource_class
+          self.class.to_s.gsub(/Controller$/, '').singularize.classify.constantize
+        end
+
+        # Foo::WidgetsController ->  widget
+        def resource_name
+          self.class.resource_name
+        end
+      end
+
+  end
+end

data/lib/express_admin/version.rb

@@ -1,3 +1,3 @@
 module ExpressAdmin
-  VERSION = "1.4.5"
+  VERSION = "1.4.6"
 end

data/lib/generators/express_admin/install/install_generator.rb

@@ -19,11 +19,6 @@ module ExpressAdmin
           File.join('test/lib/generators', @project_name, 'install', 'install_generator_test.rb')
       end
 
-      def create_admin_controller
-        template 'controllers/admin_controller.rb.erb',
-          File.join('app/controllers', @project_name, 'admin_controller.rb')
-      end
-
       def create_admin_layout
         template 'views/layouts/admin.html.et',
           File.join('app/views/layouts', @project_name, 'admin.html.et')

data/lib/generators/express_admin/scaffold/templates/controller/controller.rb

@@ -1,12 +1,5 @@
 <% module_namespacing do -%>
-class <%= controller_class_name %>Controller < AdminController
+class <%= controller_class_name %>Controller < ExpressAdmin::StandardController
 
-  defaults resource_class: <%= model_class_name %>
-
-  private
-
-    def <%= singular_table_name %>_params
-      params.require(:<%= singular_table_name %>).permit!
-    end
 end
 <% end -%>

data/test/controllers/standard_controller_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+module ExpressAdmin
+
+  class StandardControllerTest < ActiveSupport::TestCase
+
+    class WidgetsController < StandardController
+      def resource_class
+        Widget
+      end
+    end
+
+    def widgets_controller(params = {})
+      @widgets_controller ||= WidgetsController.new
+      eigenclass = class << @widgets_controller ; self ; end
+      eigenclass.send(:define_method, :params) do
+        ActionController::Parameters.new(params.with_indifferent_access)
+      end
+      eigenclass.send(:define_method, :respond_to) do |&block|
+        block.call(ActionController::MimeResponds::Collector.new([], 'text/html'))
+      end
+      @widgets_controller
+    end
+
+    test "it should have all the standard actions" do
+      [:new, :create, :show, :index, :edit, :update, :destroy].each do |action|
+        assert StandardController.instance_methods.include?(action), "StandardController does not implement ##{action}"
+      end
+    end
+
+    test "should require a subclass for instantiation" do
+      assert_raises(RuntimeError) do
+        StandardController.new
+      end
+    end
+
+    def resource
+      widgets_controller.instance_variable_get(:@widget)
+    end
+
+    def collection
+      widgets_controller.instance_variable_get(:@widgets)
+    end
+
+    test "#new should expose a new instance of resource" do
+      widgets_controller.new
+      assert resource, "@widget not provided by #new"
+      refute resource.persisted?, "@widget should not be persisted"
+    end
+
+    test "#create should expose an instance of resource" do
+      widgets_controller(widget: {column2: 'nothing'}).create
+      assert resource, "@widget not provided by #create"
+      assert resource.persisted?, "@widget not saved"
+    end
+
+    test "#show should expose an instance of resource if found" do
+      widgets_controller(id: widgets(:one).id).show
+      assert resource, "@widget not provided by #show"
+      assert resource.persisted?, "@widget not saved"
+    end
+
+    test "#index should expose a collection of resources" do
+      widgets_controller.index
+      assert collection, "@widgets not provided by #index"
+      refute collection.empty?, "@widgets is empty"
+    end
+
+    test "#edit should expose an instance of resource if found" do
+      widgets_controller(id: widgets(:one).id).edit
+      assert resource, "@widget not provided by #edit"
+      assert resource.persisted?, "@widget not saved"
+    end
+
+    test "#update should expose an updated instance of resource if found" do
+      widgets_controller(id: widgets(:one).id, widget: {column2: "Updated"}).update
+      assert resource, "@widget not provided by #update"
+      assert_equal "Updated", resource.column2
+      assert resource.persisted?, "@widget not saved"
+    end
+
+    test "#destroy destroys" do
+      @widget = Widget.create!(column2: 'Destroy Me')
+      assert @widget.persisted?
+      widgets_controller(id: @widget.id).destroy
+      assert_raises(ActiveRecord::RecordNotFound) do
+        Widget.find(@widget.id)
+      end
+    end
+
+    # test "it should provide collection and resource helpers"
+
+    # test "it should provide a default strong params"
+
+    # test "for nested resources it should try to expose a current method for parent resources"
+  end
+end

data/test/dummy/test/components/smart_form_test.rb

@@ -5,7 +5,7 @@ module ExpressAdmin
   class SmartFormTest < ActiveSupport::TestCase
 
     def resource_assigns
-      {resource: Widget.new, collection: Widget.all}
+      {resource: Widget.new, collection: Widget.all, example_engine: ExampleEngine::MockRouteProxy.new}
     end
 
     def helpers

data/test/lib/generators/express_admin/install_generator_test.rb

@@ -10,13 +10,6 @@ class ExpressAdmin::Generators::InstallGeneratorTest < Rails::Generators::TestCa
   def test_install_on_invoke
     run_generator
 
-    assert_file 'app/controllers/tmp/admin_controller.rb' do |content|
-      assert_match /module Tmp/, content
-      assert_match /class AdminController < ApplicationController/, content
-      assert_match /before_filter :authenticate_user! if defined\?\(Devise\)/, content
-      assert_match /layout "tmp\/admin"/, content
-    end
-
     assert_file 'app/views/layouts/tmp/admin.html.et' do |content|
       assert_match /render\(template: 'layouts\/express_admin\/admin'\)/, content
     end

data/test/lib/generators/express_admin/scaffold_generator_test.rb

@@ -22,10 +22,7 @@ class ExpressAdmin::Generators::ScaffoldGeneratorTest < Rails::Generators::TestC
 
     # Controller
     assert_file "app/controllers/agents_controller.rb" do |content|
-      assert_match(/class AgentsController < AdminController/, content)
-
-      assert_match(/defaults resource_class: Agent/, content)
-      assert_match(/def agent_params()/, content)
+      assert_match(/class AgentsController < ExpressAdmin::StandardController/, content)
     end
 
     # Routes

data/test/test_helper.rb

@@ -36,6 +36,11 @@ module ExampleEngine
   class Category < ::Category
     has_many :widgets, class_name: 'ExampleEngine::Widget'
   end
+  class MockRouteProxy
+    def method_missing(*args)
+      return '/whatever'
+    end
+  end
 end
 module AdditionalHelpers
 

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

@@ -25,6 +25,16 @@ module Arbre
       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:
     #
@@ -40,6 +50,8 @@ module Arbre
         assigns[name]
       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
@@ -52,6 +64,8 @@ module Arbre
     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

data/vendor/gems/express_templates/lib/express_templates/components/capabilities/resourceful.rb

@@ -8,10 +8,13 @@ module ExpressTemplates
           base.class_eval do
             has_argument :id, "The name of the collection", type: :symbol, optional: false
             has_option :collection, 'Provide an explicit collection as a resource.'
-            has_option :collection_path, 'Provide an explicit path for the collection resource.'
+            has_option :collection_path, 'Provide an explicit path for the collection resource.', type: [:string, :proc]
             has_option :resource_class, 'Overrides namespaced resource_class for using resources from a different module or namespace.'
-            has_option :resource_path, 'Overides the resource path which is otherwise inferred from the class name.'
+            has_option :resource_path, 'Overides the resource path which is otherwise inferred from the class name.', type: [:string, :proc]
             has_option :path_prefix, 'Rarely used.  Override inferred path_prefix for path helpers.'
+            # note there is some duplication here.
+            # resource_path can be specified as a proc which can specify a namespace
+            # TODO: investigate which approach is better and deprecate if desirable
             has_option :namespace, 'Rarely used.  Overrides inferred namespace for resources.'
           end
         end
@@ -123,10 +126,21 @@ module ExpressTemplates
 
         def collection_path
           if config[:collection_path]
-            config[:collection_path]
+            if config[:collection_path].respond_to?(:call)
+              config[:collection_path].call()
+            else
+              config[:collection_path]
+            end
           else
-            #super
-            helpers.instance_eval "#{collection_name_with_prefix}_path"
+            helpers.instance_eval collection_path_helper
+          end
+        end
+
+        def collection_path_helper
+          if path_namespace
+            "#{path_namespace}.#{collection_name_with_prefix}_path"
+          else
+            "#{collection_name_with_prefix}_path"
           end
         end
 
@@ -139,15 +153,37 @@ module ExpressTemplates
         end
 
         def resource_path_helper
-          "#{resource_name_with_path_prefix}_path"
+          if path_namespace
+            "#{path_namespace}.#{resource_name_with_path_prefix}_path"
+          else
+            "#{resource_name_with_path_prefix}_path"
+          end
+        end
+
+        def path_namespace
+          resource_class_name = resource_class.to_s
+          resource_class_name.match(/::/) ?
+            resource_class_name.split("::").first.try(:underscore) : nil
         end
 
-        def resource_path(ivar=false)
+        # accepts boolean to indicate whether to use an ivar or not
+        # and also may accept a resource on which we call to_param
+        def resource_path(ivar_or_resource = nil)
           if config[:resource_path]
-            config[:resource_path]
+            if config[:resource_path].respond_to?(:call) &&
+              ivar_or_resource.respond_to?(:to_param) &&
+              ![true, false].include?(ivar_or_resource)
+              config[:resource_path].call(ivar_or_resource)
+            else
+              config[:resource_path]
+            end
           else
-            # super
-            helpers.instance_eval("#{resource_path_helper}(#{ivar ? '@' : ''}#{resource_name})")
+            if ivar_or_resource.respond_to?(:to_param) &&
+              ![true, false].include?(ivar_or_resource)
+              helpers.instance_eval("#{resource_path_helper}('#{ivar_or_resource.to_param}')")
+            else
+              helpers.instance_eval("#{resource_path_helper}(#{ivar_or_resource ? '@' : ''}#{resource_name})")
+            end
           end
         end
 

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

@@ -47,10 +47,10 @@ module ExpressTemplates
         @config ||= {}
       end
 
-      def self.has_option(name, description, type: :text, required: nil, default: nil, attribute: nil)
+      def self.has_option(name, description, type: :string, required: nil, default: nil, attribute: nil, values: nil)
         raise "name must be a symbol" unless name.kind_of?(Symbol)
         option_definition = {description: description}
-        option_definition.merge!(type: type, required: required, default: default, attribute: attribute)
+        option_definition.merge!(type: type, required: required, default: default, attribute: attribute, values: values)
         self.supported_options =
           self.supported_options.merge(name => option_definition)
       end

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

@@ -28,7 +28,7 @@ module ExpressTemplates
         end
 
         def form_action
-          config[:action] || (resource.try(:persisted?) ? resource_path(ivar: true) : collection_path)
+          config[:action] || (resource.try(:persisted?) ? resource_path(true) : collection_path)
         end
 
       end

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

@@ -7,18 +7,22 @@ module ExpressTemplates
       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)
+          if resource_class.respond_to?(:reflect_on_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
         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.reflect_on_association(field_name.gsub(/_id$/, '').to_sym)
-          if reflection && reflection.macro.eql?(:belongs_to)
-            return reflection
+          if resource_class.respond_to?(:reflect_on_association)
+            # assumes the belongs_to association uses <name>_id
+            reflection = resource_class.reflect_on_association(field_name.gsub(/_id$/, '').to_sym)
+            if reflection && reflection.macro.eql?(:belongs_to)
+              return reflection
+            end
           end
         end
 

data/vendor/gems/express_templates/lib/express_templates/version.rb

@@ -1,3 +1,3 @@
 module ExpressTemplates
-  VERSION = "0.9.4"
+  VERSION = "0.9.5"
 end

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

@@ -72,6 +72,19 @@ class ConfigurableTest < ActiveSupport::TestCase
     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

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

@@ -6,10 +6,6 @@ require 'test_helper'
 
 class ExpressFormTest < ActiveSupport::TestCase
 
-  def assigns
-    {resource: resource}
-  end
-
   def simplest_form
     arbre {
       express_form(:resource) {