releaf-core 0.2.1 → 1.0.3

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

@@ -0,0 +1,125 @@
+require "rails_helper"
+
+describe Releaf::Builders::Utilities::DateFields do
+  describe ".jquery_date_format" do
+    it "returns Ruby date formaters converted to jQuery date formaters" do
+      expect(described_class.jquery_date_format("% %3N %L %M %-d")).to eq("% l l mm d")
+
+      allow(described_class).to receive(:ruby_date_format_regexp).and_return(Regexp.new("%3N"))
+      expect(described_class.jquery_date_format("% %3N %L %M %-d")).to eq("% l %L %M %-d")
+    end
+  end
+
+  describe ".ruby_date_format_regexp" do
+    it "returns Regexp for matching Ruby date formaters" do
+      expect(described_class.ruby_date_format_regexp).to be_instance_of Regexp
+    end
+
+    it "caches compiled regexp" do
+      described_class.class_variable_set(:@@jquery_date_replacement_regexp, nil)
+      expect(Regexp).to receive(:new).and_call_original.once
+      described_class.ruby_date_format_regexp
+      described_class.ruby_date_format_regexp
+    end
+  end
+
+  describe ".format_date_or_time_value" do
+    context "when given value type is :time" do
+      it "format normalized value to default format with `strftime`" do
+        value = Date.parse("15 Jan 2015")
+        time = Time.parse("15 Jan 2015 12:10:04")
+        allow(described_class).to receive(:date_or_time_default_format).with(:time).and_return("%H:%M")
+        allow(described_class).to receive(:normalize_date_or_time_value).with(value, :time).and_return(time)
+
+        expect(described_class.format_date_or_time_value(value, :time)).to eq("12:10")
+      end
+    end
+
+    context "when empty value given" do
+      it "returns given value" do
+        expect(described_class.format_date_or_time_value(nil, :time)).to eq(nil)
+      end
+    end
+
+    context "when given value type is other than :time" do
+      it "format normalized value to default format  with `I18n.l`" do
+        value = Date.parse("15 Jan 2015")
+        time = Time.parse("15 Jan 2015 12:10:04")
+
+        allow(described_class).to receive(:date_or_time_default_format).with(:date).and_return("_format_")
+        allow(described_class).to receive(:normalize_date_or_time_value).with(value, :date).and_return(time)
+        allow(I18n).to receive(:l).with(time, default: "_format_").and_return("x")
+        expect(described_class.format_date_or_time_value(value, :date)).to eq("x")
+
+
+        allow(described_class).to receive(:date_or_time_default_format).with(:datetime).and_return("_format_")
+        allow(described_class).to receive(:normalize_date_or_time_value).with(value, :datetime).and_return(time)
+        allow(I18n).to receive(:l).with(time, default: "_format_").and_return("y")
+        expect(described_class.format_date_or_time_value(value, :datetime)).to eq("y")
+      end
+    end
+  end
+
+  describe ".time_format_for_jquery" do
+    it "returns jquery time format" do
+      allow(described_class).to receive(:date_or_time_default_format).with(:time).and_return("xx")
+      allow(described_class).to receive(:jquery_date_format).with("xx").and_return("x")
+      expect(described_class.time_format_for_jquery).to eq("x")
+    end
+  end
+
+  describe ".date_format_for_jquery" do
+    it "returns jquery time format" do
+      allow(described_class).to receive(:date_or_time_default_format).with(:date).and_return("yy")
+      allow(I18n).to receive(:t).with("default", scope: "date.formats", default: "yy").and_return("a")
+      allow(described_class).to receive(:jquery_date_format).with("a").and_return("l")
+      expect(described_class.date_format_for_jquery).to eq("l")
+    end
+  end
+
+  describe ".normalize_date_or_time_value" do
+    context "when :time type given" do
+      it "casts value to time" do
+        value = Date.parse("15 Jan 2015")
+        expect(described_class.normalize_date_or_time_value(value, :time)).to be_instance_of Time
+        expect(described_class.normalize_date_or_time_value(value, :time)).to eq(value.to_time)
+      end
+    end
+
+    context "when :datetime type given" do
+      it "casts value to datetime" do
+        value = Time.parse("15 Jan 2015 12:10:04")
+        expect(described_class.normalize_date_or_time_value(value, :datetime)).to be_instance_of DateTime
+        expect(described_class.normalize_date_or_time_value(value, :datetime)).to eq(value.to_datetime)
+      end
+    end
+
+    context "when :time type given" do
+      it "casts value to date" do
+        value = DateTime.parse("15 Jan 2015 12:10:04")
+        expect(described_class.normalize_date_or_time_value(value, :date)).to be_instance_of Date
+        expect(described_class.normalize_date_or_time_value(value, :date)).to eq(value.to_date)
+      end
+    end
+  end
+
+  describe "#date_or_time_default_format" do
+    context "when date format requested requested" do
+      it "returns `%Y-%m-%d`" do
+        expect(described_class.date_or_time_default_format(:date)).to eq("%Y-%m-%d")
+      end
+    end
+
+    context "when datetime format requested requested" do
+      it "returns `%Y-%m-%d %H:%M`" do
+        expect(described_class.date_or_time_default_format(:datetime)).to eq("%Y-%m-%d %H:%M")
+      end
+    end
+
+    context "when time format requested requested" do
+      it "returns `%H:%M`" do
+        expect(described_class.date_or_time_default_format(:time)).to eq("%H:%M")
+      end
+    end
+  end
+end

data/spec/builders/releaf/builders/utilities/resolve_attribute_field_method_name_spec.rb

@@ -0,0 +1,318 @@
+require "rails_helper"
+
+describe Releaf::Builders::Utilities::ResolveAttributeFieldMethodName do
+  let(:object){ Book.new }
+  subject{ described_class.new(object: object, attribute_name: "title") }
+
+  describe "#call" do
+    before do
+      allow(subject).to receive(:field_type).and_return("color_picker")
+    end
+
+    it "returns resolved field name method" do
+      expect(subject.call).to eq("releaf_color_picker_field")
+    end
+
+
+    context "when localized attribute" do
+      it "adds i18n part to returned field name method" do
+        allow(subject).to receive(:localized_attribute?).and_return(true)
+        expect(subject.call).to eq("releaf_color_picker_i18n_field")
+      end
+    end
+  end
+
+  describe "#field_type" do
+    before do
+      allow(subject).to receive(:column_type).and_return("doubleinteger")
+    end
+
+    it "returns first positive resolver name" do
+      allow(subject).to receive(:column_field_type_resolvers).and_return([:text, :item, :richtext])
+      expect(subject).to receive(:text?).and_return(false)
+      expect(subject).to receive(:item?).and_return(true)
+      expect(subject).to_not receive(:richtext?)
+
+      expect(subject.field_type).to eq(:item)
+    end
+
+    context "when no resolvers exists" do
+      it "returns column type" do
+        allow(subject).to receive(:column_field_type_resolvers).and_return([])
+        expect(subject.field_type).to eq("doubleinteger")
+      end
+    end
+  end
+
+  describe "#column_type" do
+    let(:column){ Book.columns_hash["id"] }
+
+    before do
+      subject.attribute_name = "birth_date"
+      allow(subject).to receive(:columns_class).and_return(Author)
+      allow(column).to receive(:type).and_return("doubleinteger")
+    end
+
+    it "returns column type from columns class" do
+      allow(Author.columns_hash).to receive(:[]).with("birth_date").and_return(column)
+      expect(subject.column_type).to eq("doubleinteger")
+    end
+
+    context "when attribute does not exists within columns hash" do
+      it "returns `string` as default type" do
+        allow(Author.columns_hash).to receive(:[]).with("birth_date").and_return(nil)
+        expect(subject.column_type).to eq(:string)
+      end
+    end
+
+    it "caches resolved column type" do
+      expect(Author.columns_hash).to receive(:[]).with("birth_date").and_return(column).twice
+      subject.column_type
+      subject.column_type
+      subject.column_type
+    end
+  end
+
+  describe "#columns_class" do
+    context "when non localized attribute" do
+      it "returns object class" do
+        allow(subject).to receive(:localized_attribute?).and_return(false)
+        expect(subject.columns_class).to eq(Book)
+      end
+    end
+
+    context "when localized attribute" do
+      it "returns object translations class" do
+        allow(subject).to receive(:localized_attribute?).and_return(true)
+        expect(subject.columns_class).to eq(Book::Translation)
+      end
+    end
+  end
+
+  describe "#column_field_type_resolvers" do
+    it "returns column type resolvers" do
+      allow(subject).to receive(:column_type).and_return(:text)
+      expect(subject.column_field_type_resolvers).to eq([:link, :richtext, :textarea])
+
+      allow(subject).to receive(:column_type).and_return(:float)
+      expect(subject.column_field_type_resolvers).to eq([])
+    end
+  end
+
+  describe "#localized_attribute?" do
+    context "when object translates" do
+      context "when given attribute translatable" do
+        it "returns true" do
+          subject.attribute_name = :description
+          expect(subject.localized_attribute?).to be true
+        end
+      end
+
+      context "when attribute does not translatable" do
+        it "returns false" do
+          subject.attribute_name = :title
+          expect(subject.localized_attribute?).to be false
+        end
+      end
+    end
+
+    context "when object does not translates" do
+      it "returns false" do
+        subject.object = Releaf::Permissions::User.new
+        subject.attribute_name = :password
+        expect(subject.localized_attribute?).to be false
+      end
+    end
+  end
+
+  describe "#file?" do
+    context "when attribute name ends with `_uid` and object respond to matching file method" do
+      it "returns true" do
+        subject.attribute_name = "cover_image_uid"
+        expect(subject.file?).to be true
+      end
+    end
+
+    context "when attribute name hasn't *_uid and object respond to matching file method" do
+      it "returns false" do
+        subject.attribute_name = "genre"
+        expect(subject.file?).to be false
+      end
+    end
+
+    context "when attribute name ends with `_uid` and object does not respond to matching file method" do
+      it "returns false" do
+        subject.attribute_name = "cover_asdasdd_uid"
+        expect(subject.file?).to be false
+      end
+    end
+  end
+
+  describe "#image?" do
+    context "when attribute name matches image regexp and attribute is file" do
+      it "returns true" do
+        allow(subject).to receive(:file?).and_return(true)
+        %w(thumbnail image photo picture avatar logo banner icon).each do|prefix|
+          subject.attribute_name = "#{prefix}_uid"
+          expect(subject.image?).to be true
+        end
+      end
+    end
+
+    context "when attribute name matches image regexp and attribute is not file" do
+      it "returns false" do
+        allow(subject).to receive(:file?).and_return(false)
+        %w(thumbnail image photo picture avatar logo banner icon).each do|prefix|
+          subject.attribute_name = "#{prefix}_uid"
+          expect(subject.image?).to be false
+        end
+      end
+    end
+
+    context "when attribute name does not match image regexp and attribute is file" do
+      it "returns false" do
+        allow(subject).to receive(:file?).and_return(true)
+        %w(thumcbnail idsfmage pdhoto pictdure avdatar lodgo bdanner idcon).each do|prefix|
+          subject.attribute_name = "#{prefix}_uid"
+          expect(subject.image?).to be false
+        end
+      end
+    end
+  end
+
+  describe "#password?" do
+    context "when attribute matches password regexp" do
+      it "returns true" do
+        %w(some_password password_test password pin).each do|attribute_name|
+          subject.attribute_name = attribute_name
+          expect(subject.password?).to be true
+        end
+      end
+    end
+
+    context "when attribute does not match password regexp" do
+      it "returns false" do
+        %w(some_pasword pasword not_pin pins).each do|attribute_name|
+          subject.attribute_name = attribute_name
+          expect(subject.password?).to be false
+        end
+      end
+    end
+  end
+
+  describe "#email?" do
+    context "when attribute matches email regexp" do
+      it "returns true" do
+        %w(email some_email).each do|attribute_name|
+          subject.attribute_name = attribute_name
+          expect(subject.email?).to be true
+        end
+      end
+    end
+
+    context "when attribute does not match email regexp" do
+      it "returns false" do
+        %w(email_some mail).each do|attribute_name|
+          subject.attribute_name = attribute_name
+          expect(subject.email?).to be false
+        end
+      end
+    end
+  end
+
+  describe "#link?" do
+    context "when attribute matches link regexp" do
+      it "returns true" do
+        %w(some_url some_link link url).each do|attribute_name|
+          subject.attribute_name = attribute_name
+          expect(subject.link?).to be true
+        end
+      end
+    end
+
+    context "when attribute does not match link regexp" do
+      it "returns false" do
+        %w(urla linka).each do|attribute_name|
+          subject.attribute_name = attribute_name
+          expect(subject.link?).to be false
+        end
+      end
+    end
+  end
+
+  describe "#richtext?" do
+    context "when attribute matches richtext regexp" do
+      it "returns true" do
+        %w(some_html html).each do|attribute_name|
+          subject.attribute_name = attribute_name
+          expect(subject.richtext?).to be true
+        end
+      end
+    end
+
+    context "when attribute does not match richtext regexp" do
+      it "returns false" do
+        %w(htmla ad_htmla).each do|attribute_name|
+          subject.attribute_name = attribute_name
+          expect(subject.richtext?).to be false
+        end
+      end
+    end
+  end
+
+  describe "#textarea?" do
+    context "when column type is `text`" do
+      it "returns true" do
+        allow(subject).to receive(:column_type).and_return(:text)
+        expect(subject.textarea?).to be true
+      end
+    end
+
+    context "when column type is not `text`" do
+      it "returns false" do
+        allow(subject).to receive(:column_type).and_return(:asdasd)
+        expect(subject.textarea?).to be false
+      end
+    end
+  end
+
+  describe "#text?" do
+    context "when column type is `string`" do
+      it "returns true" do
+        allow(subject).to receive(:column_type).and_return(:string)
+        expect(subject.text?).to be true
+      end
+    end
+
+    context "when column type is not `string`" do
+      it "returns false" do
+        allow(subject).to receive(:column_type).and_return(:asdasd)
+        expect(subject.text?).to be false
+      end
+    end
+  end
+
+  describe "#item?" do
+    context "when attribute name ends with `_id` and object has matching association" do
+      it "returns true" do
+        subject.attribute_name = "author_id"
+        expect(subject.item?).to be true
+      end
+    end
+
+    context "when attribute name ends with `_id` and object hasn't matching association" do
+      it "returns false" do
+        subject.attribute_name = "author_id"
+        allow(Book).to receive(:reflect_on_association).with(:author).and_return(nil)
+        expect(subject.item?).to be false
+      end
+    end
+
+    context "when attribute does not end with `_id`" do
+      it "returns false" do
+        subject.attribute_name = "cover_asdasdd_uid"
+        expect(subject.item?).to be false
+      end
+    end
+  end
+end

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

@@ -42,7 +42,7 @@ describe Releaf::Builders::View, type: :class do
   end
 
   describe "#dialog?" do
-    let(:controller){ Releaf::BaseController.new }
+    let(:controller){ Releaf::ActionController.new }
 
     before do
       allow(template).to receive(:controller).and_return(controller)

data/spec/builders/releaf/settings/form_builder_spec.rb

@@ -0,0 +1,48 @@
+require "rails_helper"
+
+describe Releaf::Settings::FormBuilder, type: :class do
+  class FormBuilderTestHelper < ActionView::Base; end
+  let(:resource){ Releaf::Settings.new }
+  let(:template){ FormBuilderTestHelper.new }
+  let(:subject){ described_class.new(:resource, resource, template, {}) }
+
+  describe "#field_names" do
+    it "returns :value as only editable field within array" do
+      expect(subject.field_names).to eq([:value])
+    end
+  end
+
+  describe "#render_value" do
+    it "renders with resolved label text and render method" do
+      allow(subject).to receive(:value_label_text).and_return("x")
+      allow(subject).to receive(:value_render_method_name).and_return("releaf_integer_field")
+      allow(subject).to receive(:releaf_integer_field).with(:value, { options: { label: { label_text: "x" }}}).and_return("y")
+      expect(subject.render_value).to eq("y")
+    end
+  end
+
+  describe "#value_render_method_name" do
+    it "returns render method built from input type" do
+      allow(resource).to receive(:input_type).and_return(:superdate)
+      expect(subject.value_render_method_name).to eq("releaf_superdate_field")
+    end
+  end
+
+  describe "#value_label_text" do
+    context "when description is available" do
+      it "returns translated description text" do
+        allow(resource).to receive(:description).and_return("x")
+        allow(subject).to receive(:t).with("x", { scope: "settings"}).and_return("y")
+        expect(subject.value_label_text).to eq("y")
+      end
+    end
+
+    context "when description is not available" do
+      it "returns translated 'value' attribute" do
+        allow(subject).to receive(:translate_attribute).with(:value).and_return("xx")
+        allow(resource).to receive(:description).and_return(nil)
+        expect(subject.value_label_text).to eq("xx")
+      end
+    end
+  end
+end

