releaf-core 0.2.1

data/spec/features/settings_spec.rb

@@ -0,0 +1,38 @@
+require 'rails_helper'
+feature "Settings", js: true do
+  scenario "edit settings" do
+    values = [
+      {key: "content.updated_at", default: Time.parse("2014-07-01 14:33:59"), description: "Content update time", type: :time},
+      {key: "content.updated", default: true, description: "Content is updated?", type: :boolean},
+      {key: "content.rating", default: 5.65, type: :decimal},
+      {key: "content.title", default: "some"}
+    ]
+    Releaf::Settings.destroy_all
+    Releaf::Settings.register(values)
+    auth_as_user
+
+    visit releaf_core_settings_path
+    expect(page).to have_number_of_resources(4)
+
+    search "content.updated"
+    expect(page).to have_number_of_resources(2)
+
+    click_link "content.updated_at"
+    update_resource do
+      fill_in "Content update time", with: '2014-04-01 12:33:59'
+    end
+    click_link "Back to list"
+    expect(page).to have_content("2014-04-01 12:33:59")
+    expect(Releaf::Settings["content.updated_at"]).to eq(Time.parse("2014-04-01 12:33:59"))
+
+    click_link "content.updated"
+    expect(page).to have_field("Content is updated?")
+    expect(page).to have_css(".field input[type='checkbox'][checked='checked']")
+
+    visit releaf_core_settings_path
+
+    click_link "content.rating"
+    expect(page).to have_field("Value")
+    expect(page).to have_css(".field input[type='number'][value='5.65']")
+  end
+end

data/spec/features/title_spec.rb

@@ -0,0 +1,13 @@
+require 'rails_helper'
+feature "Controller title" do
+  scenario "shows only application title" do
+    visit releaf_root_path
+    expect(page.title).to eq("Dummy")
+  end
+
+  scenario "shows only controller and application title" do
+    auth_as_user
+    visit releaf_permissions_user_profile_path
+    expect(page.title).to eq("Releaf/permissions/profile - Dummy")
+  end
+end

data/spec/fixtures/common_fields.yml

@@ -0,0 +1,17 @@
+-
+  field_name: 'meta_description'
+  field_type: 'boolean'
+  apply_to: '*'
+  default: 'common stuff'
+  deny_for: 'Text'
+
+-
+  field_name: 'meta_copyright'
+  field_type: 'text'
+  apply_to: ['Text', 'ContactsController']
+  levels: [1]
+
+-
+  field_name: 'other_attribute'
+  field_type: 'text'
+  apply_to: 'ContactsController'

data/spec/helpers/application_helper_spec.rb

@@ -0,0 +1,75 @@
+require 'rails_helper'
+
+describe Releaf::ApplicationHelper do
+  describe "#releaf_table" do
+    it "returns table builder output for collection and resource class with given options" do
+      builder = Releaf::Permissions::Users::TableBuilder
+      collection = "collection"
+
+      allow(builder).to receive(:new).with(collection, TextPage, subject, toolbox: false).and_call_original
+      allow_any_instance_of(builder).to receive(:output).and_return("table")
+
+      expect(releaf_table(collection, TextPage, builder: builder, toolbox: false)).to eq("table")
+    end
+  end
+
+  describe "#merge_attributes" do
+    it "makes deep merge second over first hash" do
+      expect(helper.merge_attributes({a: {b: "c"}, d: "e"}, {a: {b: "č"}, f: "x"})).to eq(a: {b: "č"}, d: "e", f: "x")
+    end
+
+    it "merges class values from both hashes" do
+      expect(helper.merge_attributes({class: ["a", "b"]}, {})[:class]).to eq(["a", "b"])
+      expect(helper.merge_attributes({}, {class: "d c"})[:class]).to eq(["d c"])
+      expect(helper.merge_attributes({class: ["a", "b"]}, {class: "d c"})[:class]).to eq(["a", "b", "d c"])
+    end
+
+    it "removes empty class values on merging" do
+      expect(helper.merge_attributes({class: ["a", nil, "b"]}, {class: ["", "c"]})[:class]).to eq(["a", "b", "c"])
+    end
+  end
+
+  describe "#i18n_options_for_select" do
+    Color = Struct.new(:id, :to_s)
+    let(:helper) do
+      helper = instance_double(Releaf::BaseController)
+      helper.extend Releaf::ApplicationHelper
+      helper.extend ActionView::Helpers
+
+      helper
+    end
+
+    before do
+
+      translation = FactoryGirl.create(:translation, :key => "admin.xx.colors-red")
+      FactoryGirl.create(:translation_data, :lang => "en", :localization => "Color red", :translation => translation)
+      I18n.backend.reload_cache
+
+      allow(helper).to receive(:controller_scope_name).and_return("admin.xx")
+    end
+
+    context "when array of string" do
+      it "returns translated options" do
+        input = ["red", "green", "blue"]
+        output = ['<option value="red">Color red</option>', '<option selected="selected" value="green">green</option>', '<option value="blue">blue</option>'].join("\n")
+        expect(helper.i18n_options_for_select(input, "green", "colors")).to eq(output)
+      end
+    end
+
+    context "when hash" do
+      it "returns translated options" do
+        input = {"red" => "r", "green" => "g", "blue" => "b"}
+        output = ['<option value="r">Color red</option>', '<option selected="selected" value="g">green</option>', '<option value="b">blue</option>'].join("\n")
+        expect(helper.i18n_options_for_select(input, "g", "colors")).to eq(output)
+      end
+    end
+
+    context "when array of string for another translation scope" do
+      it "returns translated options" do
+        input = ["red", "green", "blue"]
+        output = ['<option value="red">red</option>', '<option selected="selected" value="green">green</option>', '<option value="blue">blue</option>'].join("\n")
+        expect(helper.i18n_options_for_select(input, "green", "colors", {:scope => "admin.products"})).to eq(output)
+      end
+    end
+  end
+end

