releaf-core 0.2.1

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

@@ -0,0 +1,142 @@
+require "rails_helper"
+
+describe Releaf::Core::ItemOrderer do
+  let(:list){ ["a", "b", "c", "d", {items: "xx"}, "e", "f", "g"] }
+  subject{ described_class.new(*list) }
+
+  describe "#initialize" do
+    it "assigns given arguments to list accessor" do
+      subject = described_class.new(:a, :b, :c)
+      expect(subject.list).to eq([:a, :b, :c])
+    end
+  end
+
+  describe "#result" do
+    it "returns list" do
+      expect(subject.result).to eq(list)
+      subject.reorder(:a, :last)
+      expect(subject.result).to eq(["b", "c", "d", {items: "xx"}, "e", "f", "g", "a"])
+    end
+  end
+
+  describe "#to_a" do
+    it "returns result" do
+      allow(subject).to receive(:result).and_return(:x)
+      expect(subject.to_a).to eq(:x)
+    end
+  end
+
+  describe "#reorder" do
+    it "returns instance of itself" do
+      expect(subject.reorder(:a, :last)).to eq(subject)
+    end
+
+    it "deletes given values and insert deleted values in reversed order at reorder index" do
+      deleted_values = {a: "x", b: "y"}
+
+      expect(subject).to receive(:delete).with([:a, :b]).ordered.and_return(deleted_values)
+      expect(subject).to receive(:reorder_index).with(:last).ordered.and_return(1)
+
+      expect{ subject.reorder([:a, :b], :last) }.to change{ subject.list }
+        .to(["a", "x", "y", "b", "c", "d", {items: "xx"}, "e", "f", "g"])
+    end
+
+    context "when given value is array" do
+      it "process unmodified given value" do
+        expect(subject).to receive(:delete).with([:a]).and_call_original
+        subject.reorder([:a], :last)
+      end
+    end
+
+    context "when given value is not array" do
+      it "puts value within array" do
+        expect(subject).to receive(:delete).with([:a]).and_call_original
+        subject.reorder(:a, :last)
+      end
+    end
+  end
+
+  describe "#reorder_index" do
+    context "when given options is :first" do
+      it "returns 0" do
+        expect(subject.reorder_index(:first)).to eq(0)
+      end
+    end
+
+    context "when given options is :last" do
+      it "returns size of current list array" do
+        expect(subject.reorder_index(:last)).to eq(8)
+        subject.list = [:a, :b]
+        expect(subject.reorder_index(:last)).to eq(2)
+      end
+    end
+
+    context "when given options is :before" do
+      it "returns index of given `before` value" do
+        allow(subject).to receive(:index).with(:items).and_return(4)
+        expect(subject.reorder_index(before: :items)).to eq(4)
+      end
+    end
+
+    context "when given options is :after" do
+      it "returns index of given `after` value increased by 1" do
+        allow(subject).to receive(:index).with(:items).and_return(4)
+        expect(subject.reorder_index(after: :items)).to eq(5)
+      end
+    end
+
+    context "when unknown option given" do
+      it "raises ArgumentError" do
+        expect{ subject.reorder_index(asdasd: :items) }.to raise_error(ArgumentError, "unknown reorder option")
+      end
+    end
+  end
+
+  describe "#index" do
+    it "returns value index by comparing list and given values casted to strings" do
+      expect(subject.index(:c)).to eq(2)
+      expect(subject.index("c")).to eq(2)
+      subject.list = ["a", :b, :c]
+      expect(subject.index("c")).to eq(2)
+    end
+
+    context "when list value is Hash" do
+      it "compares by hash first key casted to string" do
+        expect(subject.index(:items)).to eq(4)
+        expect(subject.index("items")).to eq(4)
+
+        subject.list = ["a", {"items" => "x"}]
+        expect(subject.index(:items)).to eq(1)
+        expect(subject.index("items")).to eq(1)
+      end
+    end
+  end
+
+  describe "#delete" do
+    before do
+      subject.list = [:a, :b, :c, :d, {items: "x"}]
+    end
+
+    it "deletes given values from list" do
+      expect{ subject.delete(["a", "b", "items"]) }.to change{ subject.list }.to([:c, :d])
+    end
+
+    it "returns hash with mapped deleted values" do
+      expect(subject.delete(["a", "b", "items"])).to eq("a" => :a, "b" => :b, "items" => {items: "x"})
+    end
+  end
+
+  describe ".reorder" do
+    it "returns reordered array by given options" do
+      result = described_class.reorder(list,
+                      [:a, :b] => {after: :c},
+                      d: {before: :c},
+                      g: :first,
+                      [:e, :f] => {before: :g},
+                      c:  {after: :items},
+                      items: :first
+                     )
+      expect(result).to eq([{:items=>"xx"}, "e", "f", "g", "d", "a", "b", "c"])
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+require "rails_helper"
+
+describe Releaf::Core::ResourceBase do
+  subject{ described_class.new(Book) }
+
+  describe "#initialize" do
+    it "assigns given class to resource class accessor" do
+      expect(subject.resource_class).to eq(Book)
+    end
+  end
+
+  describe "#excluded_attributes" do
+    it "returns array with id, created_at and updated_as" do
+      expect(subject.excluded_attributes).to eq(["id", "created_at", "updated_at"])
+    end
+  end
+
+  describe "#localized_attributes?" do
+    context "when resource class has globalize support" do
+      it "returns true" do
+        expect(subject.localized_attributes?).to be true
+      end
+    end
+
+    context "when resource class does not have globalize support" do
+      it "returns false" do
+        allow(subject.resource_class).to receive(:translates?).and_return(false)
+        expect(subject.localized_attributes?).to be false
+      end
+    end
+  end
+
+  describe "#localized_attributes" do
+    it "returns array of all localized attributes params" do
+      allow(subject.resource_class).to receive(:translated_attribute_names).and_return([:title, :summary])
+      expect(subject.localized_attributes).to eq(["title", "summary"])
+    end
+  end
+
+  describe "#associations_attributes" do
+    it "returns array with associations attributes within hashes" do
+      association_1 = subject.resource_class.reflections["chapters"]
+      association_2 = subject.resource_class.reflections["sequels"]
+
+      allow(subject).to receive(:associations).and_return([association_1, association_2])
+      allow(subject).to receive(:association_attributes).with(association_1).and_return(["a", "b"])
+      allow(subject).to receive(:association_attributes).with(association_2).and_return(["c", "d"])
+
+      expect(subject.associations_attributes).to eq([{chapters: ["a", "b"]}, {sequels: ["c", "d"]}])
+    end
+  end
+
+  describe "#association_attributes" do
+    it "returns association params without association excluded attributes" do
+      association = subject.resource_class.reflections["chapters"]
+      allow(described_class).to receive(:new).with(association.klass).and_call_original
+      allow_any_instance_of(described_class).to receive(:values).and_return(["a", "b", "c"])
+      allow(subject).to receive(:association_excluded_attributes).and_return(["b"])
+      expect(subject.association_attributes(association)).to eq(["a", "c"])
+    end
+  end
+
+  describe "#association_excluded_attributes" do
+    it "returns `foreign_key` and polymorphic association type key (if exists) casted to strings" do
+      association = subject.resource_class.reflections["chapters"]
+      allow(association).to receive(:foreign_key).and_return(:b)
+      expect(subject.association_excluded_attributes(association)).to eq(["b"])
+
+      allow(association).to receive(:type).and_return("x")
+      expect(subject.association_excluded_attributes(association)).to eq(["b", "x"])
+    end
+  end
+
+  describe "#values" 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)
+    end
+
+    it "returns resource params array alongside associations params" do
+      expect(subject.values).to eq(["a", "b", "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
+    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"])
+      end
+    end
+  end
+
+  describe "#base_attributes" do
+    it "returns array with non-excluded attributes" 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"])
+    end
+  end
+
+  describe "#associations" do
+    it "returns array with includable associations" do
+      reflections = subject.resource_class.reflections
+      allow(subject).to receive(:includable_association?).with(reflections["releaf_richtext_attachments"]).and_return(false)
+      allow(subject).to receive(:includable_association?).with(reflections["chapters"]).and_return(true)
+      allow(subject).to receive(:includable_association?).with(reflections["book_sequels"]).and_return(false)
+      allow(subject).to receive(:includable_association?).with(reflections["sequels"]).and_return(true)
+      allow(subject).to receive(:includable_association?).with(reflections["author"]).and_return(false)
+      allow(subject).to receive(:includable_association?).with(reflections["translations"]).and_return(false)
+
+      expect(subject.associations).to eq([reflections["chapters"], reflections["sequels"]])
+    end
+  end
+
+  describe "#includable_association?" do
+    let(:association){ subject.resource_class.reflections["chapters"] }
+
+    context "when given association type is includable, association is not excluded, not `ThroughReflection` and has nested_attributes for it" do
+      it "returns true" do
+        expect(subject.includable_association?(association)).to be true
+      end
+    end
+
+    context "when given association is not :has_many" do
+      it "returns false" do
+        allow(subject).to receive(:includable_association_types).and_return([:a, :b])
+        expect(subject.includable_association?(association)).to be false
+      end
+    end
+
+    context "when given association is `ThroughReflection`" do
+      it "returns false" do
+        allow(association).to receive(:class).and_return(ActiveRecord::Reflection::ThroughReflection)
+        expect(subject.includable_association?(association)).to be false
+      end
+    end
+
+    context "when given association has no nested_attributes for it" do
+      it "returns false" do
+        allow(subject.resource_class).to receive(:nested_attributes_options).and_return({})
+        expect(subject.includable_association?(association)).to be false
+      end
+    end
+
+    context "when given association is within excluded associations" do
+      it "returns false" do
+        allow(subject).to receive(:excluded_associations).and_return([:chapters])
+        expect(subject.includable_association?(association)).to be false
+      end
+    end
+  end
+
+  describe "#includable_association_types" do
+    it "returns array with `:has_many` and `:has_one` as includable association types" do
+      expect(subject.includable_association_types).to eq([:has_many, :has_one])
+    end
+  end
+
+  describe "#excluded_associations" do
+    it "returns array with `translations`" do
+      expect(subject.excluded_associations).to eq([:translations])
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require "rails_helper"
+
+describe Releaf::Core::ResourceFields do
+  subject{ described_class.new(Book) }
+
+  describe "#excluded_attributes" do
+    it "returns array with excluded attributes" do
+      expect(subject.excluded_attributes)
+        .to eq(%w(id created_at updated_at password password_confirmation encrypted_password))
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+require "rails_helper"
+
+describe Releaf::Core::ResourceParams do
+  subject{ described_class.new(Book) }
+
+  describe "#file_attributes" do
+    it "returns list with file attributes" do
+      expect(subject.file_attributes).to eq(["cover_image_uid"])
+
+      subject.resource_class = Node
+      expect(subject.file_attributes).to eq([])
+    end
+  end
+
+  describe "#file_attribute?" do
+    context "when given attribute exists within file attributes" do
+      it "returns true" do
+        allow(subject).to receive(:file_attributes).and_return(["color"])
+        expect(subject.file_attribute?("color")).to be true
+      end
+    end
+
+    context "when given attribute does not exist within file attributes" do
+      it "returns false" do
+        allow(subject).to receive(:file_attributes).and_return(["size"])
+        expect(subject.file_attribute?("color")).to be false
+      end
+    end
+  end
+
+  describe "#file_attribute_params" do
+    it "returns array with dragonfly specific attributes" do
+      expect(subject.file_attribute_params("cover_image_uid"))
+        .to eq(["cover_image", "retained_cover_image", "remove_cover_image"])
+    end
+  end
+
+  describe "#localized_attributes" do
+    it "returns array of all localized attributes params" do
+      allow(subject.resource_class).to receive(:translated_attribute_names).and_return(["title", "summary"])
+      allow(subject).to receive(:localized_attribute_params).with("title").and_return(["t1", "t2"])
+      allow(subject).to receive(:localized_attribute_params).with("summary").and_return(["s1", "s2"])
+      expect(subject.localized_attributes).to eq(["t1", "t2", "s1", "s2"])
+
+      allow(subject.resource_class).to receive(:translated_attribute_names).and_return([])
+      expect(subject.localized_attributes).to eq([])
+    end
+  end
+
+  describe "#localized_attribute_params" do
+    it "returns array with localized attribute within all specified locales" do
+      expect(subject.localized_attribute_params(:description)).to eq(["description_en", "description_lv"])
+
+      allow(subject.resource_class).to receive(:globalize_locales).and_return(["de"])
+      expect(subject.localized_attribute_params(:description)).to eq(["description_de"])
+    end
+  end
+
+  describe "#base_attributes" do
+    it "returns array with non-excluded and file attributes" do
+      allow(subject.resource_class).to receive(:column_names).and_return(["a", "b", "c"])
+      allow(subject).to receive(:file_attribute?).and_return(false)
+      expect(subject.base_attributes).to eq(["a", "b", "c"])
+
+      allow(subject).to receive(:file_attribute?).with("b").and_return(true)
+      allow(subject).to receive(:file_attribute_params).with("b").and_return(["b1", "b2"])
+      expect(subject.base_attributes).to eq(["a", "b1", "b2", "c"])
+
+      allow(subject).to receive(:excluded_attributes).and_return(["a"])
+      expect(subject.base_attributes).to eq(["b1", "b2", "c"])
+    end
+  end
+
+  describe "#values" do
+    before do
+      allow(subject).to receive(:associations_attributes).and_return(["x", "y"])
+    end
+
+    it "returns resource params array alongside associations params" do
+      allow(subject).to receive(:base_attributes).and_return(["a", "b"])
+      allow(subject).to receive(:localized_attributes?).and_return(false)
+      expect(subject.values).to eq(["a", "b", "x", "y"])
+    end
+
+    context "when resource has localized attributes" do
+      it "returns resource params array alongside localized attributes" do
+        allow(subject).to receive(:base_attributes).and_return(["a", "b"])
+        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"])
+      end
+    end
+  end
+
+  describe "#associations_attributes" do
+    it "returns array with associations params within hashes" do
+      association_1 = subject.resource_class.reflections["chapters"]
+      association_2 = subject.resource_class.reflections["sequels"]
+
+      allow(subject).to receive(:associations).and_return([association_1, association_2])
+      allow(subject).to receive(:association_attributes).with(association_1).and_return(["a", "b"])
+      allow(subject).to receive(:association_attributes).with(association_2).and_return(["c", "d"])
+
+      expect(subject.associations_attributes).to eq([{"chapters_attributes"=>["a", "b"]}, {"sequels_attributes"=>["c", "d"]}])
+    end
+  end
+
+  describe "#association_attributes" do
+    it "returns association params with `id` and `_destroy` params and without `foreign_key` param" do
+      association = subject.resource_class.reflections["chapters"]
+      allow(association).to receive(:foreign_key).and_return("b")
+      allow(described_class).to receive(:new).with(association.klass).and_call_original
+      allow_any_instance_of(described_class).to receive(:values).and_return(["a", "b", "c"])
+      expect(subject.association_attributes(association)).to eq(["a", "c", "id", "_destroy"])
+    end
+  end
+end