releaf-core 0.2.1 → 1.0.3

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

@@ -0,0 +1,106 @@
+require "rails_helper"
+
+describe Releaf::Builders::FormBuilder::Label, 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 "#releaf_label" do
+    it "passes options :label value to #label_text and use returned value for label text content" do
+      allow(subject).to receive(:label_text).with(:color, a: "b").and_return("xx")
+      result = '<div class="label-wrap"><label for="book_color">xx</label></div>'
+
+      expect(subject.releaf_label(:color, {}, label: {a: "b"})).to eq(result)
+    end
+
+    it "uses #label_attributes for label attributes" do
+      allow(subject).to receive(:label_attributes).with(:color, {class: "red"}, {a: "b"}).and_return(class: "red blue")
+      result = '<div class="label-wrap"><label class="red blue" for="book_color">Color</label></div>'
+
+      expect(subject.releaf_label(:color, {class: "red"}, {a: "b"})).to eq(result)
+    end
+
+    context "when options[:label][:description] is not blank" do
+      context "when label has full version" do
+        it "includes description" do
+          result = '<div class="label-wrap"><label for="book_color">Color</label><div class="description">xxx</div></div>'
+          expect(subject.releaf_label(:color, {}, label: {description: "xxx"})).to eq(result)
+        end
+      end
+
+      context "when label has minimal version" do
+        it "does not include description" do
+          result = '<label for="book_color">Color</label>'
+          expect(subject.releaf_label(:color, {}, label: {minimal: true})).to eq(result)
+        end
+      end
+    end
+
+    context "when options[:label][:minimal] is true" do
+      it "returns label tag without wrap element" do
+        result = '<label for="book_color">Color</label>'
+        expect(subject).to_not receive(:wrapper)
+        expect(subject.releaf_label(:color, {}, label: {minimal: true})).to eq(result)
+      end
+    end
+
+    context "when options[:label][:minimal] is not true" do
+      it "returns label tag with wrap element" do
+        allow(subject).to receive(:wrapper).with('<label for="book_color">Color</label>', class: "label-wrap").and_return("x")
+        expect(subject.releaf_label(:color, {}, label: {minimal: false})).to eq("x")
+        expect(subject.releaf_label(:color, {}, label: {minimal: nil})).to eq("x")
+        expect(subject.releaf_label(:color, {}, label: {adasd: "xx"})).to eq("x")
+      end
+    end
+  end
+
+  describe "#label_attributes" do
+    it "returns unmodified attributes (allow further override by other builders)" do
+      expect(subject.label_attributes(:color, {data: "x"}, {})).to eq(data: "x")
+    end
+  end
+
+  describe "#label_text" do
+    it "returns model attributes scoped translated value" do
+      allow(subject).to receive(:translate_attribute).with("color").and_return("x")
+      expect(subject.label_text(:color)).to eq("x")
+    end
+
+    context "when :label_text option exists" do
+      context "when :label_text is not blank" do
+        it "returns :label_text option" do
+          expect(subject.label_text(:color, label_text: "krāsa")).to eq("krāsa")
+        end
+      end
+
+      context "when :label_text is blank" do
+        it "returns translated value" do
+          expect(subject.label_text(:color, label_text: nil)).to eq("Color")
+          expect(subject.label_text(:color, label_text: "")).to eq("Color")
+        end
+      end
+    end
+
+    context "when :translation_key option exists" do
+      context "when :translation_key is not blank" do
+        it "passes :translation_key option to translation and return translated value" do
+          allow(subject).to receive(:translate_attribute).with("true_color").and_return("x")
+          expect(subject.label_text(:color, translation_key: "true_color")).to eq("x")
+        end
+      end
+
+      context "when :translation_key is blank" do
+        it "returns translated value" do
+          expect(subject.label_text(:color, translation_key: nil)).to eq("Color")
+          expect(subject.label_text(:color, translation_key: "")).to eq("Color")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "rails_helper"
+
+describe Releaf::Builders::FormBuilder::NumberFields, 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 "#releaf_number_field" do
+    it "returns input with type 'number'" do
+      expect(subject).to receive(:number_field).with("title", { value: nil, step: "any", class: "text" }).and_return("x")
+      expect(subject).to receive(:input_wrapper_with_label).with("title", "x", { label: {}, field: {}, options: { field: { type: "number" }}}).and_return("y")
+      expect(subject.releaf_number_field("title")).to eq("y")
+    end
+
+    context "aliases" do
+      let(:releaf_number_field_method) { subject.method(:releaf_number_field) }
+
+      it "is aliased by #releaf_integer_field" do
+        expect(subject.method(:releaf_integer_field)).to eq(releaf_number_field_method)
+      end
+
+      it "is aliased by #releaf_float_field" do
+        expect(subject.method(:releaf_float_field)).to eq(releaf_number_field_method)
+      end
+
+      it "is aliased by #releaf_decimal_field" do
+        expect(subject.method(:releaf_decimal_field)).to eq(releaf_number_field_method)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,228 @@
+require "rails_helper"
+
+describe Releaf::Builders::FormBuilder, 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){ described_class.new(:book, object, template, {}) }
+  let(:normalized_fields){
+    [
+      {
+        render_method: "render_title",
+        field: "title",
+        subfields: nil
+      },
+      {
+        render_method: "render_author_id",
+        field: "author_id",
+        subfields: nil
+      },
+      {
+        render_method: "render_chapters",
+        field: :chapters,
+        subfields: ["title", "text", "sample_html"]
+      },
+      {
+        render_method: "render_book_sequels",
+        field: :book_sequels,
+        subfields: ["sequel_id"]
+      }
+    ]
+  }
+
+  it "includes Releaf::Builders::Base" do
+    expect(described_class.ancestors).to include(Releaf::Builders::Base)
+  end
+
+  describe "#field_names" do
+    it "returns field names for object class" do
+      allow(Releaf::ResourceFields).to receive(:new).with(object.class).and_call_original
+      allow_any_instance_of(Releaf::ResourceFields).to receive(:values).and_return(["a", "b"])
+      expect(subject.field_names).to eq(["a", "b"])
+    end
+  end
+
+  describe "#field_type_method" do
+    it "returns field type method resolved with ``" do
+      allow(Releaf::Builders::Utilities::ResolveAttributeFieldMethodName).to receive(:call)
+        .with(object: object, attribute_name: "color").and_return("some_method")
+      expect(subject.field_type_method(:color)).to eq("some_method")
+    end
+  end
+
+  describe "#field_render_method_name" do
+    it "returns method name for given field" do
+      expect(subject.field_render_method_name(:title)).to eq("render_title")
+    end
+
+    context "when builder has parent builder(-s)" do
+      it "traverses through all builders and add relation name option to field name" do
+        root_builder = described_class.new(:author, Author.new, template, {})
+        middle_builder = described_class.new(:author, Author.new, template, {relation_name: :pages, parent_builder: root_builder})
+        subject.options[:parent_builder] = middle_builder
+        subject.options[:relation_name] = :chapters
+
+        expect(subject.field_render_method_name(:title)).to eq("render_pages_chapters_title")
+      end
+    end
+  end
+
+  describe "#normalize_fields" do
+    it "returns normalized fields for use with #releaf_fields method" do
+      fields = [
+        "title",
+        "author_id",
+        {chapters: ["title", "text", "sample_html"]},
+        {book_sequels: ["sequel_id"]}
+      ]
+      expect(subject.normalize_fields(fields)).to eq(normalized_fields)
+    end
+
+    it "handles multi-key hashes" do
+      fields = [
+        "title",
+        "author_id",
+        {
+          chapters: ["title", "text", "sample_html"],
+          book_sequels: ["sequel_id"]
+        }
+      ]
+      expect(subject.normalize_fields(fields)).to eq(normalized_fields)
+    end
+  end
+
+  describe "#releaf_fields" do
+    it "normalizes given fields with #normalize_fields" do
+      allow(subject).to receive(:render_field_by_options)
+      expect(subject).to receive(:normalize_fields).with([:a, :b]).and_return([:x, :y])
+      subject.releaf_fields(:a, :b)
+    end
+
+    it "passes all normalized field options to #render_field" do
+      allow(subject).to receive(:normalize_fields).and_return([:x, :y])
+      expect(subject).to receive(:render_field_by_options).with(:x)
+      expect(subject).to receive(:render_field_by_options).with(:y)
+      subject.releaf_fields(:a, :b)
+    end
+
+    it "concatenates and return all #render_field_by_options outputs with #safe_join" do
+      allow(subject).to receive(:render_field_by_options).and_return('_a_', '_b_')
+      allow(subject).to receive(:normalize_fields).and_return([:x, :y])
+      expect(subject).to receive(:safe_join).with(no_args){|&block|
+        expect(block.call).to eq(['_a_', '_b_'])
+      }.and_return("xxx")
+      expect(subject.releaf_fields(:a, :b)).to eq("xxx")
+    end
+  end
+
+  describe "#render_field_by_options" do
+    let(:options){ {
+      render_method: "sortable_column_name", # just random method here
+      field: "title",
+      subfields: [:a, :b],
+    } }
+
+    before do
+      allow(subject).to receive(:reflect_on_association).with("title").and_return(:x)
+      allow(subject).to receive(:sortable_column_name)
+        .with(no_args).and_return("_render_method_content_")
+      allow(subject).to receive(:releaf_association_fields)
+        .with(:x, [:a, :b]).and_return("_association_method_content_")
+      allow(subject).to receive(:releaf_field)
+        .with("title").and_return("_releaf_field_content_")
+    end
+
+    context "when method defined in options[:render_method] exists" do
+      it "returns this method output" do
+        expect(subject.render_field_by_options(options)).to eq("_render_method_content_")
+      end
+    end
+
+    context "when custom method does not exist" do
+      before do
+        options[:render_method] = "something_unexisting"
+      end
+
+      context "when reflection exists for given field" do
+        it "returns #releaf_association_fields by passing options[:field] and options[:subfields]" do
+          expect(subject.render_field_by_options(options)).to eq("_association_method_content_")
+        end
+      end
+
+      context "when reflection does not exist for given field" do
+        it "returns #releaf_field with options[:field] as argument" do
+          allow(subject).to receive(:reflect_on_association).with("title").and_return(nil)
+          expect(subject.render_field_by_options(options)).to eq("_releaf_field_content_")
+        end
+      end
+    end
+  end
+
+  describe "#input_wrapper_with_label" do
+    before do
+      allow(subject).to receive(:wrapper).with("input_content", class: "value").and_return("input_content")
+      allow(subject).to receive(:releaf_label).with(:color, "label_attributes", "options").and_return("label_content")
+      allow(subject).to receive(:field).with(:color, "field_attributes", "options"){ |name, field, options, &block|
+        expect(block.call).to eq("label_contentinput_content")
+      }.and_return("content")
+    end
+
+    it "returns wrapped label and input content" do
+      expect(subject.input_wrapper_with_label(:color, "input_content", label: "label_attributes", field: "field_attributes", options: "options"))
+        .to eq("content")
+    end
+
+    context "when block given" do
+      it "safely concatinate block output to content" do
+        content =  'input_content<input type="hidden" name="book[id]" id="book_id" />'
+        allow(subject).to receive(:wrapper).with(content, class: "value").and_return("input_content")
+        expect(subject.input_wrapper_with_label(:color, "input_content", label: "label_attributes", field: "field_attributes", options: "options"){ subject.hidden_field(:id) })
+          .to eq("content")
+      end
+
+      it "correctly handles block nil output" do
+        expect(subject.input_wrapper_with_label(:color, "input_content", label: "label_attributes", field: "field_attributes", options: "options"){ })
+          .to eq("content")
+      end
+    end
+  end
+
+  describe "#field_attributes" do
+    it "adds field data and class attributes and cast name to string within data attributes" do
+      expect(subject.field_attributes(:color, {}, {field: {type: "text"}})).to eq(data: {name: "color"}, class: ["field", "type-text"])
+    end
+
+    it "merges attributes over build-in data hash" do
+      expect(subject.field_attributes(:color, {data: {other: "x"}}, {})[:data]).to eq(name: "color", other: "x")
+      expect(subject.field_attributes(:color, {data: {other: "x", name: :lll}}, {})[:data]).to eq(name: :lll, other: "x")
+    end
+
+    it "supports class attributes merging" do
+      expect(subject.field_attributes(:color, {class: ["a", "b"]}, {})[:class]).to eq(["field", "type-", "a", "b"])
+    end
+  end
+
+  describe "#input_attributes" do
+    it "returns unmodified attributes (allow further override by other builders)" do
+      expect(subject.input_attributes(:color, {data: "x"}, {})).to eq(data: "x")
+    end
+  end
+
+  describe "#sortable_column_name" do
+    it "returns 'item_position'" do
+      expect( subject.sortable_column_name ).to eq 'item_position'
+    end
+  end
+
+  describe "#translate_attribute" do
+    it "translates given attribute within object translation scope" do
+      allow(object.class).to receive(:human_attribute_name).with("x").and_return("z")
+      expect(subject.translate_attribute("x")).to eq("z")
+    end
+  end
+end

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