data/spec/helpers/button_helper_spec.rb

@@ -0,0 +1,146 @@
+require 'rails_helper'
+
+describe Releaf::ButtonHelper do
+
+  describe "#releaf_button" do
+
+    it "returns an HTML button element with title, icon, text and optional extra attributes" do
+      output = '<button class="button with-icon danger secondary" title="escape&gt;&lt;this" type="button" autocomplete="off" data-x="escape&lt;this&gt;too"><i class="fa fa-plus"></i>escape&gt;&lt;this</button>'
+      expect(helper.releaf_button("escape><this", "plus", class: [ :danger, "secondary" ], 'data-x' => 'escape<this>too' )).to eq(output)
+    end
+
+    it "uses #releaf_button_attributes and #releaf_button_content to collect button attributes and content" do
+      processed_attributes = { attr: :value, data: { attrx: "valuex" } }
+
+      expect(helper).to receive(:releaf_button_attributes).with("foo", "bar", {} ).and_return(processed_attributes)
+      expect(helper).to receive(:releaf_button_content).with("foo", "bar", processed_attributes).and_return("button content")
+
+      expect(helper.releaf_button("foo", "bar")).to eq('<button attr="value" data-attrx="valuex">button content</button>')
+    end
+
+    context "when href is given in attributes" do
+
+      it "returns a link element instead of a button" do
+        html = '<a class="button with-icon" title="x" href="http://example.com/?a&amp;b"><i class="fa fa-plus"></i>x</a>'
+        expect(helper.releaf_button("x", "plus", href: "http://example.com/?a&b")).to eq(html)
+      end
+
+      it "returns a link element even if the given href is blank" do
+        html = '<a class="button with-icon" title="x"><i class="fa fa-plus"></i>x</a>'
+        expect(helper.releaf_button("x", "plus", href: nil)).to eq(html)
+      end
+
+    end
+
+  end
+
+  describe "#releaf_button_attributes" do
+
+    it "returns a hash of attributes" do
+      expect(helper.releaf_button_attributes( :text_foo, :icon_bar )).to be_a Hash
+    end
+
+    it "adds button class" do
+      expect(helper.releaf_button_attributes( :text_foo, :icon_bar )[:class]).to include( "button" )
+    end
+
+    it "sets title attribute to given text" do
+      expect(helper.releaf_button_attributes( :text_foo, :icon_bar )).to include( title: :text_foo )
+    end
+
+    context "when href attribute given" do
+      it "does not set type attribute" do
+        expect(helper.releaf_button_attributes( :text_foo, :icon_bar, href: :baz )).to_not include( :type )
+      end
+    end
+
+    context "when href attribute not given" do
+      it "sets type attribute to button" do
+        expect(helper.releaf_button_attributes( :text_foo, :icon_bar )).to include( type: :button )
+      end
+    end
+
+    context "when icon given" do
+
+      context "when text also given" do
+        it "adds with-icon class" do
+          expect(helper.releaf_button_attributes( :text_foo, :icon_bar )[:class]).to include( "with-icon" )
+        end
+      end
+
+      context "when text not given" do
+        it "adds only-icon class" do
+          expect(helper.releaf_button_attributes( nil, :icon_bar )[:class]).to include( "only-icon" )
+        end
+      end
+
+    end
+
+    context "when extra attributes given" do
+
+      it "includes given custom attributes with the default ones" do
+        expect(helper.releaf_button_attributes( :text_foo, :icon_bar, data: { x: "y" })).to include( class: ["button", "with-icon"], data: { x: "y" } )
+      end
+
+      it "overwrites default attributes if needed" do
+        expect(helper.releaf_button_attributes( :text_foo, :icon_bar, type: :submit, title: "custom")).to include( type: :submit, title: "custom" )
+      end
+
+      it "combines given class names with the deault ones" do
+        expect(helper.releaf_button_attributes( :text_foo, :icon_bar, class: "danger") ).to include( class: ["button", "with-icon", "danger"] )
+      end
+
+    end
+
+  end
+
+
+  describe "#releaf_button_content" do
+
+    let(:icon_html) { '<i class="fa fa-icon_bar"></i>' }
+
+    it "returns an html-safe buffer" do
+      expect(helper.releaf_button_content( :text_foo, :icon_bar )).to be_a ActiveSupport::SafeBuffer
+    end
+
+    context "when text and icon given" do
+      it "returns icon HTML followed by given text" do
+        expect(helper.releaf_button_content( "escape<this>text", :icon_bar )).to eq(icon_html + 'escape&lt;this&gt;text')
+      end
+    end
+
+    context "when only text given" do
+      it "returns given text" do
+        expect(helper.releaf_button_content( "escape<this>text", nil )).to eq('escape&lt;this&gt;text')
+      end
+    end
+
+    context "when only icon given" do
+
+      context "when title attribute is present" do
+        it "returns icon HTML" do
+          expect(helper.releaf_button_content( nil, :icon_bar, title: "foo" )).to eq(icon_html)
+        end
+      end
+
+      context "when title attribute is not present" do
+
+        it "raises an ArgumentError" do
+          expect{ helper.releaf_button_content(nil, :icon_bar, title: "") }.to raise_error(ArgumentError, "Title is required for icon-only buttons")
+        end
+
+      end
+
+    end
+
+
+    context "when both text and icon are blank" do
+      it "raises an ArgumentError" do
+        expect{ helper.releaf_button_content(nil, nil ) }.to raise_error(ArgumentError, "Either text or icon is required for buttons")
+        expect{ helper.releaf_button_content("", "" ) }.to raise_error(ArgumentError, "Either text or icon is required for buttons")
+      end
+    end
+
+  end
+
+end

