releaf-core 0.2.1 → 1.0.3

data/spec/builders/releaf/builders/page/menu_builder_spec.rb

@@ -0,0 +1,345 @@
+require "rails_helper"
+
+describe Releaf::Builders::Page::MenuBuilder, type: :class do
+  class MenuBuilderTestHelper < ActionView::Base
+    include FontAwesome::Rails::IconHelper
+  end
+
+  let(:controller){ Releaf::ActionController.new }
+  let(:template){ MenuBuilderTestHelper.new }
+  let(:group_item){ Releaf::ControllerGroupDefinition.new(name: "_group_name", items: []) }
+  let(:controller_item){ Releaf::ControllerDefinition.new(name: "y", controller: "_controller_") }
+  subject { described_class.new(template) }
+
+  before do
+    allow(template).to receive(:controller).and_return(controller)
+  end
+
+  it "includes Releaf::Builders::Base" do
+    expect(described_class.ancestors).to include(Releaf::Builders::Base)
+  end
+
+  it "includes Releaf::Builders::Template" do
+    expect(described_class.ancestors).to include(Releaf::Builders::Template)
+  end
+
+  describe "#output" do
+    it "returns compacter and first level menu" do
+      allow(Releaf.application.config).to receive(:menu).and_return("_menu_config")
+      allow(subject).to receive(:compacter).and_return("cmpt")
+      allow(subject).to receive(:menu_level).with("_menu_config").and_return("_items")
+
+      expect(subject.output).to eq("cmpt<nav>_items</nav>")
+    end
+  end
+
+  describe "#active?" do
+    context "when item is instance of `Releaf::ControllerGroupDefinition`" do
+      before do
+        allow(subject).to receive(:active?).and_call_original
+        allow(group_item).to receive(:controllers).and_return([:a, :b, :c])
+      end
+
+      context "when any of group item controller is active" do
+        it "returns true" do
+          allow(subject).to receive(:active?).with(:a).and_return(false)
+          allow(subject).to receive(:active?).with(:b).and_return(true)
+          expect(subject).to_not receive(:active?).with(:c)
+          expect(subject.active?(group_item)).to be true
+        end
+      end
+
+      context "when none of group item controller is active" do
+        it "returns false" do
+          allow(subject).to receive(:active?).with(:a).and_return(false)
+          allow(subject).to receive(:active?).with(:b).and_return(false)
+          allow(subject).to receive(:active?).with(:c).and_return(false)
+          expect(subject.active?(group_item)).to be false
+        end
+      end
+    end
+
+    context "when item is instance of `Releaf::ControllerDefinition`" do
+      context "when item controller name is same as current controller short name" do
+        it "returns true" do
+          allow(controller).to receive(:short_name).and_return("_controller_")
+          expect(subject.active?(controller_item)).to be true
+        end
+      end
+
+      context "when item controller name is not same as current controller short name" do
+        it "returns false" do
+          allow(controller).to receive(:short_name).and_return("_another_controller_")
+          expect(subject.active?(controller_item)).to be false
+        end
+      end
+    end
+  end
+
+  describe "#menu_level" do
+    it "returns unordered list of menu level from given items" do
+      allow(subject).to receive(:menu_item).with("a").and_return("_a_")
+      allow(subject).to receive(:menu_item).with("b").and_return("_b_")
+      expect(subject.menu_level(%w(a b))).to eq("<ul>_a__b_</ul>")
+    end
+
+    context "when all menu items content is empty" do
+      it "returns nil" do
+        allow(subject).to receive(:menu_item).with("a").and_return(nil)
+        allow(subject).to receive(:menu_item).with("b").and_return(nil)
+        expect(subject.menu_level(%w(a b))).to be nil
+      end
+    end
+  end
+
+  describe "#menu_item" do
+    before do
+      allow(subject).to receive(:item_attributes).with(controller_item).and_return(class: "red")
+      allow(subject).to receive(:menu_item_single).with(controller_item).and_return("_item")
+      allow(subject).to receive(:item_attributes).with(group_item).and_return(class: "blue")
+      allow(subject).to receive(:menu_item_group).with(group_item).and_return("_items_group")
+    end
+
+    context "when item is instance of `Releaf::ControllerDefinition`" do
+      it "returns single menu item" do
+        expect(subject.menu_item(controller_item)).to eq("<li class=\"red\">_item</li>")
+      end
+    end
+
+    context "when item is instance of `Releaf::ControllerGroupDefinition`" do
+      it "returns group menu item" do
+        expect(subject.menu_item(group_item)).to eq("<li class=\"blue\">_items_group</li>")
+      end
+    end
+  end
+
+  describe "#menu_item_single" do
+    it "returns single menu item" do
+      allow(controller_item).to receive(:path).and_return("_url")
+      allow(subject).to receive(:item_name_content).with(controller_item).and_return("_name")
+      expect(subject.menu_item_single(controller_item)).to eq("<a class=\"trigger\" href=\"_url\">_name</a>")
+    end
+  end
+
+  describe "#menu_item_group" do
+    it "returns group menu item" do
+      allow(group_item).to receive(:controllers).and_return(["a"])
+      allow(subject).to receive(:item_collapser).with(group_item).and_return("_collapser")
+      allow(subject).to receive(:item_name_content).with(group_item).and_return("_name")
+      allow(subject).to receive(:menu_level).with(["a"]).and_return("_level")
+      expect(subject.menu_item_group(group_item)).to eq("<span class=\"trigger\">_name_collapser</span>_level")
+    end
+  end
+
+  describe "#collapsed_item?" do
+    before do
+      allow(subject).to receive(:layout_settings).with("releaf.menu.collapsed._group_name").and_return(true)
+      allow(subject).to receive(:active?).with(group_item).and_return(false)
+    end
+
+    context "when non-active and permanently collapsed group item given" do
+      it "returns true" do
+        expect(subject.collapsed_item?(group_item)).to be true
+      end
+    end
+
+    context "when non-active and non-permanently collapsed group item given" do
+      it "returns false" do
+        allow(subject).to receive(:layout_settings).with("releaf.menu.collapsed._group_name").and_return(false)
+        expect(subject.collapsed_item?(group_item)).to be false
+
+        allow(subject).to receive(:layout_settings).with("releaf.menu.collapsed._group_name").and_return(nil)
+        expect(subject.collapsed_item?(group_item)).to be false
+      end
+    end
+
+    context "when active and permanently collapsed group item given" do
+      it "returns false" do
+        allow(subject).to receive(:active?).with(group_item).and_return(true)
+        expect(subject.collapsed_item?(group_item)).to be false
+      end
+    end
+
+    context "when non-active and permanently collapsed single item given" do
+      it "returns false" do
+        expect(subject).to_not receive(:active?)
+        expect(subject.collapsed_item?(controller_item)).to be false
+      end
+    end
+  end
+
+  describe "#item_attributes" do
+    it "returns data name and classes within hash" do
+      allow(subject).to receive(:item_classes).with(controller_item).and_return(["ol", "al"])
+      expect(subject.item_attributes(controller_item)).to eq(class: ["ol", "al"], data: {name: "y"})
+    end
+
+    context "when classes attribute is empty" do
+      it "does not return class attribute within returned hash" do
+        allow(subject).to receive(:item_classes).with(controller_item).and_return([])
+        expect(subject.item_attributes(controller_item)).to_not include(:class)
+      end
+    end
+  end
+
+  describe "#item_classes" do
+    context "when given item is active" do
+      it "adds `active` class to returned array" do
+        allow(subject).to receive(:active?).with(controller_item).and_return(true)
+        expect(subject.item_classes(controller_item)).to include("active")
+      end
+    end
+
+    context "when given item is collapsed" do
+      it "adds `collapsed` class to returned array" do
+        allow(subject).to receive(:collapsed_item?).with(controller_item).and_return(true)
+        expect(subject.item_classes(controller_item)).to include("collapsed")
+      end
+    end
+
+    context "when no extra classes added" do
+      it "returns empty array" do
+        allow(subject).to receive(:active?).with(controller_item).and_return(false)
+        expect(subject.item_classes(controller_item)).to eq([])
+      end
+    end
+  end
+
+  describe "#item_name_content" do
+    it "returns abbreviation and full name elements" do
+      allow(controller_item).to receive(:localized_name).and_return('Item full name')
+      allow(subject).to receive(:item_name_abbreviation).with('Item full name').and_return('Item abbreviation')
+      expect( subject.item_name_content(controller_item) ).to eq('<abbr title="Item full name">Item abbreviation</abbr><span class="name">Item full name</span>')
+    end
+  end
+
+  describe "#item_name_abbreviation" do
+
+    it "returns first two letters of given text string" do
+      expect( subject.item_name_abbreviation( "Foo bar" )).to eq("Fo")
+    end
+
+    context "when the first two letters are lowercase" do
+      it "capitalizes the first letter" do
+        expect( subject.item_name_abbreviation( "foo bar" )).to eq("Fo")
+      end
+    end
+
+    context "when the first two letters are uppercase" do
+      it "makes the second letter lowercase" do
+        expect( subject.item_name_abbreviation( "FOO BAR" )).to eq("Fo")
+      end
+    end
+
+    context "when the string contains slashes" do
+
+      it "uses the first word after the last slash" do
+        expect( subject.item_name_abbreviation( "Releaf/core/settings" )).to eq("Se")
+      end
+
+      it "ignores slashes surrounded by spaces" do
+        expect( subject.item_name_abbreviation( "Inputs / Outputs" )).to eq("In")
+      end
+
+      it "ignores trailing slashes" do
+        expect( subject.item_name_abbreviation( "Releaf/core/settings/" )).to eq("Se")
+      end
+
+      context "when string consists of a single slash" do
+        it "returns an empty string" do
+          expect( subject.item_name_abbreviation( "/" )).to eq("")
+        end
+      end
+    end
+
+    it "works with non-latin characters" do
+      expect( subject.item_name_abbreviation( "žņ" )).to eq("Žņ")
+    end
+
+    context "when given an empty string value" do
+      it "returns an empty string" do
+        expect( subject.item_name_abbreviation( "" )).to eq("")
+      end
+    end
+
+    context "when given nil" do
+      it "returns an empty string" do
+        expect( subject.item_name_abbreviation( nil )).to eq("")
+      end
+    end
+  end
+
+  describe "#item_collapser" do
+
+    it "returns a collapser span with a button and collapser icon" do
+      allow(subject).to receive(:item_collapser_icon).with(:foo).and_return(subject.icon('dummy'))
+      expect(subject.item_collapser(:foo)).to eq '<span class="collapser"><button type="button"><i class="fa fa-dummy"></i></button></span>'
+    end
+
+  end
+
+  describe "#item_collapser_icon" do
+    let(:item) { {} }
+
+    before do
+      allow(subject).to receive(:layout_settings).with('releaf.side.compact').and_return(false)
+    end
+
+    context "when side is compacted in layout settings" do
+      it "returns a beak pointing right" do
+        allow(subject).to receive(:layout_settings).with('releaf.side.compact').and_return(true)
+        allow(subject).to receive(:icon).with('chevron-right').and_return("icon ok")
+        expect(subject.item_collapser_icon(item)).to eq "icon ok"
+      end
+    end
+
+    context "when side is not compacted in layout settings" do
+      context "when the given item is collapsed" do
+        it "returns a beak pointing down" do
+          allow(subject).to receive(:collapsed_item?).with(item).and_return(true)
+          allow(subject).to receive(:icon).with('chevron-down').and_return("icon ok")
+          expect(subject.item_collapser_icon(item)).to eq "icon ok"
+        end
+      end
+      context "when the given item is expanded" do
+        it "returns a beak pointing up" do
+          allow(subject).to receive(:collapsed_item?).with(item).and_return(false)
+          allow(subject).to receive(:icon).with('chevron-up').and_return("icon ok")
+          expect(subject.item_collapser_icon(item)).to eq "icon ok"
+        end
+      end
+    end
+  end
+
+  describe "#compact_side?" do
+    it "returns layout settings for `releaf.side.compact`" do
+      allow(subject).to receive(:layout_settings).with("releaf.side.compact").and_return("_ls")
+      expect(subject.compact_side?).to eq("_ls")
+    end
+  end
+
+  describe "#compacter" do
+    before do
+      allow(subject).to receive(:button)
+        .with(nil, "angle-double-right", title: "Expand", data: {"title-expand"=>"Expand", "title-collapse"=>"Collapse"})
+        .and_return("_expand_btn")
+      allow(subject).to receive(:button)
+        .with(nil, "angle-double-left", title: "Collapse", data: {"title-expand"=>"Expand", "title-collapse"=>"Collapse"})
+        .and_return("_collapse_btn")
+    end
+
+    context "when compact mode" do
+      it "returns expanding button" do
+        allow(subject).to receive(:compact_side?).and_return(true)
+        expect(subject.compacter).to eq("<div class=\"compacter\">_expand_btn</div>")
+      end
+    end
+
+    context "when non-compact mode" do
+      it "returns collapsing button" do
+        allow(subject).to receive(:compact_side?).and_return(false)
+        expect(subject.compacter).to eq("<div class=\"compacter\">_collapse_btn</div>")
+      end
+    end
+  end
+end