@@ -6,11 +6,7 @@ describe Releaf::Builders::IndexBuilder, type: :class do
     delegate :resource_class, :table_options, to: :controller
 
     def controller
-      @controller ||= begin
-                        c = Admin::BooksController.new
-                        c.setup
-                        c
-                      end
+      @controller ||= Admin::BooksController.new
     end
   end
 
@@ -85,9 +81,22 @@ describe Releaf::Builders::IndexBuilder, type: :class do
   end
 
   describe "#header_extras" do
-    it "returns search block" do
+    before do
       allow(subject).to receive(:search_block).and_return("x")
-      expect(subject.header_extras).to eq("x")
+    end
+
+    context "when search feature is enabled" do
+      it "returns search block" do
+        allow(subject).to receive(:feature_available?).with(:search).and_return(true)
+        expect(subject.header_extras).to eq("x")
+      end
+    end
+
+    context "when search feature is disabled" do
+      it "returns nil" do
+        allow(subject).to receive(:feature_available?).with(:search).and_return(false)
+        expect(subject.header_extras).to be nil
+      end
     end
   end
 
@@ -318,11 +327,8 @@ describe Releaf::Builders::IndexBuilder, type: :class do
       expect(subject).to receive(:pagination_builder_class).and_return(dummy)
       expect( subject.pagination_block).to eq :ok
     end
