releaf-core 0.2.1 → 1.0.3

data/spec/builders/{builders → releaf/builders}/base_spec.rb

@@ -25,21 +25,30 @@ describe Releaf::Builders::Base, type: :module do
      :render, :link_to, :flash, :truncate, :radio_button_tag,
      :options_for_select, :action_name, :options_from_collection_for_select,
      :select_tag, :text_field_tag,
-     :image_tag, :jquery_date_format, :cookies, :button_tag, :merge_attributes
+     :image_tag, :cookies, :button_tag, :merge_attributes
     ].each do|method_name|
       it "deletages #{method_name} to template" do
         expect(subject).to delegate_method(method_name).to(:template)
       end
     end
 
-    [:layout_settings, :access_control, :controller_scope_name, :feature_available?,
-     :index_url].each do|method_name|
+    [:controller_scope_name, :feature_available?, :builder_class, :index_path].each do|method_name|
       it "delegates #{method_name} to controller" do
         expect(subject).to delegate_method(method_name).to(:controller)
       end
     end
   end
 
+  describe "#layout_settings" do
+    it "returns settings manager setting for given key" do
+      allow(Releaf.application.config.settings_manager).to receive(:read)
+        .with(controller: "_ctrl_", key: "a.x").and_return("xxxxx")
+      allow(subject).to receive(:controller).and_return("_ctrl_")
+
+      expect(subject.layout_settings("a.x")).to eq("xxxxx")
+    end
+  end
+
   describe "#html_escape" do
     it "escapes given value with " do
       allow(ERB::Util).to receive(:html_escape).with("a").and_return("b")
@@ -47,7 +56,6 @@ describe Releaf::Builders::Base, type: :module do
     end
   end
 
-
   it "aliases #button to #releaf_button" do
     allow(subject.template).to receive(:releaf_button).with("x", a: "y", b: "z").and_return("xx")
     expect(subject.button("x", a: "y", b: "z")).to eq("xx")
@@ -246,28 +254,16 @@ describe Releaf::Builders::Base, type: :module do
     end
   end
 
-  describe "#resource_to_text" do
-    let(:resource){ Releaf::Permissions::User.new(name: "a", surname: "b") }
-
-    context "when given resource respond to #to_text method" do
-      it "returns resource #to_text output" do
-        expect(subject.resource_to_text(resource)).to eq("a b")
-      end
-    end
-
-    context "when given resource does not respond to #to_text method" do
-      it "returns resource #to_s output" do
-        allow(resource).to receive(:respond_to?).and_call_original
-        allow(resource).to receive(:respond_to?).with(:to_text).and_return(false)
-        allow(resource).to receive(:to_s).and_return("x")
-        expect(subject.resource_to_text(resource)).to eq("x")
-      end
+  describe "#resource_title" do
+    it "pass given resource to Releaf::ResourceBase.title and return result" do
+      allow(Releaf::ResourceBase).to receive(:title).with("x").and_return("ljhg")
+      expect(subject.resource_title("x")).to eq("ljhg")
     end
   end
 
   describe "#default_translation_scope" do
     it "returns controller scope" do
-      controller = Releaf::BaseController.new
+      controller = Releaf::ActionController.new
       allow(subject).to receive(:controller).and_return(controller)
       allow(controller).to receive(:controller_scope_name).and_return("x")
       expect(subject.default_translation_scope).to eq("x")

data/spec/builders/{builders → releaf/builders}/confirm_destroy_dialog_builder_spec.rb

@@ -25,8 +25,8 @@ describe Releaf::Builders::ConfirmDestroyDialogBuilder, type: :class do
 
   before do
     subject.resource = object
-    allow(subject.template).to receive(:controller).and_return(Releaf::BaseController.new)
-    allow(subject.controller).to receive(:index_url).and_return("y")
+    allow(subject.template).to receive(:controller).and_return(Releaf::ActionController.new)
+    allow(subject.controller).to receive(:index_path).and_return("y")
   end
 
   describe "#question_content" do
@@ -37,8 +37,8 @@ describe Releaf::Builders::ConfirmDestroyDialogBuilder, type: :class do
   end
 
   describe "#description_content" do
-    it "returns `resource_to_text` value" do
-      allow(subject).to receive(:resource_to_text).with(object).and_return("xx")
+    it "returns `resource_title` value" do
+      allow(subject).to receive(:resource_title).with(object).and_return("xx")
       expect(subject.description_content).to eq("xx")
     end
   end
@@ -64,7 +64,7 @@ describe Releaf::Builders::ConfirmDestroyDialogBuilder, type: :class do
 
   describe "#confirm_url" do
     it "returns resource destroy url" do
-      allow(subject.template).to receive(:url_for).with(action: 'destroy', id: 99, index_url: "y").and_return("x")
+      allow(subject.template).to receive(:url_for).with(action: 'destroy', id: 99, index_path: "y").and_return("x")
       expect(subject.confirm_url).to eq("x")
     end
   end

data/spec/builders/{builders → releaf/builders}/confirm_dialog_builder_spec.rb

@@ -33,8 +33,8 @@ describe Releaf::Builders::ConfirmDialogBuilder, type: :class do
 
   before do
     subject.resource = object
-    allow(subject.template).to receive(:controller).and_return(Releaf::BaseController.new)
-    allow(subject.controller).to receive(:index_url).and_return("y")
+    allow(subject.template).to receive(:controller).and_return(Releaf::ActionController.new)
+    allow(subject.controller).to receive(:index_path).and_return("y")
   end
 
   describe "#section_body" do
@@ -88,17 +88,19 @@ describe Releaf::Builders::ConfirmDialogBuilder, type: :class do
     end
   end
 
-  describe "#cancel_url" do
-    it "returns index url" do
-      allow(subject).to receive(:index_url).and_return("x")
-      expect(subject.cancel_url).to eq("x")
+  describe "#cancel_path" do
+    it "returns index path" do
+      allow(subject).to receive(:index_path).and_return("x")
+      expect(subject.cancel_path).to eq("x")
     end
   end
 
   describe "#cancel_button" do
     it "returns cancel button" do
+      allow(subject).to receive(:cancel_path).and_return("xasd")
       allow(subject).to receive(:t).with("No").and_return("Noo")
-      allow(subject).to receive(:button).with("Noo", "ban", class: "secondary", data: {type: "cancel"}, href: "y").and_return("x")
+      allow(subject).to receive(:button).with("Noo", "ban", class: "secondary", data: {type: "cancel"}, href: "xasd")
+        .and_return("x")
       expect(subject.cancel_button).to eq("x")
     end
   end

data/spec/builders/{builders → releaf/builders}/edit_builder_spec.rb

@@ -20,7 +20,7 @@ describe Releaf::Builders::EditBuilder, type: :class do
 
   let(:template){ TranslationsEditBuilderTestHelper.new }
   let(:subject){ described_class.new(template) }
-  let(:controller){ Releaf::BaseController.new }
+  let(:controller){ Releaf::ActionController.new }
   let(:resource){ Book.new }
 
   before do
@@ -33,12 +33,12 @@ describe Releaf::Builders::EditBuilder, type: :class do
     before do
       allow(subject).to receive(:section_attributes).and_return(a: "b")
       allow(subject).to receive(:form_options).and_return(url: "xxx", builder: Releaf::Builders::FormBuilder)
-      allow(subject).to receive(:index_url_preserver).and_return("_index_url_")
+      allow(subject).to receive(:index_path_preserver).and_return("_index_path_")
       allow(subject).to receive(:section_blocks).and_return(["_section_","_blocks_"])
     end
 
     it "returns section with index url preserver and section blocks" do
-      expect(subject.section_content).to eq('<form class="new_book" id="new_book" action="xxx" accept-charset="UTF-8" method="post"><input name="utf8" type="hidden" value="&#x2713;" /><input type="hidden" name="yyy" value="xxx" />_index_url__section__blocks_</form>')
+      expect(subject.section_content).to eq('<form class="new_book" id="new_book" action="xxx" accept-charset="UTF-8" method="post"><input name="utf8" type="hidden" value="&#x2713;" /><input type="hidden" name="yyy" value="xxx" />_index_path__section__blocks_</form>')
     end
 
     it "assigns form instance to builder" do
@@ -47,11 +47,11 @@ describe Releaf::Builders::EditBuilder, type: :class do
     end
   end
 
-  describe "#index_url_preserver" do
+  describe "#index_path_preserver" do
     it "returns hidden index url input" do
-      allow(subject).to receive(:params).and_return(index_url: "?asd=23&lf=dd")
-      result = '<input type="hidden" name="index_url" id="index_url" value="?asd=23&amp;lf=dd" />'
-      expect(subject.index_url_preserver).to eq(result)
+      allow(subject).to receive(:params).and_return(index_path: "?asd=23&lf=dd")
+      result = '<input type="hidden" name="index_path" id="index_path" value="?asd=23&amp;lf=dd" />'
+      expect(subject.index_path_preserver).to eq(result)
     end
   end
 
@@ -78,7 +78,7 @@ describe Releaf::Builders::EditBuilder, type: :class do
           <div class="form-error-box">
               <error_notice_header />
               <ul>
-                <li class="error">Title Blank</li>
+                <li class="error">Title can&#39;t be blank</li>
               </ul>
           </div>
         ])
@@ -126,11 +126,6 @@ describe Releaf::Builders::EditBuilder, type: :class do
   end
 
   describe "#create_another_available?" do
-
-    before do
-      controller.setup
-    end
-
     context "when editing an existing record" do
       let(:resource){ FactoryGirl.create(:book) }
 
@@ -184,6 +179,125 @@ describe Releaf::Builders::EditBuilder, type: :class do
     end
   end
 
+  describe "#form_options" do
+    it "returns form options" do
+      allow(subject).to receive(:form_builder_class).and_return("CustomFormBuilderClassHere")
+      allow(subject).to receive(:form_url).and_return("/some-url-here")
+      allow(subject).to receive(:form_attributes).and_return(some: "options_here")
+      allow(subject).to receive(:resource_name).and_return(:author)
+
+      options = {
+        builder: "CustomFormBuilderClassHere",
+        as: :author,
+        url: "/some-url-here",
+        html: {some: "options_here"}
+      }
+      expect(subject.form_options).to eq(options)
+    end
+  end
+
+  describe "#form_url" do
+    it "returns form url built from form action and resource id" do
+      resource.id = 23
+      allow(subject).to receive(:form_action).and_return("upd")
+      allow(subject).to receive(:url_for).with(action: "upd", id: 23).and_return("/res/new")
+      expect(subject.form_url).to eq("/res/new")
+    end
+  end
+
+  describe "#form_action" do
+    context "when new resource" do
+      it "returns `create`" do
+        allow(resource).to receive(:new_record?).and_return(true)
+        expect(subject.form_action).to eq("create")
+      end
+    end
+
+    context "when persisted resource" do
+      it "returns `update`" do
+        allow(resource).to receive(:new_record?).and_return(false)
+        expect(subject.form_action).to eq("update")
+      end
+    end
+  end
+
+  describe "#resource_name" do
+    it "returns `:resource`" do
+      expect(subject.resource_name).to eq(:resource)
+    end
+  end
+
+  describe "#form_url" do
+    it "returns form builder class" do
+      allow(subject).to receive(:builder_class).with(:form).and_return("x")
+      expect(subject.form_builder_class).to eq("x")
+    end
+  end
+
+  describe "#form_identifier" do
+    before do
+      allow(subject).to receive(:resource_name).and_return(:book)
+    end
+
+    context "when resource has persistance check method and it's persisted" do
+      it "returns resource name prefixed with `edit-`" do
+        allow(resource).to receive(:persisted?).and_return(true)
+        expect(subject.form_identifier).to eq("edit-book")
+      end
+    end
+
+    context "when resource has persistance check method and it's not persisted" do
+      it "returns resource name prefixed with `new-`" do
+        allow(resource).to receive(:persisted?).and_return(false)
+        expect(subject.form_identifier).to eq("new-book")
+      end
+    end
+
+    context "when resource has no persistance check method" do
+      it "returns resource name prefixed with `update-`" do
+        allow(subject).to receive(:resource).and_return(String.new)
+        expect(subject.form_identifier).to eq("edit-book")
+      end
+    end
+  end
+
+  describe "#form_classes" do
+    before do
+      allow(subject).to receive(:form_identifier).and_return("xx")
+    end
+
+    it "returns array with form identifier" do
+      expect(subject.form_classes).to eq(["xx"])
+    end
+
+    context "when object has any errors" do
+      it "adds has-error class to returned array" do
+        resource.title = nil
+        resource.valid?
+        expect(subject.form_classes).to eq(["xx", "has-error"])
+      end
+    end
+  end
+
+  describe "#form_attributes" do
+    it "returns form attributes" do
+      allow(subject).to receive(:form_identifier).and_return("xx")
+      allow(subject).to receive(:form_classes).and_return(["a", "b"])
+
+      attributes = {
+         multipart: true,
+         novalidate: "",
+         class: ["a", "b"],
+         id: "xx",
+         data: {
+           "remote"=>true,
+           "remote-validation"=>true,
+           "type"=>:json
+         }
+      }
+      expect(subject.form_attributes).to eq(attributes)
+    end
+  end
 
   describe "#save_button" do
     it "returns save button" do
