releaf-core 0.2.1

data/spec/builders/builders/template_spec.rb

@@ -0,0 +1,12 @@
+require "rails_helper"
+
+describe Releaf::Builders::Template, type: :module do
+  class TemplateClassIncluder
+    include Releaf::Builders::Template
+  end
+
+  it "it assigns template argument to instance 'template' accessor on initialization" do
+    subject = TemplateClassIncluder.new("x")
+    expect(subject.template).to eq("x")
+  end
+end

data/spec/builders/builders/toolbox_builder_spec.rb

@@ -0,0 +1,67 @@
+require "rails_helper"
+
+describe Releaf::Builders::ToolboxBuilder, type: :class do
+  class ToolboxBuilderTestHelper < ActionView::Base
+    include Releaf::ButtonHelper
+    include Releaf::ApplicationHelper
+  end
+
+  subject { described_class.new(template) }
+  let(:template){ ToolboxBuilderTestHelper.new }
+
+  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
+
+  it "includes Releaf::Builders::Resource" do
+    expect(described_class.ancestors).to include(Releaf::Builders::Resource)
+  end
+
+  describe "#output" do
+    it "returns safely joined items" do
+      allow(subject).to receive(:items).and_return([ '<', ActiveSupport::SafeBuffer.new(">")])
+      expect(subject.output).to eq("<li>&lt;</li><li>></li>")
+    end
+  end
+
+  describe "#items" do
+    before{ allow(subject).to receive(:destroy_confirmation_link).and_return("x") }
+
+    context "when no destroy feature is available" do
+      it "returns array with destroy button html" do
+        allow(subject).to receive(:feature_available?).with(:destroy).and_return(true)
+        expect(subject.items).to eq(["x"])
+      end
+    end
+
+    context "when destroy feature is not available" do
+      it "returns empty array" do
+        allow(subject).to receive(:feature_available?).with(:destroy).and_return(false)
+        expect(subject.items).to eq([])
+      end
+    end
+  end
+
+  describe "#destroy_confirmation_link" do
+    it "returns destroy confirmation link" do
+      allow(subject).to receive(:t).with("Delete").and_return("dlt")
+      allow(subject).to receive(:destroy_confirmation_url).and_return("www.xxx")
+      content = '<a class="button ajaxbox danger" title="dlt" href="www.xxx" data-modal="true">dlt</a>'
+      expect(subject.destroy_confirmation_link).to eq(content)
+    end
+  end
+
+  describe "#destroy_confirmation_url" do
+    it "returns resource destroy confirmation url with index_url 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")
+      expect(subject.destroy_confirmation_url).to eq("x")
+    end
+  end
+end

data/spec/builders/builders/toolbox_spec.rb

@@ -0,0 +1,48 @@
+require "rails_helper"
+
+describe Releaf::Builders::Toolbox, type: :class do
+  class ToolboxTestTemplate < ActionView::Base
+  end
+
+  class UnitTestToolboxBuilder
+    include Releaf::Builders::Base
+    include Releaf::Builders::Template
+    include Releaf::Builders::Toolbox
+  end
+
+  subject { UnitTestToolboxBuilder.new(template) }
+  let(:template){ ToolboxTestTemplate.new }
+  let(:resource){ Releaf::Permissions::User.new }
+
+  describe "#toolbox" do
+    context "when the passed object is a new record" do
+      it "returns empty string" do
+        expect(subject.toolbox(resource)).to eq("")
+      end
+    end
+
+    context "when the passed object is an existing record" do
+      it "returns toolbox HTML with trigger and without items" do
+        resource.id = 212
+        allow(resource).to receive(:new_record?).and_return(false)
+        allow(subject).to receive(:t).with("Tools").and_return("tls")
+        allow(subject).to receive(:icon).with("ellipsis-v").and_return("<kebab_icon />".html_safe)
+        allow(subject).to receive(:icon).with("caret-up").and_return("<caret_icon />".html_safe)
+        allow(subject).to receive(:action_name).and_return("edit")
+        allow(subject).to receive(:url_for).with({action: :toolbox, id: 212, context: "edit", some_param: 89}).and_return("/toolbox_action")
+
+        expect(subject.toolbox(resource, some_param: 89)).to match_html(%Q[
+          <div class="toolbox" data-url="/toolbox_action">
+            <button class="button trigger only-icon" type="button" title="tls">
+              <kebab_icon />
+            </button>
+            <menu class="toolbox-items" type="toolbar">
+              <caret_icon />
+              <ul></ul>
+            </menu>
+        </div>
+        ])
+      end
+    end
+  end
+end

data/spec/builders/builders/view_spec.rb

@@ -0,0 +1,281 @@
+require "rails_helper"
+
+describe Releaf::Builders::View, type: :class do
+  class ViewTestHelper < ActionView::Base
+    include FontAwesome::Rails::IconHelper
+  end
+
+  class ViewTestIncluder
+    include Releaf::Builders::Base
+    include Releaf::Builders::Template
+    include Releaf::Builders::View
+  end
+
+  subject { ViewTestIncluder.new(template) }
+  let(:template){ ViewTestHelper.new }
+
+  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
+    before do
+      allow(subject).to receive(:header).and_return(ActiveSupport::SafeBuffer.new("<"))
+      allow(subject).to receive(:section).and_return(ActiveSupport::SafeBuffer.new(">"))
+    end
+
+    it "returns safely joined header and section outputs" do
+      allow(subject).to receive(:dialog?).and_return(false)
+      expect(subject.output).to eq("<>")
+    end
+
+    context "within dialog" do
+      it "does not return header content" do
+        allow(subject).to receive(:dialog?).and_return(true)
+        expect(subject.output).to eq(">")
+      end
+    end
+  end
+
+  describe "#dialog?" do
+    let(:controller){ Releaf::BaseController.new }
+
+    before do
+      allow(template).to receive(:controller).and_return(controller)
+    end
+
+    context "when controller has ajax mode enabled" do
+      it "returns true" do
+        allow(controller).to receive(:ajax?).and_return(true)
+        expect(subject.dialog?).to be true
+      end
+    end
+
+    context "when controller has ajax mode disabled" do
+      it "returns false" do
+        allow(controller).to receive(:ajax?).and_return(false)
+        expect(subject.dialog?).to be false
+      end
+    end
+  end
+
+  describe "#dialog_name" do
+    class UnitTestDialogBuilder
+      include Releaf::Builders::Base
+      include Releaf::Builders::Template
+      include Releaf::Builders::View
+    end
+
+    it "returns normalized, dashed dialog name taken from dialog class name" do
+      subject = UnitTestDialogBuilder.new(template)
+      expect(subject.dialog_name).to eq("unit-test")
+
+      subject = Releaf::Builders::EditBuilder.new(template)
+      expect(subject.dialog_name).to eq("edit")
+    end
+  end
+
+  describe "#header" do
+    it "returns safely joined breadcrumbs, flash notices and header extras within header tag" do
+      allow(subject).to receive(:breadcrumbs).and_return(ActiveSupport::SafeBuffer.new("breadcrumbs>"))
+      allow(subject).to receive(:flash_notices).and_return(ActiveSupport::SafeBuffer.new(">_and_notices_"))
+      allow(subject).to receive(:header_extras).and_return(ActiveSupport::SafeBuffer.new(">extras"))
+      expect(subject.header).to eq("<header>breadcrumbs>>_and_notices_>extras</header>")
+    end
+  end
+
+  describe "#section" do
+    it "returns safely joined section blocks within section tag" do
+      allow(subject).to receive(:section_attributes).and_return(class: "xx")
+      allow(subject).to receive(:section_blocks).and_return([ '<', ActiveSupport::SafeBuffer.new(">")])
+      expect(subject.section).to eq('<section class="xx">&lt;></section>')
+    end
+  end
+
+  describe "#section_attributes" do
+    context "within dialog" do
+      it "returns hash with dialog classes" do
+        allow(subject).to receive(:dialog?).and_return(true)
+        allow(subject).to receive(:dialog_name).and_return("xxx")
+        expect(subject.section_attributes).to eq(class: ["dialog", "xxx"])
+      end
+    end
+
+    context "when not within dialog" do
+      it "returns empty hash" do
+        allow(subject).to receive(:dialog?).and_return(false)
+        expect(subject.section_attributes).to eq({})
+      end
+    end
+  end
+
+  describe "#breadcrumbs" do
+    context "when breadcrumbs template variable exists" do
+      it "returns safely joined breadcrumbs items list within nav element" do
+        allow(subject).to receive(:template_variable).with("breadcrumbs").and_return([:a, :b, :c])
+        allow(subject).to receive(:breadcrumb_item).with(:a, false).and_return(">a")
+        allow(subject).to receive(:breadcrumb_item).with(:b, false).and_return(ActiveSupport::SafeBuffer.new(">b"))
+        allow(subject).to receive(:breadcrumb_item).with(:c, true).and_return(">c")
+        content = '<nav><ul class="breadcrumbs">&gt;a>b&gt;c</ul></nav>'
+        expect(subject.breadcrumbs).to eq(content)
+      end
+    end
+
+    context "when breadcrumbs template variable does not exists" do
+      it "returns nil" do
+        allow(subject).to receive(:template_variable).with("breadcrumbs").and_return(nil)
+        expect(subject.breadcrumbs).to be nil
+      end
+    end
+  end
+
+  describe "#breadcrumb_item" do
+    context "when given breadcrumb item has url" do
+      it "returns name wrapped within link" do
+        expect(subject.breadcrumb_item({url: "asa", name: "x"}, true)).to eq('<li><a href="asa">x</a></li>')
+      end
+    end
+
+    context "when given breadcrumb item has no url" do
+      it "returns only name" do
+        expect(subject.breadcrumb_item({name: "x"}, true)).to eq('<li>x</li>')
+      end
+    end
+
+    it "adds breadcrumb icon after except when last element given" do
+      expect(subject.breadcrumb_item({name: "x"}, true)).to eq('<li>x</li>')
+      expect(subject.breadcrumb_item({name: "x"}, false)).to eq('<li>x<i class="fa fa-chevron-right"></i></li>')
+    end
+  end
+
+  describe "#flash_notices" do
+    it "returns safely joined flash items" do
+      allow(subject).to receive(:flash).and_return(a: "xx", b: "yy")
+      allow(subject).to receive(:flash_item).with(:a, "xx").and_return(ActiveSupport::SafeBuffer.new("<a"))
+      allow(subject).to receive(:flash_item).with(:b, "yy").and_return("b>")
+      expect(subject.flash_notices).to eq("<ab&gt;")
+    end
+  end
+
+  describe "#flash_item" do
+    it "returns flash item" do
+      expect(subject.flash_item(:error, "some error")).to eq('<div class="flash" data-type="error">some error</div>')
+    end
+
+    it "supports flash item data as hash" do
+      expect(subject.flash_item(:error, "id" => "unique", "message" => "errrrrror")).to eq('<div class="flash" data-type="error" data-id="unique">errrrrror</div>')
+    end
+  end
+
+  describe "#header_extras" do
+    it "returns nil (method to override in later classes)" do
+      expect(subject.header_extras).to be nil
+    end
+  end
+
+  describe "#section_blocks" do
+    it "returns array of section header, body and footer blocks" do
+      allow(subject).to receive(:section_header).and_return("a")
+      allow(subject).to receive(:section_body).and_return("b")
+      allow(subject).to receive(:section_footer).and_return("c")
+
+      expect(subject.section_blocks).to eq(["a", "b", "c"])
+    end
+  end
+
+  describe "#section_header" do
+    it "returns header content with header extras" do
+      allow(subject).to receive(:section_header_text).and_return("sektion h")
+      allow(subject).to receive(:section_header_extras).and_return("extras")
+      expect(subject.section_header).to eq("<header><h1>sektion h</h1>extras</header>")
+    end
+  end
+
+  describe "#section_header_text" do
+    it "returns nil (method to override in later classes)" do
+      expect(subject.section_header_text).to be nil
+    end
+  end
+
+  describe "#section_header_extras" do
+    it "returns nil (method to override in later classes)" do
+      expect(subject.section_header_extras).to be nil
+    end
+  end
+
+  describe "#section_body" do
+    it "returns nil (method to override in later classes)" do
+      expect(subject.section_body).to be nil
+    end
+  end
+
+  describe "#section_footer" do
+    it "returns footer with footer attributes and content" do
+      allow(subject).to receive(:section_footer_class).and_return(["axx", "b"])
+      allow(subject).to receive(:footer_tools).and_return("footer content")
+      expect(subject.section_footer).to eq('<footer class="axx b">footer content</footer>')
+    end
+  end
+
+  describe "#section_footer_class" do
+    context "within dialog" do
+      it "returns nil" do
+        allow(subject).to receive(:dialog?).and_return(true)
+        expect(subject.section_footer_class).to be nil
+      end
+    end
+
+    context "when not within dialog" do
+      it "returns :main" do
+        allow(subject).to receive(:dialog?).and_return(false)
+        expect(subject.section_footer_class).to eq(:main)
+      end
+    end
+  end
+
+  describe "#footer_tools" do
+    it "returns footer tools" do
+      allow(subject).to receive(:footer_blocks).and_return([ActiveSupport::SafeBuffer.new("<a"), "b>"])
+      expect(subject.footer_tools).to eq('<div class="tools"><ab&gt;</div>')
+    end
+  end
+
+  describe "#footer_blocks" do
+    it "returns array of footer primary and secondary blocks" do
+      allow(subject).to receive(:footer_primary_block).and_return("a")
+      allow(subject).to receive(:footer_secondary_block).and_return("b")
+
+      expect(subject.footer_blocks).to eq(["a", "b"])
+    end
+  end
+
+  describe "#footer_primary_block" do
+    it "returns footer tools" do
+      allow(subject).to receive(:footer_primary_tools).and_return([ActiveSupport::SafeBuffer.new("<a"), "b>"])
+      expect(subject.footer_primary_block).to eq('<div class="primary"><ab&gt;</div>')
+    end
+  end
+
+  describe "#footer_secondary_block" do
+    it "returns footer tools" do
+      allow(subject).to receive(:footer_secondary_tools).and_return([ActiveSupport::SafeBuffer.new("<a"), "b>"])
+      expect(subject.footer_secondary_block).to eq('<div class="secondary"><ab&gt;</div>')
+    end
+  end
+
+  describe "#footer_primary_tools" do
+    it "returns nil (method to override in later classes)" do
+      expect(subject.footer_primary_tools).to be nil
+    end
+  end
+
+  describe "#footer_secondary_tools" do
+    it "returns nil (method to override in later classes)" do
+      expect(subject.footer_secondary_tools).to be nil
+    end
+  end
+end

data/spec/builders/builders_spec.rb

@@ -0,0 +1,134 @@
+require 'rails_helper'
+
+describe Releaf::Builders, type: :class do
+  module Admin::Advanced
+    class FormBuilder
+    end
+    class AuthorsController
+    end
+  end
+
+  class Admin::Advanced::Builders < Releaf::Builders; end
+
+  describe ".builder_class" do
+    before do
+      allow(described_class).to receive(:inherited_builder_scopes).and_return(["Releaf::Permissions::Users"])
+    end
+
+    it "returns first existing builder class from given and inherited scopes" do
+      expect(described_class).to receive(:builder_class_at_scope).with("Admin::Advanced", :form)
+        .and_return(nil).ordered
+      expect(described_class).to receive(:builder_class_at_scope).with("Releaf::Permissions::Users", :form)
+        .and_return(Releaf::Permissions::Users::FormBuilder).ordered
+
+      expect(described_class.builder_class(["Admin::Advanced"], :form)).to eq(Releaf::Permissions::Users::FormBuilder)
+    end
+
+    context "when no builders exists for given scope and type" do
+      it "raises error" do
+        allow(described_class).to receive(:builder_class_at_scope).and_return(nil)
+        error_message = 'unexisting builder (type: form; scopes: Admin::Advanced)'
+        expect{ described_class.builder_class(["Admin::Advanced"], :form) }.to raise_error(ArgumentError, error_message)
+      end
+    end
+  end
+
+  describe ".builder_class_at_scope" do
+    before do
+      allow(described_class).to receive(:constant_defined_at_scope?)
+        .with("Releaf::Builders", Object).and_return(true)
+      allow(described_class).to receive(:constant_defined_at_scope?)
+        .with("Releaf::Builders::EditBuilder", Releaf::Builders).and_return(true)
+    end
+
+    context "when scope and builder exists" do
+      it "returns builder class" do
+        expect(described_class.builder_class_at_scope("Releaf::Builders", :edit)).to eq(Releaf::Builders::EditBuilder)
+      end
+    end
+
+    context "when scope exists but builder does not" do
+      it "returns nil" do
+        allow(described_class).to receive(:constant_defined_at_scope?)
+          .with("Releaf::Builders", Object).and_return(false)
+        expect(described_class.builder_class_at_scope("Releaf::Builders", :edit)).to be nil
+      end
+    end
+
+    context "when scope does not exist" do
+      it "returns nil" do
+        allow(described_class).to receive(:constant_defined_at_scope?)
+          .with("Releaf::Builders::EditBuilder", Releaf::Builders).and_return(false)
+        expect(described_class.builder_class_at_scope("Releaf::Builders", :edit)).to be nil
+      end
+    end
+  end
+
+  describe ".constant_defined_at_scope?" do
+    before do
+      allow(Releaf).to receive(:const_get).and_call_original
+    end
+
+    it "checks constant existence within given scope" do
+      expect(Releaf).to receive(:const_get).with("Releaf::Builders::FormBuilder").and_call_original
+      described_class.constant_defined_at_scope?("Releaf::Builders::FormBuilder", Releaf)
+
+      expect(Releaf).to receive(:const_get).with("Releaf::Builders::AnotherFormBuilder").and_call_original
+      described_class.constant_defined_at_scope?("Releaf::Builders::AnotherFormBuilder", Releaf)
+
+      expect(Admin).to receive(:const_get).with("Admin:xx").and_call_original
+      described_class.constant_defined_at_scope?("Admin:xx", Admin)
+    end
+
+    context "when constant exists at given namespace" do
+      it "returns true" do
+        expect(described_class.constant_defined_at_scope?("Releaf::Builders::FormBuilder", Releaf)).to be true
+      end
+
+      it "compare constant with constant at given namespace and check whether it exists" do
+        allow(Admin).to receive(:const_get).with("Admin:xx").and_return(true)
+        expect(described_class.constant_defined_at_scope?("Admin:xx", Admin)).to be false
+      end
+    end
+
+    context "when NameError raised" do
+      context "when error message matches against constant name pattern" do
+        it "returns false" do
+          allow(described_class).to receive(:constant_name_error?)
+            .with("uninitialized constant Releaf::Builders::AnotherFormBuilder", "Releaf::Builders::AnotherFormBuilder")
+            .and_return(true)
+          expect(described_class.constant_defined_at_scope?("Releaf::Builders::AnotherFormBuilder", Releaf)).to be false
+        end
+      end
+
+      context "when error message does not match against constant name pattern" do
+        it "reraises it" do
+          allow(described_class).to receive(:constant_name_error?)
+            .with("uninitialized constant Releaf::Builders::AnotherFormBuilder", "Releaf::Builders::AnotherFormBuilder")
+            .and_return(false)
+
+          expect{ described_class.constant_defined_at_scope?("Releaf::Builders::AnotherFormBuilder", Releaf) }
+            .to raise_error(NameError, "uninitialized constant Releaf::Builders::AnotherFormBuilder")
+        end
+      end
+    end
+
+    context "when any other error raised" do
+      it "does not rescue it" do
+        allow(Releaf).to receive(:const_get).with("Releaf::Builders::FormBuilder")
+                  .and_raise(ArgumentError, "xxx")
+        expect(described_class).to_not receive(:constant_name_error?)
+
+        expect{ described_class.constant_defined_at_scope?("Releaf::Builders::FormBuilder", Releaf) }
+          .to raise_error(ArgumentError, "xxx")
+      end
+    end
+  end
+
+  describe ".inherited_builder_scopes" do
+    it "returns inherited classes except Object and BasicObject" do
+      expect(described_class.inherited_builder_scopes).to eq(["Releaf::Builders"])
+      expect(Admin::Advanced::Builders.inherited_builder_scopes).to eq(["Admin::Advanced::Builders", "Releaf::Builders"])
+    end
+  end
+end