dry_crud 1.7.0 → 2.0.0

data/lib/generators/dry_crud/templates/INSTALL

@@ -1,11 +1,11 @@
 
-Thank you for using dry_crud. Feel free to adapt all generated classes to 
-your needs. To integrate dry_crud into your code, only a few additions are 
+Thank you for using dry_crud. Feel free to adapt all generated classes to
+your needs. To integrate dry_crud into your code, only a few additions are
 required:
 
- * For uniform CRUD functionallity, just subclass your controllers from 
-   CrudController. 
- * Overwrite the :to_s method of your models for a human-friendly
+ * For uniform CRUD functionallity, just subclass your controllers from
+   CrudController.
+ * Overwrite the #to_s method of your models for a human-friendly
    representation.
 
 

data/lib/generators/dry_crud/templates/app/assets/stylesheets/crud.scss

@@ -7,26 +7,6 @@
   text-align: center;
 }
 
-.labeled {
-  vertical-align: top;
-  padding: 2px 0 2px;
-  clear: both;
-}
-
-.labeled label {
-  width: 120px;
-  padding-right: 5px;
-  float: left;
-}
-
-.labeled .value {
-  margin-left: 130px;
-}
-
-.labeled .value p {
-  margin: 0;
-}
-
 #content {
   clear: both;
   padding-top: 5px;

data/lib/generators/dry_crud/templates/app/assets/stylesheets/sample.scss

@@ -38,7 +38,7 @@ h1 {
   background-color: #F8F8F8;
 }
 
