dry_crud 2.1.1 → 2.1.2

data/app/helpers/dry_crud/table/builder.rb

@@ -1,115 +1,116 @@
 # encoding: UTF-8
 
-module DryCrud::Table
-  # A simple helper to easily define tables listing several rows of the same
-  # data type.
-  #
-  # Example Usage:
-  #   DryCrud::Table::Builder.table(entries, template) do |t|
-  #     t.col('My Header', class: 'css') {|e| link_to 'Show', e }
-  #     t.attrs :name, :city
-  #   end
-  class Builder
-
-    include Sorting
-    include Actions
-
-    attr_reader :entries, :cols, :options, :template
-
-    delegate :content_tag, :format_attr, :column_type, :association, :dom_id,
-             :captionize, :add_css_class, :content_tag_nested,
-             to: :template
-
-    def initialize(entries, template, options = {})
-      @entries = entries
-      @template = template
-      @options = options
-      @cols = []
-    end
+module DryCrud
+  module Table
+    # A simple helper to easily define tables listing several rows of the same
+    # data type.
+    #
+    # Example Usage:
+    #   DryCrud::Table::Builder.table(entries, template) do |t|
+    #     t.col('My Header', class: 'css') {|e| link_to 'Show', e }
+    #     t.attrs :name, :city
+    #   end
+    class Builder
+
+      include Sorting
+      include Actions
+
+      attr_reader :entries, :cols, :options, :template
+
+      delegate :content_tag, :format_attr, :column_type, :association, :dom_id,
+               :captionize, :add_css_class, :content_tag_nested,
+               to: :template
+
+      def initialize(entries, template, options = {})
+        @entries = entries
+        @template = template
+        @options = options
+        @cols = []
+      end
 
-    # Convenience method to directly generate a table. Renders a row for each
-    # entry in entries. Takes a block that gets the table object as parameter
-    # for configuration. Returns the generated html for the table.
-    def self.table(entries, template, options = {})
-      t = new(entries, template, options)
-      yield t
-      t.to_html
-    end
+      # Convenience method to directly generate a table. Renders a row for each
+      # entry in entries. Takes a block that gets the table object as parameter
+      # for configuration. Returns the generated html for the table.
+      def self.table(entries, template, options = {})
+        t = new(entries, template, options)
+        yield t
+        t.to_html
+      end
 
-    # Define a column for the table with the given header, the html_options
-    # used for each td and a block rendering the contents of a cell for the
-    # current entry. The columns appear in the order they are defined.
-    def col(header = '', html_options = {}, &block)
-      @cols << Col.new(header, html_options, @template, block)
-    end
+      # Define a column for the table with the given header, the html_options
+      # used for each td and a block rendering the contents of a cell for the
+      # current entry. The columns appear in the order they are defined.
+      def col(header = '', html_options = {}, &block)
+        @cols << Col.new(header, html_options, @template, block)
+      end
 
-    # Convenience method to add one or more attribute columns.
-    # The attribute name will become the header, the cells will contain
-    # the formatted attribute value for the current entry.
-    def attrs(*attrs)
-      attrs.each do |a|
-        attr(a)
+      # Convenience method to add one or more attribute columns.
+      # The attribute name will become the header, the cells will contain
+      # the formatted attribute value for the current entry.
+      def attrs(*attrs)
+        attrs.each do |a|
+          attr(a)
+        end
       end
-    end
 
-    # Define a column for the given attribute and an optional header.
-    # If no header is given, the attribute name is used. The cell will
-    # contain the formatted attribute value for the current entry.
-    def attr(a, header = nil, html_options = {}, &block)
-      header ||= attr_header(a)
-      block ||= ->(e) { format_attr(e, a) }
-      add_css_class(html_options, align_class(a))
-      col(header, html_options, &block)
-    end
+      # Define a column for the given attribute and an optional header.
+      # If no header is given, the attribute name is used. The cell will
+      # contain the formatted attribute value for the current entry.
+      def attr(a, header = nil, html_options = {}, &block)
+        header ||= attr_header(a)
+        block ||= ->(e) { format_attr(e, a) }
+        add_css_class(html_options, align_class(a))
+        col(header, html_options, &block)
+      end
 
