trestle 0.8.4 → 0.8.11

data/lib/trestle/form/fields/form_control.rb

@@ -13,15 +13,23 @@ module Trestle
         def input_group
           if @prepend || @append
             content_tag(:div, class: "input-group") do
-              concat content_tag(:span, @prepend, class: "input-group-addon") if @prepend
+              concat input_group_addon(@prepend) if @prepend
               concat yield
-              concat content_tag(:span, @append, class: "input-group-addon") if @append
+              concat input_group_addon(@append) if @append
             end
           else
             yield
           end
         end
 
+        def input_group_addon(addon)
+          if addon[:wrap]
+            content_tag(:span, addon[:content], class: "input-group-addon")
+          else
+            addon[:content]
+          end
+        end
+
         def defaults
           super.merge(class: ["form-control"])
         end
@@ -29,8 +37,10 @@ module Trestle
         def extract_options!
           super
 
-          @prepend = options.delete(:prepend)
-          @append  = options.delete(:append)
+          @prepend = { content: options.delete(:prepend),  wrap: true }  if options[:prepend]
+          @prepend = { content: options.delete(:prepend!), wrap: false } if options[:prepend!]
+          @append  = { content: options.delete(:append),   wrap: true }  if options[:append]
+          @append  = { content: options.delete(:append!),  wrap: false } if options[:append!]
         end
       end
     end

data/lib/trestle/form/fields/form_group.rb

@@ -2,19 +2,30 @@ module Trestle
   class Form
     module Fields
       class FormGroup < Field
+        WRAPPER_OPTIONS = [:help, :label, :hide_label]
+
         def render
           options[:class] << 'has-error' if errors.any?
 
-          content_tag(:div, options) do
+          content_tag(:div, options.except(*WRAPPER_OPTIONS)) do
             concat label unless options[:label] == false
-            concat block.call if block
+            concat template.capture(&block) if block
             concat help_message if options[:help]
             concat error_message if errors.any?
           end
         end
 
         def help_message
-          content_tag(:p, options[:help], class: "help-block")
+          classes = ["help-block"]
+
+          if options[:help].is_a?(Hash)
+            message = options[:help][:text]
+            classes << "floating" if options[:help][:float]
+          else
+            message = options[:help]
+          end
+
+          content_tag(:p, message, class: classes)
         end
 
         def error_message

data/lib/trestle/form/fields/select.rb

@@ -7,7 +7,7 @@ module Trestle
         def initialize(builder, template, name, choices=nil, options={}, html_options={}, &block)
           super(builder, template, name, options, &block)
 
-          @choices = Choices.new(choices || builder.object.send(name))
+          @choices = Choices.new(choices || default_choices)
           @html_options = default_html_options.merge(html_options)
         end
 
@@ -19,6 +19,10 @@ module Trestle
           Trestle::Options.new(class: ["form-control"], data: { enable_select2: true })
         end
 
+        def default_choices
+          builder.object.send(name) if builder.object
+        end
+
         # Allows an array of model instances (or a scope) to be
         # passed to the select field as the list of choices.
         class Choices

data/lib/trestle/form/fields/tag_select.rb

@@ -7,7 +7,7 @@ module Trestle
         end
 
         def default_html_options
-          super.merge(multiple: true, class: "tag-select", data: { tags: true, select_on_close: true })
+          super.merge(multiple: true, class: "tag-select", data: { tags: true })
         end
       end
     end

data/lib/trestle/form/renderer.rb

@@ -5,11 +5,11 @@ module Trestle
       include ::ActionView::Helpers::CaptureHelper
 
       # Whitelisted helpers will concatenate their result to the output buffer when called.
-      WHITELISTED_HELPERS = [:row, :col, :render, :tab, :toolbar, :table, :divider]
+      WHITELISTED_HELPERS = [:row, :col, :render, :tab, :table, :divider, :h1, :h2, :h3, :h4, :h5, :h6, :panel, :well]
 
       # Raw block helpers will pass their block argument directly to the method
       # without wrapping it in a new output buffer.
-      RAW_BLOCK_HELPERS = [:table]
+      RAW_BLOCK_HELPERS = [:table, :toolbar]
 
       # The #select and #display methods are defined on Kernel. Undefine them so
       # that they can be delegated to the form builder or template by method_missing.

data/lib/trestle/form.rb

@@ -8,10 +8,14 @@ module Trestle
     autoload :Fields
     autoload :Renderer
 
-    attr_reader :block
+    attr_reader :options, :block
 