data/spec/builders/{core → releaf}/settings/table_builder_spec.rb

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::Settings::TableBuilder, type: :class do
+describe Releaf::Settings::TableBuilder, type: :class do
   class TableBuilderTestHelper < ActionView::Base; end
   let(:template){ TableBuilderTestHelper.new }
   let(:resource_class){ Releaf::Settings }
@@ -13,9 +13,11 @@ describe Releaf::Core::Settings::TableBuilder, type: :class do
   end
 
   describe "#value_content" do
-    it "return resource value casted to string" do
-      resource = Releaf::Settings.new(value: Date.parse("2012-01-01"))
-      expect(subject.value_content(resource)).to eq("2012-01-01")
+    it "return value processed with corresponding type content format method" do
+      resource = Releaf::Settings.new(value: :x)
+      allow(resource).to receive(:input_type).and_return(:date)
+      allow(subject).to receive(:format_date_content).with(resource, :value).and_return(:y)
+      expect(subject.value_content(resource)).to eq(:y)
     end
   end
 end

data/spec/controllers/concerns/releaf/richtext_attachments_spec.rb

@@ -1,6 +1,6 @@
 require 'rails_helper'
 
-describe Releaf::Content::NodesController, type: :controller do
+describe Admin::NodesController, type: :controller do
   before do
     sign_in create(:user)
   end