-.table tr:nth-child(even) { 
+.table tr:nth-child(even) {
   background-color: #F0F0F0;
 }
 
@@ -67,6 +67,27 @@ a img {
   border: none;
 }
 
+dl {
+  vertical-align: top;
+  padding: 2px 0 2px;
+  clear: both;
+}
+
+dt {
+  width: 120px;
+  padding-right: 5px;
+  float: left;
+  font-style: italic;
+}
+
+dd {
+  margin-left: 130px;
+}
+
+dd p {
+  margin: 0;
+}
+
 .table {
   margin-top: 10px;
 }
@@ -81,7 +102,6 @@ table.table {
 div.table {}
 
 table.table th {
-  text-align: left;  
   background-color: $theme_color;
   color: white;
   font-weight: bold;
@@ -89,12 +109,12 @@ table.table th {
 }
 
 table.table th a {
-  color: white;  
+  color: white;
   text-decoration: none;
 }
 
 table.table td {
-  padding: 2px 4px;  
+  padding: 2px 4px;
 }
 
 label {

data/lib/generators/dry_crud/templates/app/controllers/crud/generic_model.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+module Crud
+  # Connects the including controller to the model whose name corrsponds to
+  # the controller's name.
+  #
+  # The two main methods are +model_class+ and +model_scope+.
+  # Additional helper methods store and retrieve values in instance variables
+  # named after their class.
+  module GenericModel
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :model_class, :models_label, :path_args
+
+    private
+
+      delegate :model_class, :models_label, :model_identifier, to: 'self.class'
+    end
+
+    private
+
+  # The scope where model entries will be listed and created.
+  # This is mainly used for nested models to provide the
+  # required context.
+  def model_scope
+<% if Rails.version < '4.0' -%>
+    model_class.scoped
+<% else -%>
+    model_class.all
+<% end -%><%# > fixing rdoc -%>
+  end
+
+    # The path arguments to link to the given model entry.
+    # If the controller is nested, this provides the required context.
+    def path_args(last)
+      last
+    end
+
+  # Get the instance variable named after the +model_class+.
+  # If the collection variable is required, pass true as the second argument.
+  def get_model_ivar(plural = false)
+    name = ivar_name(model_class)
+    name = name.pluralize if plural
+    instance_variable_get(:"@#{name}")
+  end
+
+  # Sets an instance variable with the underscored class name if the given
+  # value. If the value is a collection, sets the plural name.
+  def set_model_ivar(value)
+    name = if value.respond_to?(:klass) # ActiveRecord::Relation
+             ivar_name(value.klass).pluralize
+           elsif value.respond_to?(:each) # Array
+             ivar_name(value.first.class).pluralize
+           else
+             ivar_name(value.class)
+           end
+    instance_variable_set(:"@#{name}", value)
+  end
+
+  def ivar_name(klass)
+    klass.model_name.param_key
+  end
+
+  # Class methods from GenericModel.
+  module ClassMethods
+    # The ActiveRecord class of the model.
+    def model_class
+      @model_class ||= controller_name.classify.constantize
+    end
+
+      # The identifier of the model used for form parameters.
+      # I.e., the symbol of the underscored model name.
+      def model_identifier
+        @model_identifier ||= model_class.model_name.param_key
+      end
+
+    # A human readable plural name of the model.
+    def models_label(plural = true)
+      opts = { count: (plural ? 3 : 1) }
+      opts[:default] = model_class.model_name.human.titleize
+      opts[:default] = opts[:default].pluralize if plural
+
+      model_class.model_name.human(opts)
+    end
+  end
+
+  end
+end

data/lib/generators/dry_crud/templates/app/controllers/crud/nestable.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+
+module Crud
+  # Provides functionality to nest controllers/resources.
+  # If a controller is nested, the parent classes and namespaces
+  # may be defined as an array in the +nesting+ class attribute.
+  #
+  # For example, a cities controller, nested in country and a admin
+  # namespace, may define this attribute as follows:
+  #   self.nesting = :admin, Country
+  module Nestable
+    extend ActiveSupport::Concern
+
+    # Adds the :nesting class attribute and parent helper methods
+    # to the including controller.
+    included do
+      class_attribute :nesting
+
+      helper_method :parent, :parents
+
+      alias_method_chain :path_args, :nesting
+      alias_method_chain :model_scope, :nesting
+    end
+
+    private
+
+    # Returns the direct parent ActiveRecord of the current request, if any.
+    def parent
+      parents.select { |p| p.is_a?(ActiveRecord::Base) }.last
+    end
+
+    # Returns the parent entries of the current request, if any.
+    # These are ActiveRecords or namespace symbols, corresponding
+    # to the defined nesting attribute.
+    def parents
+      @parents ||= Array(nesting).map do |p|
+        if p.is_a?(Class) && p < ActiveRecord::Base
+          parent_entry(p)
+        else
+          p
+        end
+      end
+    end
+
+    # Loads the parent entry for the given ActiveRecord class.
+    # By default, performs a find with the class_name_id param.
+    def parent_entry(clazz)
+      set_model_ivar(clazz.find(params["#{clazz.name.underscore}_id"]))
+    end
+
+    # An array of objects used in url_for and related functions.
+    def path_args_with_nesting(last)
+      parents + [last]
+    end
+
+    # Uses the parent entry (if any) to constrain the model scope.
+    def model_scope_with_nesting
+      if parent.present?
+        parent_scope
+      else
+        model_scope_without_nesting
+      end
+    end
+
+    # The model scope for the current parent resource.
+    def parent_scope
+      parent.send(model_class.name.underscore.pluralize)
+    end
+  end
+end

data/lib/generators/dry_crud/templates/app/controllers/crud/rememberable.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+module Crud
+  # Remembers certain params of the index action in order to return
+  # to the same list after an entry was viewed or edited.
+  # If the index is called with a param :returning, the remembered params
+  # will be re-used to present the user the same list as she left it.
+  #
+  # Define a list of param keys that should be remembered for the list action
+  # with the class attribute +remember_params+.
+  #
+  # The params are stored separately for each different +remember_key+, which
+  # defaults to the current request's path.
+  module Rememberable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :remember_params
+      self.remember_params = [:q, :sort, :sort_dir, :page]
+
+      before_filter :handle_remember_params, only: [:index]
+    end
+
+    private
+
+    # Store and restore the corresponding params.
+    def handle_remember_params
+      remembered = remembered_params
+
+      restore_params_on_return(remembered)
+      store_current_params(remembered)
+      clear_void_params(remembered)
+    end
+
+    def restore_params_on_return(remembered)
+      if params[:returning]
+        remember_params.each { |p| params[p] ||= remembered[p] }
+      end
+    end
+
+    def store_current_params(remembered)
+      remember_params.each do |p|
+        remembered[p] = params[p].presence
+        remembered.delete(p) if remembered[p].nil?
+      end
+    end
+
+    def clear_void_params(remembered)
+      session[:list_params].delete(remember_key) if remembered.blank?
+    end
+
+    # Get the params stored in the session.
+    def remembered_params
+      session[:list_params] ||= {}
+      session[:list_params][remember_key] ||= {}
+    end
+
+    # Params are stored by request path to play nice when a controller
+    # is used in different routes.
+    def remember_key
+       request.path
+    end
+  end
+end

data/lib/generators/dry_crud/templates/app/controllers/crud/render_callbacks.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+module Crud
+  # Provide +before_render+ callbacks.
+  module RenderCallbacks
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Callbacks
+
+      alias_method_chain :render, :callbacks
+    end
+
+    # Helper method to run +before_render+ callbacks and render the action.
+    # If a callback renders or redirects, the action is not rendered.
+    def render_with_callbacks(*args, &block)
+      options = _normalize_render(*args, &block)
+      callback = "render_#{options[:template]}"
+
+      run_callbacks(callback) if respond_to?(:"_#{callback}_callbacks", true)
+
+      render_without_callbacks(*args, &block) unless performed?
+    end
+
+    private
+
+    # Helper method the run the given block in between the before and after
+    # callbacks of the given kinds.
+    def with_callbacks(*kinds, &block)
+      kinds.reverse.reduce(block) do |a, e|
+        -> { run_callbacks(e, &a) }
+      end.call
+    end
+
+    # Class methods for callbacks.
+    module ClassMethods
+      # Defines before callbacks for the render actions.
+      def define_render_callbacks(*actions)
+        args = actions.map { |a| :"render_#{a}" }
+        args << { only: :before,
+                  terminator: 'result == false || performed?' }
+        define_model_callbacks(*args)
+      end
+    end
+  end
+end

data/lib/generators/dry_crud/templates/app/controllers/crud/responder.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+module Crud
+  # Custom Responder that handles the controller's +path_args+.
+  # An additional :success option is used to handle action callback
+  # chain halts.
+  class Responder < ActionController::Responder
+
+    def initialize(controller, resources, options = {})
+      super(controller, with_path_args(resources, controller), options)
+    end
+
+    private
+
+    # Check whether the resource has errors. Additionally checks the :success
+    # option.
+    def has_errors?
+      options[:success] == false || super
+    end
+
+    # Wraps the resources with the path_args for correct nesting.
+    def with_path_args(resources, controller)
+      if resources.size == 1
+        Array(controller.send(:path_args, resources.first))
+      else
+        resources
+      end
+    end
+
+  end
+end

data/lib/generators/dry_crud/templates/app/controllers/crud/searchable.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+module Crud
+  # The search functionality for the index table.
+  # Define an array of searchable columns in your subclassing controllers
+  # using the class attribute +search_columns+.
+  module Searchable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :search_columns
+      self.search_columns = []
+
+      helper_method :search_support?
+
+      alias_method_chain :list_entries, :search
+    end
+
+    private
+
+    # Enhance the list entries with an optional search criteria
+    def list_entries_with_search
+      list_entries_without_search.where(search_condition)
+    end
+
+    # Compose the search condition with a basic SQL OR query.
+    def search_condition
+      if search_support? && params[:q].present?
+        col_clause = search_column_clause
+        terms = params[:q].split(/\s+/).map { |t| "%#{t}%" }
+        term_clause = terms.map { |t| "(#{col_clause})" }.join(' AND ')
+
+        term_params = terms.map { |t| [t] * search_columns.size }.flatten
+        ["(#{term_clause})", *term_params]
+      end
+    end
+
+    # SQL where clause with all search colums or'ed.
+    def search_column_clause
+      search_columns.map do |f|
+        if f.to_s.include?('.')
+          "#{f} LIKE ?"
+        else
+          "#{model_class.table_name}.#{f} LIKE ?"
+        end
+      end.join(' OR ')
+    end
+
+    # Returns true if this controller has searchable columns.
+    def search_support?
+      search_columns.present?
+    end
+
+  end
+end