data/spec/builders/{builders → releaf/builders}/resource_view_spec.rb

@@ -12,13 +12,13 @@ describe Releaf::Builders::ResourceView, type: :class do
   let(:described_class){ ResourceViewIncluder }
   let(:template){ ResourceViewTestHelper.new }
   let(:subject){ described_class.new(template) }
-  let(:controller){ Releaf::BaseController.new }
+  let(:controller){ Releaf::ActionController.new }
   let(:resource){ Book.new }
 
   before do
     allow(template).to receive(:controller).and_return(controller)
     allow(subject).to receive(:resource).and_return(resource)
-    allow(subject).to receive(:index_url).and_return("_index_url_")
+    allow(subject).to receive(:index_path).and_return("_index_path_")
   end
 
   it "includes Releaf::Builders::View" do
@@ -47,7 +47,7 @@ describe Releaf::Builders::ResourceView, type: :class do
   describe "#section_header_text" do
     before do
       allow(subject).to receive(:t).with("Create new resource").and_return("newww")
-      allow(subject).to receive(:resource_to_text).with(resource).and_return("existng")
+      allow(subject).to receive(:resource_title).with(resource).and_return("existng")
     end
 
     context "when resource is new object" do
@@ -66,7 +66,7 @@ describe Releaf::Builders::ResourceView, type: :class do
 
   describe "#section_header_extras" do
     before do
