qiita-markdown 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3ace54fd9f6e5346ddf6a794191f6500be756e39
+  data.tar.gz: d48b1fb03edf8b81e180dee32871b832ca7875d9
+SHA512:
+  metadata.gz: fba9a372384bda242a1761d42b5ce0b81c2a75199f5f3c3c1877a474882ca500d21e78b066e823894996f0ed347c18651349e96d9a76806d4f3a1f34a304e849
+  data.tar.gz: d3d4a67698fa5b495d975b8564f9e095c721608a3aaf8bcb55bbac9881f261ecbd5685822c28f21eaa2374ae2c14b08fd47e82d5a62dedfbb081fec3e1fc49ed

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install libicu-dev
+language: ruby
+rvm:
+- 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in qiita-markdown.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ryo Nakamura
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+# Qiita::Markdown [![Build Status](https://travis-ci.org/increments/qiita-markdown.svg)](https://travis-ci.org/increments/qiita-markdown)
+Qiita-specified markdown renderer.
+
+## Usage
+Qiita::Markdown::Processor provides markdown rendering logic.
+
+```ruby
+processor = Qiita::Markdown::Processor.new
+processor.call(markdown)
+# => {
+#   codes: [
+#     {
+#       code: "1 + 1\n",
+#       language: "ruby",
+#       filename: "example.rb",
+#     },
+#   ],
+#   mentioned_usernames: [
+#     "alice",
+#     "bob",
+#   ],
+#   output: "<h1>Example</h1>\n...",
+# }
+```
+
+### Filters
+Qiita::Markdown is built on [jch/html-pipeline](https://github.com/jch/html-pipeline).
+Add your favorite html-pipeline-compatible filters.
+
+```ruby
+processor = Qiita::Markdown::Processor.new
+processor.filters << HTML::Pipeline::ImageMaxWidthFilter
+processor.call(text)
+```
+
+### Context
+Processor takes optional context as a Hash which is shared by all filters.
+
+```ruby
+processor = Qiita::Markdown::Processor.new(asset_root: "http://example.com/assets")
+processor.call(text, asset_root: "http://cdn.example.com")
+```

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/lib/qiita-markdown.rb

@@ -0,0 +1 @@
+require "qiita/markdown"

data/lib/qiita/markdown.rb

@@ -0,0 +1,15 @@
+require "active_support/core_ext/object/blank"
+require "html/pipeline"
+require "linguist"
+require "nokogiri"
+require "redcarpet"
+require "sanitize"
+
+require "qiita/markdown/filters/code"
+require "qiita/markdown/filters/mention"
+require "qiita/markdown/filters/redcarpet"
+require "qiita/markdown/filters/sanitize"
+require "qiita/markdown/filters/syntax_highlight"
+require "qiita/markdown/filters/toc"
+require "qiita/markdown/processor"
+require "qiita/markdown/version"

data/lib/qiita/markdown/filters/code.rb

@@ -0,0 +1,98 @@
+module Qiita
+  module Markdown
+    module Filters
+      DEFAULT_LANGUAGE_ALIASES = {
+        "el" => "common-lisp",
+        "zsh" => "bash",
+      }
+
+      # 1. Detects language written in <pre> element.
+      # 2. Adds lang attribute (but this attribute is consumed by syntax highliter).
+      # 3. Adds detected code data into `result[:codes]`.
+      #
+      # You can pass language aliases table via context[:language_aliases].
+      class Code < HTML::Pipeline::Filter
+        def call
+          result[:codes] ||= []
+          doc.search("pre").each do |pre|
+            if code = pre.at("code")
+              label = Label.new(code["class"])
+              filename = label.filename
+              language = label.language
+              language = language_aliases[language] || language
+              pre["filename"] = filename if filename
+              pre["lang"] = language if language
+              result[:codes] << {
+                code: pre.text,
+                filename: filename,
+                language: language,
+              }
+            end
+          end
+          doc
+        end
+
+        private
+
+        def language_aliases
+          context[:language_aliases] || DEFAULT_LANGUAGE_ALIASES
+        end
+
+        # Detects language from code block label.
+        class Label
+          # @param text [String, nil]
+          def initialize(text)
+            @text = text
+          end
+
+          # @return [String, nil]
+          def filename
+            case
+            when empty?
+              nil
+            when has_only_filename?
+              sections[0]
+            else
+              sections[1]
+            end
+          end
+
+          # @example
+          #   Label.new(nil).language #=> nil
+          #   Label.new("ruby").language #=> "ruby"
+          #   Label.new("ruby:foo.rb").language #=> "ruby"
+          #   Label.new("foo.rb").language #=> "ruby"
+          # @return [String, nil]
+          def language
+            case
+            when empty?
+              nil
+            when !has_only_filename?
+              sections[0]
+            when linguist_language
+              linguist_language.default_alias_name
+            end
+          end
+
+          private
+
+          def empty?
+            @text.nil?
+          end
+
+          def has_only_filename?
+            sections[1].nil? && sections[0].include?(".")
+          end
+
+          def linguist_language
+            @linguist_language ||= Linguist::Language.find_by_filename(filename).first
+          end
+
+          def sections
+            @sections ||= (@text || "").split(":")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qiita/markdown/filters/mention.rb

@@ -0,0 +1,48 @@
+module Qiita
+  module Markdown
+    module Filters
+      # 1. Adds :mentioned_usernames into result Hash as Array of String.
+      # 2. Replaces @mention with link.
+      #
+      # You can pass :allowed_usernames context to limit mentioned usernames.
+      class Mention < HTML::Pipeline::MentionFilter
+        # Overrides HTML::Pipeline::MentionFilter's constant.
+        # Allows "_" instead of "-" in username pattern.
+        MentionPattern = /
+          (?:^|\W)
+          @((?>[\w][\w-]{1,30}\w(?:@github)?))
+          (?!\/)
+          (?=
+            \.+[ \t\W]|
+            \.+$|
+            [^0-9a-zA-Z_.]|
+            $
+          )
+        /ix
+
+        # @note Override to use customized MentionPattern and allowed_usernames logic.
+        def mention_link_filter(text, _, _)
+          text.gsub(MentionPattern) do |match|
+            name = $1
+            if allowed_usernames && !allowed_usernames.include?(name)
+              match
+            else
+              result[:mentioned_usernames] |= [name]
+              url = File.join(base_url, name)
+              match.sub(
+                "@#{name}",
+                %[<a href="#{url}" class="user-mention" target="_blank" title="#{name}">@#{name}</a>]
+              )
+            end
+          end
+        end
+
+        private
+
+        def allowed_usernames
+          context[:allowed_usernames]
+        end
+      end
+    end
+  end
+end

data/lib/qiita/markdown/filters/redcarpet.rb

@@ -0,0 +1,31 @@
+require "redcarpet"
+
+module Qiita
+  module Markdown
+    module Filters
+      class Redcarpet < HTML::Pipeline::TextFilter
+        class << self
+          # Memoize.
+          # @return [Redcarpet::Markdown]
+          def renderer
+            @renderer = ::Redcarpet::Markdown.new(
+              ::Redcarpet::Render::HTML.new(
+                hard_wrap: true,
+              ),
+              autolink: true,
+              fenced_code_blocks: true,
+              no_intra_emphasis: true,
+              strikethrough: true,
+              tables: true,
+            )
+          end
+        end
+
+        # @return [Nokogiri::HTML::DocumentFragment]
+        def call
+          Nokogiri::HTML.fragment(self.class.renderer.render(@text))
+        end
+      end
+    end
+  end
+end

data/lib/qiita/markdown/filters/sanitize.rb

@@ -0,0 +1,184 @@
+module Qiita
+  module Markdown
+    module Filters
+      # Sanitizes undesirable elements by whitelist-based rule.
+      # You can pass optional :rule and :script context.
+      class Sanitize < HTML::Pipeline::Filter
+        # Wraps a node env to transform invalid node.
+        class TransformableNode
+          def self.call(*args)
+            new(*args).transform
+          end
+
+          def initialize(env)
+            @env = env
+          end
+
+          def transform
+            if has_invalid_list_node? || has_invalid_table_node?
+              node.replace(node.children)
+            end
+          end
+
+          private
+
+          def has_invalid_list_node?
+            name == "li" && !node.ancestors.any? do |ancestor|
+              %w[ol ul].include?(ancestor.name)
+            end
+          end
+
+          def has_invalid_table_node?
+            %w[thead tbody tfoot tr td th].include?(name) && !node.ancestors.any? do |ancestor|
+              ancestor.name == "table"
+            end
+          end
+
+          def name
+            @env[:node_name]
+          end
+
+          def node
+            @env[:node]
+          end
+        end
+
+        RULE = {
+          attributes: {
+            "a" => [
+              "href",
+            ],
+            "img" => [
+              "src",
+            ],
+            "div" => [
+              "itemscope",
+              "itemtype",
+            ],
+            all: [
+              "abbr",
+              "align",
+              "alt",
+              "border",
+              "cellpadding",
+              "cellspacing",
+              "cite",
+              "class",
+              "color",
+              "cols",
+              "colspan",
+              "datetime",
+              "height",
+              "hreflang",
+              "id",
+              "itemprop",
+              "lang",
+              "name",
+              "tabindex",
+              "target",
+              "title",
+              "width",
+            ],
+          },
+          elements: [
+            "a",
+            "b",
+            "blockquote",
+            "br",
+            "code",
+            "dd",
+            "del",
+            "div",
+            "dl",
+            "dt",
+            "em",
+            "h1",
+            "h2",
+            "h3",
+            "h4",
+            "h5",
+            "h6",
+            "h7",
+            "h8",
+            "hr",
+            "i",
+            "img",
+            "ins",
+            "kbd",
+            "li",
+            "ol",
+            "p",
+            "pre",
+            "q",
+            "rp",
+            "rt",
+            "ruby",
+            "s",
+            "samp",
+            "strike",
+            "strong",
+            "sub",
+            "sup",
+            "table",
+            "tbody",
+            "td",
+            "tfoot",
+            "th",
+            "thead",
+            "tr",
+            "tt",
+            "ul",
+            "var",
+          ],
+          protocols: {
+            "a" => {
+              "href" => [
+                :relative,
+                "http",
+                "https",
+              ],
+            },
+            "img" => {
+              "src" => [
+                :relative,
+                "http",
+                "https",
+              ],
+            },
+          },
+          remove_contents: [
+            "script",
+          ],
+          transformers: TransformableNode,
+        }
+
+        SCRIPTABLE_RULE = RULE.dup.tap do |rule|
+          rule[:elements] = RULE[:elements] + ["script"]
+          rule[:remove_contents] = []
+        end
+
+        def call
+          ::Sanitize.clean_node!(doc, rule)
+          doc
+        end
+
+        private
+
+        def rule
+          case
+          when context[:rule]
+            context[:rule]
+          when has_script_context?
+            SCRIPTABLE_RULE
+          else
+            RULE
+          end
+        end
+
+        def has_script_context?
+          context[:script] == true
+        end
+      end
+    end
+  end
+end

data/lib/qiita/markdown/filters/syntax_highlight.rb

@@ -0,0 +1,98 @@
+module Qiita
+  module Markdown
+    module Filters
+      class SyntaxHighlight < HTML::Pipeline::Filter
+        DEFAULT_LANGUAGE = "text"
+
+        def call
+          doc.search("pre").each do |node|
+            Highlighter.call(
+              default_language: default_language,
+              node: node,
+            )
+          end
+          doc
+        end
+
+        private
+
+        def default_language
+          context[:default_language] || DEFAULT_LANGUAGE
+        end
+
+        class Highlighter
+          def self.call(*args)
+            new(*args).call
+          end
+
+          def initialize(default_language: nil, node: nil)
+            @default_language = default_language
+            @node = node
+          end
+
+          def call
+            outer = Nokogiri::HTML.fragment(%Q[<div class="code-frame" data-lang="#{language}">])
+            frame = outer.at('div')
+            frame.add_child(filename_node) if filename
+            frame.add_child(highlighted_node)
+            @node.replace(outer)
+          end
+
+          private
+
+          def code
+            @node.inner_text
+          end
+
+          def filename
+            @node["filename"]
+          end
+
+          def filename_node
+            %Q[<div class="code-lang"><span class="bold">#{filename}</span></div>]
+          end
+
+          def has_inline_php?
+            specific_language == "php" && code !~ /^<\?php/
+          end
+
+          def highlight(language)
+            Pygments.highlight(code, lexer: language, options: pygments_options)
+          end
+
+          def highlighted_node
+            if specific_language
+              begin
+                highlight(specific_language).presence or raise
+              rescue
+                highlight(@default_language)
+              end
+            else
+              highlight(@default_language)
+            end
+          end
+
+          def language
+            specific_language || @default_language
+          end
+
+          def language_node
+            Nokogiri::HTML.fragment(%Q[<div class="code-frame" data-lang="#{language}"></div>])
+          end
+
+          def pygments_options
+            @pygments_options ||= begin
+              options = { encoding: "utf-8" }
+              options[:startinline] = true if has_inline_php?
+              options
+            end
+          end
+
+          def specific_language
+            @node["lang"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qiita/markdown/filters/toc.rb

@@ -0,0 +1,68 @@
+module Qiita
+  module Markdown
+    module Filters
+      class Toc < HTML::Pipeline::Filter
+        def call
+          counter = Hash.new(0)
+          doc.css("h1, h2, h3, h4, h5, h6").each do |node|
+            heading = Heading.new(node, counter)
+            heading.add_anchor_element if heading.has_first_child?
+            heading.increment
+          end
+          doc
+        end
+
+        class Heading
+          def initialize(node, counter)
+            @node = node
+            @counter = counter
+          end
+
+          def add_anchor_element
+            first_child.add_previous_sibling(anchor_element)
+          end
+
+          def anchor_element
+            %[<span id="#{suffixed_id}" class="fragment"></span><a href="##{suffixed_id}"><i class="fa fa-link"></i></a>]
+          end
+
+          def content
+            @content ||= node.children.first
+          end
+
+          def count
+            @counter[id]
+          end
+
+          def first_child
+            @first_child ||= @node.children.first
+          end
+
+          def has_count?
+            count > 0
+          end
+
+          def has_first_child?
+            !!first_child
+          end
+
+          def id
+            @node.text.downcase.gsub(/[^\p{Word}\- ]/u, '').gsub(' ', '-')
+          end
+
+          def increment
+            @counter[id] += 1
+          end
+
+          def suffix
+            has_count? ? "-#{count}" : ""
+          end
+
+          def suffixed_id
+            "#{id}#{suffix}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qiita/markdown/processor.rb

@@ -0,0 +1,45 @@
+module Qiita
+  module Markdown
+    class Processor
+      DEFAULT_CONTEXT = {
+        asset_root: "/images",
+      }
+
+      DEFAULT_FILTERS = [
+        Filters::Redcarpet,
+        Filters::Sanitize,
+        Filters::Code,
+        Filters::Toc,
+        HTML::Pipeline::EmojiFilter,
+        Filters::SyntaxHighlight,
+        Filters::Mention,
+      ]
+
+      # @param [Hash] context Optional context for HTML::Pipeline.
+      def initialize(context = {})
+        @context = DEFAULT_CONTEXT.merge(context)
+      end
+
+      # Converts Markdown text into HTML string with extracted metadata.
+      #
+      # @param [String] input Markdown text.
+      # @param [Hash] context Optional context merged into default context.
+      # @return [Hash] Process result.
+      # @example
+      #   Qiita::Markdown::Processor.new.call(markdown) #=> {
+      #     codes: [...],
+      #     mentioned_usernames: [...],
+      #     output: "...",
+      #   }
+      def call(input, context = {})
+        HTML::Pipeline.new(filters, @context).call(input, context)
+      end
+
+      # @note Modify filters if you want.
+      # @return [Array<HTML::Pipeline::Filter>]
+      def filters
+        @filters ||= DEFAULT_FILTERS
+      end
+    end
+  end
+end

data/lib/qiita/markdown/version.rb

@@ -0,0 +1,5 @@
+module Qiita
+  module Markdown
+    VERSION = "0.0.1"
+  end
+end

data/qiita-markdown.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "qiita/markdown/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "qiita-markdown"
+  spec.version       = Qiita::Markdown::VERSION
+  spec.authors       = ["Ryo Nakamura"]
+  spec.email         = ["r7kamura@gmail.com"]
+  spec.summary       = "Qiita-specified markdown renderer."
+  spec.homepage      = "https://github.com/increments/qiita-markdown"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_dependency "gemoji", ">= 2.0.0"
+  spec.add_dependency "github-linguist"
+  spec.add_dependency "html-pipeline"
+  spec.add_dependency "redcarpet"
+  spec.add_dependency "sanitize"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "3.1.0"
+end

data/spec/qiita/markdown/processor_spec.rb

@@ -0,0 +1,317 @@
+require "active_support/core_ext/string/strip"
+
+describe Qiita::Markdown::Processor do
+  describe "#call" do
+    subject do
+      result[:output].to_s
+    end
+
+    let(:context) do
+      {}
+    end
+
+    let(:markdown) do
+      raise NotImplementedError
+    end
+
+    let(:result) do
+      described_class.new(context).call(markdown)
+    end
+
+    context "with valid condition" do
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          example
+        EOS
+      end
+
+      it "returns a Hash with HTML output and other metadata" do
+        expect(result[:codes]).to be_an Array
+        expect(result[:mentioned_usernames]).to be_an Array
+        expect(result[:output]).to be_a Nokogiri::HTML::DocumentFragment
+      end
+    end
+
+    context "with HTML-characters" do
+      let(:markdown) do
+        "<>&"
+      end
+
+      it "sanitizes them" do
+        should eq <<-EOS.strip_heredoc
+          <p>&lt;&gt;&amp;</p>
+        EOS
+      end
+    end
+
+    context "with headings" do
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          # a
+          ## a
+          ### a
+          ### a
+        EOS
+      end
+
+      it "adds ID for ToC" do
+        should eq <<-EOS.strip_heredoc
+          <h1>
+          <span id="a" class="fragment"></span><a href="#a"><i class="fa fa-link"></i></a>a</h1>
+
+          <h2>
+          <span id="a-1" class="fragment"></span><a href="#a-1"><i class="fa fa-link"></i></a>a</h2>
+
+          <h3>
+          <span id="a-2" class="fragment"></span><a href="#a-2"><i class="fa fa-link"></i></a>a</h3>
+
+          <h3>
+          <span id="a-3" class="fragment"></span><a href="#a-3"><i class="fa fa-link"></i></a>a</h3>
+        EOS
+      end
+    end
+
+    context "with code" do
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          ```foo.rb
+          puts 'hello world'
+          ```
+        EOS
+      end
+
+      it "returns detected codes" do
+        expect(result[:codes]).to eq [
+          {
+            code: "puts 'hello world'\n",
+            filename: "foo.rb",
+            language: "ruby",
+          },
+        ]
+      end
+    end
+
+    context 'with code & filename' do
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          ```example.rb
+          1
+          ```
+        EOS
+      end
+
+      it 'returns code-frame, code-lang, and highlighted pre element' do
+        should eq <<-EOS.strip_heredoc
+          <div class="code-frame" data-lang="ruby">
+          <div class="code-lang"><span class="bold">example.rb</span></div>
+          <div class="highlight"><pre><span class="mi">1</span>
+          </pre></div>
+          </div>
+        EOS
+      end
+
+    end
+
+    context 'with code & no filename' do
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          ```ruby
+          1
+          ```
+        EOS
+      end
+
+      it 'returns code-frame and highlighted pre element' do
+        should eq <<-EOS.strip_heredoc
+          <div class="code-frame" data-lang="ruby"><div class="highlight"><pre><span class="mi">1</span>
+          </pre></div></div>
+        EOS
+      end
+    end
+
+    context "with undefined but aliased language" do
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          ```zsh
+          true
+          ```
+        EOS
+      end
+
+      it "returns aliased language name" do
+        expect(result[:codes]).to eq [
+          {
+            code: "true\n",
+            filename: nil,
+            language: "bash",
+          },
+        ]
+      end
+    end
+
+    context "with script element" do
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          <script>alert(1)</script>
+        EOS
+      end
+
+      it "removes script element" do
+        should eq "\n"
+      end
+    end
+
+    context "with script context" do
+      before do
+        context[:script] = true
+      end
+
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          <script>alert(1)</script>
+        EOS
+      end
+
+      it "allows script element" do
+        should eq markdown
+      end
+    end
+
+    context "with mention" do
+      let(:markdown) do
+        "@alice"
+      end
+
+      it "replaces mention with link" do
+        should include(<<-EOS.strip_heredoc.rstrip)
+          <a href="/alice" class="user-mention" target="_blank" title="alice">@alice</a>
+        EOS
+      end
+    end
+
+    context "with mentions in complex patterns" do
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          @alice
+
+          ```
+            @bob
+          ```
+
+          @charlie/@dave
+          @ell_en
+          @fran-k
+          @Isaac
+          @justin
+          @justin
+          @mallory@github
+          @#{?o * 33}
+          @oo
+        EOS
+      end
+
+      it "extracts mentions correctly" do
+        expect(result[:mentioned_usernames]).to eq %W[
+          alice
+          dave
+          ell_en
+          fran-k
+          Isaac
+          justin
+          mallory@github
+        ]
+      end
+    end
+
+    context "with allowed_usernames context" do
+      before do
+        context[:allowed_usernames] = ["alice"]
+      end
+
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          @alice
+          @bob
+        EOS
+      end
+
+      it "limits mentions to allowed usernames" do
+        expect(result[:mentioned_usernames]).to eq ["alice"]
+      end
+    end
+
+    context "with normal link" do
+      let(:markdown) do
+        "[](/example)"
+      end
+
+      it "creates link for that" do
+        should eq <<-EOS.strip_heredoc
+          <p><a href="/example"></a></p>
+        EOS
+      end
+    end
+
+    context "with anchor link" do
+      let(:markdown) do
+        "[](#example)"
+      end
+
+      it "creates link for that" do
+        should eq <<-EOS.strip_heredoc
+          <p><a href="#example"></a></p>
+        EOS
+      end
+    end
+
+    context "with javascript: link" do
+      let(:markdown) do
+        "[](javascript:alert(1))"
+      end
+
+      it "removes that link by creating empty a element" do
+        should eq <<-EOS.strip_heredoc
+          <p><a></a></p>
+        EOS
+      end
+    end
+
+    context "with mailto: link" do
+      let(:markdown) do
+        "[](mailto:info@example.com)"
+      end
+
+      it "removes that link by creating empty a element" do
+        should eq <<-EOS.strip_heredoc
+          <p><a></a></p>
+        EOS
+      end
+    end
+
+    context "with emoji" do
+      let(:markdown) do
+        ":+1:"
+      end
+
+      it "replaces it with img element" do
+        should eq <<-EOS.strip_heredoc
+          <p><img class="emoji" title=":+1:" alt=":+1:" src="/images/emoji/unicode/1f44d.png" height="20" width="20" align="absmiddle"></p>
+        EOS
+      end
+    end
+
+    context "with emoji in pre or code element" do
+      let(:markdown) do
+        <<-EOS.strip_heredoc
+          ```
+          :+1:
+          ```
+        EOS
+      end
+
+      it "does not replace it" do
+        should_not include('img')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "qiita-markdown"
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.default_formatter = 'doc'
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: qiita-markdown
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryo Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gemoji
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: github-linguist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: html-pipeline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sanitize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: 
+email:
+- r7kamura@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/qiita-markdown.rb
+- lib/qiita/markdown.rb
+- lib/qiita/markdown/filters/code.rb
+- lib/qiita/markdown/filters/mention.rb
+- lib/qiita/markdown/filters/redcarpet.rb
+- lib/qiita/markdown/filters/sanitize.rb
+- lib/qiita/markdown/filters/syntax_highlight.rb
+- lib/qiita/markdown/filters/toc.rb
+- lib/qiita/markdown/processor.rb
+- lib/qiita/markdown/version.rb
+- qiita-markdown.gemspec
+- spec/qiita/markdown/processor_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/increments/qiita-markdown
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Qiita-specified markdown renderer.
+test_files:
+- spec/qiita/markdown/processor_spec.rb
+- spec/spec_helper.rb
+has_rdoc: