threddedDANIEL 0.14.5

data/lib/thredded/base_migration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Thredded
+  class BaseMigration < (Thredded.rails_gte_51? ? ActiveRecord::Migration[5.1] : ActiveRecord::Migration)
+    def user_id_type
+      Thredded.user_class.columns.find { |c| c.name == Thredded.user_class.primary_key }.sql_type
+    end
+
+    def column_type(table, column_name)
+      column_name = column_name.to_s
+      columns(table).find { |c| c.name == column_name }.sql_type
+    end
+  end
+end

data/lib/thredded/base_notifier.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Thredded
+  class BaseNotifier
+    def self.validate_notifier(notifier)
+      unless notifier.respond_to?(:key) && /^[a-z_]+$/.match(notifier.key)
+        fail "Notifier problem: #{notifier.class.name} must respond to #key with a snake_case string"
+      end
+      %i[human_name new_post new_private_post].each do |m|
+        unless notifier.respond_to?(m)
+          fail "#{notifier.class.name} must respond to ##{m}"
+        end
+      end
+    end
+
+    class NotificationsDefault
+      def initialize(enabled)
+        @enabled = enabled
+      end
+
+      attr_reader :enabled
+
+      def enabled?
+        enabled
+      end
+    end
+  end
+end

data/lib/thredded/collection_to_strings_with_cache_renderer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'action_view/renderer/abstract_renderer'
+
+module Thredded
+  class CollectionToStringsWithCacheRenderer < ActionView::AbstractRenderer
+    # The default number of threads to use for rendering.
+    mattr_accessor :render_threads
+    self.render_threads = 50
+
+    # @param view_context
+    # @param [Array<T>] collection
+    # @param [String] partial
+    # @param [ActiveSupport::Duration] expires_in
+    # @param [Integer] render_threads the number of threads to use for rendering. This is useful even on MRI ruby
+    #   for IO-bound operations.
+    # @param [Hash] locals
+    # @return Array<[T, String]>
+    def render_collection_to_strings_with_cache( # rubocop:disable Metrics/ParameterLists
+      view_context, collection:, partial:, expires_in:, render_threads: self.class.render_threads, locals: {}, **opts
+    )
+      template = @lookup_context.find_template(partial, [], true, locals, {})
+      collection = collection.to_a
+      instrument(:collection, count: collection.size) do |instrumentation_payload|
+        return [] if collection.blank?
+        keyed_collection = collection.each_with_object({}) do |item, hash|
+          key = ActiveSupport::Cache.expand_cache_key(
+            view_context.cache_fragment_name(item, virtual_path: template.virtual_path), :views
+          )
+          # #read_multi & #write may require key mutability, Dalli 2.6.0.
+          hash[key.frozen? ? key.dup : key] = item
+        end
+        cache = collection_cache
+        cached_partials = cache.read_multi(*keyed_collection.keys)
+        instrumentation_payload[:cache_hits] = cached_partials.size if instrumentation_payload
+
+        collection_to_render = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
+        rendered_partials = render_partials(
+          view_context,
+          collection: collection_to_render, render_threads: render_threads,
+          partial: partial, locals: locals, **opts
+        ).each
+
+        keyed_collection.map do |cache_key, item|
+          [item, cached_partials[cache_key] || rendered_partials.next.tap do |rendered|
+            cache.write(cache_key, rendered, expires_in: expires_in)
+          end]
+        end
+      end
+    end
+
+    private
+
+    def collection_cache
+      if ActionView::PartialRenderer.respond_to?(:collection_cache)
+        # Rails 5.0+
+        ActionView::PartialRenderer.collection_cache
+      else
+        # Rails 4.2.x
+        Rails.application.config.action_controller.cache_store
+      end
+    end
+
+    # @return [Array<String>]
+    def render_partials(view_context, collection:, render_threads:, **opts)
+      return [] if collection.empty?
+      num_threads = [render_threads, collection.size].min
+      if num_threads == 1
+        render_partials_serial(view_context, collection, opts)
+      else
+        collection.each_slice(collection.size / num_threads).map do |slice|
+          Thread.start { render_partials_serial(view_context.dup, slice, opts) }
+        end.flat_map(&:value)
+      end
+    end
+
+    # @param [Array<Object>] collection
+    # @param [Hash] opts
+    # @param view_context
+    # @return [Array<String>]
+    def render_partials_serial(view_context, collection, opts)
+      partial_renderer = ActionView::PartialRenderer.new(@lookup_context)
+      collection.map { |object| partial_renderer.render(view_context, opts.merge(object: object), nil) }
+    end
+  end
+end

data/lib/thredded/content_formatter.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Thredded
+  # Generates HTML from content source.
+  class ContentFormatter
+    # Sanitization whitelist options.
+    mattr_accessor :whitelist
+
+    self.whitelist = HTML::Pipeline::SanitizationFilter::WHITELIST.deep_merge(
+      elements: HTML::Pipeline::SanitizationFilter::WHITELIST[:elements] + %w[abbr iframe span figure figcaption],
+      transformers: HTML::Pipeline::SanitizationFilter::WHITELIST[:transformers] + [
+        lambda do |env|
+          next unless env[:node_name] == 'a'
+          a_tag = env[:node]
+          a_tag['href'] ||= '#'
+          if a_tag['href'] =~ %r{^(?:[a-z]+:)?//}
+            a_tag['target'] = '_blank'
+            a_tag['rel']    = 'nofollow noopener'
+          end
+        end
+      ],
+      attributes: {
+        'a'      => %w[href rel],
+        'abbr'   => %w[title],
+        'span'   => %w[class],
+        'div'    => %w[class],
+        :all     => HTML::Pipeline::SanitizationFilter::WHITELIST[:attributes][:all] +
+          %w[aria-label aria-labelledby aria-hidden],
+      }
+    )
+
+    # Filters that run before processing the markup.
+    # input: markup, output: markup.
+    mattr_accessor :before_markup_filters
+    self.before_markup_filters = [
+    ]
+
+    # Markup filters, such as BBCode, Markdown, Autolink, etc.
+    # input: markup, output: html.
+    mattr_accessor :markup_filters
+    self.markup_filters = [
+      Thredded::HtmlPipeline::KramdownFilter,
+    ]
+
+    # Filters that run after processing the markup.
+    # input: html, output: html.
+    mattr_accessor :after_markup_filters
+    self.after_markup_filters = [
+      # AutolinkFilter is required because Kramdown does not autolink by default.
+      # https://github.com/gettalong/kramdown/issues/306
+      Thredded::HtmlPipeline::AutolinkFilter,
+      HTML::Pipeline::EmojiFilter,
+      Thredded::HtmlPipeline::AtMentionFilter,
+    ]
+
+    # Filters that sanitize the resulting HTML.
+    # input: html, output: sanitized html.
+    mattr_accessor :sanitization_filters
+    self.sanitization_filters = [
+      HTML::Pipeline::SanitizationFilter,
+    ]
+
+    # Filters that run after sanitization
+    # input: sanitized html, output: html
+    mattr_accessor :after_sanitization_filters
+    self.after_sanitization_filters = [
+      Thredded::HtmlPipeline::OneboxFilter,
+      Thredded::HtmlPipeline::WrapIframesFilter,
+    ]
+
+    # All the HTML::Pipeline filters, read-only.
+    def self.pipeline_filters
+      filters = [
+        *before_markup_filters,
+        *markup_filters,
+        *after_markup_filters,
+        *sanitization_filters,
+        *after_sanitization_filters
+      ]
+      # Changing the result in-place has no effect on the ContentFormatter output,
+      # and is most likely the result of a programmer error.
+      # Freeze the array so that in-place changes raise an error.
+      filters.freeze
+    end
+
+    # @param view_context [Object] the context of the rendering view.
+    # @param pipeline_options [Hash]
+    def initialize(view_context, pipeline_options = {})
+      @view_context = view_context
+      @pipeline_options = pipeline_options
+    end
+
+    # @param content [String]
+    # @return [String] formatted and sanitized html-safe content.
+    def format_content(content)
+      pipeline = HTML::Pipeline.new(content_pipeline_filters, content_pipeline_options.deep_merge(@pipeline_options))
+      result = pipeline.call(content, view_context: @view_context)
+      # rubocop:disable Rails/OutputSafety
+      result[:output].to_s.html_safe
+      # rubocop:enable Rails/OutputSafety
+    end
+
+    # @param content [String]
+    # @return [String] a quote containing the formatted content
+    def self.quote_content(content)
+      result = String.new(content)
+      result.gsub!(/^(?!$)/, '> ')
+      result.gsub!(/^$/, '>')
+      result << "\n" unless result.end_with?("\n")
+      result << "\n"
+      result
+    end
+
+    protected
+
+    # @return [Array<HTML::Pipeline::Filter]>]
+    def content_pipeline_filters
+      ContentFormatter.pipeline_filters
+    end
+
+    # @return [Hash] options for HTML::Pipeline.new
+    def content_pipeline_options
+      {
+        asset_root: Rails.application.config.action_controller.asset_host || '',
+        whitelist: ContentFormatter.whitelist
+      }
+    end
+  end
+end

data/lib/thredded/database_seeder.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require 'factory_bot_rails'
+require_relative '../../spec/support/features/fake_content'
+
+# rubocop:disable HandleExceptions
+begin
+  if FactoryBot.factories.instance_variable_get(:@items).none?
+    require_relative '../../spec/factories'
+  end
+rescue NameError
+end
+# rubocop:enable HandleExceptions
+module Thredded
+  class DatabaseSeeder
+    SKIP_CALLBACKS = [
+      [Thredded::Post, :commit, :after, :auto_follow_and_notify],
+      [Thredded::PrivatePost, :commit, :after, :notify_users],
+    ].freeze
+
+    def self.run(users: 200, topics: 55, posts: (1..60))
+      STDERR.puts 'Seeding the database...'
+      # Disable callbacks to avoid creating notifications and performing unnecessary updates
+      SKIP_CALLBACKS.each { |(klass, *args)| klass.skip_callback(*args) }
+      s = new
+      Messageboard.transaction do
+        s.seed(users: users, topics: topics, posts: posts)
+        s.log 'Running after_commit callbacks'
+      end
+    ensure
+      # Re-enable callbacks
+      SKIP_CALLBACKS.each { |(klass, *args)| klass.set_callback(*args) }
+    end
+
+    def seed(users: 200, topics: 55, posts: (1..60))
+      users(count: users)
+      first_messageboard
+      topics(count: topics)
+      private_topics(count: topics)
+      posts(count: posts)
+      private_posts(count: posts)
+      create_additional_messageboards
+      follow_some_topics
+      read_some_topics
+    end
+
+    def log(message)
+      STDERR.puts "- #{message}"
+    end
+
+    def first_user
+      @first_user ||= FirstUser.new(self).find_or_create
+    end
+
+    def users(count: 1)
+      @users ||= Users.new(self).find_or_create(count: count)
+    end
+
+    def first_messageboard
+      @first_messageboard ||= FirstMessageboard.new(self).find_or_create
+    end
+
+    def create_additional_messageboards
+      meta_group_id = MessageboardGroup.create!(name: 'Meta').id
+      additional_messageboards = [
+        ['Off-Topic', "Talk about whatever here, it's all good."],
+        ['Help, Bugs, and Suggestions',
+         'Need help using the forum? Want to report a bug or make a suggestion? This is the place.', meta_group_id],
+        ['Praise', 'Want to tell us how great we are? This is the place.', meta_group_id]
+      ]
+      log "Creating #{additional_messageboards.length} additional messageboards..."
+      additional_messageboards.each do |(name, description, group_id)|
+        messageboard = Messageboard.create!(name: name, description: description, messageboard_group_id: group_id)
+        FactoryBot.create_list(:topic, 1 + rand(3), messageboard: messageboard, with_posts: 1)
+      end
+    end
+
+    def topics(count: 1)
+      @topics ||= Topics.new(self).find_or_create(count: count)
+    end
+
+    def private_topics(count: 1)
+      @private_topics ||= PrivateTopics.new(self).find_or_create(count: count)
+    end
+
+    def posts(count: (1..1))
+      @posts ||= Posts.new(self).find_or_create(count: count)
+    end
+
+    def private_posts(count: (1..1))
+      @private_posts ||= PrivatePosts.new(self).find_or_create(count: count)
+    end
+
+    def follow_some_topics(count: (5..10), count_users: (1..5))
+      log 'Following some topics...'
+      posts.each do |post|
+        Thredded::UserTopicFollow.create_unless_exists(post.user_id, post.postable_id, :posted) if post.user_id
+      end
+      follow_some_topics_by_user(first_user, count: count)
+      users.sample(count_users.min + rand(count_users.max - count_users.min + 2)).each do |user|
+        follow_some_topics_by_user(user, count: count)
+      end
+    end
+
+    def follow_some_topics_by_user(user, count: (1..10))
+      topics.sample(count.min + rand(count.max - count.min + 2)).each do |topic|
+        Thredded::UserTopicFollow.create_unless_exists(user.id, topic.id)
+      end
+    end
+
+    def read_some_topics(count: (5..10), count_users: (1..5))
+      log 'Reading some topics...'
+      topics.each do |topic|
+        read_topic(topic, topic.last_user_id) if topic.last_user_id
+      end
+      read_some_topics_by_user(first_user, count: count)
+      @users.sample(count_users.min + rand(count_users.max - count_users.min + 2)).each do |user|
+        read_some_topics_by_user(user, count: count)
+      end
+    end
+
+    def read_some_topics_by_user(user, count: (1..10))
+      topics.sample(count.min + rand(count.max - count.min + 2)).each do |topic|
+        read_topic(topic, user.id)
+      end
+    end
+
+    def read_topic(topic, user_id)
+      Thredded::UserTopicReadState.find_or_initialize_by(user_id: user_id, postable_id: topic.id)
+        .update!(read_at: topic.updated_at, page: 1)
+    end
+
+    class BaseSeedData
+      attr_reader :seeder
+
+      def initialize(seed_database = DatabaseSeeder.new)
+        @seeder = seed_database
+      end
+
+      # Utility method
+      def self.create(*args)
+        new.create(*args)
+      end
+
+      delegate :log, to: :seeder
+
+      def find_or_create(*args)
+        return @stored if @stored
+        @stored = (find || create(*args))
+      end
+
+      protected
+
+      def model_class
+        self.class::MODEL_CLASS
+      end
+
+      # @abstract
+      def create(*_args)
+        fail 'Unimplemented'
+      end
+
+      # @abstract
+      def find
+        fail 'Unimplemented'
+      end
+    end
+
+    class FirstSeedData < BaseSeedData
+      def find
+        model_class.first
+      end
+    end
+
+    class CollectionSeedData < BaseSeedData
+      def find
+        return nil unless model_class.exists?
+        model_class.all.to_a
+      end
+    end
+
+    class FirstUser < FirstSeedData
+      MODEL_CLASS = User
+
+      def create
+        log 'Creating first user...'
+        FactoryBot.create(:user, :approved, :admin, name: 'Joe', email: 'joe@example.com')
+      end
+    end
+
+    # Thredded::DatabaseSeeder::Users.create(count:200)
+    class Users < CollectionSeedData
+      MODEL_CLASS = User
+
+      def create(count: 1)
+        log "Creating #{count} users..."
+        approved_users_count = (count * 0.97).round
+        [seeder.first_user] +
+          FactoryBot.create_list(:user, approved_users_count, :approved) +
+          FactoryBot.create_list(:user, count - approved_users_count)
+      end
+    end
+
+    class FirstMessageboard < FirstSeedData
+      MODEL_CLASS = Messageboard
+
+      def create
+        log 'Creating a messageboard...'
+        @first_messageboard = FactoryBot.create(
+          :messageboard,
+          name: 'Main Board',
+          slug: 'main-board',
+          description: 'A board is not a board without some posts'
+        )
+      end
+    end
+
+    class Topics < CollectionSeedData
+      MODEL_CLASS = Topic
+
+      def create(count: 1, messageboard: seeder.first_messageboard)
+        log "Creating #{count} topics in #{messageboard.name}..."
+        FactoryBot.create_list(
+          :topic, count,
+          messageboard: messageboard,
+          user: seeder.users.sample,
+          last_user: seeder.users.sample
+        )
+      end
+    end
+
+    class PrivateTopics < CollectionSeedData
+      MODEL_CLASS = PrivateTopic
+
+      def create(count: 1)
+        Array.new(count) do
+          FactoryBot.create(
+            :private_topic,
+            user: seeder.users[1..-1].sample,
+            last_user: seeder.users.sample,
+            users: [seeder.first_user, *seeder.users.sample(1 + rand(3))]
+          )
+        end
+      end
+    end
+
+    class Posts < CollectionSeedData
+      MODEL_CLASS = Post
+
+      def create(count: (1..1))
+        log "Creating #{count} additional posts in each topic..."
+        seeder.topics.flat_map do |topic|
+          last_post_at = random_duration(0..72.hours).ago
+          posts_count = (count.min + rand(count.max + 1))
+          posts = range_of_dates_in_order(up_to: last_post_at, count: posts_count).map.with_index do |written_at, i|
+            author = i.zero? ? topic.user : seeder.users.sample
+            FactoryBot.create(:post, postable: topic, messageboard: seeder.first_messageboard,
+                                     user: author, created_at: written_at, updated_at: written_at)
+          end
+          topic.update!(last_user_id: posts.last.user.id, updated_at: last_post_at, last_post_at: last_post_at)
+          posts
+        end
+      end
+
+      def range_of_dates_in_order(up_to: Time.zone.now, count: 1)
+        written = up_to
+        Array.new(count - 1) { written -= random_duration(10.minutes..6.hours) }.reverse + [up_to]
+      end
+
+      def random_duration(range)
+        (range.min.to_i + rand(range.max.to_i)).seconds
+      end
+    end
+
+    class PrivatePosts < CollectionSeedData
+      MODEL_CLASS = PrivatePost
+
+      def create(count: (1..1))
+        log "Creating #{count} additional posts in each private topic..."
+        seeder.private_topics.flat_map do |topic|
+          (count.min + rand(count.max + 1)).times do |i|
+            author = i.zero? ? topic.user : topic.users.sample
+            FactoryBot.create(:private_post, postable: topic, user: author)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength