content-pipeline 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10007c34df98a2b87c657b803c10c3790234caeb
-  data.tar.gz: 539627a02f703acd5dd0526fd0733fcd7cb8d317
+  metadata.gz: b05e4ba2c18469028c3062e838dfe6ce04085599
+  data.tar.gz: 0154fe65c6601b4ad3b7539a5986c3a58391000d
 SHA512:
-  metadata.gz: b7a1faffb09772f6bf58fcc3dc50805bb72799a1b9b9c07e8468f3b4956317551ea4b845d1c03437fee5c14aa37433ea3d8c7c9b1f9fbde24cf203aca53ee455
-  data.tar.gz: ce17d05c9e7c01ca1164ed19fd1f36cf019c0441e0562227e7f59972afb2056f4c7c76bf917c3b77b7c48f321dcf44dfd45ce721f72c87e2fed540d1d162538a
+  metadata.gz: f552817247cd9e852c5b935705d63cd065ccba52cfd2c6f960ec2fcc94955059f3bd2926c4039fe63dd8bda0c26d3db5d195e156fe360fa6799dde4c9aa254e5
+  data.tar.gz: c405bdbd8f9488567a8afb3bc82346812305a6eea1ddbebd3a7609ab0815cd177a2450dacb6aec9fca19c29a0e04dfb4934056a06dbaf8c650ae3dd71ffa9348

data/Gemfile

@@ -3,7 +3,9 @@ gemspec
 
 group :development do
   gem "kramdown"
+  gem "gemoji"
   gem "rake"
+  gem "pry"
 
   unless RbConfig::CONFIG["ruby_install_name"] == "jruby"
     gem "pygments.rb"

data/License

@@ -1,11 +1,10 @@
 Copyright 2013-2014 Jordon Bedwell
 
-Licensed under the Apache License, Version 2.0 (the "License"); you may
-not use this file except in compliance with the License. You may obtain
-a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
+Licensed under the Apache License, Version 2.0 (the "License"); you maynot use
+this file except in compliance with the License. You may obtain a copy of the
+License at: http://www.apache.org/licenses/LICENSE-2.0
 
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-implied. See the License for the specific language governing
-permissions and limitations under the License.
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express orimplied. See the License for the
+specific language governing permissions and limitations under the License.

data/Readme.md

@@ -20,6 +20,11 @@ gem 'content-pipeline', '~> <VERSION>'
 Content Pipeline is extremely simple to use out of the box:
 
 ```ruby
+
+# ---------------------------------------------------------------------
+# With custom filters and global-filter options + per-filter options.
+# ---------------------------------------------------------------------
+
 pipeline = Content::Pipeline.new([ MyFilter ], {
   :my_filter => {
     :o1 => true
@@ -31,15 +36,31 @@ pipeline.filter('# Markdown', {
     :o1 => false
   }
 })
+
+# ---------------------------------------------------------------------
+# With only global-filter options + per-filter options.
+# ---------------------------------------------------------------------
+
+pipeline = Content::Pipeline.new({
+  :my_filter => {
+    :o1 => true
+  }
+})
+
+pipeline.filter("# Markdown", {
+  :my_filter => {
+    :o1 => false
+  }
+})
 ```
 
 ```ruby
 Content::Pipeline.new.filter('# Markdown')
 ```
 
-* Supports multiple Markdowns.
 * Supports global options with overrides.
-* By default uses both `CodeHighlight` and `Markdown`.
+* By default uses `CodeHighlight`, `Markdown`, `Gemoji`.
+* Supports multiple Markdowns.
 
 *It should be noted that if you send a list of filters you wish to use, it will not use the default filters at all.  So where you see `[ MyFilter ]` that will be the only filter that is ran, since it automatically assumes this is the pipeline you wish to use.*
 
@@ -47,15 +68,15 @@ Content::Pipeline.new.filter('# Markdown')
 
 Filter options are set globally and can be overriden each time the filter is ran, this allows for you to setup a single pipeline and then adjust it on the fly on a per-content basis, for example if you wish to run `Markdown` `:safe` on user comments but not on posts, then you would simply setup the global pipeline and then each time you parse a user comment send the content with the hash `{ :markdown => { :safe => true }}`.
 
-*All options are keyed based on their class name, so `MyFilter` would have the option key `:my_filter`*
+*All options are keyed based on their class name, so `MyFilter` would have the option key `:my_filter` but it also supports `:myfilter`*
 
 ### Content::Pipeline::Filters::Markdown
 
 The Markdown filter allows you to choose between `github-markdown` and `kramdown`, and by default will use `kramdown` on jRuby and `github-markdown` on any other Ruby that supports it.  **These dependencies are loose, which means you must install the one you wish to use.**
 
 Options:
