archangel 0.0.2

data/spec/inputs/archangel/meta_keywords_input_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  RSpec.describe "META Keywords custom input for simple_form", type: :input do
+    before { concat input_for(:foo, :select_field, as: :meta_keywords) }
+
+    it "applies class to field" do
+      assert_select "input.meta_keywords", count: 1
+    end
+  end
+end

data/spec/inputs/archangel/role_input_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  RSpec.describe "Role custom input for simple_form", type: :input do
+    before { concat input_for(:foo, :select_field, as: :role) }
+
+    it "applies class to field" do
+      assert_select "select.role", count: 1
+    end
+
+    it "has options" do
+      assert_select "option", count: Archangel::ROLES.count
+      assert_select "select[multiple=multiple]", count: 0
+    end
+  end
+end

data/spec/inputs/archangel/theme_input_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  RSpec.describe "Theme custom input for simple_form", type: :input do
+    before { concat input_for(:foo, :select_field, as: :theme) }
+
+    it "applies class to field" do
+      assert_select "select.theme", count: 1
+    end
+
+    it "has options" do
+      assert_select "option", count: Archangel.themes.count
+    end
+  end
+end

data/spec/inputs/archangel/time_picker_input_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  RSpec.describe "Time picker custom input for simple_form", type: :input do
+    before do
+      concat input_for(:foo, :input_field, as: :time_picker)
+    end
+
+    it "applies class to field" do
+      assert_select "input.timepicker", count: 1
+    end
+  end
+end

data/spec/inputs/archangel/wysiwyg_input_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  RSpec.describe "WYSIWYG custom input for simple_form", type: :input do
+    before do
+      concat input_for(:foo, :input_field, as: :wysiwyg)
+    end
+
+    it "applies class to field" do
+      assert_select "textarea.wysiwyg", count: 1
+    end
+  end
+end

data/spec/jobs/archangel/application_job_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  RSpec.describe ApplicationJob, type: :job do
+  end
+end

data/spec/lib/archangel/liquid/filters/link_to_filter_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Filters
+      RSpec.describe LinkToFilter, type: :liquid_filter do
+        let(:site) { create(:site) }
+        let(:context) do
+          ::Liquid::Context.new({ "site" => site }, {}, view: view)
+        end
+
+        def link_to(link_text, *args)
+          link_to(args.first, link_text)
+        end
+
+        context "#link_to" do
+          let(:link_text) { "Hello world!" }
+
+          it "returns the link with no text provided" do
+            content = "{{ '#{link_text}' | link_to }}"
+            result = ::Liquid::Template.parse(content).render(context)
+
+            expect(result).to eq(link_text)
+          end
+
+          it "returns the link with nil link provided" do
+            link = nil
+            content = "{{ '#{link_text}' | link_to: #{link} }}"
+            result = ::Liquid::Template.parse(content).render(context)
+
+            expect(result).to eq(link_text)
+          end
+
+          it "returns the link with empty link string provided" do
+            link = ""
+            content = "{{ '#{link_text}' | link_to: #{link} }}"
+            result = ::Liquid::Template.parse(content).render(context)
+
+            expect(result).to eq(link_text)
+          end
+
+          it "returns the link with URL" do
+            link = "https://example.com"
+            content = "{{ '#{link_text}' | link_to: '#{link}' }}"
+            result = ::Liquid::Template.parse(content).render(context)
+
+            expect(result).to eq("<a href=\"#{link}\">#{link_text}</a>")
+          end
+
+          it "returns the link with path" do
+            link = "path/to/something"
+            content = "{{ '#{link_text}' | link_to: '#{link}' }}"
+            result = ::Liquid::Template.parse(content).render(context)
+
+            expect(result).to eq("<a href=\"#{link}\">#{link_text}</a>")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/archangel/liquid/tags/application_tag_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Tags
+      RSpec.describe ApplicationTag, type: :liquid_tag do
+      end
+    end
+  end
+end

