releaf-core 2.0.0 → 2.0.1

data/spec/lib/releaf/action_controller/search_spec.rb

@@ -1,84 +0,0 @@
-require 'rails_helper'
-
-describe Releaf::ActionController::Search do
-  let(:subject){ DummyActionControllerSearchIncluder.new }
-
-  class DummySearcher < Releaf::Search
-  end
-
-  class DummyActionControllerSearchIncluder < Releaf::ActionController
-    include Releaf::ActionController::Features
-    include Releaf::ActionController::Search
-
-    def resource_class
-      Book
-    end
-  end
-
-  describe "#search" do
-    before do
-      allow(subject).to receive(:searchable_fields).and_return([:name, :email])
-      allow(subject).to receive(:feature_available?).with(:search).and_return(true)
-
-      subject.instance_variable_set(:@collection, "_collection")
-      allow(subject).to receive(:searcher_class).and_return(DummySearcher)
-      allow(DummySearcher).to receive(:prepare).with(relation: "_collection", fields: [:name, :email], text: "_some")
-        .and_return("_collection_with_search")
-    end
-
-    context "when feature is enabled, text and searchable fields is not blank" do
-      it "replaces collection with searchable collection" do
-        expect{ subject.search("_some") }.to change{ subject.instance_variable_get(:@collection) }
-          .from("_collection").to("_collection_with_search")
-      end
-    end
-
-    context "when `show` feature is not available" do
-      it "does not replace collection with searchable collection" do
-        allow(subject).to receive(:feature_available?).with(:search).and_return(false)
-        expect{ subject.search("_some") }.to_not change{ subject.instance_variable_get(:@collection) }
-      end
-    end
-
-    context "when blank search given" do
-      it "does not replace collection with searchable collection" do
-        expect{ subject.search("") }.to_not change{ subject.instance_variable_get(:@collection) }
-      end
-    end
-
-    context "when no search fields exists" do
-      it "does not replace collection with searchable collection" do
-        allow(subject).to receive(:searchable_fields).and_return([])
-        expect{ subject.search("_some") }.to_not change{ subject.instance_variable_get(:@collection) }
-      end
-    end
-  end
-
-  describe "#searcher_class" do
-    it "returns `Releaf::Search` class" do
-      expect(subject.searcher_class).to eq(Releaf::Search)
-    end
-  end
-
-  describe "#searchable_fields" do
-    let(:searchable_fields){ Releaf::DefaultSearchableFields.new(Author) }
-
-    it "adds itself as helper" do
-      expect(subject._helper_methods).to include(:searchable_fields)
-    end
-
-    it "returns default searchable fields from `Releaf::DefaultSearchableFields` instance" do
-      allow(Releaf::DefaultSearchableFields).to receive(:new).with(Book).and_return(searchable_fields)
-      allow(searchable_fields).to receive(:find).and_return("x").once
-
-      expect(subject.searchable_fields).to eq("x")
-    end
-
-    it "caches returned searchable fields" do
-      allow(Releaf::DefaultSearchableFields).to receive(:new).and_return(searchable_fields)
-      expect(searchable_fields).to receive(:find).and_return("x").once
-      subject.searchable_fields
-      subject.searchable_fields
-    end
-  end
-end

data/spec/lib/releaf/application_spec.rb

@@ -1,43 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Application do
-  describe "#configure" do
-    it "assigns new configuration instance, evaluate block, initialize locales and components" do
-      configuration = Releaf::Configuration.new
-      allow(Releaf::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(:initialize_locales).ordered
-      expect(configuration).to receive(:initialize_components).ordered
-      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::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/assets_resolver_spec.rb

@@ -1,130 +0,0 @@
-require "rails_helper"
-
-describe Releaf::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
-
-    context "when controller assets of given type (javascripts/stylesheets) exists" do
-      it "returns array with controller specific asset alognside base assets" do
-        allow(described_class).to receive(:assets).and_return(
-          "controllers/releaf/i18n_database/translations.js" => "controllers/releaf/i18n_database/translations.js",
-          "controllers/releaf/i18n_database/translations.css" => "controllers/releaf/i18n_database/translations.css",
-        )
-        expect(described_class.controller_assets("releaf/i18n_database/translations", :javascripts))
-          .to eq(["a", "b", "controllers/releaf/i18n_database/translations.js"])
-
-        expect(described_class.controller_assets("releaf/i18n_database/translations", :stylesheets))
-          .to eq(["a", "b", "controllers/releaf/i18n_database/translations.css"])
-      end
-    end
-
-    context "when no controller assets of given type (javascripts/stylesheets) exists" do
-      it "returns only base assets" do
-        allow(described_class).to receive(:assets).and_return(
-          "controllers/releaf/i18n_database/translations.fonts" => "controllers/releaf/i18n_database/translations.fonts",
-          "i18n_database/translations.css" => "i18n_database/translations.css",
-        )
-        expect(described_class.controller_assets("releaf/i18n_database/translations", :javascripts))
-          .to eq(["a", "b"])
-
-        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 uniq controller scoped stylesheets and javascripts" do
-      allow(Rails.application.assets_manifest).to receive(:files).and_return(
-        "controllers/releaf/content/nodes-72ac849dd467fe827933f15c45ea77a2b7beac55379147f3be4a21779787f484.js"=>{"logical_path"=>"controllers/releaf/content/nodes.js", "mtime"=>"2015-12-01T13:55:41+02:00", "size"=>1530, "digest"=>"72ac849dd467fe827933f15c45ea77a2b7beac55379147f3be4a21779787f484", "integrity"=>"sha256-cqyEndRn/oJ5M/FcRep3ore+rFU3kUfzvkohd5eH9IQ="},
-        "controllers/releaf/content/nodes-2ac6b38702a01d9e0918adasasdasda45e746.css"=>{"logical_path"=>"controllers/releaf/content/nodes.css", "mtime"=>"2016-02-18T13:36:15+02:00", "size"=>4301, "digest"=>"2ac6b38702a01d9e0918adasasdasda45e746", "integrity"=>"sha256-asdasdasdsa+adasdasda="},
-        # simulate old assets cache here
-        "controllers/releaf/content/nodes-adsaassdkdasd.css"=>{"logical_path"=>"controllers/releaf/content/nodes.css", "mtime"=>"2016-02-18T13:36:15+02:00", "size"=>4301, "digest"=>"adsaassdkdasd", "integrity"=>"sha256-asdasdasdsa+adasdasda="},
-        "releaontxzcent/nodes-asdassdasdsaasdasd.css"=>{"logical_path"=>"releaontxzcent/nodes-asdassdasdsaasdasd.css", "mtime"=>"2016-01-18T13:36:15+02:00", "size"=>5919, "digest"=>"asdassdasdsaasdasd", "integrity"=>"sha256-KsazhwKgHZ4JGPBY+SOznIMgzfph9Bx0lHUrZIpF50Y="},
-        "controllers/releaf/permissions/sessions-9eb2f3275ea7578a6a95ca413d318a9984ef93c0d6645f11cf77fe82a2639cf0.css"=>{"logical_path"=>"controllers/releaf/permissions/sessions.css", "mtime"=>"2016-01-18T13:36:15+02:00", "size"=>2205, "digest"=>"9eb2f3275ea7578a6a95ca413d318a9984ef93c0d6645f11cf77fe82a2639cf0", "integrity"=>"sha256-nrLzJ16nV4pqlcpBPTGKmYTvk8DWZF8Rz3f+gqJjnPA="}
-      )
-
-      list = [
-        "controllers/releaf/content/nodes.js",
-        "controllers/releaf/content/nodes.css",
-        "controllers/releaf/permissions/sessions.css"
-      ]
-      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 = [
-        "controllers/admin/books.js",
-        "controllers/admin/nodes.js",
-        "controllers/admin/other_site/other_nodes.js",
-        "controllers/admin/nodes.css",
-        "controllers/admin/other_site/other_nodes.css",
-        "controllers/releaf/content/nodes.js",
-        "controllers/releaf/content/nodes.css",
-        "controllers/releaf/permissions/sessions.css",
-        "controllers/releaf/i18n_database/translations.js",
-        "controllers/releaf/i18n_database/translations.css"
-      ]
-      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")
-      allow(described_class).to receive(:assets_hash).with("a").and_return("aa")
-      allow(described_class).to receive(:assets_hash).with("b").and_return("bb")
-    end
-
-    context "when compiled assets is not available" do
-      it "returns grouped non compiled assets" do
-        allow(described_class).to receive(:compiled_assets?).and_return(false)
-        expect(described_class.assets).to eq("bb")
-      end
-    end
-
-    context "when compiled assets available" do
-      before do
-        allow(described_class).to receive(:compiled_assets?).and_return(true)
-      end
-
-      it "caches grouped compiled assets list" do
-        expect(described_class).to receive(:assets_hash).once.and_return("aa")
-        described_class.assets
-        described_class.assets
-      end
-
-      it "returns grouped compiled assets" do
-        expect(described_class.assets).to eq("aa")
-      end
-    end
-  end
-end

data/spec/lib/releaf/build_errors_hash_spec.rb

@@ -1,141 +0,0 @@
-require 'rails_helper'
-
-describe Releaf::BuildErrorsHash do
-  let(:resource) { Book.new }
-  let(:error){ ActiveModel::ErrorMessage.new("blank value", :blank) }
-
-  subject do
-    described_class.new(resource: resource, field_name_prefix: :resource)
-  end
-
-  describe "#call" do
-    it "returns hash with merged errors" do
-      allow(subject).to receive(:errors).and_return([
-        {
-          field_name: "name",
-          message: "error blank",
-          error_code: :blank,
-        },
-        {
-          field_name: "name",
-          message: "invalid format",
-          error_code: :invalid_format,
-        },
-        {
-          field_name: "surname",
-          message: "error blank",
-          error_code: :blank,
-        },
-      ])
-      expect(subject.call).to eq(
-        "name" => [{message: "error blank", error_code: :blank}, {message: "invalid format", error_code: :invalid_format}],
-        "surname" => [{message: "error blank", error_code: :blank}]
-      )
-    end
-  end
-
-  describe "#errors" do
-    it "returns flattened errors array" do
-      allow(resource).to receive(:errors).and_return(name: "er1", surname: "er2", role: "er3")
-      allow(subject).to receive(:format_error).with(:name, "er1").and_return("error1")
-      allow(subject).to receive(:format_error).with(:surname, "er2").and_return("error2")
-      allow(subject).to receive(:format_error).with(:role, "er3").and_return(["error3", "error4"])
-      expect(subject.errors).to eq(["error1", "error2", "error3", "error4"])
-    end
-  end
-
-  describe "#format_error" do
-    before do
-      allow(subject).to receive(:attribute_error).with(:name, "er1").and_return("error1")
-      allow(subject).to receive(:nested_attribute_errors).with(:name).and_return(["error1", "error2"])
-    end
-
-    context "when resource attribute given" do
-      it "returns attribute error" do
-        allow(subject).to receive(:resource_attribute?).and_return(true)
-        expect(subject.format_error(:name, "er1")).to eq("error1")
-      end
-    end
-
-    context "when nested attribute given" do
-      it "returns nested attribute errors" do
-        allow(subject).to receive(:resource_attribute?).and_return(false)
-        expect(subject.format_error(:name, "er1")).to eq(["error1", "error2"])
-      end
-    end
-  end
-
-  describe "#attribute_error" do
-    it "returns attribute error hash" do
-      allow(subject).to receive(:field_name).with(:name).and_return("xxx_name")
-      expect(subject.format_error(:name, error)).to eq(field_name: "xxx_name", error_code: :blank, message: "blank value")
-    end
-  end
-
-  describe "#single_association?" do
-    context "for :belongs_to association" do
-      it "returns true" do
-        expect( subject.single_association?('author') ).to be true
-      end
-    end
-
-    context "for :has_many association" do
-      it "returns false" do
-        expect( subject.single_association?('chapters') ).to be false
-      end
-    end
-
-    context "for :has_one association" do
-      it "returns true" do
-        allow(subject).to receive(:association_type).with('author').and_return(:has_one)
-        expect( subject.single_association?('author') ).to be true
-      end
-    end
-  end
-
-  describe "#association" do
-    it "returns active record reflection of association" do
-      expect( subject.send(:association, 'author') ).to eq Book.reflect_on_association(:author)
-    end
-  end
-
-  describe "#association_type" do
-    it "returns active record reflection macro" do
-      expect( subject.association_type('author') ).to eq :belongs_to
-    end
-  end
-
-  describe "#resource_attribute?" do
-    context "when attribute name contains dot" do
-      it "returns false" do
-        expect( subject.resource_attribute?('test.attribute') ).to be false
-      end
-    end
-
-    context "when attribute name doesn't contain dot" do
-      it "returns true" do
-        expect( subject.resource_attribute?('test') ).to be true
-      end
-    end
-  end
-
-  describe "#field_name" do
-    context "when error is on base" do
-      it "returns resource field_id" do
-        expect( subject.field_name('base')).to eq 'resource'
-      end
-    end
-
-    context "when attribute is association" do
-      it "returns field_id for associations foreign key" do
-        expect( subject.field_name('author')).to eq 'resource[author_id]'
-      end
-    end
-
-    context "when attribute is not association" do
-      it "returns field_id for field" do
-        expect( subject.field_name('title')).to eq 'resource[title]'
-      end
-    end
-  end
-end

data/spec/lib/releaf/configuration_spec.rb

@@ -1,205 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Configuration do
-  class DummyComponentA
-    def self.configure_component; end
-  end
-  class DummyComponentB
-    def self.initialize_component; end
-  end
-  class DummyComponentC
-    def self.initialize_component; end
-    def self.configure_component; end
-  end
-
-  describe "#components=" do
-    before do
-      allow(subject).to receive(:flatten_components).with(["x", "s"])
-        .and_return([DummyComponentA, DummyComponentB, DummyComponentC])
-    end
-
-    it "assigns normalized components" do
-      expect{ subject.components = ["x", "s"] }.to change{ subject.components }.to([DummyComponentA, DummyComponentB, DummyComponentC])
-    end
-
-    it "calls component configuration if available" do
-      expect(DummyComponentA).to receive(:configure_component).ordered
-      expect(DummyComponentC).to receive(:configure_component).ordered
-      subject.components = ["x", "s"]
-    end
-  end
-
-  describe "#initialize_components" do
-    it "adds component configuration and calls component initializing method if available" do
-      allow(subject).to receive(:components).and_return([DummyComponentA, DummyComponentB, DummyComponentC])
-      expect(DummyComponentB).to receive(:initialize_component).ordered
-      expect(DummyComponentC).to receive(:initialize_component).ordered
-      subject.initialize_components
-    end
-  end
-
-  describe "#add_configuration" do
-    it "creates configuration class accessor for given configuration instance, and assigns given instance to it" do
-      class Releaf::Configuration::DummySampleConfiguration; end
-      configuration = Releaf::Configuration::DummySampleConfiguration.new
-
-      expect(subject.respond_to?(:dummy_sample)).to be false
-      subject.add_configuration(configuration)
-
-      expect(subject.respond_to?(:dummy_sample)).to be true
-      expect(subject.dummy_sample).to eq(configuration)
-    end
-  end
-
-  describe "#initialize_locales" do
-    before do
-      subject.available_locales = [:a, :b]
-      subject.available_admin_locales = [:b, :c]
-      allow(::I18n).to receive(:available_locales=)
-    end
-
-    it "assigns available locales to `I18n.available_locales`" do
-      expect(::I18n).to receive(:available_locales=).with([:a, :b])
-      subject.initialize_locales
-    end
-
-    context "when no `available_admin_locales` defined" do
-      it "overwrites it with available locales" do
-        expect{ subject.initialize_locales }.to_not change{ subject.available_admin_locales }
-
-        subject.available_admin_locales = nil
-        expect{ subject.initialize_locales }.to change{ subject.available_admin_locales }.to eq([:a, :b])
-      end
-    end
-  end
-
-  describe "#all_locales" do
-    before do
-      subject.available_locales = [:a, :b]
-      subject.available_admin_locales = [:b, :c]
-    end
-
-    it "merges unique locales form admin and available locales, casts it to strings and assign to `all_locales`" do
-      expect( subject.all_locales ).to eq(["a", "b", "c"])
-    end
-
-    it "caches resolved locales" do
-      expect(subject).to receive(:available_locales).and_call_original.once
-      expect(subject).to receive(:available_admin_locales).and_call_original.once
-      subject.all_locales
-      subject.all_locales
-    end
-  end
-
-  describe "#flatten_components" do
-    it "returns recursively flattened component list" do
-      class DummyComponentA; end
-      class DummyComponentB
-        def self.components
-          ["o", "p"]
-        end
-      end
-
-      allow(subject).to receive(:flatten_components).and_call_original
-      allow(subject).to receive(:flatten_components).with(["o", "p"]).and_return(["x", "y"])
-      expect(subject.flatten_components([DummyComponentA, DummyComponentB])).to eq([DummyComponentA, "x", "y", DummyComponentB])
-    end
-  end
-
-  describe "#menu=" do
-    it "normalizes menu before assigning" do
-      allow(described_class).to receive(:normalize_controllers).with(["a"]).and_return(["aa"])
-      expect{ subject.menu = ["a"] }.to change{ subject.menu }.to(["aa"])
-    end
-  end
-
-  describe "#additional_controllers=" do
-    it "normalizes additional controllers before assigning" do
-      allow(described_class).to receive(:normalize_controllers).with(["b"]).and_return(["bb"])
-      expect{ subject.additional_controllers = ["b"] }.to change{ subject.additional_controllers }.to(["bb"])
-    end
-  end
-
-  describe "#controllers" do
-    it "returns extracted controllers from menu and additional controllers attributes" do
-      allow(subject).to receive(:menu).and_return(["a", "b"])
-      allow(subject).to receive(:additional_controllers).and_return(["c", "d"])
-      allow(subject).to receive(:extract_controllers).with(["a", "b", "c", "d"]).and_return("xxx")
-      expect( subject.controllers ).to eq("xxx")
-    end
-
-    it "caches resolved controllers" do
-      expect(subject).to receive(:extract_controllers).and_call_original.once
-      subject.controllers
-      subject.controllers
-    end
-  end
-
-  describe "#available_controllers" do
-    before do
-      allow(subject).to receive(:controllers).and_return("c" => "d", "l" => "k")
-    end
-
-    it "returns controller names" do
-      expect( subject.available_controllers ).to eq(["c", "l"])
-    end
-
-    it "caches resolved controller names" do
-      expect(subject).to receive(:controllers).and_call_original.once
-      subject.available_controllers
-      subject.available_controllers
-    end
-  end
-
-  describe "#extract_controllers" do
-    it "returns recursively built hash with controllers from given array" do
-      item_1 = Releaf::ControllerDefinition.new(name: "aa", controller: :a)
-      item_2 = Releaf::ControllerDefinition.new(name: "bb", controller: :b)
-      item_3 = Releaf::ControllerDefinition.new(name: "cc", controller: :c)
-      item_4 = Releaf::ControllerDefinition.new(name: "dd", controller: :d)
-      item_5 = Releaf::ControllerDefinition.new(name: "ff", controller: :f)
-
-      group_item_1 = Releaf::ControllerGroupDefinition.new(name: "x", items: [])
-      group_item_2 = Releaf::ControllerGroupDefinition.new(name: "y", items: [])
-      allow(group_item_1).to receive(:controllers).and_return([item_3, item_4])
-      allow(group_item_2).to receive(:controllers).and_return([item_5])
-
-      list = [item_1, group_item_1, group_item_2, item_2]
-      result = {a: item_1, b: item_2, c: item_3, d: item_4, f: item_5}
-      expect(subject.extract_controllers(list)).to eq(result)
-    end
-  end
-
-  describe ".normalize_controllers" do
-    it "returns list of normalized controllers" do
-      item_1 = Releaf::ControllerDefinition.new(name: "aa", controller: :a)
-      item_2 = Releaf::ControllerDefinition.new(name: "bb", controller: :b)
-      item_3 = Releaf::ControllerDefinition.new(name: "cc", controller: :c)
-
-      group_item_1 = Releaf::ControllerGroupDefinition.new(name: "x", items: [])
-      group_item_2 = Releaf::ControllerGroupDefinition.new(name: "y", items: [])
-
-      allow(Releaf::ControllerGroupDefinition).to receive(:new).with(items: "x").and_return(group_item_2)
-      allow(Releaf::ControllerDefinition).to receive(:new).with(name: "y").and_return(item_2)
-      allow(Releaf::ControllerDefinition).to receive(:new).with("z").and_return(item_3)
-
-      list = [
-        item_1,
-        group_item_1,
-        {items: "x"},
-        {name: "y"},
-        "z"
-      ]
-
-      result = [
-        item_1,
-        group_item_1,
-        group_item_2,
-        item_2,
-        item_3
-      ]
-
-      expect(described_class.normalize_controllers(list)).to eq(result)
-    end
-  end
-end