releaf-core 1.1.21 → 2.1.1

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

@@ -1,345 +0,0 @@
-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/releaf/builders/pagination_builder_spec.rb

@@ -1,330 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Builders::PaginationBuilder, type: :class do
-
-  class PaginationTestView < ActionView::Base
-    include Releaf::ApplicationHelper
-    include Releaf::ButtonHelper
-    include FontAwesome::Rails::IconHelper
-  end
-
-  let(:template){ PaginationTestView.new }
-
-  let(:items_per_page) { 3 }
-  let(:current_page_number) { 1 }
-  let(:collection){ Book.page(current_page_number).per_page(items_per_page) }
-  let(:params){ { search: "xxx"} }
-  let(:subject){ described_class.new(template, collection: collection, params: params ) }
-
-  before do |example|
-    unless example.metadata[:stub_url_for] === false
-      allow(template).to receive(:url_for) { |params| "http://example.com/?#{params.to_query}" }
-    end
-  end
-
-  it "provides accessor for template given in constructor" do
-    subject = described_class.new( :foo )
-    expect( subject.template ).to eq :foo
-  end
-
-  it "provides accessor for collection given in constructor" do
-    subject = described_class.new( nil, collection: :foo )
-    expect( subject.collection ).to eq :foo
-  end
-
-  it "provides accessor for params given in constructor" do
-    subject = described_class.new( nil, params: :foo )
-    expect( subject.params ).to eq :foo
-  end
-
-
-  describe "#output" do
-
-    context "when collection has no entries" do
-      it "returns nil" do
-        expect(subject.total_entries).to eq 0
-        expect(subject).to_not receive(:pagination_block)
-        expect(subject.output).to be nil
-      end
-    end
-
-    context "when collection has less entries than allowed on one page" do
-      before do
-        FactoryGirl.create( :book )
-      end
-
-      it "returns nil" do
-        expect(subject.total_entries).to eq 1
-        expect(subject).to_not receive(:pagination_block)
-        expect(subject.output).to be nil
-      end
-    end
-
-    context "when collection has exactly the number of entries that fits on one page" do
-      before do
-        items_per_page.times do
-          FactoryGirl.create( :book )
-        end
-      end
-
-      it "returns nil" do
-        expect(subject.total_entries).to eq 3
-        expect(subject).to_not receive(:pagination_block)
-        expect(subject.output).to be nil
-      end
-    end
-
-
-    context "when collection has more than one page" do
-      before do
-        (items_per_page + 1).times do
-          FactoryGirl.create( :book )
-        end
-      end
-
-      it "returns #pagination_block" do
-        expect(subject.total_entries).to eq 4
-        expect(subject).to receive(:pagination_block).and_return('ok')
-        expect(subject.output).to eq "ok"
-      end
-    end
-
-  end
-
-  describe "#pagination_block" do
-
-    let(:current_page_number) { 2 }
-
-    it "returns pagination parts wrapped in a container" do
-      allow(subject).to receive(:pagination_parts).and_return [ "<strong>weak</strong>".html_safe, "<escape_me>" ]
-      expect(subject.pagination_block).to match_html %Q[
-          <div class="pagination">
-              <strong>weak</strong>
-              &lt;escape_me&gt;
-          </div>
-      ]
-    end
-
-    it "returns pagination buttons and select with options" do
-
-      14.times do
-        FactoryGirl.create :book
-      end
-
-      expect(subject.pagination_block).to match_html %Q[
-        <div class="pagination">
-
-          <a class="button only-icon secondary previous" title="Previous page" rel="prev" href="http://example.com/?page=1&amp;search=xxx">
-            <i class="fa fa-chevron-left"></i>
-          </a>
-
-          <select name="page">
-            <option value="1">1-3</option>
-            <option value="2" selected="selected">4-6</option>
-            <option value="3">7-9</option>
-            <option value="4">10-12</option>
-            <option value="5">13-14</option>
-          </select>
-
-          <a class="button only-icon secondary next" title="Next page" rel="next" href="http://example.com/?page=3&amp;search=xxx">
-            <i class="fa fa-chevron-right"></i>
-          </a>
-
-        </div>
-      ]
-
-    end
-
-  end
-
-
-  describe "#pagination_parts" do
-    it "returns an array with previous page button, page select and next page button" do
-      allow(subject).to receive(:previous_page_button).and_return("previous")
-      allow(subject).to receive(:next_page_button).and_return("next")
-      allow(subject).to receive(:pagination_select).and_return("select")
-      expect(subject.pagination_parts).to eq [ "previous", "select", "next" ]
-    end
-  end
-
-
-  def previous_page_button
-    page_button( -1, 'previous', 'chevron-left' )
-  end
-
-  def next_page_button
-    page_button( 1, 'next', 'chevron-right' )
-  end
-
-  describe "#previous_page_button" do
-    it "returns #page_button with -1 offset and appropriate class and icon names" do
-      expect(subject).to receive(:page_button).with( -1, 'previous', 'chevron-left').and_return('ok')
-      expect(subject.previous_page_button).to eq 'ok'
-    end
-  end
-
-  describe "#next_page_button" do
-    it "returns #page_button with +1 offset and appropriate class and icon names" do
-      expect(subject).to receive(:page_button).with( 1, 'next', 'chevron-right').and_return('ok')
-      expect(subject.next_page_button).to eq 'ok'
-    end
-  end
-
-  describe "#page_button" do
-
-    before do
-      allow(subject).to receive(:t).with('Foo page', scope: 'pagination').and_return('Foo page label')
-      allow(subject).to receive(:t).with('Bar page', scope: 'pagination').and_return('Bar page label')
-
-    end
-
-    context "when calculated relative page number is valid" do
-
-      it "returns a button with correct class and rel attributes and a href pointing to the offset page" do
-
-        5.times do
-          FactoryGirl.create(:book)
-        end
-
-        expect(subject.page_button( 1, 'foo', 'foo-icon' )).to match_html %Q[
-          <a class="button only-icon secondary foo" title="Foo page label" rel="next" href="http://example.com/?page=2&amp;search=xxx">
-            <i class="fa fa-foo-icon"></i>
-          </a>
-        ]
-      end
-
-    end
-
-    context "when the calculated relative page number is invalid" do
-
-      it "returns a disabled button with correct class" do
-        expect(subject.page_button( -1, 'bar', 'bar-icon' )).to match_html %Q[
-          <button class="button only-icon secondary bar" title="Bar page label" type="button" autocomplete="off" disabled="disabled">
-            <i class="fa fa-bar-icon"></i>
-          </button>
-        ]
-      end
-
-    end
-
-  end
-
-
-  describe "#page_numbers" do
-
-    it "returns an array of integers from 1 to total number of pages" do
-      allow(collection).to receive(:total_pages).and_return(12)
-      expect(subject.page_numbers).to eq [1,2,3,4,5,6,7,8,9,10,11,12]
-    end
-
-  end
-
-
-  describe "#relative_page_number" do
-
-    before do
-      allow(collection).to receive(:current_page).and_return(3)
-      allow(collection).to receive(:total_pages).and_return(12)
-    end
-
-    context "when adding the offset to current page number" do
-      context "results in a valid page number" do
-        it "returns the page number" do
-          expect(subject.relative_page_number(-1)).to eq 2
-        end
-      end
-
-      context "results in a page number larger than the total number of pages" do
-        it "returns nil" do
-          expect(subject.relative_page_number(10)).to be nil
-        end
-      end
-
-      context "results in a page number less than one" do
-        it "returns nil" do
-          expect(subject.relative_page_number(-3)).to be nil
-        end
-      end
-    end
-
-  end
-
-
-  describe "#relative_page_relationship" do
-
-    context "when given -1" do
-      it "returns :prev" do
-        expect(subject.relative_page_relationship(-1)).to eq :prev
-      end
-    end
-
-    context "when given 1" do
-      it "returns :next" do
-        expect(subject.relative_page_relationship(1)).to eq :next
-      end
-    end
-
-    [0, -2, 3, nil, true, false].each do |arg|
-      context "when given #{arg.nil? ? 'nil' : arg.to_s}" do
-        it "returns nil" do
-          expect(subject.relative_page_relationship(arg)).to be nil
-        end
-      end
-    end
-
-  end
-
-  describe "#page_url", stub_url_for: false do
-
-    it "calls url_for on template with added page number param" do
-      expect(template).to receive(:url_for).with( search: "xxx", page: 3).and_return("ok")
-      expect(subject.page_url(3)).to eq "ok"
-    end
-
-  end
-
-  describe "#pagination_select" do
-
-    it "returns select tag with pagination options" do
-      allow(subject).to receive(:pagination_options).and_return [ "<option>1-2</option>".html_safe, "<escape_me>" ]
-      expect(subject.pagination_select).to match_html %Q[
-          <select name="page">
-              <option>1-2</option>
-              &lt;escape_me&gt;
-          </select>
-      ]
-    end
-
-  end
-
-  describe "#pagination_options" do
-
-    let(:current_page_number) { 2 }
-
-    it "returns an array with option tags for page select" do
-      allow(subject).to receive(:page_numbers).and_return( [ 1, 2, 3 ] )
-      allow(subject).to receive(:page_label) { |page_number| "page label #{page_number}" }
-      expect(subject.pagination_options).to eq [
-        '<option value="1">page label 1</option>',
-        '<option value="2" selected="selected">page label 2</option>',
-        '<option value="3">page label 3</option>'
-      ]
-    end
-
-  end
-
-
-  describe "#page_label" do
-
-    before do
-      14.times { FactoryGirl.create :book }
-    end
-
-    it "returns a string with the numbers of first and last items in page" do
-      expect(subject.page_label(1)).to eq "1-3"
-      expect(subject.page_label(5)).to eq "13-14"
-    end
-  end
-
-
-end