releaf-core 0.2.1 → 1.0.3

data/spec/lib/releaf/build_errors_hash_spec.rb

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

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

data/spec/lib/releaf/controller_definition_spec.rb

@@ -0,0 +1,49 @@
+require "rails_helper"
+
+describe Releaf::ControllerDefinition do
+  subject{ described_class.new(name: "op", controller: "admin/books") }
+
+  describe ".for" do
+    it "returns definition from applicaiton controller config for given controller name" do
+      allow(Releaf.application.config).to receive(:controllers).and_return("xxx" => "yyy")
+      expect(described_class.for("xxx")).to eq("yyy")
+    end
+  end
+
+  describe "#initialize" do
+    it "assigns `name` option value" do
+      expect(subject.name).to eq("op")
+    end
+
+    it "assigns `controller` option value to `controller_name`" do
+      expect(subject.controller_name).to eq("admin/books")
+    end
+
+    context "when no `name` option value given" do
+      it "takes `controller` option value as `name` value" do
+        subject = described_class.new(controller: "admin/books")
+        expect(subject.name).to eq("admin/books")
+      end
+    end
+
+    context "when string passed instead of Hash" do
+      it "takes string as controller option value" do
+        subject = described_class.new("admin/authors")
+        expect(subject.controller_name).to eq("admin/authors")
+      end
+    end
+  end
+
+  describe "#localized_name" do
+    it "returns localized name" do
+      allow(I18n).to receive(:t).with("op", scope: "admin.controllers").and_return("poiugasd")
+      expect(subject.localized_name).to eq("poiugasd")
+    end
+  end
+
+  describe "#path" do
+    it "returns controller index path" do
+      expect(subject.path).to eq("/admin/books")
+    end
+  end
+end

data/spec/lib/releaf/controller_group_definition_spec.rb

@@ -0,0 +1,27 @@
+require "rails_helper"
+
+describe Releaf::ControllerGroupDefinition do
+  subject{ described_class.new(name: "xxx", items: [:a, :b]) }
+
+  before do
+    allow(Releaf::ControllerDefinition).to receive(:new).with(:a).and_return("c_a")
+    allow(Releaf::ControllerDefinition).to receive(:new).with(:b).and_return("c_b")
+  end
+
+  describe "#initialize" do
+    it "assigns `name` option value" do
+      expect(subject.name).to eq("xxx")
+    end
+
+    it "assigns array with initialized `Releaf::ControllerDefinition` items built from `items` option value" do
+      expect(subject.controllers).to eq(["c_a", "c_b"])
+    end
+  end
+
+  describe "#localized_name" do
+    it "returns localized name" do
+      allow(I18n).to receive(:t).with("xxx", scope: "admin.controllers").and_return("poiugasd")
+      expect(subject.localized_name).to eq("poiugasd")
+    end
+  end
+end

data/spec/lib/releaf/{core/default_searchable_fields_spec.rb → default_searchable_fields_spec.rb}

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::DefaultSearchableFields do
+describe Releaf::DefaultSearchableFields do
   # emulate klass::Translations
   with_model :SearchableObjectTranslations, scope: :all do
     table do |t|

data/spec/lib/releaf/instance_cache_spec.rb

@@ -0,0 +1,98 @@
+require "rails_helper"
+
+describe Releaf::InstanceCache, type: :class do
+  class InstanceCacheIncluder
+    include Releaf::InstanceCache
+    cache_instance_methods :some_value, :another_value
+    cache_instance_method :one_more_another_value
+
+    def calculated_value
+      instance_cache(:calculated_value) do
+        some_value
+      end
+    end
+
+    def some_value
+      1 + 2
+    end
+
+    def another_value
+      "xx"
+    end
+
+    def one_more_another_value
+      "yy"
+    end
+  end
+
+  subject{ InstanceCacheIncluder.new }
+
+  it "keeps previously defined `method_added` method" do
+    class InstanceCacheIncluder2
+      cattr_accessor :test_value
+
+      def self.method_added(method_name)
+        self.test_value = method_name if method_name == :some_value
+      end
+      include Releaf::InstanceCache
+      cache_instance_method :some_value
+
+      def some_value
+        :xx
+      end
+    end
+
+    subject = InstanceCacheIncluder2.new
+    expect(InstanceCacheIncluder2.test_value).to eq(:some_value)
+    allow(subject).to receive(:instance_cache_original_some_value).and_return(:yyy).once
+    expect(subject.some_value).to eq(:yyy)
+    subject.some_value
+  end
+
+  describe ".instance_cache_original_method_name" do
+    it "returns name of uncached original method name" do
+      expect(subject.class.instance_cache_original_method_name(:some_method)).to eq("instance_cache_original_some_method")
+    end
+  end
+
+  describe "#instance_cache" do
+    it "stores block value to instance cache store" do
+      expect{ subject.calculated_value }.to change{ subject.instance_cache_store[:calculated_value] }.to(3)
+    end
+
+    it "returns returns value when caching happen" do
+      expect(subject.calculated_value).to eq(3)
+    end
+
+    it "returns cached value when called second time" do
+      subject.calculated_value
+      expect(subject.calculated_value).to eq(3)
+    end
+
+    it "does not evaluate block twice when called second time" do
+      expect(subject).to receive(:some_value).and_call_original.once
+      subject.calculated_value
+      subject.calculated_value
+    end
+  end
+
+  describe "#reset_instance_cache" do
+    it "assigns empty hash to instance hash store" do
+      subject.instance_cache_store[:x] = 1
+      expect{ subject.reset_instance_cache }.to change{ subject.instance_cache_store }.from(x: 1).to({})
+    end
+  end
+
+  describe ".cache_instance_methods" do
+    it "adds cache wrapper for all given methods" do
+      expect(subject.class.cached_instance_methods).to eq([:some_value, :another_value, :one_more_another_value])
+
+      allow(subject).to receive(:instance_cache_original_another_value).and_return("xxx").once
+      expect(subject).to receive(:instance_cache) do|x, &block|
+        expect(block.call).to eq("xxx")
+      end.and_return("yyy")
+
+      expect(subject.another_value).to eq("yyy")
+    end
+  end
+end