data/spec/lib/releaf/core/application_spec.rb

@@ -0,0 +1,42 @@
+require "rails_helper"
+
+describe Releaf::Core::Application do
+  describe "#configure" do
+    it "assigns new `Releaf::Core::Configuration` instance, evaluate block and call instance configuration" do
+      configuration = Releaf::Core::Configuration.new
+      allow(Releaf::Core::Configuration).to receive(:new).and_return(configuration)
+
+      expect(subject).to receive(:config=).with(configuration).and_call_original.ordered
+      expect(configuration).to receive(:menu=).with("x").ordered
+      expect(configuration).to receive(:configure)
+      subject.configure{ config.menu = "x" }
+    end
+  end
+
+  describe "#render_layout" do
+    before do
+      class DummyBuilder
+        def initialize(x)
+        end
+
+        def output(&block)
+          yield
+        end
+      end
+
+      subject.config = Releaf::Core::Configuration.new
+      allow(subject.config).to receive(:layout_builder_class_name).and_return("DummyBuilder")
+      builder = DummyBuilder.new("xx")
+      allow(DummyBuilder).to receive(:new).with("tmpl").and_return(builder)
+    end
+
+    it "returns layout builder rendered layout" do
+      expect(subject.render_layout("tmpl"){ "pp" }).to eq("pp")
+    end
+
+    it "returns html safe content" do
+      expect(subject.render_layout("tmpl"){ "pp" }.html_safe?).to be true
+    end
+  end
+end
+

data/spec/lib/releaf/core/assets_resolver_spec.rb