-    def initialize(&block)
-      @block = block
+    def initialize(options={}, &block)
+      @options, @block = options, block
+    end
+
+    def dialog?
+      options[:dialog] == true
     end
 
     def render(template, instance)

data/lib/trestle/hook.rb

@@ -0,0 +1,27 @@
+module Trestle
+  class Hook
+    attr_reader :name, :options, :block
+
+    def initialize(name, options={}, &block)
+      @name, @options, @block = name, options, block
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && name == other.name && options == other.options && block == other.block
+    end
+
+    def visible?(context)
+      if options[:if]
+        context.instance_exec(&options[:if])
+      elsif options[:unless]
+        !context.instance_exec(&options[:unless])
+      else
+        true
+      end
+    end
+
+    def evaluate(context)
+      context.instance_exec(&block)
+    end
+  end
+end

data/lib/trestle/model_name.rb

@@ -0,0 +1,64 @@
+require "active_model/naming"
+
+module Trestle
+  class ModelName
+    attr_reader :klass
+
+    delegate :downcase, :upcase, :titleize, :titlecase, to: :to_s
+
+    def initialize(klass)
+      @klass = klass
+      @name = klass.respond_to?(:model_name) ? klass.model_name : ActiveModel::Name.new(klass)
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && klass == other.klass
+    end
+
+    def to_s
+      singular
+    end
+
+    def singular(options={})
+      human(default_singular, options)
+    end
+    alias_method :singularize, :singular
+
+    def plural(options={})
+      if i18n_supported? && i18n_pluralizations_available?
+        human(default_plural, { count: :many }.merge(options))
+      else
+        default_plural
+      end
+    end
+    alias_method :pluralize, :plural
+
+  protected
+    # Default singular version if it cannot be determined from i18n
+    def default_singular
+      @name.name.demodulize.titleize
+    end
+
+    # Default plural version if it cannot be determined from i18n
+    def default_plural
+      singular.pluralize(I18n.locale)
+    end
+
+    # Safely delegates to ActiveModel::Name#human, catching exceptions caused by missing pluralizations
+    def human(default, options={})
+      @name.human(options.merge(default: default))
+    rescue I18n::InvalidPluralizationData
+      default
+    end
+
+    # Checks if the model can be translated by ActiveModel
+    def i18n_supported?
+      klass.respond_to?(:lookup_ancestors) && klass.respond_to?(:i18n_scope)
+    end
+
+    # Checks if multiple pluralization forms (e.g. zero/one/few/many/other) are available from i18n
+    def i18n_pluralizations_available?
+      @name.human(count: nil).is_a?(Hash)
+    end
+  end
+end

data/lib/trestle/navigation/group.rb

@@ -26,6 +26,10 @@ module Trestle
         end
       end
 
+      def merge(other)
+        self.class.new(name, options.merge(other.options))
+      end
+
       def priority
         case options[:priority]
         when :first
@@ -40,6 +44,10 @@ module Trestle
       def label
         I18n.t("admin.navigation.groups.#{name}", default: name.to_s.titlecase)
       end
+
+      def id
+        name.to_s.parameterize
+      end
     end
 
     class NullGroup
@@ -59,9 +67,17 @@ module Trestle
         NullGroup.hash
       end
 
+      def id
+        nil
+      end
+
       def <=>(other)
         -1
       end
+
+      def merge(other)
+        self
+      end
     end
   end
 end

data/lib/trestle/navigation/item.rb

@@ -40,7 +40,7 @@ module Trestle
       end
 
       def label
-        I18n.t("admin.navigation.items.#{name}", default: name.to_s.titlecase)
+        options[:label] || I18n.t("admin.navigation.items.#{name}", default: name.to_s.titlecase)
       end
 
       def icon
@@ -55,6 +55,16 @@ module Trestle
         Badge.new(options[:badge]) if badge?
       end
 
+      def visible?(context)
+        if options[:if]
+          context.instance_exec(&options[:if])
+        elsif options[:unless]
+          !context.instance_exec(&options[:unless])
+        else
+          true
+        end
+      end
+
       class Badge
         attr_reader :text
 

data/lib/trestle/navigation.rb

@@ -7,16 +7,17 @@ module Trestle
     autoload :Group
     autoload :NullGroup, "trestle/navigation/group"
 
-    def initialize(blocks)
-      @blocks = blocks
-    end
+    attr_reader :items
 
-    def items
-      @blocks.map(&:items).flatten
+    def initialize(items)
+      @items = items
     end
 
     def by_group