data/spec/lib/releaf/{core/resource_base_spec.rb → resource_base_spec.rb}

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::ResourceBase do
+describe Releaf::ResourceBase do
   subject{ described_class.new(Book) }
 
   describe "#initialize" do
@@ -31,9 +31,28 @@ describe Releaf::Core::ResourceBase do
   end
 
   describe "#localized_attributes" do
-    it "returns array of all localized attributes params" do
+    before do
       allow(subject.resource_class).to receive(:translated_attribute_names).and_return([:title, :summary])
-      expect(subject.localized_attributes).to eq(["title", "summary"])
+    end
+
+    it "caches returned result" do
+      expect(subject).to receive(:localized_attributes?).and_return(true).once
+      subject.localized_attributes
+      subject.localized_attributes
+    end
+
+    context "when resource has localized attributes" do
+      it "returns array of all localized attributes params" do
+        allow(subject).to receive(:localized_attributes?).and_return(true)
+        expect(subject.localized_attributes).to eq(["title", "summary"])
+      end
+    end
+
+    context "when resource has no localized attributes" do
+      it "returns empty array" do
+        allow(subject).to receive(:localized_attributes?).and_return(false)
+        expect(subject.localized_attributes).to eq([])
+      end
     end
   end
 
@@ -75,36 +94,29 @@ describe Releaf::Core::ResourceBase do
     before do
       allow(subject).to receive(:associations_attributes).and_return(["x", "y"])
       allow(subject).to receive(:base_attributes).and_return(["a", "b"])
-      allow(subject).to receive(:localized_attributes?).and_return(false)
+      allow(subject).to receive(:localized_attributes).and_return(["c", "d"])
     end
 
-    it "returns resource params array alongside associations params" do
-      expect(subject.values).to eq(["a", "b", "x", "y"])
+    it "returns resource base and localized attributes array alongside associations params" do
+      expect(subject.values).to eq(["a", "b", "c", "d", "x", "y"])
     end
 
-    context "when `include_associations` is false" do
-      it "does not include association params" do
-        expect(subject.values(include_associations: false)).to eq(["a", "b"])
-      end
+    it "excludes all excludable base and localized attributes from returned array" do
+      allow(subject).to receive(:excluded_attributes).and_return(["a", "d", "x"])
+      expect(subject.values).to eq(["b", "c", "x", "y"])
     end
 
-    context "when resource has localized attributes" do
-      it "returns resource base attributes array alongside localized attributes" do
-        allow(subject).to receive(:localized_attributes?).and_return(true)
-        allow(subject).to receive(:localized_attributes).and_return(["c", "d"])
-        expect(subject.values).to eq(["a", "b", "c", "d", "x", "y"])
+    context "when `include_associations` is false" do
+      it "does not include association params" do
+        expect(subject.values(include_associations: false)).to eq(["a", "b", "c", "d"])
       end
     end
   end
 
   describe "#base_attributes" do
-    it "returns array with non-excluded attributes" do
+    it "returns array of resource columns" do
       allow(subject.resource_class).to receive(:column_names).and_return(["a", "b", "c"])
-      allow(subject).to receive(:excluded_attributes).and_return(["a"])
-      expect(subject.base_attributes).to eq(["b", "c"])
-
-      allow(subject).to receive(:excluded_attributes).and_return(["c"])
-      expect(subject.base_attributes).to eq(["a", "b"])
+      expect(subject.base_attributes).to eq(["a", "b", "c"])
     end
   end
 
@@ -171,4 +183,30 @@ describe Releaf::Core::ResourceBase do
       expect(subject.excluded_associations).to eq([:translations])
     end
   end
+
+  describe ".title" do
+    let(:resource){ Releaf::Permissions::User.new(name: "a", surname: "b") }
+    it "tries all `title_methods` methods and returns first existing method result" do
+      allow(described_class).to receive(:title_methods).and_return([:to_s, :id, :releaf_title])
+      allow(resource).to receive(:to_s).and_return("x")
+      allow(resource).to receive(:id).and_return("zz")
+      allow(resource).to receive(:releaf_title).and_return("yy")
+
+      allow(resource).to receive(:respond_to?).with(:to_s).and_return(false)
+      allow(resource).to receive(:respond_to?).with(:id).and_return(false)
+      allow(resource).to receive(:respond_to?).with(:releaf_title).and_return(true)
+      expect(described_class.title(resource)).to eq("yy")
+
+      allow(resource).to receive(:respond_to?).with(:to_s).and_return(false)
+      allow(resource).to receive(:respond_to?).with(:id).and_return(true)
+      expect(resource).to_not receive(:respond_to?).with(:releaf_title)
+      expect(described_class.title(resource)).to eq("zz")
+    end
+  end
+
+  describe ".title_methods" do
+    it "returns array of methods for trying cast resource to text" do
+      expect(described_class.title_methods).to eq([:releaf_title, :name, :title, :to_s])
+    end
+  end
 end

data/spec/lib/releaf/{core/resource_fields_spec.rb → resource_fields_spec.rb}

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::ResourceFields do
+describe Releaf::ResourceFields do
   subject{ described_class.new(Book) }
 
   describe "#excluded_attributes" do