-* `:type` => [`:gfm`, `:markdown`, `:kramdown`] - The Markdown filter you wish to use.
-* `:safe` => [`true`, `false`] - Does basic filtering, removes images and strips autolinked anchors.
+* `:type` => [`:gfm`, `:markdown`, `md`, `:kramdown`]
+* `:safe` => [`true`, `false`]
 
 *You should not need to adjust any of your "\`\`\`" because the `Markdown` filter will automatically convert those to `~~~` if you choose Kramdown.  This is not done because one way is
 better than the other, it's done so that people can remain agnostic.*
@@ -65,4 +86,12 @@ better than the other, it's done so that people can remain agnostic.*
 The code highlight filter allows you to highlight code, with or without Pygments.  If Pygments is supported it will require it and syntax highlight, otherwise it will simply wrap your code in the normal code style and not syntax highlight it.  You will still have the line numbers, just not the fancy syntax highlight.
 
 Options:
-* `:default` - The default syntax language -- If not defined it will default to "ruby".
+* `:default` - `:ruby`
+
+### Content::Pipeline::Filters::Gemoji
+
+The Gemoji filter allows you to convert `:gemoji:` into image tags, liquid asset tags and if you really really need it, a custom tag by sending a proc.  By default it will use the path `/asset` which can be overriden.
+
+* `:as_liquid_asset` - `nil`
+* `:tag` - `Proc` - 2args - path, name.
+* `:asset_path` - `/assets`

data/lib/content/pipeline/core_extensions/hash_ext.rb

@@ -1,15 +1,5 @@
 module CoreExtensions
-
-  # -------------------------------------------------------------------
-  # Hash Extensions.
-  # -------------------------------------------------------------------
-
   module HashExt
-
-    # -----------------------------------------------------------------
-    # Merge a hash, merging hashes in hashes with hashes in hashes.
-    # -----------------------------------------------------------------
-
     unless method_defined?(:deep_merge)
       def deep_merge(new_hash)
         merge(new_hash) do |k, o, n|

data/lib/content/pipeline/core_extensions/object_ext.rb

@@ -1,26 +1,18 @@
 require "nokogiri"
 
 module CoreExtensions
-
-  # -------------------------------------------------------------------
-  # Object Extensions.
-  # -------------------------------------------------------------------
-
   module ObjectExt
     def jruby?
       RbConfig::CONFIG["ruby_install_name"] == "jruby"
     end
 
-    # -----------------------------------------------------------------
-    # Convert an element to a Nokogiri document fragment.
-    # -----------------------------------------------------------------
+    # -------------------------------------------------------------------------
 
     def to_nokogiri_fragment
+      return self if self.is_a?(Nokogiri::HTML::DocumentFragment)
       Nokogiri::HTML.fragment(self.to_s)
     end
   end
 end
 
-# ---------------------------------------------------------------------
-
 Object.send(:include, CoreExtensions::ObjectExt)

data/lib/content/pipeline/filters/code_highlight.rb

@@ -1,21 +1,23 @@
 require "pygments" unless jruby?
 
 class Content::Pipeline::Filters::CodeHighlight < Content::Pipeline::Filter
-  add_filter :highlight
+  add_filter({
+    :highlight => :nokogiri
+  })
+
+  # ---------------------------------------------------------------------------
 
   Matcher = /<pre>(.+)<\/pre>/m
   Templates = {
     :numb => %Q{<span class="line-number">%s</span>\n},
     :line => '<span class="line">%s</span>',
-    :wrap => <<-HTML
+    :wrap => <<-HTML,
       <figure class="code">
         <div class="highlight">
           <table>
             <tbody>
               <tr>
-                <td class="gutter">
-                  <pre>%s</pre>
-                </td>
+                %s
                 <td class="code">
                   <pre><code class="%s">%s</code></pre>
                 </td>
@@ -25,9 +27,22 @@ class Content::Pipeline::Filters::CodeHighlight < Content::Pipeline::Filter
         </div>
       </figure>
     HTML
+
+    :gutter => <<-HTML
+      <td class="gutter">
+        <pre>%s</pre>
+      </td>
+    HTML
   }
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
+
+  def initialize(*args)
+    super(*args)
+    @opts[:gutter] = true if @opts[:gutter].nil?
+  end
+
+  # ---------------------------------------------------------------------------
 
   private
   def highlight