@@ -195,13 +309,6 @@ describe Releaf::Builders::EditBuilder, type: :class do
     end
   end
 
-  describe "#form_options" do
-    it "returns controller form options for current action and resource" do
-      allow(controller).to receive(:form_options).with(:edit, resource, :resource).and_return(:y)
-      expect(subject.form_options).to eq(:y)
-    end
-  end
-
   describe "#form_fields" do
     it "returns form `releaf_fields` output for form `field_names` casted to array" do
       form = Releaf::Builders::FormBuilder.new(:book, Book.new, template, {})

data/spec/builders/releaf/builders/form_builder/associations_spec.rb

@@ -0,0 +1,129 @@
+require "rails_helper"
+
+describe Releaf::Builders::FormBuilder::Associations, type: :class do
+  class FormBuilderTestHelper < ActionView::Base
+    include Releaf::ApplicationHelper
+    include Releaf::ButtonHelper
+    include FontAwesome::Rails::IconHelper
+  end
+
+  let(:template){ FormBuilderTestHelper.new }
+  let(:object){ Book.new }
+  let(:subject){ Releaf::Builders::FormBuilder.new(:book, object, template, {}) }
+
+  describe "#reflect_on_association" do
+    it "returns reflection for given reflection name" do
+      expect(subject.reflect_on_association(:author)).to eq(object.class.reflections["author"])
+      expect(subject.reflect_on_association("author")).to eq(object.class.reflections["author"])
+    end
+  end
+
+  describe "#association_reflector" do
+    before do
+      resource_fields = subject.resource_fields
+      allow(resource_fields).to receive(:association_attributes).with(:x).and_return([:c, :d])
+
+      allow(subject).to receive(:resource_fields).and_return(resource_fields)
+      allow(subject).to receive(:sortable_column_name).and_return("sortable column name")
+    end
+
+    it "returns association reflector for given reflection" do
+      expect(subject.association_reflector(:x, [:a, :b])).to be_instance_of Releaf::Builders::AssociationReflector
+    end
+
+    it "pass reflection, fields and sortable column name to association reflector constructor" do
+      expect(Releaf::Builders::AssociationReflector).to receive(:new)
+        .with(:x, [:a, :b], "sortable column name")
+      subject.association_reflector(:x, [:a, :b])
+    end
+
+    context "when given fields is nil" do
+      it "uses resource fields returned association fields instead" do
+        expect(Releaf::Builders::AssociationReflector).to receive(:new)
+          .with(:x, [:c, :d], "sortable column name")
+        subject.association_reflector(:x, nil)
+      end
+    end
+  end
+
+  describe "#releaf_association_fields" do
+    let(:reflector){ Releaf::Builders::AssociationReflector.new(:a, :b, :c) }
+    let(:fields){ ["a"] }
+
+    before do
+      allow(subject).to receive(:association_reflector).with(:author, fields).and_return(reflector)
+      allow(subject).to receive(:releaf_has_many_association).with(reflector).and_return("_has_many_content_")
+      allow(subject).to receive(:releaf_belongs_to_association).with(reflector).and_return("_belongs_to_content_")
+      allow(subject).to receive(:releaf_has_one_association).with(reflector).and_return("_has_one_content_")
+    end
+
+    context "when reflector macro is :has_many" do
+      it "renders association with #releaf_has_many_association" do
+        allow(reflector).to receive(:macro).and_return(:has_many)
+        expect(subject.releaf_association_fields(:author, fields)).to eq("_has_many_content_")
+      end
+    end
+
+    context "when :belongs_to association given" do
+      it "renders association with #releaf_belongs_to_association" do
+        allow(reflector).to receive(:macro).and_return(:belongs_to)
+        expect(subject.releaf_association_fields(:author, fields)).to eq("_belongs_to_content_")
+      end
+    end
+
+    context "when :has_one association given" do
+      it "renders association with #releaf_has_one_association" do
+        allow(reflector).to receive(:macro).and_return(:has_one)
+        expect(subject.releaf_association_fields(:author, fields)).to eq("_has_one_content_")
+      end
+    end
+
+    context "when non implemented assocation type given" do
+      it "raises error" do
+        allow(reflector).to receive(:macro).and_return(:new_macro_type)
+        expect{ subject.releaf_association_fields(:author, fields) }.to raise_error("not implemented")
+      end
+    end
+  end
+
+  describe "#releaf_item_field_choices" do
+    before do
+      collection = [Author.new(name: "a", surname: "b", id: 1), Author.new(name: "c", surname: "d", id: 2)]
+      allow(subject).to receive(:releaf_item_field_collection)
+        .with(:author_id, x: "a").and_return(collection)
+    end
+
+    context "when no select_options passed within options" do
+      it "returns corresponding collection array" do
+        expect(subject.releaf_item_field_choices(:author_id, x: "a")).to eq([["a b", 1], ["c d", 2]])
+      end
+    end
+
+    context "when options have select_options passed" do
+      it "returns `select_options` value" do
+        expect(subject.releaf_item_field_choices(:author_id, select_options: "xx")).to eq("xx")
+      end
+    end
+  end
+
+  describe "#releaf_item_field_collection" do
+    context "when collection exists within options" do
+      it "returns collection" do
+        expect(subject.releaf_item_field_collection(:author_id, collection: "x")).to eq("x")
+      end
+    end
+
+    context "when collection does not exist within options" do
+      it "returns all relation objects" do
+        allow(Author).to receive(:all).and_return("y")
+        expect(subject.releaf_item_field_collection(:author_id)).to eq("y")
+      end
+    end
+  end
+
+  describe "#relation_name" do
+    it "strips _id from given string and returns it as symbol" do
+      expect(subject.relation_name("admin_id")).to eq(:admin)
+    end
+  end
+end

data/spec/builders/releaf/builders/form_builder/date_fields_spec.rb

@@ -0,0 +1,86 @@
+require "rails_helper"
+
+describe Releaf::Builders::FormBuilder::DateFields, type: :class do
+  class FormBuilderTestHelper < ActionView::Base
+    include Releaf::ApplicationHelper
+    include Releaf::ButtonHelper
+    include FontAwesome::Rails::IconHelper
+  end
+
+  let(:template){ FormBuilderTestHelper.new }
+  let(:object){ Book.new }
+  let(:subject){ Releaf::Builders::FormBuilder.new(:book, object, template, {}) }
+
+  describe "#date_or_time_field" do
+    it "returns releaf text field with resolved date or time input attributes" do
+      allow(subject).to receive(:date_or_time_field_input_attributes)
+        .with(:published_at, :datetime, a: 1).and_return(aa: 11)
+      allow(subject).to receive(:releaf_text_field)
+        .with(:published_at, input: {aa: 11}, label: {b: 1}, field: {c: 3}, options: {field: {type: "datetime"}, d: 4})
+        .and_return("_fld")
+
+      expect(subject.date_or_time_field(:published_at, :datetime, input: {a: 1}, label: {b: 1},
+                                        field: {c: 3}, options: {d: 4}))
+        .to eq("_fld")
+    end
+  end
+
+  describe "#date_or_time_field_input_attributes" do
+    before do
+      allow(object).to receive(:published_at).and_return("_val")
+      allow(Releaf::Builders::Utilities::DateFields).to receive(:format_date_or_time_value)
+        .with("_val", :datetime).and_return("_frmt_val")
+      allow(Releaf::Builders::Utilities::DateFields).to receive(:date_format_for_jquery).and_return("_date_frm")
+      allow(Releaf::Builders::Utilities::DateFields).to receive(:time_format_for_jquery).and_return("_time_frm")
+    end
+
+    it "returns date or time field input attributes" do
+      expect(subject.date_or_time_field_input_attributes(:published_at, :datetime, {})).to eq(
+        class: "text datetime-picker",
+        value: "_frmt_val",
+        data: {"date-format"=>"_date_frm", "time-format"=>"_time_frm"}
+      )
+    end
+
+    it "deep merges given attributes over resolved" do
+      expect(subject.date_or_time_field_input_attributes(:published_at, :datetime, data: {"date-format" => "LK"})).to eq(
+        class: "text datetime-picker",
+        value: "_frmt_val",
+        data: {"date-format"=>"LK", "time-format"=>"_time_frm"}
+      )
+    end
+  end
+
+  describe "#releaf_datetime_field" do
+    it "returns releaf date or time field with `datetime` option" do
+      expect(subject).to receive(:date_or_time_field)
+        .with("year", :datetime, input: {a: "b"}, label: {c: "d"}, field: {e: "f"}, options: {g: "h"})
+        .and_return("x")
+
+      expect(subject.releaf_datetime_field("year", input: {a: "b"}, label: {c: "d"}, field: {e: "f"}, options: {g: "h"}))
+        .to eq("x")
+    end
+  end
+
+  describe "#releaf_time_field" do
+    it "returns releaf date or time field with `time` option" do
+      expect(subject).to receive(:date_or_time_field)
+        .with("year", :time, input: {a: "b"}, label: {c: "d"}, field: {e: "f"}, options: {g: "h"})
+        .and_return("x")
+
+      expect(subject.releaf_time_field("year", input: {a: "b"}, label: {c: "d"}, field: {e: "f"}, options: {g: "h"}))
+        .to eq("x")
+    end
+  end
+
+  describe "#releaf_date_field" do
+    it "returns releaf date or time field with `date` option" do
+      expect(subject).to receive(:date_or_time_field)
+        .with("year", :date, input: {a: "b"}, label: {c: "d"}, field: {e: "f"}, options: {g: "h"})
+        .and_return("x")
+
+      expect(subject.releaf_date_field("year", input: {a: "b"}, label: {c: "d"}, field: {e: "f"}, options: {g: "h"}))
+        .to eq("x")
+    end
+  end
+end

data/spec/builders/releaf/builders/form_builder/i18n_fields_spec.rb

@@ -0,0 +1,48 @@
+require "rails_helper"
+
+describe Releaf::Builders::FormBuilder::I18nFields, type: :class do
+  class FormBuilderTestHelper < ActionView::Base
+    include Releaf::ApplicationHelper
+    include Releaf::ButtonHelper
+    include FontAwesome::Rails::IconHelper
+  end
+
+  let(:template){ FormBuilderTestHelper.new }
+  let(:object){ Book.new }
+  let(:subject){ Releaf::Builders::FormBuilder.new(:book, object, template, {}) }
+
+  describe "#locales" do
+    it "returns object globalize locales" do
+      allow(subject.object.class).to receive(:globalize_locales).and_return([:de, :ru])
+      expect(subject.locales).to eq([:de, :ru])
+    end
+  end
+
+  describe "#default_locale" do
+    before do
+      allow(subject).to receive(:layout_settings).with("releaf.i18n.locale").and_return("de")
+      allow(I18n).to receive(:locale).and_return(:ru)
+      allow(subject).to receive(:locales).and_return([:de, :ru])
+    end
+
+    context "when layout settings has stored locale" do
+      it "returns stored locale normalized to symbol" do
+        expect(subject.default_locale).to eq(:de)
+      end
+    end
+
+    context "when layout settings hasn't stored locale" do
+      it "returns current I18n locale" do
+        allow(subject).to receive(:layout_settings).with("releaf.i18n.locale").and_return(nil)
+        expect(subject.default_locale).to eq(:ru)
+      end
+    end
+
+    context "when stored locale or I18n locale is not within form locales" do
+      it "returns first form locale" do
+        allow(subject).to receive(:locales).and_return([:lv, :en])
+        expect(subject.default_locale).to eq(:lv)
+      end
+    end
+  end
+end