data/spec/lib/archangel/liquid/tags/asset_tag_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Tags
+      RSpec.describe AssetTag, type: :liquid_tag do
+        let(:site) { create(:site) }
+        let(:context) do
+          ::Liquid::Context.new({ "site" => site }, {}, view: view)
+        end
+
+        it "raises error with invalid syntax" do
+          content = "{% asset %}"
+
+          expect { ::Liquid::Template.parse(content).render(context) }.to(
+            raise_error(::Liquid::SyntaxError)
+          )
+        end
+
+        it "returns link for non-image asset" do
+          asset = create(:asset, :stylesheet, site: site)
+
+          result = ::Liquid::Template.parse("{% asset '#{asset.file_name}' %}")
+                                     .render(context)
+          expected = %r{<a href="#{asset.file.url}">#{asset.file_name}\</a>}
+
+          expect(result).to match(expected)
+        end
+
+        it "returns image asset" do
+          asset = create(:asset, site: site)
+
+          result = ::Liquid::Template.parse("{% asset '#{asset.file_name}' %}")
+                                     .render(context)
+
+          expect(result).to match(
+            %r{<img alt="#{asset.file_name}" src="#{asset.file.url}" />}
+          )
+        end
+
+        context "with `size` attribute" do
+          %w[small tiny].each do |size|
+            it "returns `#{size}` sized image asset" do
+              asset = create(:asset, site: site)
+
+              content = "{% asset '#{asset.file_name}' size: '#{size}' %}"
+              result = ::Liquid::Template.parse(content).render(context)
+
+              asset_file_url = asset.file.send(size.to_sym).url
+
+              expect(result).to match(
+                %r{<img alt="#{asset.file_name}" src="#{asset_file_url}" />}
+              )
+            end
+          end
+
+          it "returns original image asset" do
+            asset = create(:asset, site: site)
+
+            content = "{% asset '#{asset.file_name}' size: 'unknown_size' %}"
+            result = ::Liquid::Template.parse(content).render(context)
+
+            expect(result).to match(
+              %r{<img alt="#{asset.file_name}" src="#{asset.file.url}" />}
+            )
+          end
+        end
+
+        it "returns image with options" do
+          asset = create(:asset, site: site)
+
+          content = "{% asset '#{asset.file_name}' alt:'This is the alt tag' %}"
+          result = ::Liquid::Template.parse(content).render(context)
+          expect(result).to match(
+            %r{<img alt="This is the alt tag" src="#{asset.file.url}" />}
+          )
+        end
+
+        it "returns nothing when asset not found" do
+          result = ::Liquid::Template.parse("{% asset 'whatever.jpg' %}")
+                                     .render(context)
+
+          expect(result).to eq("")
+        end
+      end
+    end
+  end
+end

data/spec/lib/archangel/liquid/tags/collection_tag_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Tags
+      RSpec.describe CollectionTag, type: :liquid_tag do
+        let(:site) { create(:site) }
+
+        let(:context) do
+          ::Liquid::Context.new({ "site" => site }, {}, view: view)
+        end
+
+        it "raises error with invalid syntax" do
+          content = "{% collection things %}"
+
+          expect { ::Liquid::Template.parse(content).render(context) }.to(
+            raise_error(::Liquid::SyntaxError)
+          )
+        end
+
+        it "returns nothing to the view" do
+          create(:collection, site: site, slug: "my-collection")
+
+          content = "{% collection things = 'my-collection' %}"
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to eq("")
+        end
+
+        it "returns collection content" do
+          collection = create(:collection, site: site, slug: "my-collection")
+          create(:field, :required, collection: collection, slug: "name")
+          create(:entry, collection: collection, value: { name: "First" })
+          create(:entry, collection: collection, value: { name: "Second" })
+
+          content = <<-LIQUID
+            {% collection things = 'my-collection' %}
+            {% for item in things %}
+              {{ forloop.index }}: {{ item.name }}
+            {% endfor %}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to include("1: Second")
+          expect(result).to include("2: First")
+        end
+
+        it "returns collection content with limit and offset" do
+          collection = create(:collection, site: site, slug: "my-collection")
+          create(:field, :required, collection: collection, slug: "name")
+          create(:entry, collection: collection, value: { name: "First" })
+          create(:entry, collection: collection, value: { name: "Second" })
+          create(:entry, collection: collection, value: { name: "Third" })
+
+          content = <<-LIQUID
+            {% collection things = 'my-collection' limit:1 offset:2 %}
+            {% for item in things %}
+              {{ forloop.index }}: {{ item.name }}
+            {% endfor %}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to include("1: Second")
+
+          expect(result).not_to include("First")
+          expect(result).not_to include("Third")
+        end
+
+        it "returns nothing for empty collection" do
+          collection = create(:collection, site: site, slug: "my-collection")
+          create(:field, :required, collection: collection, slug: "name")
+
+          content = <<-LIQUID
+            {%- collection things = 'my-collection' -%}
+            {%- for item in things -%}
+              {{ item.name }}
+            {%- endfor -%}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to eq("")
+        end
+
+        it "returns nothing for unknown collection" do
+          content = <<-LIQUID
+            {%- collection things = 'unknown-collection' -%}
+            {%- for item in things -%}
+              {{ item.name }}
+            {%- endfor -%}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to eq("")
+        end
+      end
+    end
+  end
+end

data/spec/lib/archangel/liquid/tags/collectionfor_tag_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Tags
+      RSpec.describe CollectionforTag, type: :liquid_tag do
+        let(:site) { create(:site) }
+
+        let(:context) do
+          ::Liquid::Context.new({ "site" => site }, {}, view: view)
+        end
+
+        it "raises error with invalid syntax" do
+          content = <<-LIQUID
+            {% collectionfor item as 'my-collection' %}
+              {{ forloop.index }}: {{ item.name }}
+            {% endcollectionfor %}
+          LIQUID
+
+          expect { ::Liquid::Template.parse(content).render(context) }.to(
+            raise_error(::Liquid::SyntaxError)
+          )
+        end
+
+        it "returns nothing to the view" do
+          create(:collection, site: site, slug: "my-collection")
+
+          content = <<-LIQUID
+            {%- collectionfor item in 'my-collection' -%}
+              {{ forloop.index }}: {{ item.name }}
+            {%- endcollectionfor -%}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to eq("")
+        end
+
+        it "returns collection content" do
+          collection = create(:collection, site: site, slug: "my-collection")
+          create(:field, :required, collection: collection, slug: "name")
+          create(:entry, collection: collection, value: { name: "First" })
+          create(:entry, collection: collection, value: { name: "Second" })
+          create(:entry, collection: collection, value: { name: "Third" })
+
+          content = <<-LIQUID
+            {% collectionfor item in 'my-collection' %}
+              {{ forloop.index }}: {{ item.name }}
+            {% endcollectionfor %}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to include("1: Third")
+          expect(result).to include("2: Second")
+          expect(result).to include("3: First")
+        end
+
+        it "returns collection content with limit and offset" do
+          collection = create(:collection, site: site, slug: "my-collection")
+          create(:field, :required, collection: collection, slug: "name")
+          create(:entry, collection: collection, value: { name: "First" })
+          create(:entry, collection: collection, value: { name: "Second" })
+          create(:entry, collection: collection, value: { name: "Third" })
+
+          content = <<-LIQUID
+            {% collectionfor item in 'my-collection' limit:1 offset:2 %}
+              {{ forloop.index }}: {{ item.name }}
+            {% endcollectionfor %}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to include("1: Second")
+
+          expect(result).not_to include("First")
+          expect(result).not_to include("Third")
+        end
+
+        it "returns reversed collection content" do
+          collection = create(:collection, site: site, slug: "my-collection")
+          create(:field, :required, collection: collection, slug: "name")
+          create(:entry, collection: collection, value: { name: "First" })
+          create(:entry, collection: collection, value: { name: "Second" })
+          create(:entry, collection: collection, value: { name: "Third" })
+
+          content = <<-LIQUID
+            {% collectionfor item in 'my-collection' reversed %}
+              {{ forloop.index }}: {{ item.name }}
+            {% endcollectionfor %}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to include("1: First")
+          expect(result).to include("2: Second")
+          expect(result).to include("3: Third")
+        end
+
+        it "returns collection content with a break" do
+          collection = create(:collection, site: site, slug: "my-collection")
+          create(:field, :required, collection: collection, slug: "name")
+          create(:entry, collection: collection, value: { name: "First" })
+          create(:entry, collection: collection, value: { name: "Second" })
+          create(:entry, collection: collection, value: { name: "Third" })
+
+          content = <<-LIQUID
+            {%- collectionfor item in 'my-collection' -%}
+              {% if item.name == 'Second' %}
+                {% break %}
+              {% else %}
+                {{ item.name }}
+              {% endif %}
+            {%- endcollectionfor -%}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to include("Third")
+          expect(result).not_to include("Second")
+          expect(result).not_to include("First")
+        end
+
+        it "returns collection content with a continue" do
+          collection = create(:collection, site: site, slug: "my-collection")
+          create(:field, :required, collection: collection, slug: "name")
+          create(:entry, collection: collection, value: { name: "First" })
+          create(:entry, collection: collection, value: { name: "Second" })
+          create(:entry, collection: collection, value: { name: "Third" })
+
+          content = <<-LIQUID
+            {%- collectionfor item in 'my-collection' -%}
+              {% if item.name == 'Second' %}
+                {% continue %}
+              {% else %}
+                {{ item.name }}
+              {% endif %}
+            {%- endcollectionfor -%}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to include("Third")
+          expect(result).not_to include("Second")
+          expect(result).to include("First")
+        end
+
+        it "returns nothing for unknown collection" do
+          content = <<-LIQUID
+            {%- collectionfor item in 'unknown-collection' -%}
+              {{ forloop.index }}: {{ item.name }}
+            {%- endcollectionfor -%}
+          LIQUID
+
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result).to eq("")
+        end
+      end
+    end
+  end
+end

data/spec/lib/archangel/liquid/tags/csrf_meta_tags_tag_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Tags
+      RSpec.describe CsrfMetaTagsTag, type: :liquid_tag,
+                                      disable: :verify_partial_doubles do
+        let(:context) { ::Liquid::Context.new({}, {}, view: view) }
+
+        it "returns CSRF meta tags" do
+          allow(view).to receive(:protect_against_forgery?).and_return(true)
+          allow(view).to(
+            receive(:form_authenticity_token)
+              .and_return("rails_form_authenticity_token")
+          )
+
+          result = ::Liquid::Template.parse("{% csrf_meta_tags %}")
+                                     .render(context)
+
+          expected_param =
+            '<meta name="csrf-param" content="authenticity_token" />'
+          expected_token =
+            '<meta name="csrf-token" content="rails_form_authenticity_token" />'
+
+          expect(result).to include(expected_param)
+          expect(result).to include(expected_token)
+        end
+      end
+    end
+  end
+end

data/spec/lib/archangel/liquid/tags/gist_tag_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Tags
+      RSpec.describe GistTag, type: :liquid_tag do
+        let(:site) { create(:site) }
+        let(:context) do
+          ::Liquid::Context.new({ "site" => site }, {}, view: view)
+        end
+
+        it "raises error with invalid syntax" do
+          content = "{% gist %}"
+
+          expect { ::Liquid::Template.parse(content).render(context) }.to(
+            raise_error(::Liquid::SyntaxError)
+          )
+        end
+
+        it "returns gist" do
+          gist = "9bbaf7332bff1042c2d83fc88683b9df"
+          result = ::Liquid::Template.parse("{% gist '#{gist}' %}")
+                                     .render(context)
+
+          expect(result).to include("https://gist.github.com/#{gist}.js")
+        end
+
+        it "returns gist with file" do
+          gist = "9bbaf7332bff1042c2d83fc88683b9df"
+          file = "hello.rb"
+          content = "{% gist '#{gist}' file: '#{file}' %}"
+          result = ::Liquid::Template.parse(content).render(context)
+
+          expect(result)
+            .to include("https://gist.github.com/#{gist}.js?file=#{file}")
+        end
+      end
+    end
+  end
+end

data/spec/lib/archangel/liquid/tags/locale_tag_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Tags
+      RSpec.describe LocaleTag, type: :liquid_tag,
+                                disable: :verify_partial_doubles do
+        let(:context) { ::Liquid::Context.new({}, {}, view: view) }
+
+        it "returns current locale" do
+          allow(view).to receive(:locale).and_return("en")
+
+          result = ::Liquid::Template.parse("{% locale %}").render(context)
+
+          expect(result).to eq("en")
+        end
+      end
+    end
+  end
+end

data/spec/lib/archangel/liquid/tags/meta_tags_tag_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Tags
+      RSpec.describe MetaTagsTag, type: :liquid_tag,
+                                  disable: :verify_partial_doubles do
+        let(:context) { ::Liquid::Context.new({}, {}, view: view) }
+
+        it "returns meta tags" do
+          canonical = "<link rel=\"canonical\" href=\"http://localhost/\">"
+
+          allow(view).to receive(:display_meta_tags).and_return(canonical)
+
+          result = ::Liquid::Template.parse("{% meta_tags %}").render(context)
+
+          expect(result).to eq(canonical)
+        end
+      end
+    end
+  end
+end

data/spec/lib/archangel/liquid/tags/text_direction_tag_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module Archangel
+  module Liquid
+    module Tags
+      RSpec.describe TextDirectionTag, type: :liquid_tag,
+                                       disable: :verify_partial_doubles do
+        let(:context) { ::Liquid::Context.new({}, {}, view: view) }
+
+        it "returns `ltr` text direction" do
+          allow(view).to receive(:text_direction).and_return("ltr")
+
+          result = ::Liquid::Template.parse("{% text_direction %}")
+                                     .render(context)
+
+          expect(result).to eq("ltr")
+        end
+
+        it "returns `rtl` text direction" do
+          allow(view).to receive(:text_direction).and_return("rtl")
+
+          result = ::Liquid::Template.parse("{% text_direction %}")
+                                     .render(context)
+
+          expect(result).to eq("rtl")
+        end
+      end
+    end
+  end
+end