-
   end
 
-
-
   describe "#resource_creation_button" do
     it "returns resource creation button" do
       allow(subject.template).to receive(:url_for).with(controller: "_controller_name_", action: "new").and_return("x")
@@ -342,4 +348,17 @@ describe Releaf::Builders::IndexBuilder, type: :class do
       expect(subject.section_body).to eq('<div class="body">xx</div>')
     end
   end
+
+  describe "#table_options" do
+    it "returns table options" do
+      allow(subject).to receive(:builder_class).with(:table).and_return("CustomTableBuilderClassHere")
+      allow(subject).to receive(:feature_available?).with(:toolbox).and_return("boolean_value_here")
+
+      options = {
+        builder: "CustomTableBuilderClassHere",
+        toolbox: "boolean_value_here"
+      }
+      expect(subject.table_options).to eq(options)
+    end
+  end
 end

data/spec/builders/releaf/builders/page/header_builder_spec.rb

@@ -0,0 +1,65 @@
+require "rails_helper"
+
+describe Releaf::Builders::Page::HeaderBuilder, type: :class do
+  class PageHeaderBuilderTestHelper < ActionView::Base
+    include Rails.application.routes.url_helpers
+    include FontAwesome::Rails::IconHelper
+
+    def protect_against_forgery?
+      true
+    end
+
+    def form_authenticity_token
+      "xxx"
+    end
+
+    def request_forgery_protection_token
+      "yyy"
+    end
+  end
+
+  subject { described_class.new(template) }
+  let(:template){ PageHeaderBuilderTestHelper.new }
+
+  describe "#output" do
+    it "returns safely joined items" do
+      allow(subject).to receive(:items).and_return([ '<', ActiveSupport::SafeBuffer.new(">")])
+      expect(subject.output).to eq("&lt;>")
+    end
+  end
+
+  describe "#items" do
+    it "returns array of home link, profile block and logout form content" do
+      allow(subject).to receive(:home_link).and_return("a")
+      expect(subject.items).to eq(["a"])
+    end
+  end
+
+  describe "#home_link" do
+    it "returns home link with a logo" do
+      allow(subject).to receive(:home_url).and_return("www.xxx")
+      allow(subject).to receive(:home_text).and_return("Rrr")
+      allow(subject).to receive(:home_image_path).and_return("releaf/foo.png")
+      content = '<a class="home" href="www.xxx"><img alt="Rrr" src="/images/releaf/foo.png" /></a>'
+      expect(subject.home_link).to eq(content)
+    end
+  end
+
+  describe "#home_url" do
+    it "returns home url" do
+      expect(subject.home_url).to eq("/admin")
+    end
+  end
+
+  describe "#home_image_path" do
+    it "returns image to the logo image asset" do
+      expect(subject.home_image_path).to eq("releaf/logo.png")
+    end
+  end
+
+  describe "#home_text" do
+    it "returns releaf home link text" do
+      expect(subject.home_text).to eq("Releaf")
+    end
+  end
+end