-      Hash[stable_sort(items.group_by(&:group)).map { |group, items| [group, stable_sort(items)] }]
+      sorted_groups = stable_sort(items.group_by { |item| groups[item.group.id] })
+      sorted_items = sorted_groups.map { |group, items| [group, stable_sort(items)] }
+
+      Hash[sorted_items]
     end
 
     def each(&block)
@@ -28,9 +29,26 @@ module Trestle
       sorted.first.first if sorted.any?
     end
 
+    def visible(context)
+      self.class.new(items.select { |item| item.visible?(context) })
+    end
+
+    def self.build(blocks)
+      new(blocks.map(&:items).flatten)
+    end
+
   private
     def stable_sort(items)
       items.sort_by.with_index { |item, i| [item, i] }
     end
+
+    def groups
+      @groups ||= items.inject({}) { |groups, item|
+        group = groups[item.group.id]
+
+        groups[item.group.id] = group ? group.merge(item.group) : item.group
+        groups
+      }
+    end
   end
 end

data/lib/trestle/options.rb

@@ -4,13 +4,15 @@ module Trestle
       self[hash]
     end
 
-    def merge(other)
-      dup.merge!(other)
+    def merge(other, &block)
+      dup.merge!(other, &block)
     end
 
-    def merge!(other)
-      deep_merge!(other || {}) do |key, v1, v2|
-        if v1.is_a?(Array)
+    def merge!(other, &block)
+      super(other || {}) do |key, v1, v2|
+        if v1.is_a?(Hash) && v2.is_a?(Hash)
+          v1.merge(v2, &block)
+        elsif v1.is_a?(Array)
           v1 + Array(v2)
         else
           v2

data/lib/trestle/reloader.rb

@@ -34,7 +34,7 @@ module Trestle
     end
 
     def load_paths
-      ActiveSupport::Dependencies.autoload_paths.grep(/\/app\/admin\Z/)
+      Trestle.config.load_paths.map { |path| path.respond_to?(:call) ? path.call : path }.flatten.map(&:to_s)
     end
 
   private

data/lib/trestle/resource/adapter_methods.rb

@@ -0,0 +1,62 @@
+module Trestle
+  class Resource
+    module AdapterMethods
+      extend ActiveSupport::Concern
+
+      # Adapter instance bound to the current resource's context.
+      def adapter
+        @adapter ||= adapter_class.new(self, @context)
+      end
+
+      module ClassMethods
+        # Declares a method that is handled by the admin's adapter class.
+        def adapter_method(name)
+          delegate name, to: :adapter
+
+          singleton_class.class_eval do
+            delegate name, to: :adapter
+          end
+        end
+
+        # Defines an admin-specific adapter method.
+        #
+        # The given block is wrapped rather than passed to #define_method directly, so that
+        # adapter methods can be defined with incomplete block parameters. Unfortunately
+        # this means we lose the ability to call super from within a custom adapter method.
+        def define_adapter_method(name, &block)
+          return unless block_given?
+
+          adapter_methods.module_eval do
+            define_method(name) do |*args|
+              instance_exec(*args, &block)
+            end
+          end
+        end
+
+        # Returns the adapter class for this admin.
+        #
+        # Defaults to a subclass of `Trestle.config.default_adapter` with
+        # the admin-specific adapter methods module included.
+        def adapter_class
+          @adapter_class ||= Class.new(Trestle.config.default_adapter).include(adapter_methods)
+        end
+
+        # Sets an explicit adapter class for this admin.
+        # A subclass is created with the admin-specific adapter methods module included.
+        def adapter_class=(klass)
+          @adapter_class = Class.new(klass).include(adapter_methods)
+        end
+
+        # Module container for admin-specific adapter methods.
+        def adapter_methods
+          @adapter_methods ||= Module.new
+        end
+
+        # Unbound instance of adapter.
+        def adapter
+          @adapter ||= adapter_class.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/trestle/resource/builder.rb

@@ -5,46 +5,53 @@ module Trestle
       self.controller = Controller
 
       def adapter(&block)
-        klass = admin.adapter
-        klass.instance_eval(&block) if block_given?
+        klass = admin.adapter_class
+        klass.class_eval(&block) if block_given?
         klass
       end
 
       def adapter=(adapter)
-        admin.adapter = adapter
+        admin.adapter_class = adapter
+      end
+
+      def remove_action(*actions)
+        actions.each do |action|
+          controller.remove_possible_method(action.to_sym)
+          admin.actions.delete(action.to_sym)
+        end
       end
 
       def collection(&block)
-        admin.collection = block
+        admin.define_adapter_method(:collection, &block)
       end
 
       def find_instance(&block)
-        admin.find_instance = block
+        admin.define_adapter_method(:find_instance, &block)
       end
       alias instance find_instance
 
       def build_instance(&block)
-        admin.build_instance = block
+        admin.define_adapter_method(:build_instance, &block)
       end
 
       def update_instance(&block)
-        admin.update_instance = block
+        admin.define_adapter_method(:update_instance, &block)
       end
 
       def save_instance(&block)
-        admin.save_instance = block
+        admin.define_adapter_method(:save_instance, &block)
       end
 
       def delete_instance(&block)
-        admin.delete_instance = block
+        admin.define_adapter_method(:delete_instance, &block)
       end
 
       def to_param(&block)
-        admin.to_param = block
+        admin.define_adapter_method(:to_param, &block)
       end
 
       def params(&block)
-        admin.permitted_params = block
+        admin.define_adapter_method(:permitted_params, &block)
       end
 
       def decorator(decorator)
@@ -52,27 +59,28 @@ module Trestle
       end
 
       def decorate_collection(&block)
-        admin.decorate_collection = block
+        admin.define_adapter_method(:decorate_collection, &block)
       end
 
       def merge_scopes(&block)
-        admin.merge_scopes = block
+        admin.define_adapter_method(:merge_scopes, &block)
       end
 
       def sort(&block)
-        admin.sort = block
+        admin.define_adapter_method(:sort, &block)
       end
 
       def sort_column(column, &block)
         admin.column_sorts[column.to_sym] = block
       end
 
-      def paginate(&block)
-        admin.paginate = block
+      def paginate(options={}, &block)
+        admin.pagination_options = admin.pagination_options.merge(options)
+        admin.define_adapter_method(:paginate, &block)
       end
 
       def count(&block)
-        admin.count = block
+        admin.define_adapter_method(:count, &block)
       end
 
       def scope(name, scope=nil, options={}, &block)
@@ -83,6 +91,24 @@ module Trestle
 
         admin.scopes[name] = Scope.new(admin, name, options, &(scope || block))
       end
+
+      def return_to(options={}, &block)
+        actions = options.key?(:on) ? Array(options[:on]) : [:create, :update, :destroy]
+
+        actions.each do |action|
+          admin.return_locations[action.to_sym] = block
+        end
+      end
+
+    protected
+      def normalize_table_options(name, options)
+        if name.is_a?(Hash)
+          # Default index table
+          name, options = :index, name.reverse_merge(sortable: true)
+        end
+
+        [name, options.reverse_merge(admin: admin)]
+      end
     end
   end
 end

data/lib/trestle/resource/collection.rb

@@ -0,0 +1,68 @@
+module Trestle
+  class Resource
+    class Collection
+      delegate :collection, :paginate, :finalize_collection, :decorate_collection,
+               :scopes, :merge_scopes, :column_sorts, :sort, to: :@admin
+
+      def initialize(admin, options={})
+        @admin, @options = admin, options
+      end
+
+      def prepare(params)
+        collection = collection(params)
+        collection = apply_scopes(collection, params)  if scope?
+        collection = apply_sorting(collection, params) if sort?
+        collection = paginate(collection, params)      if paginate?
+        collection = finalize_collection(collection)   if finalize?
+        collection = decorate_collection(collection)   if decorate?
+        collection
+      end
+
+      def scope?
+        @options[:scope] != false
+      end
+
+      def sort?
+        @options[:sort] != false
+      end
+
+      def paginate?
+        @options[:paginate] != false
+      end
+
+      def finalize?
+        @options[:finalize] != false
+      end
+
+      def decorate?
+        @options[:decorate] != false
+      end
+
+    private
+      def apply_scopes(collection, params)
+        unscoped = collection(params)
+
+        active_scopes(params).reduce(collection) do |collection, scope|
+          merge_scopes(collection, scope.apply(unscoped))
+        end
+      end
+
+      def active_scopes(params)
+        scopes.values.select { |s| s.active?(params) }
+      end
+
+      def apply_sorting(collection, params)
+        return collection unless params[:sort]
+
+        field = params[:sort].to_sym
+        order = params[:order].to_s.downcase == "desc" ? :desc : :asc
+
+        if column_sorts.has_key?(field)
+          @admin.instance_exec(collection, order, &column_sorts[field])
+        else
+          sort(collection, field, order)
+        end
+      end
+    end
+  end
+end