@@ -0,0 +1,113 @@
+require "rails_helper"
+
+describe Releaf::Core::AssetsResolver do
+  describe ".base_assets" do
+    it "returns array with `releaf/application`" do
+      expect(described_class.base_assets).to eq(["releaf/application"])
+    end
+  end
+
+  describe ".controller_assets" do
+    before do
+      allow(described_class).to receive(:base_assets).and_return(["a", "b"])
+    end
+
+    it "returns array with controller specific asset alognside base assets" do
+      allow(described_class).to receive(:assets).and_return(
+        "releaf/i18n_database/translations" => {
+          javascripts: ["c"],
+          stylesheets: ["d", "e"],
+        }
+      )
+      expect(described_class.controller_assets("releaf/i18n_database/translations", :javascripts))
+        .to eq(["a", "b", "c"])
+      expect(described_class.controller_assets("releaf/i18n_database/translations", :stylesheets))
+        .to eq(["a", "b", "d", "e"])
+    end
+
+    context "when no controller specific assets exists" do
+      it "returns only base assets" do
+        allow(described_class).to receive(:assets).and_return({})
+        expect(described_class.controller_assets("releaf/i18n_database/translations", :stylesheets))
+          .to eq(["a", "b"])
+      end
+    end
+  end
+
+  describe ".compiled_assets" do
+    it "returns array with controller scoped stylesheets and javascripts" do
+      allow(Rails.application.assets_manifest).to receive(:files).and_return(
+        "releaf/controllers/releaf/content/nodes-72ac849dd467fe827933f15c45ea77a2b7beac55379147f3be4a21779787f484.js"=>{"logical_path"=>"releaf/controllers/releaf/content/nodes.js", "mtime"=>"2015-12-01T13:55:41+02:00", "size"=>1530, "digest"=>"72ac849dd467fe827933f15c45ea77a2b7beac55379147f3be4a21779787f484", "integrity"=>"sha256-cqyEndRn/oJ5M/FcRep3ore+rFU3kUfzvkohd5eH9IQ="},
+        "releaf/controllers/releaf/content/nodes-2ac6b38702a01d9e0918f058f923b39c8320cdfa61f41c7494752b648a45e746.css"=>{"logical_path"=>"releaf/controllers/releaf/content/nodes.css", "mtime"=>"2016-01-18T13:36:15+02:00", "size"=>5919, "digest"=>"2ac6b38702a01d9e0918f058f923b39c8320cdfa61f41c7494752b648a45e746", "integrity"=>"sha256-KsazhwKgHZ4JGPBY+SOznIMgzfph9Bx0lHUrZIpF50Y="},
+        "releaf/controllers/releaf/permissions/sessions-9eb2f3275ea7578a6a95ca413d318a9984ef93c0d6645f11cf77fe82a2639cf0.css"=>{"logical_path"=>"releaf/controllers/releaf/permissions/sessions.css", "mtime"=>"2016-01-18T13:36:15+02:00", "size"=>2205, "digest"=>"9eb2f3275ea7578a6a95ca413d318a9984ef93c0d6645f11cf77fe82a2639cf0", "integrity"=>"sha256-nrLzJ16nV4pqlcpBPTGKmYTvk8DWZF8Rz3f+gqJjnPA="}
+      )
+
+      list = {
+        "releaf/content/nodes"=>{:stylesheets=>["releaf/controllers/releaf/content/nodes.css"],
+                                 :javascripts=>["releaf/controllers/releaf/content/nodes.js"]},
+        "releaf/permissions/sessions" => {:stylesheets=>["releaf/controllers/releaf/permissions/sessions.css"], :javascripts=>[]}
+      }
+      expect(described_class.compiled_assets).to eq(list)
+    end
+  end
+
+  describe ".noncompiled_assets" do
+    it "returns array with controller scoped stylesheets and javascripts" do
+      list = {
+        "releaf/content/nodes"=>{:stylesheets=>["releaf/controllers/releaf/content/nodes"],
+                                 :javascripts=>["releaf/controllers/releaf/content/nodes"]},
+        "releaf/i18n_database/translations"=>{:stylesheets=>["releaf/controllers/releaf/i18n_database/translations"],
+                                              :javascripts=>["releaf/controllers/releaf/i18n_database/translations"]},
+        "releaf/permissions/sessions" => {:stylesheets=>["releaf/controllers/releaf/permissions/sessions"], :javascripts=>[]}
+      }
+      expect(described_class.noncompiled_assets).to eq(list)
+    end
+  end
+
+  describe ".compiled_assets?" do
+    context "when `Rails.application.assets` is not nil" do
+      it "returns true" do
+        allow(Rails.application).to receive(:assets).and_return(nil)
+        expect(described_class.compiled_assets?).to be true
+      end
+    end
+
+    context "when `Rails.application.assets` is nil" do
+      it "returns false" do
+        allow(Rails.application).to receive(:assets).and_return("x")
+        expect(described_class.compiled_assets?).to be false
+      end
+    end
+  end
+
+  describe ".assets" do
+    before do
+      described_class.class_variable_set(:@@compiled_assets, nil)
+      allow(described_class).to receive(:compiled_assets).and_return("a")
+      allow(described_class).to receive(:noncompiled_assets).and_return("b")
+    end
+
+    context "when compiled assets is not available" do
+      it "returns non compiled assets" do
+        allow(described_class).to receive(:compiled_assets?).and_return(false)
+        expect(described_class.assets).to eq("b")
+      end
+    end
+
+    context "when compiled assets available" do
+      before do
+        allow(described_class).to receive(:compiled_assets?).and_return(true)
+      end
+
+      it "caches compiled assets list" do
+        expect(described_class).to receive(:compiled_assets).once.and_return("a")
+        described_class.assets
+        described_class.assets
+      end
+
+      it "returns compiled assets" do
+        expect(described_class.assets).to eq("a")
+      end
+    end
+  end
+end