@@ -38,23 +53,42 @@ class Content::Pipeline::Filters::CodeHighlight < Content::Pipeline::Filter
     end
   end
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
+  # @arg String: The "multi-line" string you wish to parse.
+  # @arg String: The "programming language" you wish to highlight as.
+  # ---------------------------------------------------------------------------
 
   private
   def wrap(str, lang)
-    lines, numbs = "", ""; str.each_line.with_index(1) do |line, numb|
-      lines+= Templates[:line] % line
-      numbs+= Templates[:numb] % numb
+    lines, numbs = "", ""
+
+    str.each_line.with_index(1) do |l, n|
+      lines+= Templates[:line] % l
+
+      if @opts[:gutter]
+        numbs+= Templates[:numb] % n
+      end
     end
 
-    [numbs, lang, lines]
+    if ! @opts[:gutter]
+      [
+        numbs, lang, lines
+      ]
+    else
+      [
+        Templates[:gutter] % numbs, lang, lines
+      ]
+    end
   end
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
+  # @arg String: The "multi-line" string you wish to highlight.
+  # @arg String: The lang you wish to use when highlighting the string.
+  # ---------------------------------------------------------------------------
 
   private
   def pygments(str, lang)
-    return str if jruby? || !Pygments::Lexer[lang]
+    return str if jruby? || ! Pygments::Lexer[lang]
     Pygments::Lexer[lang].highlight(str) =~ Matcher ? $1 : str
   end
 end

data/lib/content/pipeline/filters/gemoji.rb

@@ -0,0 +1,67 @@
+require "gemoji"
+
+class Content::Pipeline::Filters::Gemoji < Content::Pipeline::Filter
+  EmojiPattern = /(?:^\s*|\s+):(#{Emoji.names.map { |n| Regexp.escape(n) }.join("|")}):(?:\s+|\s*$)/m
+  EmojiTag = %Q{<img class="emoji" src="%s" alt=":%s:" height="20" width="20">}
+  EmojiLiquidTag = %Q{{%%img "%s" ":%s:" %%}}
+
+  add_filter({
+    :gemoji => :nokogiri
+  })
+
+  # ---------------------------------------------------------------------------
+  # This is a simple wrapper method around the default initialize.
+  # ---------------------------------------------------------------------------
+
+  def initialize(*args)
+    super(*args)
+    # I should make this an addon.
+    @opts[:asset_path] ||= "/assets"
+  end
+
+  # ---------------------------------------------------------------------------
+  # Because of the way that Nokogiri behaves we need to go out of our
+  # way and ensure that we capture both text nodes in the root and
+  # text nodes in elements (such as paragraphs and shit like that...)
+  # ---------------------------------------------------------------------------
+
+  private
+  def gemoji
+    @str = @str.to_nokogiri_fragment
+    [:xpath, :search].each do |t|
+      @str.send(t, "text()").each do |n|
+        parse_node(n)
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # @arg Nokogiri::XML::Text: The Text node you wish to parse.
+  # ---------------------------------------------------------------------------
+
+  def parse_node(node)
+    return node if node.ancestors.any? do |n|
+      n.node_name == "code" || n.node_name == "pre"
+    end
+
+    # Because it's no more performant than 40 objs.
+    node.replace(node.to_html.gsub(EmojiPattern) do
+      ep = "#{@opts[:asset_path].chomp("/")}/#{$1}.png"
+      en = $1
+
+      if ! @opts[:tag] && ! @opts[:tag].is_a?(Proc)
+        if @opts[:as_liquid_asset]
+          EmojiLiquidTag % [
+            ep, en
+          ]
+        else
+          EmojiTag % [
+            ep, en
+          ]
+        end
+      else
+        @opts[:tag].call(ep, en)
+      end
+    end)
+  end
+end

data/lib/content/pipeline/filters/markdown.rb

@@ -1,35 +1,56 @@
 class Content::Pipeline::Filters::Markdown < Content::Pipeline::Filter
-  add_filter :markdown, :strip_html
+  add_filter({
+    :markdown => :str,
+    :strip_html => :nokogiri
+  })
+
+  # ---------------------------------------------------------------------------
 
   private
-  def default_markdown
-    (jruby?) ? :kramdown : :gfm
+  def default
+    jruby? ? :kramdown : :gfm
   end
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
 
   private
   def markdown
-    type = @opts.fetch(:type, default_markdown)
-    @str = convert_backtick(@str)
-
+    @type = @opts.fetch(:type, default)
+    @str = backtick(@str)
     @str = case
-    when type =~ /\Amarkdown|gfm\Z/
-      require "github/markdown"
-      GitHub::Markdown.to_html(@str, type).strip
+      when @type =~ /\Amd|markdown|gfm\Z/ then parse_github
     else
-      require "kramdown"
-      str = Kramdown::Document.new(@str, :enable_coderay => false)
-      normalize_kramdown(str.to_html).strip
+      parse_kramdown
     end
   end
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
+
+  private
+  def parse_github
+    require "github/markdown"
+    GitHub::Markdown.to_html(@str, @type).strip
+  end
+
+  # ---------------------------------------------------------------------------
+
+  private
+  def parse_kramdown
+    require "kramdown"
+    str = Kramdown::Document.new(@str, {
+      :enable_coderay => false
+    })
+
+    # For consistent output, like it ok?!
+    normalize_kramdown(str.to_html).strip
+  end
+
+  # ---------------------------------------------------------------------------
 
   private
   def strip_html
-    @str = @str.to_nokogiri_fragment
     if @opts[:safe]
+      @str = @str.to_nokogiri_fragment
       private_methods(false).keep_if { |m| m =~ /\Astrip_/ }.each do |m|
         unless m == :strip_html
           send(m)
@@ -38,7 +59,7 @@ class Content::Pipeline::Filters::Markdown < Content::Pipeline::Filter
     end
   end
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
 
   private
   def strip_links
@@ -47,7 +68,7 @@ class Content::Pipeline::Filters::Markdown < Content::Pipeline::Filter
     end
   end
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
 
   private
   def strip_image
@@ -56,14 +77,18 @@ class Content::Pipeline::Filters::Markdown < Content::Pipeline::Filter
     end
   end
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
+  # @arg String: The Markdown string, convert `` to ~~~.
+  # ---------------------------------------------------------------------------
 
   private
-  def convert_backtick(str)
+  def backtick(str)
     str.gsub(/^`{3}(\s?[a-zA-Z0-9]+)?$/, "~~~\\1")
   end
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
+  # @arg String: The converted Markdown string, from Kramdown.
+  # ---------------------------------------------------------------------------
 
   private
   def normalize_kramdown(str)

data/lib/content/pipeline/filters.rb

@@ -1,38 +1,81 @@
+require "forwardable"
+
 class Content::Pipeline
   class Filter
+    extend Forwardable
+
+    def_delegator "self.class.filters", :each_with_index
+    def_delegator "self.class.filters", :each
+    def_delegator "self.class.filters", :size
+    def_delegator "self.class.filters", :[]
+    def_delegator "self.class", :filters
+
+    # -------------------------------------------------------------------------
+
     def initialize(str, opts = nil)
       @opts, @str = (opts || {}), str
     end
 
-    # -----------------------------------------------------------------
-    # Run the set of filters the user wants ran on the filter.
-    # -----------------------------------------------------------------
+    # -------------------------------------------------------------------------
+    # @arg Array: The next filter in the chain, to check the types.
+    # -------------------------------------------------------------------------
+
+    def run(next_filter = nil)
+      return @str unless size > 0
+
+      each_with_index do |f, i|
+        send(f.first)
 
-    def run
-      self.class.filters.each do |f|
-        send(f)
+        unless size == i + 1 || @str.is_a?(String) || \
+            self[i + 1].last == :nokogiri
+
+          @str = @str.to_s
+        end
       end
 
-      @str.to_s
-    end
+      next_filter = next_filter.filters.first if next_filter
+      if ! next_filter || next_filter.last != :nokogiri
+        return @str.to_s
+      end
 
-    # -----------------------------------------------------------------
+      @str
+    end
 
     class << self
       attr_reader :filters
 
+      # -----------------------------------------------------------------------
+      # @arg Hash: The filters and the type of input they prefer.
+      # -----------------------------------------------------------------------
+
       def add_filter(*filters)
         @filters ||= []
-        @filters.push(*filters.flatten)
+
+        filters.each do |f|
+          if f.is_a?(Hash)
+            f.each do |k, v|
+              @filters.push([
+                k, v
+              ])
+            end
+          else
+            @filters.push([
+              f,
+              :str
+            ])
+          end
+        end
       end
     end
   end
 
-  # -------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
 
   module Filters
     require_relative "filters/code_highlight"
     require_relative "filters/markdown"
-    DEFAULT_FILTERS = [ Markdown, CodeHighlight ].freeze
+    require_relative "filters/gemoji"
+    #  The filters I prefer to use by default are here.
+    DEFAULT_FILTERS = [ Markdown, CodeHighlight, Gemoji ].freeze
   end
 end

data/lib/content/pipeline/jekyll/convertor.rb

@@ -0,0 +1,27 @@
+require "content/pipeline"
+
+module Content::Pipeline::Jekyll
+  class Convertor < Jekyll::Convertor
+    CONTENT_PIPELINE = Content::Pipeline.new
+
+    def matches(ext)
+      ext =~ /\.(md|markdown)\Z/
+    end
+
+    # -------------------------------------------------------------------------
+
+    def output_ext(ext)
+      ".html"
+    end
+
+    # -------------------------------------------------------------------------
+    # It should be noted that MARKDOWN_CONVERTOR uses the default options
+    # provided by Content::Pipeline at:
+    #   https://github.com/envygeeks/content-pipeline
+    # -------------------------------------------------------------------------
+
+    def convert(data)
+      CONTENT_PIPELINE.filter(data)
+    end
+  end
+end

data/lib/content/pipeline/version.rb

@@ -1,5 +1,5 @@
 module Content
   class Pipeline
-    VERSION = "1.0.3"
+    VERSION = "1.1.0"
   end
 end

data/lib/content/pipeline.rb

@@ -6,28 +6,64 @@ module Content
     require_relative "pipeline/filters"
     attr_reader :filters, :opts
 
-    # -----------------------------------------------------------------
+    # -------------------------------------------------------------------------
+    # @arg Array: The filters you would like to use or next:
+    # @arg Hash : Your "default options" that should be "global."
+    # -------------------------------------------------------------------------
 
-    def initialize(filters = Filters::DEFAULT_FILTERS, opts = {})
+    def initialize(filters = nil, opts = nil)
+      if filters.is_a?(Hash) && opts.nil?
+        opts = filters
+        filters =  nil
+      end
+
+
+      opts = {} if opts.nil?
+      filters = Filters::DEFAULT_FILTERS if filters.nil?
       @opts, @filters = opts.freeze, [ filters ].flatten.freeze
     end
 
-    # -----------------------------------------------------------------
+    # -------------------------------------------------------------------------
+    # @arg String: The incomming string that will be modified.
+    # @arg Hash  : The secondary opts to override the "defaults".
+    # -------------------------------------------------------------------------
 
     def filter(out, opts = {})
+      return out if out.nil? || out.empty? || @filters.empty?
+
       opts = @opts.deep_merge(opts)
-      @filters.each do |f|
-        out = f.new(out, opts[to_opt(f)]).run
+      @filters.each_with_index do |f, i|
+        fopts = opts.values_at(*to_opt(f)).delete_if(&:nil?). \
+          reduce({}, :merge)
+
+        out = f.new(out, fopts).run(@filters[i + 1])
       end
 
     out
     end
 
-    # -----------------------------------------------------------------
+    # -------------------------------------------------------------------------
+    # @arg Object: An object (preferably a class or module.)
+    # -------------------------------------------------------------------------
 
     private
     def to_opt(cls)
-      cls.name.split(/::/).last.downcase.to_sym
+      cls = cls.name.split(/::/).last
+
+      [
+        cls.downcase,
+        underscore_cls(cls) ].uniq.map(&:to_sym)
+    end
+
+    # -------------------------------------------------------------------------
+    # @arg String: The name of the class you wish to adjust.
+    # -------------------------------------------------------------------------
+
+    private
+    def underscore_cls(cls)
+      (cls[0].downcase + cls[1..-1]).gsub(/([A-Z])/) do
+        "_" + $1.downcase
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: content-pipeline
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Jordon Bedwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-11 00:00:00.000000000 Z
+date: 2014-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -30,56 +30,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: rspec-expect_error
+  name: envygeeks-coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: envygeeks-coveralls
+  name: rspec-collection_matchers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.0'
 - !ruby/object:Gem::Dependency
   name: luna-rspec-formatters
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
 description: A less restrictive version of html-pipeline for content.
 email: envygeeks@gmail.com
 executables: []
@@ -95,7 +95,9 @@ files:
 - lib/content/pipeline/core_extensions/object_ext.rb
 - lib/content/pipeline/filters.rb
 - lib/content/pipeline/filters/code_highlight.rb
+- lib/content/pipeline/filters/gemoji.rb
 - lib/content/pipeline/filters/markdown.rb
+- lib/content/pipeline/jekyll/convertor.rb
 - lib/content/pipeline/version.rb
 homepage: https://github.com/envygeeks/content-pipeline
 licenses:
@@ -117,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Adds a pipeline for your content.