data/spec/builders/releaf/builders/page/layout_builder_spec.rb

@@ -0,0 +1,170 @@
+require "rails_helper"
+
+describe Releaf::Builders::Page::LayoutBuilder, type: :class do
+  class DummyBuilder
+    include Releaf::Builders::Base
+    include Releaf::Builders::Template
+    def output; end
+  end
+
+  class DummyAssetsResolver
+    def self.controller_assets(_a, _b); end
+  end
+
+  class PageHeaderBuilderTestHelper < ActionView::Base
+    include Rails.application.routes.url_helpers
+    include FontAwesome::Rails::IconHelper
+
+    def protect_against_forgery?
+      true
+    end
+
+    def form_authenticity_token
+      "xxx"
+    end
+
+    def request_forgery_protection_token
+      "yyy"
+    end
+  end
+
+  class NewRolesController < Releaf::Permissions::RolesController
+  end
+
+  subject { described_class.new(template) }
+  let(:template){ PageHeaderBuilderTestHelper.new }
+
+  describe "#controller_classes" do
+    it "returns array of ignorable ancester classes" do
+      allow(subject).to receive(:controller).and_return(NewRolesController.new)
+      expect(subject.controller_classes).to eq([Releaf::Permissions::RolesController, NewRolesController])
+
+      allow(subject).to receive(:controller).and_return(Releaf::Permissions::RolesController.new)
+      expect(subject.controller_classes).to eq([Releaf::Permissions::RolesController])
+
+      allow(subject).to receive(:controller).and_return(Releaf::Permissions::SessionsController.new)
+      expect(subject.controller_classes).to eq([Releaf::Permissions::SessionsController])
+    end
+  end
+
+  describe "#header_builder" do
+    it "returns `Releaf::Builders::Page::HeaderBuilder` class" do
+      expect(subject.header_builder).to eq(Releaf::Builders::Page::HeaderBuilder)
+    end
+  end
+
+  describe "#assets_resolver" do
+    it "returns `Releaf::AssetsResolver` class" do
+      expect(subject.assets_resolver).to eq(Releaf::AssetsResolver)
+    end
+  end
+
+  describe "#stylesheets" do
+    it "returns stylesheets from assets resolver for given controller" do
+      allow(subject).to receive(:assets_resolver).and_return(DummyAssetsResolver)
+      allow(subject).to receive(:controller_name).and_return("_controller")
+      allow(DummyAssetsResolver).to receive(:controller_assets).with("_controller", :stylesheets)
+        .and_return("x")
+      expect(subject.stylesheets).to eq("x")
+    end
+  end
+
+  describe "#javascripts" do
+    it "returns javascripts from assets resolver for given controller" do
+      allow(subject).to receive(:assets_resolver).and_return(DummyAssetsResolver)
+      allow(subject).to receive(:controller_name).and_return("_controller")
+      allow(DummyAssetsResolver).to receive(:controller_assets).with("_controller", :javascripts)
+        .and_return("y")
+      expect(subject.javascripts).to eq("y")
+    end
+  end
+
+  describe "#header" do
+    it "returns menu builder output wrapped within `aside` tag" do
+      menu_builder = DummyBuilder.new(template)
+      allow(menu_builder).to receive(:output).and_return("_header")
+      allow(DummyBuilder).to receive(:new).with(template).and_return(menu_builder)
+      allow(subject).to receive(:header_builder).and_return(DummyBuilder)
+      allow(subject).to receive(:tag).with(:header, "_header").and_return("<_header>")
+
+      expect(subject.header).to eq("<_header>")
+    end
+  end
+
+  describe "#menu" do
+    it "returns menu builder output wrapped within `aside` tag" do
+      menu_builder = DummyBuilder.new(template)
+      allow(menu_builder).to receive(:output).and_return("_menu")
+      allow(DummyBuilder).to receive(:new).with(template).and_return(menu_builder)
+      allow(subject).to receive(:menu_builder).and_return(DummyBuilder)
+      allow(subject).to receive(:tag).with(:aside, "_menu").and_return("<_menu>")
+
+      expect(subject.menu).to eq("<_menu>")
+    end
+  end
+
+  describe "#menu_builder" do
+    it "returns `Releaf::Builders::Page::MenuBuilder` class" do
+      expect(subject.menu_builder).to eq(Releaf::Builders::Page::MenuBuilder)
+    end
+  end
+
+  describe "#body" do
+    it "returns body with body attributes and" do
+      allow(subject).to receive(:assets).with(:javascripts, :javascript_include_tag).and_return("_assets_")
+      allow(subject).to receive(:body_atttributes).and_return(class: ["xx", "y"], id: "121212")
+      allow(subject).to receive(:body_content){|*args, &block| expect(block.call).to eq("x") }.and_return("body content")
+      expect(subject.body{ "x" }).to eq("<body class=\"xx y\" id=\"121212\">body content_assets_</body>")
+    end
+  end
+
+  describe "#controller_body_classes" do
+    it "returns normalized html classes from controller classes" do
+      allow(subject).to receive(:controller_classes).and_return([Releaf::ActionController, Releaf::Permissions::RolesController])
+      expect(subject.controller_body_classes).to eq(["controller-releaf-action", "controller-releaf-permissions-roles"])
+    end
+  end
+
+  describe "#settings_path" do
+    it "returns root controller settings path" do
+      allow(subject).to receive(:url_for).with(action: "store_settings", controller: "/releaf/root", only_path: true)
+        .and_return("asdasdasd")
+      expect(subject.settings_path).to eq("asdasdasd")
+    end
+  end
+
+  describe "#body_atttributes" do
+    it "returns hash with classes and data-settings-path" do
+      allow(subject).to receive(:controller_body_classes).and_return(["a", "b"])
+      allow(subject).to receive(:settings_path).and_return("/xxx/sett")
+      expect(subject.body_atttributes).to eq(class: ["application-dummy", "a", "b"], "data-settings-path" => "/xxx/sett")
+    end
+  end
+
+  describe "#head_blocks" do
+    it "returns array" do
+      {
+        title: :title_sym,
+        meta: :meta_sym,
+        favicons: :favicon_sym,
+        ms_tile: :ms_tile_sym,
+        assets: :assets_sym,
+        csrf: :csrf_sym,
+      }.each_pair do |method, stub_answer|
+        allow(subject).to receive(method).and_return stub_answer
+      end
+
+      expect(subject.head_blocks).to match_array(
+        [
+          :title_sym,
+          :meta_sym,
+          :favicon_sym,
+          :ms_tile_sym,
+          :assets_sym,
+          :csrf_sym,
+        ]
+      )
+    end
+  end
+end
+