railswiki 0.1.0

data/app/helpers/railswiki/application_helper.rb

@@ -0,0 +1,26 @@
+require_dependency "redcarpet"
+
+module Railswiki
+  module ApplicationHelper
+    include WikiHelper
+    include TitleHelper
+
+    def time_ago(time)
+      description = if time.present?
+        "#{time_ago_in_words(time)} ago"
+      else
+        "never!"
+      end
+
+      content_tag "span", description, title: "#{time}", class: "time_ago"
+    end
+
+    def user_link(user)
+      if user.present?
+        link_to user.name, user
+      else
+        content_tag "i", "nobody!", class: "invalid_user"
+      end
+    end
+  end
+end

data/app/helpers/railswiki/histories_helper.rb

@@ -0,0 +1,4 @@
+module Railswiki
+  module HistoriesHelper
+  end
+end

data/app/helpers/railswiki/invites_helper.rb

@@ -0,0 +1,4 @@
+module Railswiki
+  module InvitesHelper
+  end
+end

data/app/helpers/railswiki/pages_helper.rb

@@ -0,0 +1,76 @@
+module Railswiki
+  module PagesHelper
+    class SpecialPage
+      attr_reader :title, :author, :latest_version
+
+      def initialize(title:)
+        @title = title
+        @author = nil
+        @latest_version = nil
+      end
+
+      def builtin_page?
+        true
+      end
+
+      def content
+        case title
+        when "Special:Welcome"
+          "Welcome to your new wiki."
+        when "Special:Header"
+          <<-wiki_content
+  [[Home]]
+  {{Special:Search}}
+          wiki_content
+        when "Special:Search"
+          Railswiki::ApplicationController.render(
+            partial: "shared/search",
+            assigns: {},
+            formats: [:md]
+          )
+        when "Special:Footer"
+          <<-wiki_content
+  Copyright {{Special:Year}}
+          wiki_content
+        when "Special:Formatting"
+          Railswiki::ApplicationController.render(
+            partial: "shared/formatting",
+            assigns: {},
+            formats: [:md]
+          )
+        when "Special:Year"
+          "#{Time.now.year}"
+        else
+          "Unknown special page '#{title}'"
+        end
+      end
+    end
+
+    def special_page(title)
+      SpecialPage.new({
+        title: "Special:#{title}",
+      })
+    end
+
+    def special_pages
+      [
+        special_page("Welcome"),
+        special_page("Header"),
+        special_page("Footer"),
+        special_page("Formatting"),
+        special_page("Search"),
+        special_page("Year")
+      ]
+    end
+
+    def is_special_page?(page)
+      is_special_page_title?(page.title)
+    end
+
+    def is_special_page_title?(title)
+      return false if title.nil?
+
+      !! special_pages.select { |p| p.title.downcase == title.downcase }.first
+    end
+  end
+end

data/app/helpers/railswiki/sessions_helper.rb

@@ -0,0 +1,4 @@
+module Railswiki
+  module SessionsHelper
+  end
+end

data/app/helpers/railswiki/title_helper.rb

@@ -0,0 +1,7 @@
+module Railswiki
+  module TitleHelper
+    def title(page_title)
+      content_for(:title) { page_title.join(" - ") }
+    end
+  end
+end

data/app/helpers/railswiki/uploaded_files_helper.rb

@@ -0,0 +1,4 @@
+module Railswiki
+  module UploadedFilesHelper
+  end
+end

data/app/helpers/railswiki/users_helper.rb

@@ -0,0 +1,4 @@
+module Railswiki
+  module UsersHelper
+  end
+end

data/app/helpers/railswiki/wiki_helper.rb

