integral 1.0.0

data/lib/generators/templates/sitemap.rb

@@ -0,0 +1,41 @@
+# :nocov:
+##
+# SitemapGenerator configuration
+#
+# To generate a sitemap run 'rake sitemap:refresh'
+#
+# Run this task at least once/day (depending on the size of the website) to keep sitemap up to date.
+# Heroku Scheduler or a cron job can be used to do this.
+#
+# https://github.com/kjvarga/sitemap_generator#sitemap-configuration
+# #
+
+# Set the host name for URL creation
+SitemapGenerator::Sitemap.default_host = Rails.application.routes.default_url_options[:host]
+
+# Best to compress (gzip) the sitemap, however some analytics tools require uncompressed
+# SitemapGenerator::Sitemap.compress = false
+
+# Remote sitemap storage config - Use this if you're running on a ephemeral filesystem (Heroku)
+# SitemapGenerator::Sitemap.sitemaps_host = "https://s3-#{ENV.fetch('AWS_REGION')}.amazonaws.com/#{ENV.fetch('AWS_S3_BUCKET_NAME')}/"
+# SitemapGenerator::Sitemap.public_path = 'tmp/'
+# SitemapGenerator::Sitemap.sitemaps_path = 'sitemaps/'
+# SitemapGenerator::Sitemap.adapter = SitemapGenerator::WaveAdapter.new
+
+SitemapGenerator::Sitemap.create do
+  # Add page paths, skip path of dynamic homepage
+  homepage = Integral::Page.find_by_id(Integral::Settings['homepage_id'])
+  Integral::Page.published.find_each do |page|
+    add page.path, lastmod: page.updated_at unless page == homepage
+  end
+
+  if Integral.blog_enabled?
+    integral = Integral::Engine.routes.url_helpers
+    add integral.posts_path
+    add integral.tags_path
+
+    Integral::Post.published.find_each do |object|
+      add integral.post_path(object), lastmod: object.updated_at
+    end
+  end
+end

data/lib/integral.rb

@@ -0,0 +1,155 @@
+require 'devise'
+require 'devise_invitable'
+
+require 'integral/version'
+require 'integral/router'
+require 'integral/middleware/page_router'
+require 'integral/engine'
+require 'integral/slack_bot'
+require 'integral/button_link_renderer'
+require 'integral/google_tag_manager'
+require 'integral/foundation_builder'
+require 'integral/grids/activities_grid'
+require 'integral/grids/pages_grid'
+require 'integral/grids/users_grid'
+require 'integral/grids/lists_grid'
+require 'integral/grids/posts_grid'
+require 'integral/grids/images_grid'
+require 'integral/acts_as_listable'
+require 'integral/widgets/recent_posts'
+require 'integral/widgets/swiper_list'
+require 'integral/content_renderer'
+require 'integral/list_renderer'
+require 'integral/swiper_list_renderer'
+require 'integral/list_item_renderer'
+require 'integral/partial_list_item_renderer'
+require 'integral/chart_renderer/base'
+require 'integral/chart_renderer/donut'
+require 'integral/chart_renderer/line'
+
+# Integral
+module Integral
+  # Enables engine configuration
+  def self.configure
+    yield(self)
+  end
+
+  #
+  mattr_accessor :backend_namespace
+  @@backend_namespace = 'admin'
+
+  #
+  mattr_accessor :backend_locales
+  @@backend_locales = [:en]
+
+  #
+  mattr_accessor :additional_settings_params
+  @@additional_settings_params = []
+
+  #
+  mattr_accessor :additional_widgets
+  @@additional_widgets = []
+
+  #
+  mattr_accessor :additional_post_params
+  @@additional_post_params = []
+
+  #
+  mattr_accessor :additional_page_params
+  @@additional_page_params = []
+
+  #
+  mattr_accessor :gtm_container_id
+  @@gtm_container_id = ''
+
+  #
+  mattr_accessor :blog_enabled
+  @@blog_enabled = true
+
+  #
+  mattr_accessor :blog_namespace
+  @@blog_namespace = 'blog'
+
+  #
+  mattr_accessor :black_listed_paths
+  @@black_listed_paths = ['/admin']
+
+  #
+  mattr_accessor :root_path
+  @@root_path = nil
+
+  #
+  mattr_accessor :frontend_parent_controller
+  @@frontend_parent_controller = 'Integral::ApplicationController'
+
+  #
+  mattr_accessor :editor_image_size_limit
+  @@editor_image_size_limit = [1600, 1600]
+
+  #
+  mattr_accessor :image_thumbnail_size
+  @@image_thumbnail_size = [50, 50]
+
+  #
+  mattr_accessor :image_small_size
+  @@image_small_size = [500, 500]
+
+  #
+  mattr_accessor :image_medium_size
+  @@image_medium_size = [800, 800]
+
+  #
+  mattr_accessor :image_large_size
+  @@image_large_size = [1600, 1600]
+
+  #
+  mattr_accessor :additional_page_templates
+  @@additional_page_templates = []
+
+  #
+  mattr_accessor :compression_enabled
+  @@compression_enabled = true
+
+  #
+  mattr_accessor :image_compression_quality
+  @@image_compression_quality = 85
+
+  #
+  mattr_accessor :editable_persisted_images
+  @@editable_persisted_images = false
+
+  #
+  mattr_accessor :slack_web_hook_url
+  @@slack_web_hook_url = nil
+
+  #
+  mattr_accessor :description_length_maximum
+  @@description_length_maximum = 300
+
+  #
+  mattr_accessor :description_length_minimum
+  @@description_length_minimum = 50
+
+  #
+  mattr_accessor :title_length_maximum
+  @@title_length_maximum = 60
+
+  #
+  mattr_accessor :title_length_minimum
+  @@title_length_minimum = 4
+
+  # @return [Boolean] Shortcut to find out if blog is enabled
+  def self.blog_enabled?
+    Integral.blog_enabled == true
+  end
+
+  # @return [Boolean] Compression status
+  def self.compression_enabled?
+    Integral.compression_enabled == true
+  end
+
+  # @return [Boolean] Enables Dynamic Routing of the homepage using Integral::Middleware::Router
+  def self.dynamic_homepage_enabled?
+    Integral.root_path.nil?
+  end
+end

data/lib/integral/acts_as_listable.rb

@@ -0,0 +1,45 @@
+module Integral
+  # Handles listable behaviour
+  module ActsAsListable
+    class << self
+       # Keeps a track of listable objects
+       attr_writer :objects
+     end
+
+    # Accessor for listable objects
+    def self.objects
+      @objects ||= []
+    end
+
+    ActiveSupport.on_load(:active_record) do
+      # ActiveRecord::Base extension
+      class ActiveRecord::Base
+        # Adds listable behaviour to objects
+        def self.acts_as_listable(_options = {})
+          Integral::ActsAsListable.objects << self
+
+          # @return [Hash] instance as a list item
+          # Keys include: id, title, subtitle, image, description, url
+          def to_list_item
+            raise NotImplementedError
+          end
+
+          # @return [Hash] listable options to be used within a RecordSelector widget.
+          # Expects the following keys: record_title, selector_path, selector_title
+          # TODO: Move these options into acts_as_listable initializer
+          def self.listable_options
+            raise NotImplementedError
+          end
+
+          before_save :touch_list_items
+
+          # Touch all list items the instance is associated with
+          def touch_list_items
+            list_items = Integral::ListItem.where(type: 'Integral::Object', object_id: id, object_type: self.class.to_s)
+            list_items.find_each(&:touch)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/integral/button_link_renderer.rb

@@ -0,0 +1,54 @@
+module Integral
+  # Foundation pagination with buttons
+  class ButtonLinkRenderer < WillPaginate::ViewHelpers::LinkRenderer
+    # The URL or page
+    def url(page)
+      page
+    end
+
+    # Link item
+    def link(text, target, attributes = {})
+      attributes['data-page'] = target if target.is_a?(Integer)
+      tag(:button, text, attributes)
+    end
+
+    # Pagination container
+    def to_html
+      list_items = pagination.map do |item|
+        item.is_a?(Integer) ? page_number(item) : send(item)
+      end.join(@options[:link_separator])
+
+      tag(:ul, list_items, class: "pagination #{@options[:class]}")
+    end
+
+    # Container attributes
+    def container_attributes
+      super.except(:link_options)
+    end
+
+    protected
+
+    def page_number(page)
+      link_options = @options[:link_options] || {}
+
+      if page == current_page
+        tag :li, tag(:span, page), class: 'current'
+      else
+        tag :li, link(page, page, link_options.merge(rel: rel_value(page)))
+      end
+    end
+
+    def previous_or_next_page(page, text, classname)
+      link_options = @options[:link_options] || {}
+      if page
+        tag :li, link(text, page, link_options), class: classname
+      else
+        tag :li, tag(:span, text), class: format('%s disabled', classname)
+      end
+    end
+
+    # def gap
+    #   tag :li, '', class: 'ellipsis'
+    # end
+  end
+end

data/lib/integral/chart_renderer/base.rb

@@ -0,0 +1,80 @@
+module Integral
+  # Renders chart markup to be used with ChartJS
+  # http://www.chartjs.org/
+  #
+  # TODO: How to handle caching?
+  module ChartRenderer
+    # Base class which all Charts should inherit from
+    class Base
+      # Render chart markup
+      def self.render(dataset, options = {})
+        renderer = new(dataset, options)
+        renderer.render
+      end
+
+      # @param [Hash] dataset
+      # @param [Hash] options
+      def initialize(dataset, options = {})
+        @dataset = dataset
+        @options = options
+      end
+
+      # Render chart markup
+      def render
+        data = process_data
+
+        return respond_with_chart(data) if data_available?(data)
+        respond_with_no_data_available
+      end
+
+      private
+
+      # @return [String] Markup which frontend uses to build a graph
+      def respond_with_chart(_data)
+        raise NotImplementedError
+      end
+
+      # Process data values from provided dataset to be converted into graph markup
+      def process_data
+        raise NotImplementedError
+      end
+
+      # Controller used to render partials
+      def controller
+        ApplicationController
+      end
+
+      # Renders a given partial
+      #
+      # @param [String] path partial path to render
+      # @param [Hash] locals optional hash of variables to pass to partial
+      #
+      # @return [String] Markup which frontend uses to build a graph
+      def render_partial(path, locals = {})
+        controller.render(partial: "integral/backend/shared/graphs/#{path}",
+                          locals: locals,
+                          layout: false)
+      end
+
+      # @return [Boolean] whether or not any data is present
+      def data_available?(data)
+        return false if data.empty?
+
+        if data.first.is_a?(Array)
+          data = data.map(&:uniq).uniq
+
+          return true if data.length > 1
+          data = data.first
+        end
+
+        data = data.uniq
+        !(data.length == 1 && data.first.zero?)
+      end
+
+      # @return [String] Markup which informs users of no available data to build graph
+      def respond_with_no_data_available
+        render_partial('no_data_available')
+      end
+    end
+  end
+end

data/lib/integral/chart_renderer/donut.rb

@@ -0,0 +1,21 @@
+module Integral
+  module ChartRenderer
+    # http://www.chartjs.org/samples/latest/charts/doughnut.html
+    class Donut < Base
+      private
+
+      def respond_with_chart(data)
+        locals = {
+          data: data,
+          dataset: @dataset
+        }
+        render_partial('donut', locals)
+      end
+
+      # Line will fail if no 'period' option is supplied throw wrong argument error or w.e
+      def process_data
+        @dataset.map { |item| item[:scope].count }
+      end
+    end
+  end
+end

data/lib/integral/chart_renderer/line.rb

@@ -0,0 +1,24 @@
+module Integral
+  module ChartRenderer
+    # http://www.chartjs.org/samples/latest/charts/line.html
+    class Line < Base
+      private
+
+      def respond_with_chart(data)
+        labels = (1..7).collect { |i| (Date.today - i.day).strftime('%a') }.join(',')
+        locals = {
+          data: data,
+          dataset: @dataset,
+          labels: labels
+        }
+        render_partial('line', locals)
+      end
+
+      # Line will fail if no 'period' option is supplied throw wrong argument error or w.e
+      def process_data
+        raw_data = @dataset.map { |item| item[:scope].group_by_day(:created_at, last: 7, current: false).count }
+        raw_data.map(&:values)
+      end
+    end
+  end
+end

data/lib/integral/content_renderer.rb

@@ -0,0 +1,78 @@
+module Integral
+  # Handles the rendering of dynamic content (Widgets) within static HTML
+  # A widget could be used to list recent articles from the blog, featured content from a list, etc
+  #
+  # Example Widget Markup
+  # <p class='integral-widget' data-widget-type='recent_posts' data-widget-value-tagged='awesome-tag'>
+  class ContentRenderer
+    # Markup defining a widget
+    PLACEHOLDER_SELECTOR = 'p.integral-widget'.freeze
+
+    # @return [Array] available widgets used to render dynamic content
+    def self.widgets
+      widgets = [
+        ['recent_posts', 'Integral::Widgets::RecentPosts'],
+        ['swiper_list', 'Integral::Widgets::SwiperList']
+      ]
+
+      widgets.concat Integral.additional_widgets
+    end
+
+    # Renders WYSIWYG html, converting any widget placeholders to dynamic content
+    #
+    # @param raw_html [String]
+    #
+    # @return [String] Parsed content
+    def self.render(raw_html)
+      html = Nokogiri::HTML(raw_html)
+      html.css(self::PLACEHOLDER_SELECTOR).each do |placeholder|
+        widget_type = placeholder.attributes['data-widget-type']&.value
+
+        placeholder.replace(render_widget(widget_type, widget_options(placeholder.attributes)))
+      end
+
+      html.css('body').inner_html.html_safe
+    end
+
+    # Parse placeholder attributes to find any widget options
+    #
+    # @param placeholder_attributes [Hash] raw placeholder attributes
+    #
+    # @return [Hash] widget options
+    def self.widget_options(placeholder_attributes)
+      options = {}
+      keys = placeholder_attributes.keys.select { |key| key.starts_with?('data-widget-value-') }
+
+      keys.each { |key| options[key.remove('data-widget-value-').to_sym] = placeholder_attributes[key].value }
+      options
+    end
+
+    # Renders a specific widget using the provided options
+    #
+    # @param type [String] Type of widget to render
+    # @param options [Hash] Widget options to use when rendering
+    #
+    # @return [String] widget content
+    def self.render_widget(type, options)
+      widget = widgets.find { |w| w[0] == type }
+
+      return widget_not_available_message unless widget.present?
+
+      widget[1].constantize.render(options)
+    rescue StandardError => error
+      respond_with_widget_error(error)
+    end
+
+    # Handles widget errors
+    def self.respond_with_widget_error(error)
+      Rails.logger.error(error.message)
+
+      '<!-- Error rendering widget -->'
+    end
+
+    # @return [String] Widget not available message
+    def self.widget_not_available_message
+      '<!-- Widget not available -->'
+    end
+  end
+end