trestle 0.8.3 → 0.8.6

data/lib/trestle/adapters/active_record_adapter.rb

@@ -2,19 +2,19 @@ module Trestle
   module Adapters
     module ActiveRecordAdapter
       def collection(params={})
-        admin.model.all
+        model.all
       end
 
       def find_instance(params)
-        admin.model.find(params[:id])
+        model.find(params[:id])
       end
 
-      def build_instance(params={})
-        admin.model.new(params)
+      def build_instance(attrs={}, params={})
+        model.new(attrs)
       end
 
-      def update_instance(instance, params)
-        instance.assign_attributes(params)
+      def update_instance(instance, attrs, params={})
+        instance.assign_attributes(attrs)
       end
 
       def save_instance(instance)
@@ -25,10 +25,6 @@ module Trestle
         instance.destroy
       end
 
-      def to_param(instance)
-        instance
-      end
-
       def unscope(scope)
         scope.unscoped
       end
@@ -37,27 +33,57 @@ module Trestle
         scope.merge(other)
       end
 
+      def count(collection)
+        collection.count
+      end
+
       def sort(collection, field, order)
         collection.reorder(field => order)
       end
 
-      def paginate(collection, params)
-        collection = Kaminari.paginate_array(collection) unless collection.respond_to?(:page)
-        collection.page(params[:page])
+      def human_attribute_name(attribute, options={})
+        model.human_attribute_name(attribute, options)
       end
 
-      def count(collection)
-        collection.count
+      def default_table_attributes
+        default_attributes.reject do |attribute|
+          inheritance_column?(attribute) || counter_cache_column?(attribute)
+        end
       end
 
+      def default_form_attributes
+        default_attributes.reject do |attribute|
+          primary_key?(attribute) || inheritance_column?(attribute) || counter_cache_column?(attribute)
+        end
+      end
+
+    protected
       def default_attributes
-        admin.model.columns.map do |column|
-          if column.name.end_with?("_id") && (reflection = admin.model.reflections[column.name.sub(/_id$/, '')])
-            Attribute::Association.new(admin, column.name, reflection.klass)
+        model.columns.map do |column|
+          if column.name.end_with?("_id") && (name = column.name.sub(/_id$/, '')) && (reflection = model.reflections[name])
+            Attribute::Association.new(column.name, class: -> { reflection.klass }, name: name, polymorphic: reflection.polymorphic?, type_column: reflection.foreign_type)
+          elsif column.name.end_with?("_type") && (name = column.name.sub(/_type$/, '')) && (reflection = model.reflections[name])
+            # Ignore type columns for polymorphic associations
           else
-            Attribute.new(admin, column.name, column.type)
+            Attribute.new(column.name, column.type, array_column?(column) ? { array: true } : {})
           end
-        end
+        end.compact
+      end
+
+      def primary_key?(attribute)
+        attribute.name.to_s == model.primary_key
+      end
+
+      def inheritance_column?(attribute)
+        attribute.name.to_s == model.inheritance_column
+      end
+
+      def counter_cache_column?(attribute)
+        attribute.name.to_s.end_with?("_count")
+      end
+
+      def array_column?(column)
+        column.respond_to?(:array?) && column.array?
       end
     end
   end

data/lib/trestle/adapters/adapter.rb

@@ -0,0 +1,176 @@
+module Trestle
+  module Adapters
+    class Adapter
+      attr_reader :admin
+      delegate :model, to: :admin
+
+      def initialize(admin)
+        @admin = admin
+      end
+
+      # Loads the initial collection for use by the index action.
+      #
+      # params - Unfiltered params hash from the controller
+      #
+      # Returns a scope object that can be chained with other methods (e.g. sort, paginate, count, etc).
+      def collection(params={})
+        raise NotImplementedError
+      end
+
+      # Finds (and returns) an individual instance for use by the show, edit, update, destroy actions.
+      #
+      # params - Unfiltered params hash from the controller
+      def find_instance(params)
+        raise NotImplementedError
+      end
+
+      # Builds (and returns) a new instance for new/create actions.
+      #
+      # attrs  - Permitted attributes to set on the new instance
+      # params - Unfiltered params hash from the controller
+      def build_instance(attrs={}, params={})
+        raise NotImplementedError
+      end
+
+      # Updates (but does not save) a given resource's attributes.
+      #
+      # instance - The instance to update
+      # attrs    - Permitted attributes to update on the instance
+      # params   - Unfiltered params hash from the controller
+      #
+      # The return value is ignored.
+      def update_instance(instance, attrs, params={})
+        raise NotImplementedError
+      end
+
+      # Saves an instance (used by the create and update actions).
+      #
+      # instance - The instance to save
+      #
+      # Returns a boolean indicating the success/fail status of the save.
+      def save_instance(instance)
+        raise NotImplementedError
+      end
+
+      # Deletes an instance (used by the destroy action).
+      #
+      # instance - The instance to delete
+      #
+      # Returns a boolean indicating the success/fail status of the deletion.
+      def delete_instance(instance)
+        raise NotImplementedError
+      end
+
+      # Decorates a collection for rendering by the index view.
+      # Decorating is the final step in preparing the collection for the view.
+      #
+      # collection - The collection to decorate
+      #
+      # Returns an enumerable collection of instances.
+      def decorate_collection(collection)
+        collection
+      end
+
+      # Converts an instance to a URL parameter. The result of this method is passed to the #find_instance
+      # adapter method as params[:id]. It is recommended to simply use the instance's #id, as other potential options
+      # such as a permalink/slug could potentially be changed during editing.
+      #
+      # instance - The instance to convert
+      #
+      # Returns the URL representation of the instance.
+      def to_param(instance)
+        instance.id
+      end
+
+      # Unscopes a collection so that it can be merged with other scopes without duplication or interference.
+      #
+      # scope - The scope to unscope
+      #
+      # Returns a scope object.
+      def unscope(scope)
+        scope
+      end
+
+      # Merges scopes together for Trestle scope application and counting.
+      #
+      # scope - The first scope
+      # other - The second scope
+      #
+      # Returns a scope object representing the combination of the two given scopes.
+      def merge_scopes(scope, other)
+        raise NotImplementedError
+      end
+
+      # Counts the number of objects in a collection for use by scope links.
+      #
+      # collection - The collection to count
+      #
+      # Returns the total number (integer) of objects in the collection.
+      def count(collection)
+        raise NotImplementedError
+      end
+
+      # Sorts the collection by the given field and order.
+      # This method is called when an explicit sort column for the given field is not defined.
+      #
+      # collection - The collection to sort
+      # field      - The field to sort by
+      # order      - Symbol (:asc or :desc) representing the sort order (ascending or descending)
+      #
+      # Returns a scope object
+      def sort(collection, field, order)
+        raise NotImplementedError
+      end
+
+      # Paginates a collection for use by the index action.
+      #
+      # collection - The collection to paginate
+      # params     - Unfiltered params hash from the controller:
+      #              :page - current page number
+      #
+      # Returns a Kaminari-compatible scope corresponding to a single page.
+      def paginate(collection, params)
+        collection = Kaminari.paginate_array(collection.to_a) unless collection.respond_to?(:page)
+        collection.page(params[:page])
+      end
+
+      # Filters the submitted form parameters and returns a whitelisted attributes 'hash'
+      # that can be set or updated on a model instance.
+      #
+      # IMPORTANT: By default, all params are permitted, which assumes a trusted administrator. If this is not the
+      # case, a `params` block should be individually declared for each admin with the set of permitted parameters.
+      #
+      # params - Unfiltered params hash from the controller
+      #
+      # Returns the permitted set of parameters as a ActionController::Parameters object.
+      def permitted_params(params)
+        params.require(admin.admin_name.singularize).permit!
+      end
+
+      # Produces a human-readable name for a given attribute, applying I18n where appropriate.
+      # See ActiveModel::Translation for an implementation of this method.
+      #
+      # attribute - Attribute name (Symbol)
+      # options   - Hash of options [not currently used]
+      #
+      # Returns the human-readable name of the given attribute as a String.
+      def human_attribute_name(attribute, options={})
+        attribute.to_s.titleize
+      end
+
+      # Generates a list of attributes that should be rendered by the index (table) view.
+      #
+      # Returns an Array of Trestle::Attribute and/or Trestle::Attribute::Association objects.
+      def default_table_attributes
+        raise NotImplementedError
+      end
+
+      # Generates a list of attributes that should be rendered by the new/show/edit (form) views.
+      #
+      # Returns an Array of Trestle::Attribute and/or Trestle::Attribute::Association objects.
+      def default_form_attributes
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/trestle/adapters/sequel_adapter.rb

@@ -0,0 +1,85 @@
+begin
+  require "sequel"
+rescue LoadError
+  $stderr.puts "You don't have sequel installed in your application. Please add it to your Gemfile and run bundle install"
+  raise
+end
+
+Sequel::Model.plugin :active_model
+
+module Trestle
+  module Adapters
+    module SequelAdapter
+      def collection(params={})
+        model.dataset
+      end
+
+      def find_instance(params)
+        model[params[:id]]
+      end
+
+      def build_instance(attrs={}, params={})
+        model.new(attrs)
+      end
+
+      def update_instance(instance, attrs, params={})
+        instance.set(attrs)
+      end
+
+      def save_instance(instance)
+        instance.save
+      end
+
+      def delete_instance(instance)
+        instance.destroy
+      end
+
+      def unscope(scope)
+        scope.unfiltered
+      end
+
+      def merge_scopes(scope, other)
+        scope.intersect(other)
+      end
+
+      def count(collection)
+        collection.count
+      end
+
+      def sort(collection, field, order)
+        collection.order(Sequel.send(order, field))
+      end
+
+      def default_table_attributes
+        default_attributes.reject do |attribute|
+          inheritance_column?(attribute)
+        end
+      end
+
+      def default_form_attributes
+        default_attributes.reject do |attribute|
+          primary_key?(attribute) || inheritance_column?(attribute)
+        end
+      end
+
+    protected
+      def default_attributes
+        model.db_schema.map do |column_name, column_attrs|
+          if column_name.to_s.end_with?("_id") && (name = column_name.to_s.sub(/_id$/, '')) && (reflection = model.association_reflection(name.to_sym))
+            Attribute::Association.new(column_name, class: -> { reflection.associated_class }, name: name)
+          else
+            Attribute.new(column_name, column_attrs[:type])
+          end
+        end
+      end
+
+      def primary_key?(attribute)
+        attribute.name.to_s == model.primary_key.to_s
+      end
+
+      def inheritance_column?(attribute)
+        model.respond_to?(:sti_key) && attribute.name.to_s == model.sti_key.to_s
+      end
+    end
+  end
+end

data/lib/trestle/adapters.rb

@@ -2,73 +2,16 @@ module Trestle
   module Adapters
     extend ActiveSupport::Autoload
 
+    autoload :Adapter
+
     autoload :ActiveRecordAdapter
     autoload :DraperAdapter
+    autoload :SequelAdapter
 
-    class Adapter
-      attr_reader :admin
-
-      def initialize(admin)
-        @admin = admin
-      end
-
-      def collection(params={})
-        raise NotImplementedError
-      end
-
-      def find_instance(params)
-        raise NotImplementedError
-      end
-
-      def build_instance(params={})
-        raise NotImplementedError
-      end
-
-      def update_instance(instance, params)
-        raise NotImplementedError
-      end
-
-      def save_instance(instance)
-        raise NotImplementedError
-      end
-
-      def delete_instance(instance)
-        raise NotImplementedError
-      end
-
-      def decorate_collection(collection)
-        collection
-      end
-
-      def merge_scopes(scope, other)
-        raise NotImplementedError
-      end
-
-      def sort(collection, params)
-        raise NotImplementedError
-      end
-
-      def paginate(collection, params)
-        raise NotImplementedError
-      end
-
-      def count(collection)
-        raise NotImplementedError
-      end
-
-      def permitted_params(params)
-        params.require(admin.admin_name.singularize).permit!
-      end
-
-      def default_attributes
-        raise NotImplementedError
-      end
-
-      # Creates a new Adapter class with the given modules mixed in
-      def self.compose(*modules)
-        Class.new(self) do
-          modules.each { |mod| include(mod) }
-        end
+    # Creates a new Adapter class with the given modules mixed in
+    def self.compose(*modules)
+      Class.new(Adapter) do
+        modules.each { |mod| include(mod) }
       end
     end
   end

data/lib/trestle/admin/builder.rb

@@ -42,8 +42,8 @@ module Trestle
         admin.table = Table::Builder.build(options.reverse_merge(admin: admin, sortable: true), &block)
       end
 
-      def form(&block)
-        admin.form = Form.new(&block)
+      def form(options={}, &block)
+        admin.form = Form.new(options, &block)
       end
 
       def admin(&block)
@@ -59,6 +59,14 @@ module Trestle
       def routes(&block)
         @admin.additional_routes = block
       end
+
+      def breadcrumb(label=nil, path=nil, &block)
+        if block_given?
+          @admin.breadcrumb = block
+        else
+          @admin.breadcrumb = -> { Breadcrumb.new(label, path) }
+        end
+      end
     end
   end
 end

data/lib/trestle/admin.rb

@@ -14,6 +14,7 @@ module Trestle
       attr_accessor :additional_routes
 
       attr_writer :options
+      attr_writer :breadcrumb
 
       def options
         @options ||= {}
@@ -24,7 +25,15 @@ module Trestle
       end
 
       def breadcrumb
-        Breadcrumb.new(admin_name.titleize.pluralize, path)
+        if @breadcrumb
+          Breadcrumb.cast(@breadcrumb.call)
+        else
+          default_breadcrumb
+        end
+      end
+
+      def default_breadcrumb
+        Breadcrumb.new(I18n.t("admin.breadcrumbs.#{admin_name}", default: admin_name.titleize), path)
       end
 
       def admin_name
@@ -47,6 +56,10 @@ module Trestle
         Engine.routes.url_for(options.merge(controller: controller_namespace, action: action, only_path: true))
       end
 
+      def actions
+        [:index]
+      end
+
       def routes
         admin = self
 

data/lib/trestle/attribute.rb

@@ -1,53 +1,30 @@
 module Trestle
   class Attribute
-    attr_reader :admin, :name, :type
+    attr_reader :name, :type, :options
 
-    def initialize(admin, name, type)
-      @admin, @name, @type = admin, name.to_sym, type
+    def initialize(name, type, options={})
+      @name, @type, @options = name.to_sym, type, options
     end
 
-    def association?
-      type == :association
-    end
-
-    def boolean?
-      type == :boolean
-    end
-
-    def text?
-      type == :text
-    end
-
-    def datetime?
-      [:datetime, :time, :date].include?(type)
-    end
-
-    def primary_key?
-      name.to_s == admin.model.primary_key
-    end
-
-    def inheritance_column?
-      name.to_s == admin.model.inheritance_column
-    end
-
-    def counter_cache?
-      name.to_s.end_with?("_count")
+    def array?
+      options[:array] == true
     end
 
     class Association < Attribute
-      attr_reader :association_class
-
-      def initialize(admin, name, association_class)
-        super(admin, name, :association)
-        @association_class = association_class
+      def initialize(name, options={})
+        super(name, :association, options)
       end
 
       def association_name
-        name.to_s.sub(/_id$/, "")
+        options[:name] || name.to_s.sub(/_id$/, "")
+      end
+
+      def association_class
+        options[:class].respond_to?(:call) ? options[:class].call : options[:class]
       end
 
-      def association_admin
-        Trestle.admins[association_class.name.underscore.pluralize]
+      def polymorphic?
+        options[:polymorphic] == true
       end
     end
   end

data/lib/trestle/breadcrumb.rb

@@ -10,11 +10,30 @@ module Trestle
       label == other.label && path == other.path
     end
 
+    def self.cast(obj)
+      case obj
+      when Breadcrumb
+        obj
+      when String
+        new(obj)
+      when Array
+        new(*obj)
+      else
+        raise ArgumentError, "Unable to cast #{obj.inspect} to Breadcrumb"
+      end
+    end
+
     class Trail
+      include Enumerable
+
       def initialize(breadcrumbs=[])
         @breadcrumbs = Array(breadcrumbs)
       end
 
+      def ==(other)
+        to_a == other.to_a
+      end
+
       def dup
         self.class.new(@breadcrumbs.dup)
       end

data/lib/trestle/configuration.rb

@@ -64,10 +64,10 @@ module Trestle
     option :persistent_params, [:sort, :order, :scope]
 
     # List of methods to try calling on an instance when displayed by the `display` helper
-    option :display_methods, [:display_name, :full_name, :name, :title, :username, :login, :email, :to_s]
+    option :display_methods, [:display_name, :full_name, :name, :title, :username, :login, :email]
 
     # Default adapter class used by all admin resources
-    option :default_adapter, Adapters::Adapter.compose(Adapters::ActiveRecordAdapter, Adapters::DraperAdapter)
+    option :default_adapter, Adapters.compose(Adapters::ActiveRecordAdapter, Adapters::DraperAdapter)
 
     # Register a custom form field class
     def form_field(name, klass)
@@ -83,7 +83,18 @@ module Trestle
     end
 
     # List of i18n keys to pass into the Trestle.i18n JavaScript object
-    option :javascript_i18n_keys, ["admin.confirmation.title", "admin.confirmation.delete", "admin.confirmation.cancel"]
+    option :javascript_i18n_keys, ["admin.confirmation.title", "admin.confirmation.delete", "admin.confirmation.cancel", "trestle.dialog.error", "admin.buttons.ok"]
+
+    # List of load paths for where to find admin definitions
+    option :load_paths, [
+      -> { ActiveSupport::Dependencies.autoload_paths.grep(/\/app\/admin\Z/) }
+    ]
+
+
+    ## Debugging
+
+    # Enable debugging of form errors
+    option :debug_form_errors, Rails.env.development?
 
 
     ## Callbacks

data/lib/trestle/display.rb

@@ -14,7 +14,7 @@ module Trestle
 
   private
     def display_method
-      @display_method ||= Trestle.config.display_methods.find { |m| @instance.respond_to?(m) }
+      @display_method ||= Trestle.config.display_methods.find { |m| @instance.respond_to?(m) } || :to_s
     end
   end
 end