@@ -0,0 +1,189 @@
+require_dependency "redcarpet"
+
+module Railswiki
+  module WikiHelper
+    include PagesHelper
+
+    def include_wiki(page_or_title)
+      if page_or_title.is_a?(Page)
+        page = page_or_title
+      else
+        page = select_page(page_or_title)
+      end
+
+      return raw "<!-- no page #{page_or_title} -->" unless page
+
+      wiki_classes = "wiki-included wiki-#{classify_title(page.title)}"
+
+      return raw "<div class=\"#{wiki_classes}\">#{markdown_without_wrap.render page.content}</div>"
+    end
+
+    def include_wiki_class(page)
+      "<div>" + yield + "</div>"
+    end
+
+    def select_page(page_or_title)
+      @select_pages ||= Hash.new do |hash, ref|
+        # Don't try to include blank pages in here
+        return if ref.blank?
+
+        hash[ref] = Page.where(id: ref).
+          or(Page.where(title: [ref, unprettify_title(ref)]).
+          or(Page.where(lowercase_title: [ref.downcase, unprettify_title(ref.downcase), unprettify_slug(ref.downcase)]))).
+          first
+        hash[ref] ||= special_pages.select { |page| page.title.downcase == ref.downcase }.first
+      end
+      @select_pages[page_or_title]
+    end
+
+    def prettify_title(title)
+      title.gsub(/ /, "_")
+    end
+
+    def prettify_slug(title)
+      title.downcase.gsub(/ /, "-")
+    end
+
+    def unprettify_title(title)
+      title.present? ? title.gsub(/_/, " ") : nil
+    end
+
+    def unprettify_slug(title)
+      title.present? ? title.gsub(/-/, " ") : nil
+    end
+
+    def classify_title(title)
+      title.gsub(/[^a-z0-9\-_]+/i, "_")
+    end
+
+    def wiki_path(page, options = {})
+      page = "." if page == ""
+
+      if page.respond_to?(:title)
+        title_or_slug_path(page.title, options)
+      else
+        title_or_slug_path(page, options)
+      end
+    end
+
+    def title_or_slug_path(title, options)
+      if title == "Home" || title == "home"
+        return Rails.application.routes.url_helpers.root_path(options)
+      end
+
+      if Railswiki::Engine.use_slugs
+        Rails.application.routes.url_helpers.slug_path(prettify_slug(title), options)
+      else
+        Railswiki::Engine.routes.url_helpers.title_path(prettify_title(title), options)
+      end
+    end
+
+    def markdown
+      @markdown ||= Redcarpet::Markdown.new(MarkdownRenderer.new(html_options), markdown_options)
+    end
+
+    def markdown_without_wrap
+      @markdown_without_wrap ||= Redcarpet::Markdown.new(MarkdownRendererWithoutWrap.new(), markdown_options)
+    end
+
+    def markdown_options
+      {
+        tables: true,
+        autolink: true,
+        no_intra_emphasis: true
+      }
+    end
+
+    def html_options
+      {
+      }
+    end
+  end
+
+  class MarkdownRenderer < Redcarpet::Render::HTML
+    include WikiHelper
+
+    def preprocess(full_document)
+      code_blocks = []
+
+      # Strip out code blocks
+      full_document = full_document.gsub(/(```[^`]+?```)/im) do |match|
+        code_blocks << match
+        "__code_marker:#{code_blocks.length - 1}__"
+      end
+
+      # Include templates {{template}}
+      full_document = full_document.gsub(/\{\{([^\}]+)\}\}/i) do |match|
+        template = select_page($1)
+        if template && template.content
+          # Because we are only including the raw content here, and not
+          # rendering the markdown before including it, it's not possible
+          # to have a stack overflow here. If this ever changes to
+          # somehow call preprocess() again, you MUST add a test to prevent
+          # infinite inclusion.
+          # It also means we don't need to `raw` the output.
+          "#{template.content}"
+        else
+          "*** Unknown template #{$1} ***"
+        end
+      end
+
+      # Wiki links [[link|title|extra html]]
+      full_document = full_document.gsub(/\[\[([^\n]+?)\|([^\n]+?)\|([^\n]+?)\]\]/i) do |match|
+        "<a href=\"#{wiki_path($1)}\" #{$3}>#{$2}</a>"
+      end
+
+      # Wiki links [[link|title]]
+      full_document = full_document.gsub(/\[\[([^\n]+?)\|([^\n]+?)\]\]/i) do |match|
+        "[#{$2}](#{wiki_path($1)})"
+      end
+
+      # Wiki links [[link]]
+      full_document = full_document.gsub(/\[\[([^\n]+?)\]\]/i) do |match|
+        "[#{$1}](#{wiki_path($1)})"
+      end
+
+      # Re-insert code blocks
+      full_document = full_document.gsub(/__code_marker:(\d+)__/) do |match|
+        code_blocks[$1.to_i]
+      end
+
+      full_document
+    end
+
+    # Image resizing as per https://github.com/vmg/redcarpet/issues/487
+    def image(link, title, alt_text)
+      if link =~ /^(.+?)\s*=+(\d+)(?:px|)$/
+        # ![alt](url.png =100px)
+        # ![alt](url.png =100)
+        %(<img src="#{$1}" style="max-width: #{$2}px;" alt="#{alt_text}">)
+      elsif link =~ /^(.+?)\s*=+(\d+)(?:px|)x(\d+)(?:px|)$/
+        # ![alt](url.png =30x50)
+        %(<img src="#{$1}" style="max-width: #{$2}px; max-height: #{$3}px;" alt="#{alt_text}">)
+      elsif link =~ /^(.+?)\s*=+(\d+)%$/
+        # ![alt](url.png =50%)
+        %(<img src="#{$1}" style="max-width: #{$2}%;" alt="#{alt_text}">)
+      elsif link =~ /^(.+?)\s*=+(\d+)%x(\d+)%$/
+        # ![alt](url.png =50%x50%)
+        %(<img src="#{$1}" style="max-width: #{$2}%; max-height: #{$3}%;" alt="#{alt_text}">)
+      else
+        %(<img src="#{link}" title="#{title}" alt="#{alt_text}">)
+      end
+    end
+
+    def postprocess(full_document)
+      full_document = full_document.gsub(/<p>= ([^ <>]+)<\/p>/i) do |match|
+        "<#{$1}>"
+      end
+
+      full_document
+    end
+  end
+
+  # Remove the <p> tags around the output as per https://github.com/vmg/redcarpet/issues/92
+  class MarkdownRendererWithoutWrap < MarkdownRenderer
+    def postprocess(full_document)
+      Regexp.new(/\A<p>(.*)<\/p>\Z/m).match(full_document)[1] rescue full_document
+    end
+  end
+end

data/app/jobs/railswiki/application_job.rb

@@ -0,0 +1,4 @@
+module Railswiki
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/railswiki/application_mailer.rb

@@ -0,0 +1,6 @@
+module Railswiki
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/railswiki/application_record.rb

@@ -0,0 +1,5 @@
+module Railswiki
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/railswiki/history.rb

@@ -0,0 +1,14 @@
+module Railswiki
+  class History < ApplicationRecord
+    belongs_to :page
+    belongs_to :author, class_name: "User"
+
+    def expose_json
+      {
+        id: id,
+        updated_at: created_at,
+        content: body
+      }
+    end
+  end
+end

data/app/models/railswiki/invite.rb

@@ -0,0 +1,20 @@
+require "email_validator"
+
+module Railswiki
+  class Invite < ApplicationRecord
+    belongs_to :inviting_user, class_name: "User"
+    belongs_to :invited_user, class_name: "User"
+
+    validates :email, presence: true, uniqueness: true, email: true
+    validates :inviting_user, presence: true
+    validates :role, presence: true, inclusion: { in: User::AVAILABLE_ROLES }
+
+    validate :user_cannot_already_be_registered
+
+    def user_cannot_already_be_registered
+      if accepted_at.nil? && User.where(email: email).any?
+        errors.add(:email, "is already registered as a user")
+      end
+    end
+  end
+end

data/app/models/railswiki/page.rb

@@ -0,0 +1,56 @@
+module Railswiki
+  class Page < ApplicationRecord
+    attr_accessor :default_content
+
+    has_many :histories, dependent: :destroy
+
+    validates :title, presence: true, uniqueness: true
+    validates :lowercase_title, presence: true, uniqueness: true
+
+    before_validation :save_lowercase_title, on: [:create, :update]
+    validate :lowercase_title_must_equal_title
+
+    delegate :author, to: :latest_version, allow_nil: true
+
+    def content
+      latest_version.present? ? latest_version.body : default_content
+    end
+
+    def latest_version
+      @latest_version ||= histories.where(id: latest_version_id).first
+    end
+
+    def expose_json
+      {
+        id: id,
+        title: title,
+        updated_at: latest_version.created_at,
+        content: content
+      }
+    end
+
+    def builtin_page?
+      false
+    end
+
+    def self.search(query)
+      if query
+        where("title LIKE :query COLLATE utf8_general_ci", query: "%#{query}%")
+      else
+        all
+      end
+    end
+
+    private
+
+    def lowercase_title_must_equal_title
+      if title.downcase != lowercase_title.downcase
+        errors.add(:lowercase_title, "does not match the lowercase title")
+      end
+    end
+
+    def save_lowercase_title
+      self.lowercase_title = self.title.downcase
+    end
+  end
+end

data/app/models/railswiki/uploaded_file.rb

@@ -0,0 +1,32 @@
+require_dependency 'carrierwave'
+require_dependency 'carrierwave/orm/activerecord'
+
+module Railswiki
+  class UploadedFile < ApplicationRecord
+    mount_uploader :file, FileUploader
+
+    belongs_to :user
+
+    validates :title, presence: true, uniqueness: true
+    validate :file_exists
+
+    delegate :content_type, to: :file
+
+    def file_url
+      file.url.sub "public/", ""
+    end
+
+    def is_image?
+      file.content_type && MIME::Types[file.content_type].any? &&
+          MIME::Types[file.content_type].first.media_type == "image"
+    end
+
+    private
+
+    def file_exists
+      if file.file.nil?
+        errors.add(:file, "does not exist")
+      end
+    end
+  end
+end