rails_den 2.0.0

data/lib/generators/rails_den/install/views/views_generator.rb

@@ -0,0 +1,56 @@
+require "rails/generators"
+require "rails_den"
+
+module RailsDen
+  module Generators
+    module Install
+      class ViewsGenerator < Rails::Generators::Base
+        source_root RailsDen::Engine.root.join("app/views").to_s
+
+        desc "Copies RailsDen's default views into the host application."
+
+        def copy_views
+          copy_file(
+            "layouts/rails_den/application.html.erb",
+            "app/views/layouts/rails_den/application.html.erb"
+          )
+
+          copy_file(
+            "rails_den/sessions/new.html.erb",
+            "app/views/rails_den/sessions/new.html.erb"
+          )
+
+          copy_file(
+            "rails_den/registrations/new.html.erb",
+            "app/views/rails_den/registrations/new.html.erb"
+          )
+
+          copy_file(
+            "rails_den/registrations/edit.html.erb",
+            "app/views/rails_den/registrations/edit.html.erb"
+          )
+
+          copy_file(
+            "rails_den/passwords/new.html.erb",
+            "app/views/rails_den/passwords/new.html.erb"
+          )
+
+          copy_file(
+            "rails_den/passwords/edit.html.erb",
+            "app/views/rails_den/passwords/edit.html.erb"
+          )
+
+          copy_file(
+            "rails_den/passwords_mailer/reset.html.erb",
+            "app/views/rails_den/passwords_mailer/reset.html.erb"
+          )
+
+          copy_file(
+            "rails_den/passwords_mailer/reset.text.erb",
+            "app/views/rails_den/passwords_mailer/reset.text.erb"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rails/commands/rails_den/import/discourse/discourse_command.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "rails_den/import/discourse"
+
+module Rails
+  module Command
+    module RailsDen
+      module Import
+        class DiscourseCommand < Base
+          desc "rails_den:import:discourse BACKUP_PATH",
+               "Import an official Discourse backup into RailsDen"
+
+          def perform(backup_path = nil)
+            unless backup_path.present?
+              print_usage
+              exit 1
+            end
+
+            boot_application!
+
+            require "rails_den/import/discourse/importer"
+
+            ::RailsDen::Import::Discourse::Importer.new(
+              backup_path: backup_path,
+              out: $stdout
+            ).call
+          rescue ::RailsDen::Import::Discourse::ImportError => import_error
+            error "RailsDen Discourse import failed: #{import_error.message}"
+            exit 1
+          end
+
+          private
+
+          def print_usage
+            error "RailsDen Discourse Import"
+            error ""
+            error "Create and download an official Discourse backup, then run:"
+            error ""
+            error "  bin/rails rails_den:import:discourse /path/to/discourse-backup.tar.gz"
+            error ""
+            error "The importer requires PostgreSQL."
+            error "Imported users must reset their password before first sign-in."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_den/cli.rb

@@ -0,0 +1,174 @@
+require "bundler"
+require "rails_den/version"
+require "rails_den/view_installer"
+require "rails/generators"
+require "rails/generators/rails/app/app_generator"
+
+module RailsDen
+  class CLI
+    DEFAULT_TEMPLATE_PATH = File.expand_path(
+      "standalone_template.rb",
+      __dir__
+    )
+
+    def self.start(
+      argv,
+      out: $stdout,
+      err: $stderr,
+      app_generator: Rails::Generators::AppGenerator,
+      view_installer_class: RailsDen::ViewInstaller,
+      template_path: DEFAULT_TEMPLATE_PATH
+    )
+      new(
+        argv,
+        out: out,
+        err: err,
+        app_generator: app_generator,
+        view_installer_class: view_installer_class,
+        template_path: template_path
+      ).start
+    end
+
+    def initialize(
+      argv,
+      out:,
+      err:,
+      app_generator:,
+      view_installer_class:,
+      template_path:
+    )
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @app_generator = app_generator
+      @view_installer_class = view_installer_class
+      @template_path = template_path
+    end
+
+    def start
+      command = @argv.shift
+
+      case command
+      when nil, "-h", "--help", "help"
+        print_help
+        0
+      when "-v", "--version", "version"
+        @out.puts RailsDen::VERSION
+        0
+      when "new"
+        create_application
+      when "install:views"
+        install_views
+      else
+        @err.puts "Unknown command: #{command}"
+        @err.puts
+        print_help(@err)
+        1
+      end
+    rescue ArgumentError => error
+      @err.puts error.message
+      1
+    end
+
+    private
+
+    def create_application
+      name = @argv.shift
+
+      if name.nil? || name.strip.empty?
+        @err.puts "Usage: rails_den new NAME [rails options]"
+        return 1
+      end
+
+      rails_options = @argv.dup
+
+      unless database_option_present?(rails_options)
+        rails_options << "--database=postgresql"
+      end
+
+      Bundler.with_unbundled_env do
+        @app_generator.start(
+          [
+            name,
+            *rails_options,
+            "--template=#{@template_path}"
+          ]
+        )
+      end
+
+      0
+    end
+
+    def database_option_present?(arguments)
+      arguments.any? do |argument|
+        argument == "-d" ||
+          argument.start_with?("-d=") ||
+          argument == "--database" ||
+          argument.start_with?("--database=")
+      end
+    end
+
+    def install_views
+      force = false
+
+      @argv.each do |argument|
+        case argument
+        when "--force"
+          force = true
+        else
+          @err.puts "Unknown option for install:views: #{argument}"
+          @err.puts
+          @err.puts "Usage: rails_den install:views [--force]"
+          return 1
+        end
+      end
+
+      installer = @view_installer_class.new(
+        destination_root: Dir.pwd,
+        out: @out
+      )
+
+      installer.install(force: force)
+
+      @out.puts
+      @out.puts "RailsDen views are now available under app/views."
+      @out.puts "Your local copies override RailsDen's packaged defaults."
+
+      0
+    end
+
+    def print_help(io = @out)
+      io.puts <<~HELP
+        RailsDen #{RailsDen::VERSION}
+
+        Usage:
+          rails_den new NAME [rails options]
+          rails_den install:views [--force]
+          rails_den --version
+          rails_den --help
+
+        Commands:
+          new NAME
+              Create a new standalone RailsDen application.
+
+              PostgreSQL is used by default. Pass a Rails database option
+              to choose a different database.
+
+          install:views
+              Copy RailsDen's packaged views into the current Rails app
+              so they can be customized.
+
+              Existing files are preserved by default.
+              Use --force to replace them with RailsDen's defaults.
+
+        Examples:
+          rails_den new community
+          rails_den new community --database=sqlite3
+
+          cd community
+          rails_den install:views
+          rails_den install:views --force
+      HELP
+    end
+  end
+end

data/lib/rails_den/configuration.rb

@@ -0,0 +1,173 @@
+module RailsDen
+  class Configuration
+    DEFAULT_ATTACHMENT_ALLOWED_TYPES = {
+      "jpg" => [
+        "image/jpeg"
+      ],
+      "jpeg" => [
+        "image/jpeg"
+      ],
+      "png" => [
+        "image/png"
+      ],
+      "gif" => [
+        "image/gif"
+      ],
+      "webp" => [
+        "image/webp"
+      ],
+      "pdf" => [
+        "application/pdf"
+      ],
+      "txt" => [
+        "text/plain"
+      ],
+      "md" => [
+        "text/plain",
+        "text/markdown"
+      ],
+      "csv" => [
+        "text/plain",
+        "text/csv"
+      ]
+    }.freeze
+
+    attr_accessor :community_name,
+                  :user_class,
+                  :current_user_method,
+                  :current_user_resolver,
+                  :authentication_method,
+                  :authentication_handler,
+                  :parent_controller,
+                  :registration_enabled,
+                  :public_revision_history,
+                  :user_display_name_method,
+                  :user_mention_name_method,
+                  :user_mention_resolver,
+                  :user_mention_candidates_resolver,
+                  :user_search_resolver,
+                  :user_mention_path_resolver,
+                  :formatting_adapter,
+                  :onebox_enabled,
+                  :onebox_allowed_ports,
+                  :onebox_open_timeout,
+                  :onebox_read_timeout,
+                  :onebox_max_response_bytes,
+                  :onebox_max_redirects,
+                  :onebox_user_agent,
+                  :onebox_cache_ttl,
+                  :onebox_twitch_parent_hosts,
+                  :visit_inactivity_window,
+                  :attachment_allowed_types,
+                  :attachment_max_size,
+                  :allow_member_created_tags,
+                  :max_tags_per_topic,
+                  :search_adapter,
+                  :can_access_board,
+                  :presence_enabled,
+                  :presence_visibility,
+                  :presence_redis_url,
+                  :presence_heartbeat_interval,
+                  :presence_expiration,
+                  :presence_away_after,
+                  :presence_recently_active_window,
+                  :gamification_enabled,
+                  :leaderboard_enabled,
+                  :gamification_topic_points,
+                  :gamification_reply_points,
+                  :licensing_api_url,
+                  :licensing_open_timeout,
+                  :licensing_read_timeout,
+                  :licensing_verification_interval,
+                  :licensing_retry_interval
+
+    def initialize
+      @community_name = "RailsDen"
+      @user_class = "User"
+      @current_user_method = :current_user
+      @current_user_resolver = nil
+      @authentication_method = :authenticate_user!
+      @authentication_handler = nil
+      @parent_controller = "ApplicationController"
+      @registration_enabled = true
+      @public_revision_history = false
+      @user_display_name_method = :username
+      @user_mention_name_method = :username
+      @user_mention_resolver = nil
+
+      # Receives a normalized prefix and bounded limit, and returns host identities.
+      @user_mention_candidates_resolver = nil
+
+      # Receives a normalized search query and bounded limit, and returns host identities.
+      @user_search_resolver = nil
+
+      @user_mention_path_resolver = nil
+      @formatting_adapter = :markdown
+      @onebox_enabled = true
+      @onebox_allowed_ports = [80, 443]
+      @onebox_open_timeout = 3
+      @onebox_read_timeout = 5
+      @onebox_max_response_bytes = 2 * 1024 * 1024
+      @onebox_max_redirects = 5
+      @onebox_user_agent = "RailsDen Onebox"
+      @onebox_cache_ttl = 86_400
+      @onebox_twitch_parent_hosts = []
+      @visit_inactivity_window = 30.minutes
+      @attachment_allowed_types =
+        DEFAULT_ATTACHMENT_ALLOWED_TYPES
+          .transform_values(&:dup)
+      @attachment_max_size = 10.megabytes
+      @allow_member_created_tags = false
+      @max_tags_per_topic = 5
+
+      # Portable by default. PostgreSQL hosts may opt into :postgresql.
+      @search_adapter = :basic
+
+      # Optional host-defined board eligibility gate.
+      #
+      # Receives:
+      #   user, board
+      #
+      # Returns:
+      #   false - deny access to the board
+      #   true  - eligible; continue through RailsDen permissions
+      #   nil   - no host decision; continue through RailsDen permissions
+      @can_access_board = nil
+
+      @presence_enabled = true
+      @presence_visibility = :members_only
+
+      @presence_redis_url =
+        ENV["RAILS_DEN_REDIS_URL"]
+          .to_s
+          .strip
+
+      if @presence_redis_url.empty?
+        @presence_redis_url =
+          ENV["REDIS_URL"]
+            .to_s
+            .strip
+      end
+
+      if @presence_redis_url.empty?
+        @presence_redis_url =
+          "redis://127.0.0.1:6379/0"
+      end
+
+      @presence_heartbeat_interval = 30.seconds
+      @presence_expiration = 90.seconds
+      @presence_away_after = 5.minutes
+      @presence_recently_active_window = 24.hours
+
+      @gamification_enabled = true
+      @leaderboard_enabled = false
+      @gamification_topic_points = 5
+      @gamification_reply_points = 2
+      @licensing_api_url = nil
+      @licensing_open_timeout = 3
+      @licensing_read_timeout = 5
+      @licensing_verification_interval = 24.hours
+      @licensing_retry_interval = 1.hour
+    end
+  end
+end

data/lib/rails_den/engine.rb

@@ -0,0 +1,10 @@
+module RailsDen
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsDen
+
+    initializer "rails_den.configure_react_rails",
+                before: "react_rails.setup_engine" do |app|
+      app.config.react.sprockets_strategy = false
+    end
+  end
+end

data/lib/rails_den/extensions/descriptor.rb

@@ -0,0 +1,138 @@
+require "pathname"
+require "rubygems/requirement"
+require "rubygems/version"
+
+module RailsDen
+  module Extensions
+    class Descriptor
+      TYPES = %i[plugin theme].freeze
+      KEY_PATTERN = /\A[a-z0-9][a-z0-9_]*\z/
+
+      attr_reader :type,
+                  :key,
+                  :name,
+                  :version,
+                  :rails_den_requirement,
+                  :license_product,
+                  :license_key,
+                  :view_path,
+                  :stylesheet,
+                  :javascript
+
+      def initialize(
+        type:,
+        key:,
+        name:,
+        version:,
+        rails_den_requirement:,
+        license_product: nil,
+        license_key: nil,
+        view_path: nil,
+        stylesheet: nil,
+        javascript: nil
+      )
+        @type = normalize_type(type)
+        @key = normalize_key(key).freeze
+        @name = normalize_required_string(name, "name").freeze
+        @parsed_version = Gem::Version.new(version.to_s.strip).freeze
+        @version = @parsed_version.to_s.freeze
+        @parsed_requirement = Gem::Requirement.new(rails_den_requirement.to_s.strip).freeze
+        @rails_den_requirement = @parsed_requirement.to_s.freeze
+        @license_product = normalize_optional_string(license_product)&.freeze
+        @license_key = normalize_optional_string(license_key)&.freeze
+        validate_license_metadata!
+        @view_path = normalize_view_path(view_path)&.freeze
+        @stylesheet = normalize_optional_string(stylesheet)&.freeze
+        @javascript = normalize_optional_string(javascript)&.freeze
+        @attributes = build_attributes.freeze
+
+        freeze
+      rescue ArgumentError => error
+        raise InvalidDescriptorError, error.message
+      end
+
+      def licensed?
+        !license_product.nil?
+      end
+
+      def compatible?
+        @parsed_requirement.satisfied_by?(
+          Gem::Version.new(RailsDen::VERSION)
+        )
+      end
+
+      def theme?
+        type == :theme
+      end
+
+      def plugin?
+        type == :plugin
+      end
+
+      def to_h
+        @attributes
+      end
+
+      private
+
+      def normalize_type(value)
+        normalized = value.to_sym
+        return normalized if TYPES.include?(normalized)
+
+        raise InvalidDescriptorError,
+              "type must be plugin or theme"
+      rescue NoMethodError
+        raise InvalidDescriptorError,
+              "type must be plugin or theme"
+      end
+
+      def normalize_key(value)
+        normalized = normalize_required_string(value, "key")
+        return normalized if KEY_PATTERN.match?(normalized)
+
+        raise InvalidDescriptorError,
+              "key must contain only lowercase letters, numbers, and underscores"
+      end
+
+      def normalize_required_string(value, attribute)
+        normalized = value.to_s.strip
+        return normalized unless normalized.empty?
+
+        raise InvalidDescriptorError,
+              "#{attribute} must be present"
+      end
+
+      def normalize_optional_string(value)
+        normalized = value.to_s.strip
+        normalized unless normalized.empty?
+      end
+
+      def normalize_view_path(value)
+        normalized = normalize_optional_string(value)
+        Pathname.new(normalized) if normalized
+      end
+
+      def validate_license_metadata!
+        return if license_product.nil? == license_key.nil?
+
+        raise InvalidDescriptorError,
+              "license_product and license_key must be supplied together"
+      end
+
+      def build_attributes
+        {
+          type: type,
+          key: key,
+          name: name,
+          version: version,
+          rails_den_requirement: rails_den_requirement,
+          license_product: license_product,
+          license_key: license_key,
+          view_path: view_path,
+          stylesheet: stylesheet,
+          javascript: javascript
+        }
+      end
+    end
+  end
+end

data/lib/rails_den/extensions/registry.rb

@@ -0,0 +1,65 @@
+require "thread"
+
+module RailsDen
+  module Extensions
+    class Registry
+      def initialize
+        @descriptors = {}
+        @mutex = Mutex.new
+      end
+
+      def register(descriptor)
+        unless descriptor.compatible?
+          raise IncompatibleVersionError,
+                "#{descriptor.name} requires RailsDen #{descriptor.rails_den_requirement}"
+        end
+
+        @mutex.synchronize do
+          existing = @descriptors[descriptor.key]
+
+          if existing
+            return existing if existing.to_h == descriptor.to_h
+
+            raise DuplicateRegistrationError,
+                  "extension key #{descriptor.key.inspect} is already registered"
+          end
+
+          @descriptors[descriptor.key] = descriptor
+        end
+
+        descriptor
+      end
+
+      def all
+        query
+      end
+
+      def plugins
+        query(&:plugin?)
+      end
+
+      def themes
+        query(&:theme?)
+      end
+
+      def find(key)
+        @mutex.synchronize do
+          @descriptors[key.to_s.strip]
+        end
+      end
+
+      private
+
+      def query(&filter)
+        @mutex.synchronize do
+          descriptors = @descriptors.values
+          descriptors = descriptors.select(&filter) if filter
+
+          descriptors
+            .sort_by { |descriptor| [descriptor.name.downcase, descriptor.key] }
+            .freeze
+        end
+      end
+    end
+  end
+end