mc_markdown 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bd77c3ac8d404a34b13fce0798dce8e0ecd703ef
+  data.tar.gz: 01143bd86643d7fcc301f47e56da0be1dc3ba361
+SHA512:
+  metadata.gz: 343a2e49df1c68dc69479d67bd25c77a5d833e3c508d8f62dccc6467e3316d97c95c960276c6af980fba068d35f742d3d7b33f99b7ba0514de4faf4f315fb5a6
+  data.tar.gz: f94055d08e32929046ce2c8f81aca889818cb959601fae05fa69bb05def250ee8e1b261636545c061763c5f74faac8fd9d031e98884ac660b97a1b5c7ec3cd4e

data/lib/mc_markdown.rb

@@ -0,0 +1,11 @@
+require 'redcarpet'
+
+# Parsing
+require_relative 'mc_markdown/parsers'
+
+# Formatters
+require_relative 'mc_markdown/formatters'
+
+# Util
+require_relative 'mc_markdown/extensions'
+require_relative 'mc_markdown/renderers'

data/lib/mc_markdown/extensions.rb

@@ -0,0 +1,10 @@
+module MCMarkdown
+  module Extensions
+    attr_reader :extensions
+
+    def initialize extensions={}
+      @extensions = extensions
+      super extensions
+    end
+  end
+end

data/lib/mc_markdown/formatters.rb

@@ -0,0 +1,9 @@
+require_relative 'formatters/common_misspellings'
+require_relative 'formatters/header_with_id'
+require_relative 'formatters/image'
+require_relative 'formatters/links'
+require_relative 'formatters/lists'
+require_relative 'formatters/escape_merge_tags'
+require_relative 'formatters/blockquote'
+require_relative 'formatters/blocks'
+require_relative 'formatters/wistia'

data/lib/mc_markdown/formatters/blockquote.rb

@@ -0,0 +1,38 @@
+module MCMarkdown
+  module Formatter
+    module Blockquote
+
+      # http://rubular.com/r/9DaY7IwzEV
+      BLOCK_QUOTE_PATTERN = /(?<!>\n) (^>\s[^>].+)/x
+
+      def preprocess doc
+        doc.gsub!(BLOCK_QUOTE_PATTERN) do |match|
+          match.prepend "\n{{break_quote}}\n"
+        end
+
+        if defined?(super)
+          return super(doc)
+        else
+          return doc
+        end
+      end
+
+      def postprocess doc
+        doc.gsub! "\n<p>{{break_quote}}</p>", ""
+
+        if defined?(super)
+          return super(doc)
+        else
+          return doc
+        end
+      end
+
+      def block_quote quote
+        quote = quote.strip.gsub( "<p>{{break_quote}} ", '</blockquote><blockquote><p>').gsub(/\n/, '')
+
+        "<blockquote>" << quote << "</blockquote>"
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/formatters/blocks.rb

@@ -0,0 +1,47 @@
+module MCMarkdown
+  module Formatter
+    module Blocks
+
+      def preprocess doc
+        doc.gsub!( Parser::BlockTag::Block.open_block ) do |match|
+          "\n\n#{match}\n\n"
+        end
+
+        doc.gsub!( Parser::BlockTag::Block.close_block ) do |match|
+          "\n\n#{match}\n\n"
+        end
+
+        if defined?(super)
+          return super(doc)
+        else
+          return doc
+        end
+      end
+
+      def postprocess doc
+        doc = Parser::BlockTag.new(doc, BlockFormatter).parsed
+
+        if defined?(super)
+          return super(doc)
+        else
+          return doc
+        end
+      end
+
+      class BlockFormatter < Parser::Formatter
+
+        def notes attributes={}
+          content = attributes[:content]
+          "<div class=\"notes\">\n\n#{content}\n\n</div>"
+        end
+
+        def callout attributes={}
+          content = attributes[:content]
+          "<div class=\"callout\">\n\n#{content}\n\n</div>"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/formatters/common_misspellings.rb

@@ -0,0 +1,26 @@
+module MCMarkdown
+  module Formatter
+    module CommonMisspellings
+
+      def preprocess doc
+
+        replacements = {
+          "(&ldqou;)"  =>  "“",
+          "(&rdqou;)"  =>  "”",
+          "(&rsqou;)"  =>  "’"
+        }
+
+        replacements.each do |bad_regex, correction|
+          doc.gsub! /#{bad_regex}/xi, correction
+        end
+
+        if defined?(super)
+          return super(doc)
+        else
+          return doc
+        end
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/formatters/escape_merge_tags.rb

@@ -0,0 +1,21 @@
+module MCMarkdown
+  module Formatter
+    module EscapeMergeTags
+      ALLOWED_CHARACTERS = ['w', ':', '_', '<', '>', '/' ]
+
+      def emphasis text
+        characters = ALLOWED_CHARACTERS.map { |char| "\\#{char}" }.join("")
+        unless text.match /^\| .+ \|$/x
+          "<em>#{text}</em>"
+        else
+          "*#{convert_em_tags_to_underscores(text)}*"
+        end
+      end
+
+      def convert_em_tags_to_underscores string
+        string.gsub( /<\/?em>/, '_' )
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/formatters/header_with_id.rb

@@ -0,0 +1,34 @@
+require 'slugity/extend_string'
+
+module MCMarkdown
+  module Formatter
+    module HeaderWithID
+
+      def header text, header_level
+        header_levels = Array(header_options.fetch(:level, 1))
+        return "<h#{header_level}>#{text}</h#{header_level}>" unless header_levels.include?(header_level)
+
+        # add ids to all h1 headers (pray they're unique)
+        if header_options.fetch(:template_tag_headers, false)
+          namespace = "{{section_id}}"
+        else
+          namespace = "#{header_options.fetch(:slug, 'section')}-#{text.strip.to_slug}"
+        end
+
+        return "<h#{header_level} id='#{namespace}'>#{text}</h#{header_level}>"
+      end
+
+      def header_options
+        if defined?(extensions)
+          options = extensions.fetch(:header_with_id, {})
+          options[:template_tag_headers] = extensions.fetch(:template_tag_headers, false)
+        else
+          options = {}
+        end
+
+        return options
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/formatters/image.rb

@@ -0,0 +1,55 @@
+module MCMarkdown
+  module Formatter
+    module Image
+
+      # http://rubular.com/r/lss0C9HqoP
+      # $1 => alt
+      # $2 => class/attrs
+      IMG_ATTRIBUTES_PATTERN = /^ ([^_{}]+)? (?:{(.+?)})? \s?$/x
+
+      # add classes to images and render title as figure/figcaption
+      # ![alt {class}](/path/to/img.jpg "caption")
+      def image link, title, alt_text
+        return "![#{alt_text}](#{link}#{(title && !title.empty?) ? " \"#{title}\"" : ''})" if extensions[:no_images]
+
+        match_data = IMG_ATTRIBUTES_PATTERN.match (alt_text || "")
+        alt_text = match_data[1] || ""
+        attrs    = match_data[2] || ""
+
+        # check for attrs in class field
+        if attrs.include? ':'
+          attrs = attrs.split(', ').each_with_object([]) do |frag, out|
+            frag = frag.split ':'
+            out.push "#{frag[0].strip}='#{frag[1].strip}'"
+            out
+          end.join(" ") + " "
+        elsif !attrs.empty?
+          classes = attrs
+          attrs   = "class='#{attrs}' "
+        end
+
+        if title
+          return "<figure class='img #{classes}'>" +
+                 "<img src='#{link}' alt='#{alt_text.strip}' />" +
+                 "<figcaption>" + ::Redcarpet::Markdown.new( self ).render(title).strip + "</figcaption>" +
+                 "</figure>"
+        else
+          return "<img src='#{link}' alt='#{alt_text.strip}' #{attrs}/>"
+        end
+      end
+
+      # need to strip paragraph tags from around
+      # figures, has potential to cause invalid markup
+      def postprocess doc
+        doc = doc.gsub( /<p><figure/, '<figure' ).gsub( /<\/figure><\/p>/, '</figure>' )
+
+        if defined?(super)
+          return super(doc)
+        else
+          return doc
+        end
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/formatters/links.rb

@@ -0,0 +1,51 @@
+module MCMarkdown
+  module Formatter
+    module Links
+
+      # http://rubular.com/r/nVJvYdiGud
+      # $1 => text
+      # $2 => junk
+      # $3 => class/attrs
+      # $4 => target
+      LINK_ATTRIBUTES_PATTERN = /^ ([^_{}]+) ({(.+?)})? (\s\_[a-zA-Z]+)? \s?$/x
+
+
+      # add ability to add classes to links
+      # [Link Test {class} _target ](link)
+      def link link, title, content
+        return "[#{content}](#{link}#{(title && !title.empty?) ? " \"#{title}\"" : ''})" if extensions[:no_links]
+
+        match_data = LINK_ATTRIBUTES_PATTERN.match content
+        content    = match_data[1]
+        attrs      = match_data[3] || ""
+        target     = match_data[4]
+
+        # check for attrs in class field
+        if attrs.include? ':'
+          attrs = attrs.split(', ').each_with_object([]) do |frag, out|
+            frag = frag.split ':'
+            out.push "#{frag[0].strip}='#{frag[1].strip}'"
+            out
+          end.join(" ")
+        elsif !attrs.empty?
+          attrs = "class='#{attrs}'"
+        end
+
+        if extensions[:xml]
+          link.encode!(xml: :text)
+          # content gets loosely encoded before it
+          # enters the formatter
+        end
+
+        # there is always a link
+        return_string = "<a href='#{link}'"
+        return_string << " " << attrs                if !attrs.empty?
+        return_string << " target='#{target.strip}'" if target
+        return_string << ">#{content.strip}</a>"
+
+        return return_string
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/formatters/lists.rb

@@ -0,0 +1,33 @@
+module MCMarkdown
+  module Formatter
+    module Lists
+
+      def list content, list_type
+        tag = ( list_type == :ordered ) ? "ol" : "ul"
+        tag = (/\<dt\>/.match(content) ) ? "dl" : tag
+
+        "<#{tag} class='list markers'>#{content}</#{tag}>"
+      end
+
+      def list_item text, list_type
+        if /\n\:\s*\n/.match(text)
+          match_data = /^((.*)\n\:\s*\n)/.match(text)
+          title = "<p>" << match_data[2].gsub('<p>','') << "</p>"
+
+          # strip the title from the text, but leave <p> tags
+          text = text.gsub( match_data[1].gsub(/\<\/?p\>/,''), '')
+
+          # strip opening and closing p tags
+          text = text.strip.gsub( /(\A\<p\>|\<\/p\>\z)/, '' )
+
+          text = "<p>" << text << "</p>"
+
+          "<dt>#{title}</dt><dd>#{text}</dd>"
+        else
+          "<li>#{text.strip}</li>"
+        end
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/formatters/wistia.rb

@@ -0,0 +1,64 @@
+module MCMarkdown
+  module Formatter
+    module Wistia
+
+      def preprocess doc
+        doc = Parser::ShortTag.new(doc, WistiaFormatter).parsed
+
+        if defined?(super)
+          return super(doc)
+        else
+          return doc
+        end
+      end
+
+      class WistiaFormatter < Parser::Formatter
+
+        def video attributes={}
+          wistia_id = attributes.delete(:id)
+          options = defaults.merge(attributes)
+
+          query_params = options.map do |attr,value|
+            # camel case attribute names
+            camel_case = attr.to_s.split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
+            "#{camel_case}=#{value}"
+          end
+
+          html_params = {
+            src: "http://fast.wistia.com/embed/iframe/#{wistia_id}?#{query_params.join('&')}",
+            allowtransparency: 'true',
+            frameborder: '0',
+            scrolling: 'no',
+            class: 'wistia_embed',
+            name: 'wistia_embed',
+            width: options[:video_width],
+            height: options[:video_height]
+          }
+
+          if wistia_id
+            "<iframe #{render_params( html_params )}></iframe>"
+          else
+            ""
+          end
+        end
+
+        private
+
+          def defaults
+            {
+              version: "v1",
+              video_width: 600,
+              video_height: 400,
+              controls_visible_on_load: true
+            }
+          end
+
+          def render_params params
+            params.map { |attr, value| "#{attr}='#{value}'" }.join(' ')
+          end
+
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/parsers.rb

@@ -0,0 +1,4 @@
+require_relative 'parsers/block_tag'
+require_relative 'parsers/formatter'
+require_relative 'parsers/short_tag'
+require_relative 'parsers/frontmatter'

data/lib/mc_markdown/parsers/block_tag.rb

@@ -0,0 +1,70 @@
+module MCMarkdown
+  module Parser
+
+    class BlockTag
+
+      attr_reader :content
+      attr_reader :formatter
+
+      def initialize content, formatter
+        @content = content
+        @formatter = formatter.new
+      end
+
+      def parsed
+        content.gsub Block.pattern do |match|
+          tag = Block.new(match)
+          formatter.format(tag)
+        end
+      end
+
+      class Block
+        class << self
+          def pattern
+            / #{open_block} (.*?) #{close_block} /xm
+          end
+
+          def open_block
+            / (?:#{open_tag})? \{\{(.+?)\}\} #{repeated_spaces} (?:#{close_tag})? /x
+          end
+
+          def close_block
+            / (?:#{open_tag})? #{repeated_spaces} \{\{\/(.+?)\}\} (?:#{close_tag})? /x
+          end
+
+          def open_tag
+            / < (?:\w+?) > /x
+          end
+
+          def close_tag
+            / < (?:\/) (?:\w+?) > /x
+          end
+
+          private
+
+            def repeated_spaces
+              / (?:[\s\t]*) /x
+            end
+        end
+
+
+        attr_reader :orig
+        attr_reader :type
+        attr_reader :attributes
+
+        def initialize content
+          @orig = content
+        end
+
+        def type
+          @_type ||= @orig.match( Block.pattern )[1]
+        end
+
+        def attributes
+          @_attributes ||= { content: @orig.match( Block.pattern )[2].strip }
+        end
+      end
+    end
+
+  end
+end

data/lib/mc_markdown/parsers/formatter.rb

@@ -0,0 +1,17 @@
+module MCMarkdown
+  module Parser
+
+    class Formatter
+
+      def format tag
+        if self.respond_to? tag.type
+          self.public_send(tag.type, tag.attributes)
+        else
+          tag.orig
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mc_markdown/parsers/frontmatter.rb

@@ -0,0 +1,39 @@
+module MCMarkdown
+  module Parsers
+
+    class Frontmatter
+      attr_reader :content
+
+      def initialize content
+        @content = content
+      end
+
+      def parsed
+        match   = content.match( frontmatter_regex )
+        raw_fm  = match[1]
+        content = match[2]
+
+        if raw_fm && !raw_fm.empty?
+          frontmatter = SafeYAML.load raw_fm, safe: true,
+                                              deserialize_symbols:  true,
+                                              raise_on_unknown_tag: true
+        else
+          frontmatter = {}
+        end
+
+        [ frontmatter, content ]
+      end
+
+      private
+
+        def frontmatter_regex
+          # http://rubular.com/r/tJ6VoFBuqK
+          # [1] => frontmatter || nil
+          # [2] => content
+          /(?:(?:\A-{3,}\s*\n+) (.+?) (?:-{3,}\s*\n+))? (.*)/mx
+        end
+
+    end
+
+  end
+end

data/lib/mc_markdown/parsers/short_tag.rb

@@ -0,0 +1,51 @@
+module MCMarkdown
+  module Parser
+
+    class ShortTag
+
+      attr_reader :content
+      attr_reader :formatter
+
+      def initialize content, formatter
+        @content = content
+        @formatter = formatter.new
+      end
+
+      def parsed
+        content.gsub Tag.pattern do |match|
+          tag = Tag.new(match)
+          formatter.format(tag)
+        end
+      end
+
+      class Tag
+
+        def self.pattern
+          /\{\{ (.*?) \}\}/x
+        end
+
+        attr_reader :orig
+        attr_reader :type
+        attr_reader :attributes
+
+        def initialize matched_string
+          @orig = matched_string
+          @data = @orig.match( Tag.pattern )[1].strip.split(' ')
+          @type = @data.shift
+          @attributes = @data.map { |set| set.scan( attribute_pattern ) }.inject({}) do |out,pair|
+            out[ pair[0][0].to_sym ] = pair[0][1]
+            out
+          end
+        end
+
+        private
+
+          def attribute_pattern
+            / (\w+) = ['"](.+?)['"] /x
+          end
+
+      end
+
+    end
+  end
+end

data/lib/mc_markdown/renderers.rb

@@ -0,0 +1,46 @@
+module MCMarkdown
+  module Renderers
+    class << self
+
+      def use renderer_class, options={}
+        fetch( { class: renderer_class, extensions: options.delete(:extensions), options: options } )
+      end
+
+      private
+
+        def store
+          @_store ||= {}
+        end
+
+        def fetch renderer_key
+          store.fetch(renderer_key) { add(renderer_key) }
+        end
+
+        def add renderer_key
+          extensions = renderer_key[:extensions] || {}
+
+          store[renderer_key] = Redcarpet::Markdown.new(
+            ::MCMarkdown.const_get( renderer_key[:class].to_s.capitalize ).new( renderer_key[:options] ),
+            extensions
+          )
+        end
+
+    end
+  end
+
+  def self.render input, renderer=:base, options={}
+    Renderers.use(renderer, options).render(input)
+  end
+
+  def self.render_with_frontmatter input, renderer=:base, options={}
+    require 'safe_yaml/load'
+
+    frontmatter, content = Parsers::Frontmatter.new(input).parsed
+    rendered_content     = Renderers.use(renderer, options).render(content)
+
+    [ frontmatter, rendered_content ]
+  end
+end
+
+require_relative 'renderers/html'
+require_relative 'renderers/base'

data/lib/mc_markdown/renderers/base.rb

@@ -0,0 +1,12 @@
+module MCMarkdown
+  class Base < Html
+    include ::MCMarkdown::Formatter::Lists
+    include ::MCMarkdown::Formatter::Image
+    include ::MCMarkdown::Formatter::Links
+    include ::MCMarkdown::Formatter::EscapeMergeTags
+    include ::MCMarkdown::Formatter::CommonMisspellings
+    include ::MCMarkdown::Formatter::Blockquote
+    include ::MCMarkdown::Formatter::Blocks
+    include ::MCMarkdown::Formatter::Wistia
+  end
+end

data/lib/mc_markdown/renderers/html.rb

@@ -0,0 +1,5 @@
+module MCMarkdown
+  class Html < Redcarpet::Render::HTML
+    include Extensions
+  end
+end

data/lib/mc_markdown/version.rb

@@ -0,0 +1,3 @@
+module MCMarkdown
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: mc_markdown
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Steven Sloan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: slugity
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: safe_yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: ' MailChimp flavoured markdown syntax using RedCarpet '
+email:
+- stevenosloan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mc_markdown.rb
+- lib/mc_markdown/extensions.rb
+- lib/mc_markdown/formatters.rb
+- lib/mc_markdown/formatters/blockquote.rb
+- lib/mc_markdown/formatters/blocks.rb
+- lib/mc_markdown/formatters/common_misspellings.rb
+- lib/mc_markdown/formatters/escape_merge_tags.rb
+- lib/mc_markdown/formatters/header_with_id.rb
+- lib/mc_markdown/formatters/image.rb
+- lib/mc_markdown/formatters/links.rb
+- lib/mc_markdown/formatters/lists.rb
+- lib/mc_markdown/formatters/wistia.rb
+- lib/mc_markdown/parsers.rb
+- lib/mc_markdown/parsers/block_tag.rb
+- lib/mc_markdown/parsers/formatter.rb
+- lib/mc_markdown/parsers/frontmatter.rb
+- lib/mc_markdown/parsers/short_tag.rb
+- lib/mc_markdown/renderers.rb
+- lib/mc_markdown/renderers/base.rb
+- lib/mc_markdown/renderers/html.rb
+- lib/mc_markdown/version.rb
+homepage: http://github.com/mailchimp/mc_markdown
+licenses:
+- New-BSD
+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.4.5
+signing_key: 
+specification_version: 4
+summary: MailChimp flavoured markdown syntax using RedCarpet
+test_files: []