releaf-core 2.0.0 → 2.0.1

data/spec/features/settings_spec.rb

@@ -1,70 +0,0 @@
-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"},
-      {key: "content.date", default: DateTime.parse("2015-05-02"), type: "date"},
-      {key: "content.textarea", type: :textarea},
-      {key: "content.richtext", type: :richtext},
-    ]
-    Releaf::Settings.destroy_all
-    Releaf::Settings.register(*values)
-    auth_as_user
-
-    visit releaf_settings_path
-    expect(page).to have_number_of_resources(7)
-    expect(page).to have_css(".table.releaf\\/settings tbody tr:first-child td:first-child", text: "content.date")
-    expect(page).to have_css(".table.releaf\\/settings tbody tr:first-child td:nth-child(2)", text: /^Sat, 02 May 2015 00:00:00 \+0000$/)
-    expect(page).to have_css(".table.releaf\\/settings tbody tr:last-child td:first-child", text: "content.updated_at")
-
-    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("12:33")
-    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_settings_path
-
-    click_link "content.rating"
-    expect(page).to have_field("Value")
-    expect(page).to have_css(".field input[type='number'][value='5.65']")
-
-    click_link "Back to list"
-
-    click_link "content.textarea"
-    expect(page).to have_field("Value")
-    expect(page).to have_css(".field textarea[name='resource[value]']")
-
-    update_resource do
-      fill_in "Value", with: "AA\nBB\nCC\nDD\n"
-    end
-    click_link "Back to list"
-
-    expect(Releaf::Settings["content.textarea"]).to eq("AA\r\nBB\r\nCC\r\nDD\r\n")
-    expect(page).to have_content("AA BB CC DD")
-
-    click_link "content.richtext"
-    wait_for_all_richtexts
-
-    update_resource do
-      fill_in_richtext "Value", with: "<p>EE<br/>FF</p>\nGG\n<b>HH</b>\n"
-    end
-    click_link "Back to list"
-
-    expect(Releaf::Settings["content.richtext"]).to eq("<p>EE<br />\r\nFF</p>\r\n\r\n<p>GG <b>HH</b></p>\r\n")
-    expect(page).to have_content("EE FF GG HH")
-  end
-end

data/spec/features/title_spec.rb

@@ -1,13 +0,0 @@
-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

@@ -1,17 +0,0 @@
--
-  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

@@ -1,73 +0,0 @@
-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::ActionController)
-      helper.extend Releaf::ApplicationHelper
-      helper.extend ActionView::Helpers
-
-      helper
-    end
-
-    before do
-      translation = Releaf::I18nDatabase::I18nEntry.create(key: "admin.xx.colors-red")
-      translation.i18n_entry_translation.create(locale: "en", text: "Color red")
-      Releaf::I18nDatabase::Backend.reset_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

@@ -1,146 +0,0 @@
-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/action_controller/features_spec.rb

@@ -1,171 +0,0 @@
-require 'rails_helper'
-
-describe Releaf::ActionController::Features do
-  let(:subject){ DummyActionControllerFeaturesIncluder.new }
-
-  class DummyActionControllerFeaturesIncluder < Releaf::ActionController
-    include Releaf::ActionController::Features
-    include Releaf::Responders
-    def params
-      {action: "some_action"}
-    end
-  end
-
-  describe "#verify_feature_availability!" do
-    before do
-      allow(subject).to receive(:action_feature).with("some_action").and_return(:feature_name)
-    end
-
-    it "adds itself to before filters" do
-      before_actions = subject._process_action_callbacks.select{|f| f.kind == :before}.map{|f| f.filter }
-      expect(before_actions).to include(:verify_controller_access!)
-    end
-
-    context "when no feature defined for action" do
-      it "doesn no raise `Releaf::FeatureDisabled` exception" do
-        allow(subject).to receive(:action_feature).with("some_action").and_return(nil)
-        expect{ subject.verify_feature_availability! }.to_not raise_error
-      end
-    end
-
-    context "when current feature is available" do
-      it "doesn no raise `Releaf::FeatureDisabled` exception" do
-        allow(subject).to receive(:feature_available?).with(:feature_name).and_return(true)
-        expect{ subject.verify_feature_availability! }.to_not raise_error
-      end
-    end
-
-    context "when current feature is not available" do
-      it "raises `Releaf::FeatureDisabled` exception with stringified feature name" do
-        allow(subject).to receive(:feature_available?).with(:feature_name).and_return(false)
-        expect{ subject.verify_feature_availability! }.to raise_error(Releaf::FeatureDisabled, "feature_name")
-      end
-    end
-  end
-
-  describe "#action_feature" do
-    before do
-      allow(subject).to receive(:action_features).and_return(create: "xxx", te: "kkk")
-    end
-
-    it "returns matching feature for given action from action features" do
-      expect(subject.action_feature(:create)).to eq("xxx")
-    end
-
-    it "symbolize given action name" do
-      expect(subject.action_feature("te")).to eq("kkk")
-    end
-  end
-
-  describe "#features" do
-    it "returns array instance" do
-      expect(subject.features).to be_instance_of Array
-    end
-
-    it "returned array contains features as symbols" do
-      subject.features.each do|feature_name|
-        expect(feature_name).to be_instance_of Symbol
-      end
-    end
-  end
-
-  describe "#action_features" do
-    it "returns instance of `Hash`" do
-      expect(subject.action_features).to be_instance_of(Hash)
-    end
-
-    it "returns hash with action and feature mapp as symbols" do
-      subject.action_features.each_pair do|action_name, feature_name|
-        expect(action_name).to be_instance_of(Symbol)
-        expect(feature_name).to be_instance_of(Symbol)
-      end
-    end
-
-    context "when `show` feature is available" do
-      it "returns show to show feature mapping" do
-        allow(subject).to receive(:feature_available?).with(:show).and_return(true)
-        expect(subject.action_features[:show]).to eq(:show)
-      end
-    end
-
-    context "when `show` feature is not available" do
-      it "returns show to edit feature mapping" do
-        allow(subject).to receive(:feature_available?).with(:show).and_return(false)
-        expect(subject.action_features[:show]).to eq(:edit)
-      end
-    end
-  end
-
-  describe "#feature_disabled" do
-    before do
-      allow(subject).to receive(:action_responder).with(:feature_disabled).and_return("_res")
-    end
-
-    it "adds itself as rescue handler from `Releaf::FeatureDisabled` exception" do
-      expect(Hash[subject.rescue_handlers]["Releaf::FeatureDisabled"]).to eq(:feature_disabled)
-    end
-
-    it "calls disabled feature responder" do
-      expect(subject).to receive(:respond_with).with(nil, responder: "_res")
-      subject.feature_disabled(Releaf::FeatureDisabled.new("xx"))
-    end
-
-    it "assigns @feature instance variable from exception message" do
-      allow(subject).to receive(:respond_with)
-      expect{ subject.feature_disabled(Releaf::FeatureDisabled.new("xx")) }.to change{ subject.instance_variable_get(:@feature) }
-        .to("xx")
-    end
-  end
-
-  describe "#feature_available?" do
-    it "adds itself as helper" do
-      expect(subject._helper_methods).to include(:feature_available?)
-    end
-
-    it "returns whether feature is defined within features variable" do
-      allow(subject).to receive(:features).and_return([:edit])
-      expect(subject.feature_available?(:create)).to be false
-
-      allow(subject).to receive(:features).and_return([:edit, :create])
-      expect(subject.feature_available?(:create)).to be true
-    end
-
-    context "when `search` feature requested" do
-      it "also checks whether `index` feature is enabled" do
-        allow(subject).to receive(:feature_available?).with(:search).and_call_original
-        allow(subject).to receive(:feature_available?).with(:index).and_return(false)
-
-        allow(subject).to receive(:features).and_return([:edit])
-        expect(subject.feature_available?(:search)).to be false
-
-        allow(subject).to receive(:features).and_return([:edit, :search])
-        expect(subject.feature_available?(:search)).to be false
-
-        allow(subject).to receive(:feature_available?).with(:index).and_return(true)
-        expect(subject.feature_available?(:search)).to be true
-
-        allow(subject).to receive(:features).and_return([:edit])
-        expect(subject.feature_available?(:search)).to be false
-      end
-    end
-
-    context "when `create_another` feature requested" do
-      it "also checks whether `create` feature is enabled" do
-        allow(subject).to receive(:feature_available?).with(:create_another).and_call_original
-        allow(subject).to receive(:feature_available?).with(:create).and_return(false)
-
-        allow(subject).to receive(:features).and_return([:edit])
-        expect(subject.feature_available?(:create_another)).to be false
-
-        allow(subject).to receive(:features).and_return([:edit, :create_another])
-        expect(subject.feature_available?(:create_another)).to be false
-
-        allow(subject).to receive(:feature_available?).with(:create).and_return(true)
-        expect(subject.feature_available?(:create_another)).to be true
-
-        allow(subject).to receive(:features).and_return([:edit])
-        expect(subject.feature_available?(:create_another)).to be false
-      end
-    end
-  end
-end