-      allow(subject).to receive(:toolbox).with(resource, index_url: "_index_url_").and_return("_tlbx_")
+      allow(subject).to receive(:toolbox).with(resource, index_path: "_index_path_").and_return("_tlbx_")
       allow(subject).to receive(:feature_available?).with(:toolbox).and_return(true)
     end
 
@@ -122,17 +122,17 @@ describe Releaf::Builders::ResourceView, type: :class do
 
   describe "#back_to_list?" do
     before do
-      allow(subject).to receive(:params).and_return(index_url: "xxx")
+      allow(subject).to receive(:params).and_return(index_path: "xxx")
       allow(subject).to receive(:feature_available?).with(:index).and_return(true)
     end
 
-    context "when index feature is available and index_url is present within params" do
+    context "when index feature is available and index_path is present within params" do
       it "returns true" do
         expect(subject.back_to_list?).to be true
       end
     end
 
-    context "when index_url is not present within params" do
+    context "when index_path is not present within params" do
       it "returns false" do
         allow(subject).to receive(:params).and_return(search: "xxx")
         expect(subject.back_to_list?).to be false
@@ -150,7 +150,7 @@ describe Releaf::Builders::ResourceView, type: :class do
   describe "#back_to_list_button" do
     it "returns `back to list` button" do
       allow(subject).to receive(:button)
