releaf-core 2.0.0 → 2.0.1

data/spec/builders/releaf/builders/template_spec.rb

@@ -1,12 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Builders::Template, type: :module do
-  class TemplateClassIncluder
-    include Releaf::Builders::Template
-  end
-
-  it "it assigns template argument to instance 'template' accessor on initialization" do
-    subject = TemplateClassIncluder.new("x")
-    expect(subject.template).to eq("x")
-  end
-end

data/spec/builders/releaf/builders/toolbox_builder_spec.rb

@@ -1,67 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Builders::ToolboxBuilder, type: :class do
-  class ToolboxBuilderTestHelper < ActionView::Base
-    include Releaf::ButtonHelper
-    include Releaf::ApplicationHelper
-  end
-
-  subject { described_class.new(template) }
-  let(:template){ ToolboxBuilderTestHelper.new(ActionView::LookupContext.new(nil), {}, nil) }
-
-  it "includes Releaf::Builders::Base" do
-    expect(described_class.ancestors).to include(Releaf::Builders::Base)
-  end
-
-  it "includes Releaf::Builders::Template" do
-    expect(described_class.ancestors).to include(Releaf::Builders::Template)
-  end
-
-  it "includes Releaf::Builders::Resource" do
-    expect(described_class.ancestors).to include(Releaf::Builders::Resource)
-  end
-
-  describe "#output" do
-    it "returns safely joined items" do
-      allow(subject).to receive(:items).and_return([ '<', ActiveSupport::SafeBuffer.new(">")])
-      expect(subject.output).to eq("<li>&lt;</li><li>></li>")
-    end
-  end
-
-  describe "#items" do
-    before{ allow(subject).to receive(:destroy_confirmation_link).and_return("x") }
-
-    context "when no destroy feature is available" do
-      it "returns array with destroy button html" do
-        allow(subject).to receive(:feature_available?).with(:destroy).and_return(true)
-        expect(subject.items).to eq(["x"])
-      end
-    end
-
-    context "when destroy feature is not available" do
-      it "returns empty array" do
-        allow(subject).to receive(:feature_available?).with(:destroy).and_return(false)
-        expect(subject.items).to eq([])
-      end
-    end
-  end
-
-  describe "#destroy_confirmation_link" do
-    it "returns destroy confirmation link" do
-      allow(subject).to receive(:t).with("Delete").and_return("dlt")
-      allow(subject).to receive(:destroy_confirmation_url).and_return("www.xxx")
-      content = '<a class="button ajaxbox danger" title="dlt" href="www.xxx" data-modal="true">dlt</a>'
-      expect(subject.destroy_confirmation_link).to eq(content)
-    end
-  end
-
-  describe "#destroy_confirmation_url" do
-    it "returns resource destroy confirmation url with index_path param" do
-      subject.resource = Book.new(id: 99)
-      allow(subject.template).to receive(:url_for).with(action: :confirm_destroy, id: 99, index_path: "y").and_return("x")
-      allow(subject.template).to receive(:controller).and_return(Releaf::ActionController.new)
-      allow(subject.controller).to receive(:index_path).and_return("y")
-      expect(subject.destroy_confirmation_url).to eq("x")
-    end
-  end
-end

data/spec/builders/releaf/builders/toolbox_spec.rb

@@ -1,48 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Builders::Toolbox, type: :class do
-  class ToolboxTestTemplate < ActionView::Base
-  end
-
-  class UnitTestToolboxBuilder
-    include Releaf::Builders::Base
-    include Releaf::Builders::Template
-    include Releaf::Builders::Toolbox
-  end
-
-  subject { UnitTestToolboxBuilder.new(template) }
-  let(:template){ ToolboxTestTemplate.new(ActionView::LookupContext.new(nil), {}, nil) }
-  let(:resource){ Releaf::Permissions::User.new }
-
-  describe "#toolbox" do
-    context "when the passed object is a new record" do
-      it "returns empty string" do
-        expect(subject.toolbox(resource)).to eq("")
-      end
-    end
-
-    context "when the passed object is an existing record" do
-      it "returns toolbox HTML with trigger and without items" do
-        resource.id = 212
-        allow(resource).to receive(:new_record?).and_return(false)
-        allow(subject).to receive(:t).with("Tools").and_return("tls")
-        allow(subject).to receive(:icon).with("ellipsis-v").and_return("<kebab_icon />".html_safe)
-        allow(subject).to receive(:icon).with("caret-up").and_return("<caret_icon />".html_safe)
-        allow(subject).to receive(:action_name).and_return("edit")
-        allow(subject).to receive(:url_for).with({action: :toolbox, id: 212, context: "edit", some_param: 89}).and_return("/toolbox_action")
-
-        expect(subject.toolbox(resource, some_param: 89)).to match_html(%Q[
-          <div class="toolbox" data-url="/toolbox_action">
-            <button class="button trigger only-icon" type="button" title="tls">
-              <kebab_icon />
-            </button>
-            <menu class="toolbox-items" type="toolbar">
-              <caret_icon />
-              <ul></ul>
-            </menu>
-        </div>
-        ])
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-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, format: "_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, format: "_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

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