-    # Renders the table as HTML.
-    def to_html
-      content_tag :table, options do
-        content_tag(:thead, html_header) +
-        content_tag_nested(:tbody, entries) { |e| html_row(e) }
+      # Renders the table as HTML.
+      def to_html
+        content_tag :table, options do
+          content_tag(:thead, html_header) +
+          content_tag_nested(:tbody, entries) { |e| html_row(e) }
+        end
       end
-    end
 
-    # Returns css classes used for alignment of the cell data.
-    # Based on the column type of the attribute.
-    def align_class(attr)
-      entry = entries.present? ? entry_class.new : nil
-      case column_type(entry, attr)
-      when :integer, :float, :decimal
-        'right' unless association(entry, attr, :belongs_to)
-      when :boolean
-        'center'
+      # Returns css classes used for alignment of the cell data.
+      # Based on the column type of the attribute.
+      def align_class(attr)
+        entry = entries.present? ? entry_class.new : nil
+        case column_type(entry, attr)
+        when :integer, :float, :decimal
+          'right' unless association(entry, attr, :belongs_to)
+        when :boolean
+          'center'
+        end
       end
-    end
 
-    # Creates a header string for the given attr.
-    def attr_header(attr)
-      captionize(attr, entry_class)
-    end
+      # Creates a header string for the given attr.
+      def attr_header(attr)
+        captionize(attr, entry_class)
+      end
 
-    private
+      private
 
-    # Renders the header row of the table.
-    def html_header
-      content_tag_nested(:tr, cols) { |c| c.html_header }
-    end
+      # Renders the header row of the table.
+      def html_header
+        content_tag_nested(:tr, cols) { |c| c.html_header }
+      end
 
-    # Renders a table row for the given entry.
-    def html_row(entry)
-      attrs = {}
-      attrs[:id] = dom_id(entry) if entry.respond_to?(:to_key)
-      content_tag_nested(:tr, cols, attrs) { |c| c.html_cell(entry) }
-    end
+      # Renders a table row for the given entry.
+      def html_row(entry)
+        attrs = {}
+        attrs[:id] = dom_id(entry) if entry.respond_to?(:to_key)
+        content_tag_nested(:tr, cols, attrs) { |c| c.html_cell(entry) }
+      end
 
-    # Determines the class of the table entries.
-    # All entries should be of the same type.
-    def entry_class
-      if entries.respond_to?(:klass)
-        entries.klass
-      else
-        entries.first.class
+      # Determines the class of the table entries.
+      # All entries should be of the same type.
+      def entry_class
+        if entries.respond_to?(:klass)
+          entries.klass
+        else
+          entries.first.class
+        end
       end
     end
-
   end
 end

data/app/helpers/dry_crud/table/col.rb

@@ -1,25 +1,26 @@
 # encoding: UTF-8
 
-module DryCrud::Table
-  # Helper class to store column information.
-  class Col < Struct.new(:header, :html_options, :template, :block) #:nodoc:
+module DryCrud
+  module Table
+    # Helper class to store column information.
+    class Col < Struct.new(:header, :html_options, :template, :block) #:nodoc:
 
-    delegate :content_tag, :capture, to: :template
+      delegate :content_tag, :capture, to: :template
 
-    # Runs the Col block for the given entry.
-    def content(entry)
-      entry.nil? ? '' : capture(entry, &block)
-    end
+      # Runs the Col block for the given entry.
+      def content(entry)
+        entry.nil? ? '' : capture(entry, &block)
+      end
 
-    # Renders the header cell of the Col.
-    def html_header
-      content_tag(:th, header, html_options)
-    end
+      # Renders the header cell of the Col.
+      def html_header
+        content_tag(:th, header, html_options)
+      end
 
-    # Renders a table cell for the given entry.
-    def html_cell(entry)
-      content_tag(:td, content(entry), html_options)
+      # Renders a table cell for the given entry.
+      def html_cell(entry)
+        content_tag(:td, content(entry), html_options)
+      end
     end
-
   end
 end

data/app/helpers/dry_crud/table/sorting.rb

@@ -1,61 +1,63 @@
 # encoding: UTF-8
 
-module DryCrud::Table
-  # Provides headers with sort links. Expects a method :sortable?(attr)
-  # in the template/controller to tell if an attribute is sortable or not.
-  # Extracted into an own module for convenience.
-  module Sorting
-    # Create a header with sort links and a mark for the current sort
-    # direction.
-    def sort_header(attr, label = nil)
-      label ||= attr_header(attr)
-      template.link_to(label, sort_params(attr)) + current_mark(attr)
-    end
+module DryCrud
+  module Table
+    # Provides headers with sort links. Expects a method :sortable?(attr)
+    # in the template/controller to tell if an attribute is sortable or not.
+    # Extracted into an own module for convenience.
+    module Sorting
+      # Create a header with sort links and a mark for the current sort
+      # direction.
+      def sort_header(attr, label = nil)
+        label ||= attr_header(attr)
+        template.link_to(label, sort_params(attr)) + current_mark(attr)
+      end
 
-    # Same as :attrs, except that it renders a sort link in the header
-    # if an attr is sortable.
-    def sortable_attrs(*attrs)
-      attrs.each { |a| sortable_attr(a) }
-    end
+      # Same as :attrs, except that it renders a sort link in the header
+      # if an attr is sortable.
+      def sortable_attrs(*attrs)
+        attrs.each { |a| sortable_attr(a) }
+      end
 
-    # Renders a sort link header, otherwise similar to :attr.
-    def sortable_attr(a, header = nil, &block)
-      if template.sortable?(a)
-        attr(a, sort_header(a, header), &block)
-      else
-        attr(a, header, &block)
+      # Renders a sort link header, otherwise similar to :attr.
+      def sortable_attr(a, header = nil, &block)
+        if template.sortable?(a)
+          attr(a, sort_header(a, header), &block)
+        else
+          attr(a, header, &block)
+        end
       end
-    end
 
-    private
+      private
 
-    # Request params for the sort link.
-    def sort_params(attr)
-      params.merge(sort: attr, sort_dir: sort_dir(attr))
-    end
+      # Request params for the sort link.
+      def sort_params(attr)
+        params.merge(sort: attr, sort_dir: sort_dir(attr))
+      end
 
-    # The sort mark, if any, for the given attribute.
-    def current_mark(attr)
-      if current_sort?(attr)
-        (sort_dir(attr) == 'asc' ? ' ↑' : ' ↓').html_safe
-      else
-        ''
+      # The sort mark, if any, for the given attribute.
+      def current_mark(attr)
+        if current_sort?(attr)
+          (sort_dir(attr) == 'asc' ? ' ↑' : ' ↓').html_safe
+        else
+          ''
+        end
       end
-    end
 
-    # Returns true if the given attribute is the current sort column.
-    def current_sort?(attr)
-      params[:sort] == attr.to_s
-    end
+      # Returns true if the given attribute is the current sort column.
+      def current_sort?(attr)
+        params[:sort] == attr.to_s
+      end
 
-    # The sort direction to use in the sort link for the given attribute.
-    def sort_dir(attr)
-      current_sort?(attr) && params[:sort_dir] == 'asc' ? 'desc' : 'asc'
-    end
+      # The sort direction to use in the sort link for the given attribute.
+      def sort_dir(attr)
+        current_sort?(attr) && params[:sort_dir] == 'asc' ? 'desc' : 'asc'
+      end
 
-    # Delegate to template.
-    def params
-      template.params
+      # Delegate to template.
+      def params
+        template.params
+      end
     end
   end
 end

data/app/helpers/format_helper.rb

@@ -38,7 +38,7 @@ module FormatHelper
   # Renders a simple unordered list, which will
   # simply render all passed items or yield them
   # to your block.
-  def simple_list(items, ul_options = {}, &block)
+  def simple_list(items, ul_options = {})
     content_tag_nested(:ul, items, ul_options) do |item|
       content_tag(:li, block_given? ? yield(item) : f(item))
     end
@@ -157,7 +157,7 @@ module FormatHelper
 
   # Returns true if no link should be created when formatting the given
   # association.
-  def assoc_link?(assoc, val)
+  def assoc_link?(_assoc, val)
     respond_to?("#{val.class.model_name.singular_route_key}_path".to_sym)
   end
 

data/app/helpers/table_helper.rb

@@ -15,7 +15,7 @@ module TableHelper
   # appended to the attribute columns.
   # If entries is empty, an appropriate message is rendered.
   # An options hash may be given as the last argument.
-  def plain_table(entries, *attrs, &block)
+  def plain_table(entries, *attrs)
     options = attrs.extract_options!
     add_css_class(options, 'table table-striped table-hover')
     builder = options.delete(:builder) || DryCrud::Table::Builder
@@ -73,7 +73,7 @@ module TableHelper
 
   private
 
-  def explode_attrs_with_options(attrs, &block)
+  def explode_attrs_with_options(attrs)
     options = attrs.extract_options!
     if !block_given? && attrs.blank?
       attrs = default_crud_attrs

data/lib/generators/dry_crud/file_generator.rb

@@ -10,7 +10,7 @@ module DryCrud
 
     argument :filename, type: :string, desc: 'Name or part of the filename to copy. Must match exactly one file.'
 
-    def copy_file
+    def copy_matching_file
       files = matching_files
       case files.size
       when 1
@@ -29,7 +29,7 @@ module DryCrud
 
     def matching_files
       all_template_files.collect do |root, files|
-        files.select do |f| 
+        files.select do |f|
           included = f.include?(filename)
           @root_folder = root if included
           included

data/lib/generators/dry_crud/templates/spec/controllers/crud_test_models_controller_spec.rb

@@ -195,7 +195,7 @@ describe CrudTestModelsController do
     context '.js', format: :js, combine: 'ijs' do
       it_should_respond
       it_should_assign_entries
-      its(:body) { should == 'index js' }
+      it { response.body.should == 'index js' }
     end
   end
 
@@ -318,6 +318,7 @@ describe CrudTestModelsController do
           it_should_persist_entry(false)
           it_should_not_have_flash(:notice)
           it_should_not_have_flash(:alert)
+          it_should_render_error_json
 
           it 'should not assign companions' do
             assigns(:companions).should be_nil
@@ -327,8 +328,6 @@ describe CrudTestModelsController do
             controller.called_callbacks.should ==
               [:before_create, :before_save]
           end
-
-          its(:body) { should match(/errors/) }
         end
       end
     end
@@ -376,12 +375,11 @@ describe CrudTestModelsController do
       context '.json', format: :json, combine: 'ujivp' do
         it_should_respond(422)
         it_should_not_have_flash(:notice)
+        it_should_render_error_json
 
         it 'should have called the correct callbacks' do
           controller.called_callbacks.should == [:before_update, :before_save]
         end
-
-        its(:body) { should match(/errors/) }
       end
     end
 
@@ -414,7 +412,7 @@ describe CrudTestModelsController do
       context '.json', format: :json, combine: 'djf' do
         it_should_respond(422)
         it_should_not_have_flash(:notice)
-        its(:body) { should match(/errors/) }
+        it_should_render_error_json
       end
 
       context 'callback', perform_request: false do