-        .with("to_list", "caret-left", {class: "secondary", href: "_index_url_"}).and_return("_btn_")
+        .with("to_list", "caret-left", {class: "secondary", href: "_index_path_"}).and_return("_btn_")
       allow(subject).to receive(:t).with("Back to list").and_return("to_list")
       expect(subject.back_to_list_button).to eq("_btn_")
     end

data/spec/builders/{builders → releaf/builders}/table_builder_spec.rb

@@ -29,10 +29,6 @@ describe Releaf::Builders::TableBuilder, type: :class do
     expect(described_class.ancestors).to include(Releaf::Builders::Toolbox)
   end
 
-  it "includes Releaf::Builders::Orderer" do
-    expect(described_class.ancestors).to include(Releaf::Builders::Orderer)
-  end
-
   describe "#initialize" do
     it "assigns collection" do
       expect(subject.collection.to_sql).to eq(collection.to_sql)
@@ -66,8 +62,8 @@ describe Releaf::Builders::TableBuilder, type: :class do
 
   describe "#column_names" do
     it "returns column names for resource_class" do
-      allow(Releaf::Core::ResourceTableFields).to receive(:new).with(subject.resource_class).and_call_original
-      allow_any_instance_of(Releaf::Core::ResourceTableFields).to receive(:values)
+      allow(Releaf::ResourceTableFields).to receive(:new).with(subject.resource_class).and_call_original
+      allow_any_instance_of(Releaf::ResourceTableFields).to receive(:values)
         .with(include_associations: false).and_return(["a", "b"])
       expect(subject.column_names).to eq(["a", "b"])
     end
@@ -200,12 +196,12 @@ describe Releaf::Builders::TableBuilder, type: :class do
 
   describe "#head_cell_content" do
     it "returns translated column scoped to resource class attributes" do
-      allow(resource_class).to receive(:human_attribute_name).with("some_long_name", create_default: false).and_return("Taittls")
+      allow(resource_class).to receive(:human_attribute_name).with("some_long_name").and_return("Taittls")
       expect(subject.head_cell_content("some_long_name")).to eq('Taittls')
     end
 
     it "casts given column to string" do
-      allow(resource_class).to receive(:human_attribute_name).with("title", create_default: false).and_return("Taittls")
+      allow(resource_class).to receive(:human_attribute_name).with("title",).and_return("Taittls")
       expect(subject.head_cell_content(:title)).to eq('Taittls')
     end
 
@@ -236,16 +232,16 @@ describe Releaf::Builders::TableBuilder, type: :class do
   end
 
   describe "#row_url" do
-    let(:controller){ Releaf::BaseController.new }
+    let(:controller){ Releaf::ActionController.new }
 
     before do
       allow(subject).to receive(:controller).and_return(controller)
-      allow(controller).to receive(:index_url).and_return("_index_url_")
+      allow(controller).to receive(:index_path).and_return("_index_path_")
     end
 
     it "returns edit url for given resource" do
       allow(subject).to receive(:row_url_action).with(resource).and_return(:show)
-      allow(template).to receive(:url_for).with(action: :show, id: 77, index_url: "_index_url_").and_return('_url_')
+      allow(template).to receive(:url_for).with(action: :show, id: 77, index_path: "_index_path_").and_return('_url_')
       expect(subject.row_url(resource)).to eq('_url_')
     end
 
@@ -258,7 +254,7 @@ describe Releaf::Builders::TableBuilder, type: :class do
   end
 
   describe "#row_url_action" do
-    let(:controller){ Releaf::BaseController.new }
+    let(:controller){ Releaf::ActionController.new }
 
     before do
       allow(subject).to receive(:controller).and_return(controller)
@@ -369,26 +365,15 @@ describe Releaf::Builders::TableBuilder, type: :class do
   end
 
   describe "#format_string_content" do
-    context "when resource column value respond to #to_text method" do
-      it "returns value #to_text" do
-        fake_obj = double
-        allow(fake_obj).to receive(:to_text).and_return("nineninine")
-
-        allow(subject).to receive(:column_value).with(resource, :id)
-          .and_return(fake_obj)
+    context "when resource column value respond to #resource_title method" do
+      it "returns resource to title result" do
+        another_obj = Book.new
+        allow(subject).to receive(:column_value).with(resource, :id).and_return(another_obj)
+        allow(subject).to receive(:resource_title).with(another_obj).and_return("nineninine")
 
         expect(subject.format_string_content(resource, :id)).to eq("nineninine")
       end
     end
-
-    context "when resource column value do not respond to #to_text method" do
-      it "returns value casted to string" do
-        allow(subject).to receive(:column_value).with(resource, :id)
-          .and_return(99)
-
-        expect(subject.format_string_content(resource, :id)).to eq("99")
-      end
-    end
   end
 
   describe "#format_boolean_content" do
@@ -435,8 +420,8 @@ describe Releaf::Builders::TableBuilder, type: :class do
       allow(subject).to receive(:column_value).with(resource, :created_at)
         .and_return(value)
 
-      expect(I18n).to receive(:l).with(value, format: :default, default: "%Y-%m-%d %H:%M:%S")
-        .and_call_original
+      allow(I18n).to receive(:l).with(value, format: :default, default: "%Y-%m-%d %H:%M:%S")
+        .and_return("2012-12-29 17:12:07")
 
       expect(subject.format_datetime_content(resource, :created_at)).to eq("2012-12-29 17:12:07")
     end
@@ -490,48 +475,26 @@ describe Releaf::Builders::TableBuilder, type: :class do
     let(:controller){ double(ActionController::Base) }
     before do
       allow(subject).to receive(:controller).and_return(controller)
-      allow(controller).to receive(:index_url).and_return("_index_url_")
+      allow(controller).to receive(:index_path).and_return("_index_path_")
     end
 
     it "returns cell with toolbox" do
       allow(subject).to receive(:toolbox)
-        .with(resource, index_url: "_index_url_").and_return("_toolbox_")
+        .with(resource, index_path: "_index_path_").and_return("_toolbox_")
 
       content = '<td class="only-icon toolbox-cell">_toolbox_</td>'
       expect(subject.toolbox_cell(resource, {})).to eq(content)
     end
 
     it "merges given toolbox options and passes it to toolbox heplper" do
-      allow(subject.controller).to receive(:index_url).and_return("_index_url_")
+      allow(subject.controller).to receive(:index_path).and_return("_index_path_")
       expect(subject).to receive(:toolbox)
-        .with(resource, index_url: "_index_url_", some_url: "xx").and_return("_toolbox_")
+        .with(resource, index_path: "_index_path_", some_url: "xx").and_return("_toolbox_")
       subject.toolbox_cell(resource, {toolbox: {some_url: "xx"}})
 
       expect(subject).to receive(:toolbox)
-        .with(resource, index_url: "xx").and_return("_toolbox_")
-      subject.toolbox_cell(resource, {toolbox: {index_url: "xx"}})
-    end
-  end
-
-  describe "#format_image_content" do
-    context "when resource value is not blank" do
-      let(:resource){ create(:book, cover_image: File.expand_path('../fixtures/cs.png', __dir__)) }
-
-      it "returns thumnail image" do
-        pattern = /\<img alt=\"\" src=\"\/media\/.*\" \/\>/
-        expect(subject.format_image_content(resource, :cover_image_uid)).to match(pattern)
-      end
-
-      it "uses 16px height for thumbnail" do
-        expect(resource.cover_image).to receive(:thumb).with('x16').and_call_original
-        subject.format_image_content(resource, :cover_image_uid)
-      end
-    end
-
-    context "when resource value is blank" do
-      it "returns nil" do
-        expect(subject.format_image_content(resource, :cover_image_uid)).to be nil
-      end
+        .with(resource, index_path: "xx").and_return("_toolbox_")
+      subject.toolbox_cell(resource, {toolbox: {index_path: "xx"}})
     end
   end
 
@@ -551,21 +514,22 @@ describe Releaf::Builders::TableBuilder, type: :class do
   describe "#column_type_format_method" do
     it "uses column klass and column name for type calculation" do
       allow(subject).to receive(:column_klass).with(resource_class, "some.column").and_return(Chapter)
-      expect(subject).to receive(:column_type).with(Chapter, "some.column")
-      subject.column_type_format_method("some.column")
+      allow(subject).to receive(:column_type).with(Chapter, "some.column").and_return(:extra_type)
+      allow(subject).to receive(:type_format_method).with(:extra_type).and_return("extra_type_method")
+      expect(subject.column_type_format_method("some.column")).to eq("extra_type_method")
     end
+  end
 
+  describe "#type_format_method" do
     context "when format method for returned column type exists" do
       it "returns column type format method" do
-        allow(subject).to receive(:column_type).and_return(:date)
-        expect(subject.column_type_format_method(:title)).to eq(:format_date_content)
+        expect(subject.type_format_method(:date)).to eq(:format_date_content)
       end
     end
 
     context "when format method for returned column type does not exist" do
       it "returns :format_string_content" do
-        allow(subject).to receive(:column_type).and_return(:big_boolean)
-        expect(subject.column_type_format_method(:title)).to eq(:format_string_content)
+        expect(subject.type_format_method(:big_boolean)).to eq(:format_string_content)
       end
     end
   end
@@ -573,7 +537,6 @@ describe Releaf::Builders::TableBuilder, type: :class do
   describe "#cell_format_method" do
     before do
       allow(subject).to receive(:association_column?).with(:title).and_return(false)
-      allow(subject).to receive(:image_column?).with(:title).and_return(false)
       allow(subject).to receive(:column_type_format_method).with(:title).and_return(:format_crazy_shit)
     end
 
@@ -587,13 +550,6 @@ describe Releaf::Builders::TableBuilder, type: :class do
         expect(subject.cell_format_method(:title)).to eq(:format_association_content)
       end
     end
-
-    context "when #association_column? returns true for given column" do
-      it "returns :format_association_content" do
-        allow(subject).to receive(:image_column?).with(:title).and_return(true)
-        expect(subject.cell_format_method(:title)).to eq(:format_image_content)
-      end
-    end
   end
 
   describe "#association_column?" do
@@ -612,11 +568,11 @@ describe Releaf::Builders::TableBuilder, type: :class do
 
   describe "#cell" do
     context "when cell options :url value is blank" do
-      it "returns cell with #cell_content output" do
+      it "returns cell with #cell_contentoutput wrapped in a span" do
         options = {a: "x"}
         allow(subject).to receive(:cell_content)
           .with(resource, :title, options).and_return("_cell_content_")
-        content = '<td>_cell_content_</td>'
+        content = '<td><span>_cell_content_</span></td>'
 
         expect(subject.cell(resource, :title, options)).to eq(content)
 
@@ -626,7 +582,7 @@ describe Releaf::Builders::TableBuilder, type: :class do
     end
 
     context "when cell options :url value is not blank" do
-      it "returns cell with #cell_content output wrapped in 'a' element" do
+      it "returns cell with #cell_content output wrapped in a link" do
         allow(subject).to receive(:cell_content)
           .with(resource, :title, {a: "x", url: "y"}).and_return("_cell_content_")
 

data/spec/builders/{builders → releaf/builders}/toolbox_builder_spec.rb

@@ -56,11 +56,11 @@ describe Releaf::Builders::ToolboxBuilder, type: :class do
   end
 
   describe "#destroy_confirmation_url" do
-    it "returns resource destroy confirmation url with index_url param" do
+    it "returns resource destroy confirmation url with index_path param" do
       subject.resource = Book.new(id: 99)
-      allow(subject.template).to receive(:url_for).with(action: :confirm_destroy, id: 99, index_url: "y").and_return("x")
-      allow(subject.template).to receive(:controller).and_return(Releaf::BaseController.new)
-      allow(subject.controller).to receive(:index_url).and_return("y")
+      allow(subject.template).to receive(:url_for).with(action: :confirm_destroy, id: 99, index_path: "y").and_return("x")
+      allow(subject.template).to receive(:controller).and_return(Releaf::ActionController.new)
+      allow(subject.controller).to receive(:index_path).and_return("y")
       expect(subject.destroy_confirmation_url).to eq("x")
     end
   end