archangel 0.0.2

data/lib/archangel/liquid/tags/widget_tag.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Archangel
+  module Liquid
+    module Tags
+      ##
+      # Widget custom tag for Liquid
+      #
+      # Example
+      #   {% widget "widget-name" %}
+      #   {% widget 'widget-name' %}
+      #   {% widget widget-name %}
+      #
+      class WidgetTag < ApplicationTag
+        ##
+        # Regex for tag syntax
+        #
+        SYNTAX = /(?<slug>#{::Liquid::QuotedFragment}+)\s*/o
+
+        ##
+        # Widget for Liquid
+        #
+        # @param tag_name [String] the Liquid tag name
+        # @param markup [String] the passed options
+        # @param options [Object] options
+        #
+        def initialize(tag_name, markup, options)
+          super
+
+          match = SYNTAX.match(markup)
+
+          if match.blank?
+            raise ::Liquid::SyntaxError, Archangel.t("errors.syntax.widget")
+          end
+
+          @slug = ::Liquid::Variable.new(match[:slug], options).name
+        end
+
+        ##
+        # Render the Widget
+        #
+        # @param context [Object] the Liquid context
+        # @return [String] the rendered Widget
+        #
+        def render(context)
+          return if slug.blank?
+
+          environments = context.environments.first
+          site = environments["site"]
+
+          widget = load_widget_for(site)
+
+          return if widget.blank?
+
+          rendered_widget = render_widget(widget.content, environments)
+
+          template = widget.template
+
+          if template.present?
+            rendered_widget = render_templated_widget(template, rendered_widget)
+          end
+
+          rendered_widget
+        end
+
+        protected
+
+        attr_reader :slug
+
+        def load_widget_for(site)
+          site.widgets.find_by!(slug: slug)
+        rescue StandardError
+          nil
+        end
+
+        def render_widget(content, assigns)
+          Archangel::RenderService.call(content, assigns)
+        end
+
+        def render_templated_widget(template_content, widget_content)
+          Archangel::TemplateRenderService.call(
+            template_content,
+            content_for_layout: widget_content
+          )
+        end
+      end
+    end
+  end
+end
+
+::Liquid::Template.register_tag("widget", Archangel::Liquid::Tags::WidgetTag)

data/lib/archangel/liquid/tags/youtube_tag.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Archangel
+  module Liquid
+    module Tags
+      ##
+      # YouTube custom tag for Liquid
+      #
+      # Example
+      #   Given the YouTube URL https://www.youtube.com/watch?v=-X2atEH7nCg
+      #   {% youtube "-X2atEH7nCg" %}
+      #   {% youtube "-X2atEH7nCg" width:800 height:600 %}
+      #   {% youtube "-X2atEH7nCg" id:"my_video" class:"my-video" %}
+      #   {% youtube "-X2atEH7nCg" autoplay:1 %}
+      #   {% youtube "-X2atEH7nCg" captions: %}
+      #   {% youtube "-X2atEH7nCg" loop:1 %}
+      #   {% youtube "-X2atEH7nCg" annotations:1 %}
+      #   {% youtube "-X2atEH7nCg" start:10 %}
+      #   {% youtube "-X2atEH7nCg" end:60 %}
+      #   {% youtube "-X2atEH7nCg" showinfo:0 %}
+      #   {% youtube "-X2atEH7nCg" allowfullscreen: %}
+      #   {% youtube "-X2atEH7nCg" allowtransparency:0 %}
+      #   {% youtube "-X2atEH7nCg" frameborder:4 %}
+      #
+      class YoutubeTag < ApplicationTag
+        ##
+        # Regex for tag syntax
+        #
+        SYNTAX = /
+          (?<key>#{::Liquid::QuotedFragment}+)
+          \s*
+          (?<attributes>.*)
+          \s*
+        /omx
+
+        ##
+        # Regex for attributes
+        #
+        SYNTAX_ATTRIBUTES = /
+          (?<key>\w+)
+          \s*
+          \:
+          \s*
+          (?<value>#{::Liquid::QuotedFragment})
+        /ox
+
+        ##
+        # YouTube video embed for Liquid
+        #
+        # @param tag_name [String] the Liquid tag name
+        # @param markup [String] the passed options
+        # @param options [Object] options
+        #
+        def initialize(tag_name, markup, options)
+          super
+
+          match = SYNTAX.match(markup)
+
+          if match.blank?
+            raise ::Liquid::SyntaxError, Archangel.t("errors.syntax.youtube")
+          end
+
+          @key = ::Liquid::Variable.new(match[:key], options).name
+          @attributes = {}
+
+          match[:attributes].scan(SYNTAX_ATTRIBUTES) do |key, value|
+            @attributes[key.to_sym] = ::Liquid::Expression.parse(value)
+          end
+        end
+
+        ##
+        # Render the YouTube video
+        #
+        # @param _context [Object] the Liquid context
+        # @return [String] the rendered video
+        #
+        def render(_context)
+          return if key.blank?
+
+          content_tag(:iframe, "", video_attributes)
+        end
+
+        protected
+
+        attr_reader :attributes, :key
+
+        def video_attributes
+          {
+            id: attributes.fetch(:id, nil),
+            class: attributes.fetch(:class, nil),
+            style: attributes.fetch(:style, nil),
+            src: video_url,
+            width: video_width,
+            height: video_height,
+            frameborder: attributes.fetch(:frameborder, 0),
+            allowtransparency: attributes.fetch(:allowtransparency, "true"),
+            allowFullScreen:
+              attributes.fetch(:allowfullscreen, "allowFullScreen")
+          }
+        end
+
+        def video_url
+          [
+            "https://www.youtube.com/embed/#{key}",
+            video_url_params
+          ].join("?")
+        end
+
+        def video_url_params
+          {
+            ecver: 1,
+            autohide: 2,
+            color: attributes.fetch(:color, "red"),
+            autoplay: attributes.fetch(:autoplay, 0),
+            cc_load_policy: attributes.fetch(:captions, 0),
+            iv_load_policy: attributes.fetch(:annotations, 0),
+            loop: attributes.fetch(:loop, 0),
+            showinfo: attributes.fetch(:showinfo, 1),
+            start: attributes.fetch(:start, nil),
+            end: attributes.fetch(:end, nil),
+            width: video_width,
+            height: video_height
+          }.compact.reject { |_, value| value.blank? }.to_query
+        end
+
+        def video_width
+          attributes.fetch(:width, 640)
+        end
+
+        def video_height
+          attributes.fetch(:height, 360)
+        end
+      end
+    end
+  end
+end
+
+::Liquid::Template.register_tag("youtube", Archangel::Liquid::Tags::YoutubeTag)

data/lib/archangel/liquid_view.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Archangel
+  ##
+  # Liquid view renderer
+  #
+  class LiquidView
+    ##
+    # Liquid view
+    #
+    # @param view [String] the view
+    #
+    def initialize(view)
+      @view = view
+    end
+
+    ##
+    # Render Liquid content
+    #
+    # @param template [String] the content
+    # @return [String] the rendered content
+    #
+    def self.call(template)
+      "Archangel::LiquidView.new(self).render(
+        #{template.source.inspect}, local_assigns)"
+    end
+
+    ##
+    # Render Liquid content
+    #
+    # @param template [String] the content
+    # @param local_assigns [Hash] the local assigned variables
+    # @return [String] the rendered content
+    #
+    def render(template, local_assigns = {})
+      @view.controller.headers["Content-Type"] ||= "text/html; charset=utf-8"
+
+      assigns = default_assigns(local_assigns)
+      options = { filters: default_filters, registers: default_registers }
+
+      Archangel::RenderService.call(template, assigns, options)
+    end
+
+    protected
+
+    def default_assigns(local_assigns)
+      assigns = @view.assigns
+
+      if @view.content_for?(:layout)
+        assigns["content_for_layout"] = @view.content_for(:layout)
+      end
+
+      assigns.merge(local_assigns.stringify_keys)
+    end
+
+    def default_controller
+      @view.controller
+    end
+
+    def default_filters
+      extra_filters = []
+
+      controller_class = default_controller.class
+
+      if controller_class.respond_to?(:liquid_filters)
+        controller_class.liquid_filters.each do |method|
+          extra_filters.merge! default_controller.send(method)
+        end
+      end
+
+      extra_filters
+    end
+
+    def default_registers
+      extra_registers = {}
+
+      controller_class = default_controller.class
+
+      if controller_class.respond_to?(:liquid_registers)
+        controller_class.liquid_registers.each do |method|
+          extra_registers.merge! default_controller.send(method)
+        end
+      end
+
+      {
+        view: @view,
+        controller: default_controller,
+        helper: ActionController::Base.helpers
+      }.merge extra_registers
+    end
+  end
+end

data/lib/archangel/testing_support/context/view_controller_context.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Archangel
+  module TestingSupport
+    ##
+    # View Controller testing support
+    #
+    module ViewControllerContext
+      extend ActiveSupport::Concern
+
+      def setup_view_and_controller
+        @view                 = ActionView::Base.new
+        @controller           = ActionController::Base.new
+        @request              = ActionDispatch::TestRequest.new(
+          "PATH_INFO" => "/"
+        )
+        @response             = ActionDispatch::TestResponse.new
+
+        @response.request     = @request
+        @controller.request   = @request
+        @controller.response  = @response
+        @controller.params    = {}
+
+        @view.assign_controller(@controller)
+        @view.class.send(:include, @controller._helpers)
+        @view.class.send(:include, ::Rails.application.routes.url_helpers)
+      end
+
+      def view
+        @view
+      end
+
+      def controller
+        @controller
+      end
+
+      def context(assigns = {})
+        options = {
+          helper: @view,
+          view: @view,
+          controller: @controller
+        }
+
+        @context ||= ::Liquid::Context.new(assigns, {}, options)
+      end
+
+      def expect_template_result(template, expected, assigns = {})
+        assigns.each { |key, value| context[key] = value }
+
+        actual = ::Liquid::Template.parse(template).render!(context)
+        expect(actual.to_s.strip).to eq(expected.to_s.strip)
+      end
+    end
+  end
+end

data/lib/archangel/testing_support/factories/archangel_assets.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :asset, class: "Archangel::Asset" do
+    site
+    sequence(:file_name) { |n| "image-#{n}.jpg" }
+    file { fixture_file_upload(uploader_test_image) }
+    content_type "image/jpg"
+    file_size 123
+
+    trait :stylesheet do
+      file { fixture_file_upload(uploader_test_stylesheet) }
+      content_type "text/css"
+    end
+
+    trait :deleted do
+      deleted_at { Time.current }
+    end
+  end
+end

data/lib/archangel/testing_support/factories/archangel_collections.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :collection, class: "Archangel::Collection" do
+    site
+    sequence(:name) { |n| "Collection #{n}" }
+    sequence(:slug) { |n| "collection-#{n}" }
+
+    trait :deleted do
+      deleted_at { Time.current }
+    end
+
+    trait :with_fields do
+      transient do
+        fields_count 3
+      end
+
+      after(:create) do |collection, evaluator|
+        create_list(:field, evaluator.fields_count, collection: collection)
+      end
+    end
+  end
+end

data/lib/archangel/testing_support/factories/archangel_entries.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :entry, class: "Archangel::Entry" do
+    collection
+    value { ActiveSupport::JSON.encode(title: "Title", content: "Content") }
+    available_at { Time.current }
+
+    trait :deleted do
+      deleted_at { Time.current }
+    end
+
+    trait :unavailable do
+      deleted_at nil
+    end
+  end
+end

data/lib/archangel/testing_support/factories/archangel_fields.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :field, class: "Archangel::Field" do
+    collection
+    sequence(:label) { |n| "Field #{n} Label" }
+    sequence(:slug) { |n| "field-#{n}" }
+    value "Field default value"
+    classification "string"
+    required false
+
+    trait :required do
+      required true
+    end
+
+    trait :deleted do
+      deleted_at { Time.current }
+    end
+  end
+end

data/lib/archangel/testing_support/factories/archangel_pages.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :page, class: "Archangel::Page" do
+    site
+    template nil
+    sequence(:title) { |n| "Page #{n} Title" }
+    sequence(:slug) { |n| "page-#{n}" }
+    content "<p>Content of the page</p>"
+    meta_keywords "default,keywords,of,my,page"
+    meta_description "Default description of my page"
+    homepage false
+    published_at { Time.current }
+
+    trait :with_parent do
+      association :parent, factory: :page
+    end
+
+    trait :with_template do
+      association :template, factory: :template, partial: false
+    end
+
+    trait :homepage do
+      homepage true
+    end
+
+    trait :unpublished do
+      published_at nil
+    end
+
+    trait :future do
+      published_at { 1.week.from_now }
+    end
+
+    trait :deleted do
+      deleted_at { Time.current }
+    end
+  end
+end

data/lib/archangel/testing_support/factories/archangel_sites.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :site, class: "Archangel::Site" do
+    sequence(:name) { |n| "Site #{n} Name" }
+    locale "en"
+    meta_keywords "default,keywords,of,my,site"
+    meta_description "Default description of my site"
+
+    trait :logo do
+      logo { fixture_file_upload(uploader_test_image) }
+    end
+
+    trait :favicon do
+      favicon { fixture_file_upload(uploader_test_favicon) }
+    end
+
+    trait :deleted do
+      deleted_at { Time.current }
+    end
+  end
+end

data/lib/archangel/testing_support/factories/archangel_templates.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :template, class: "Archangel::Template" do
+    site
+    sequence(:name) { |n| "Template #{n} Name" }
+    content <<-CONTENT
+      <p>BEFORE TEMPLATE<p>
+      <p>{{ content_for_layout }}<p>
+      <p>AFTER TEMPLATE<p>
+    CONTENT
+    partial false
+
+    trait :partial do
+      partial true
+    end
+
+    trait :deleted do
+      deleted_at { Time.current }
+    end
+  end
+end

data/lib/archangel/testing_support/factories/archangel_users.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :user, class: "Archangel::User" do
+    site
+    sequence(:name) { |n| "User #{n}" }
+    sequence(:username) { |n| "username#{n}" }
+    sequence(:email) { |n| "user#{n}@example.com" }
+    password "password"
+    sequence(:confirmation_token) { |n| "token-#{n}" }
+    confirmed_at { Time.current }
+    confirmation_sent_at { Time.current }
+
+    trait :avatar do
+      avatar { fixture_file_upload(uploader_test_image) }
+    end
+
+    trait :admin do
+      role "admin"
+    end
+
+    trait :editor do
+      role "editor"
+    end
+
+    trait :unconfirmed do
+      confirmed_at nil
+    end
+
+    trait :reset do
+      reset_password_token "abc123"
+      reset_password_sent_at { Time.current }
+    end
+
+    trait :locked do
+      failed_attempts 10
+      unlock_token "123abc"
+      locked_at { Time.current }
+    end
+
+    trait :tracks do
+      sign_in_count 2
+      current_sign_in_at { Time.current }
+      last_sign_in_at { 1.day.ago }
+      current_sign_in_ip "127.0.0.1"
+      last_sign_in_ip "127.0.0.1"
+    end
+
+    trait :deleted do
+      deleted_at { Time.current }
+    end
+  end
+end

data/lib/archangel/testing_support/factories/archangel_widgets.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :widget, class: "Archangel::Widget" do
+    site
+    template nil
+    sequence(:name) { |n| "Widget #{n}" }
+    sequence(:slug) { |n| "widget-#{n}" }
+    content "<p>Content of the widget</p>"
+
+    trait :with_template do
+      association :template, factory: :template, partial: true
+    end
+
+    trait :deleted do
+      deleted_at { Time.current }
+    end
+  end
+end

data/lib/archangel/testing_support/fixtures/stylesheet.css

@@ -0,0 +1,3 @@
+body {
+  background-color: #fff;
+}

data/lib/archangel/testing_support/helpers/authorization_helpers.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Archangel
+  module TestingSupport
+    ##
+    # Authorization helpers for testing
+    #
+    module AuthorizationHelpers
+      ##
+      # Authorization helpers for controller testing
+      #
+      module Controller
+        def stub_authorization!(user = double("user"))
+          user.blank? ? stub_blank_authorization : stub_user_authorization(user)
+        end
+
+        private
+
+        def stub_blank_authorization
+          allow(request.env["warden"]).to(receive(:authenticate!))
+                                      .and_throw(:warden, scope: :user)
+          allow(controller).to receive(:current_user).and_return(nil)
+        end
+
+        def stub_user_authorization(user)
+          allow(request.env["warden"]).to(receive(:authenticate!))
+                                      .and_return(user)
+          allow(controller).to receive(:current_user).and_return(user)
+        end
+      end
+
+      ##
+      # Authorization helpers for feature testing
+      #
+      module Feature
+        include Warden::Test::Helpers
+
+        Warden.test_mode!
+
+        def stub_authorization!(user = nil)
+          user ||= create(:user)
+
+          login_as user, scope: :user
+
+          user
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Archangel::TestingSupport::AuthorizationHelpers::Controller,
+                 type: :controller
+
+  config.include Archangel::TestingSupport::AuthorizationHelpers::Feature,
+                 type: :feature
+end