extended_markdownizer 0.1.2

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+docs/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use ruby-1.9.2@markdownizer

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in markdownizer.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    markdownizer (0.3.5)
+      activerecord (>= 3.0.3)
+      coderay
+      rdiscount
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.4)
+      activesupport (= 3.0.4)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.4)
+      activemodel (= 3.0.4)
+      activesupport (= 3.0.4)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.4)
+    arel (2.0.8)
+    builder (2.1.2)
+    coderay (0.9.7)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    i18n (0.5.0)
+    mustache (0.12.0)
+    pygments (0.0.1.a)
+    rdiscount (1.6.8)
+    rocco (0.5)
+      mustache
+      rdiscount
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    tzinfo (0.3.24)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 3.0.3)
+  coderay
+  git
+  markdownizer!
+  pygments
+  rdiscount
+  rocco
+  rspec (~> 2.5.0)

data/Rakefile

@@ -0,0 +1,65 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+# Bring in Rocco tasks
+require 'rocco/tasks'
+require 'rake/clean'
+Rocco::make 'docs/', 'lib/extended_markdownizer.rb'
+
+desc 'Build extended_markdownizer docs'
+task :docs => :rocco
+directory 'docs/'
+
+desc 'Build docs and open in browser for the reading'
+task :read => :docs do
+  sh 'open docs/lib/rocco.html'
+end
+
+# Make index.html a copy of extended_markdownizer.html
+file 'docs/index.html' => ['docs/lib/extended_markdownizer.html'] do |f|
+  cp 'docs/lib/extended_markdownizer.html', 'docs/index.html', :preserve => true
+end
+task :docs => 'docs/index.html'
+CLEAN.include 'docs/index.html'
+
+# Alias for docs task
+task :doc => :docs
+
+# GITHUB PAGES ===============================================================
+
+site = 'docs'
+source_branch = 'master'
+deploy_branch = 'gh-pages'
+
+desc "generate and deploy website to github user pages"
+multitask :pages do
+  puts ">>> Deploying #{deploy_branch} branch to Github Pages <<<"
+  require 'git'
+  repo = Git.open('.')
+  puts "\n>>> Checking out #{deploy_branch} branch <<<\n"
+  repo.branch("#{deploy_branch}").checkout
+  (Dir["*"] - [site]).each { |f| rm_rf(f) }
+  Dir["#{site}/*"].each {|f| mv(f, "index.html")}
+  rm_rf(site)
+  puts "\n>>> Moving generated site files <<<\n"
+  Dir["**/*"].each {|f| repo.add(f) }
+  repo.status.deleted.each {|f, s| repo.remove(f)}
+  puts "\n>>> Commiting: Site updated at #{Time.now.utc} <<<\n"
+  message = ENV["MESSAGE"] || "Site updated at #{Time.now.utc}"
+  repo.commit(message)
+  puts "\n>>> Pushing generated site to #{deploy_branch} branch <<<\n"
+  repo.push
+  puts "\n>>> Github Pages deploy complete <<<\n"
+  repo.branch("#{source_branch}").checkout
+end
+
+# TESTS =====================================================================
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+task :test => [:spec]

data/Readme.md

@@ -0,0 +1,78 @@
+#Extended Markdownizer
+
+A simple gem for Rails 3 to render some ActiveRecord text field as Markdown!
+
+Based on [Markdownizer](https://github.com/codegram/markdownizer), by [Txus](https://github.com/txus).
+
+It mixes CodeRay and RDiscount to give you awesome code highlighting :)
+
+Besides that:
+
+* Converts Youtube urls into embedded videos. 
+* Converts Vimeo urls into embedded videos. 
+* Detects urls and converts into anchors.
+
+You can check the generated Rocco documentation on the [project
+page](http://josem.github.com/extended_markdownizer/).
+
+##Install
+
+In your Gemfile:
+
+    gem 'extended_markdownizer'
+
+If you want code highlighting, you should run this generator too:
+
+    rails generate extended_markdownizer:install
+
+This will place a extended_markdownizer.css file in your `public/stylesheets` folder.
+You will have to require it manually in your layouts, or through `jammit`, or
+whatever.
+
+## Usage
+
+In your model, let's say, Post:
+
+    class Post < ActiveRecord::Base
+      extended_markdownize! :body
+      # In this case we want to treat :body as markdown.
+      # You can pass an options hash to the code renderer, such as:
+      #
+      #   extended_markdownize! :body, :line_numbers => :table
+      #
+    end
+
+Extended Markdownizer needs an additional field (`:rendered_body`), which you should
+generate in a migration. (If the attribute was `:some_other_field`, it would need
+`:rendered_some_other_field`!) All these fields should have the type `:text`.
+
+You save your posts with markdown text like this:
+
+    Post.create body: """
+      # My H1 title
+      Markdown is awesome!
+      ## Some H2 title...
+
+      {% code ruby %}
+      {% caption 'This caption will become an h5 and also a property of the enclosing div' %}
+      {% highlight [1,2,3] %}  <- this will highlight lines 1, 2 and 3 (it accepts a Range as well)
+
+        # All this code will be highlighted properly! :)
+        def my_method(*my_args)
+          something do
+            . . .
+          end
+        end
+
+      {% endcode %}
+    """
+
+And then, in your view you just have to call `<%= raw @post.rendered_body %>` :)
+
+##TODO
+* Update specs
+* Improve docs
+
+## Copyright
+Markdown: Copyright (c) 2011 Codegram. See LICENSE for details.
+Extended Markdown: Copyright (c) 2011 José M. Gilgado

data/extended_markdownizer.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "extended_markdownizer/version"
+
+Gem::Specification.new do |s|
+  s.name        = "extended_markdownizer"
+  s.version     = ExtendedMarkdownizer::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["José M. Gilgado"]
+  s.email       = ["jm.gilgado@gmail.com"]
+  s.homepage    = "https://github.com/josem/extended_markdownizer"
+  s.summary     = %q{Render any text as markdown, with code highlighting and all!}
+  s.description = %q{Render any text as markdown, with code highlighting, url detection and conversion of youtube/vimeo urls into embedded videos}
+
+  s.rubyforge_project = "extended_markdownizer"
+
+  s.add_runtime_dependency 'activerecord', '>= 3.0.3'
+  s.add_runtime_dependency 'rdiscount'
+  s.add_runtime_dependency 'coderay'
+
+  s.add_development_dependency 'rocco'
+  s.add_development_dependency 'git'
+  s.add_development_dependency 'rspec', '~> 2.5.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/init.rb

@@ -0,0 +1 @@
+require 'extended_markdownizer'

data/lib/extended_markdownizer.rb

@@ -0,0 +1,242 @@
+# **ExtendedMarkdownizer** is a simple solution to a simple problem.
+#
+# It is a lightweight Rails 3 gem which enhances any ActiveRecord model with a
+# singleton `markdownize!` method, which makes any text attribute renderable as
+# Markdown. It mixes CodeRay and RDiscount to give you awesome code
+# highlighting, too!
+#
+# If you have any suggestion regarding new features, Check out the [Github repo][gh],
+# fork it and submit a nice pull request :)
+#
+
+#### Install ExtendedMarkdownizer
+
+# Get ExtendedMarkdownizer in your Rails 3 app through your Gemfile:
+#
+#     gem 'extended_markdownizer'
+#
+# If you don't use Bundler, you can alternatively install ExtendedMarkdownizer with
+# Rubygems:
+#
+#     gem install extended_markdownizer
+#
+# If you want code highlighting, you should run this generator too:
+#
+#     rails generate extended_markdownizer:install
+#
+# This will place a `markdownizer.css` file in your `public/stylesheets`
+# folder. You will have to require it manually in your layouts, or through
+# `jammit`, or whatever.
+# 
+# [gh]: http://github.com/josem/markdownizer
+
+#### Usage
+
+# In your model, let's say, `Post`:
+#
+#     class Post < ActiveRecord::Base
+#       # In this case we want to treat :body as markdown
+#       # This will require `body` and `rendered_body` fields
+#       # to exist previously (otherwise it will raise an error).
+#       markdownize! :body
+#     end
+#
+# Then you can create a `Post` using Markdown syntax, like this:
+#
+#    Post.create body: """
+#       # My H1 title
+#       Markdown is awesome!
+#       ## Some H2 title...
+# 
+#       {% code ruby %}
+# 
+#         # All this code will be highlighted properly! :)
+#         def my_method(*my_args)
+#           something do
+#             3 + 4
+#           end
+#         end
+# 
+#       {% endcode %}
+#    """
+#
+# After that, in your view you just have to call `@post.rendered_body` and,
+# provided you included the generated css in your layout, it will display nice
+# and coloured :)
+
+#### Show me the code!
+
+# We'll need to include [RDiscount][rd]. This is the Markdown parsing library.
+# Also, [CodeRay][cr] will provide code highlighting. We require `active_record` as
+# well, since we want to extend it with our DSL.
+#
+# [rd]: http://github.com/rtomayko/rdiscount
+# [cr]: http://github.com/rubychan/coderay
+require 'rdiscount'
+require 'coderay'
+require 'active_record' unless defined?(ActiveRecord)
+
+module ExtendedMarkdownizer
+
+  class << self
+    # Here we define two helper methods. These will be called from the model to
+    # perform the corresponding conversions and parsings.
+   
+    # `ExtendedMarkdownizer.markdown` method converts plain Markdown text to formatted html.
+    # To parse the markdown in a coherent hierarchical context, you must provide it
+    # with the current hierarchical level of the text to be parsed.
+    def markdown(text, hierarchy = 0)
+      text.gsub! %r[^(\s*)(#+)(.+)$] do
+        $1 << ('#' * hierarchy) << $2 << $3
+      end
+      text.gsub!("\\#",'#')
+      RDiscount.new(text).to_html
+    end
+
+    # `ExtendedMarkdownizer.coderay` method parses a code block delimited from `{% code
+    # ruby %}` until `{% endcode %}` and replaces it with appropriate classes for
+    # code highlighting. It can take many languages aside from Ruby.
+    #
+    # With a hash of options you can specify `:line_numbers` (`:table` or `:inline`),
+    # and the class of the enclosing div with `:enclosing_class`.
+    #
+    # It also parses a couple of special idioms:
+    #
+    #   * {% caption 'my caption' %} introduces an h5 before the code and passes
+    #     the caption to the enclosing div as well.
+    #
+    #   * {% highlight [1,2,3] %} highlights lines 1, 2 and 3. It accepts any
+    #     Enumerable, so you can also give a Range (1..3).
+    #
+    def coderay(text, options = {})
+      text.gsub(%r[\{% code (\w+?) %\}(.+?)\{% endcode %\}]m) do
+        options.delete(:highlight_lines)
+        options.delete(:caption)
+
+        enclosing_class = options[:enclosing_class] || 'markdownizer_code'
+
+        code, language = $2.strip, $1.strip
+
+        # Mark comments to avoid conflicts with Header parsing
+        code.gsub!(/(#+)/) do
+          '\\' + $1
+        end
+
+        code, options, caption = extract_caption_from(code, options)
+        code, options = extract_highlights_from(code, options)
+
+        html_caption = caption ? '<h5>' << caption << '</h5>' : nil
+
+        "<div class=\"#{enclosing_class}#{caption ? "\" caption=\"#{caption}" : ''}\">" << 
+          (html_caption || '') <<
+            CodeRay.scan(code, language).div({:css => :class}.merge(options)) <<
+              "</div>"
+      end
+    end
+    
+    # `ExtendedMarkdownizer.urls_into_anchors` method converts the urls in the text into anchors
+    def urls_into_anchors(text)
+      text.gsub(/^(((http|https):\/\/)?)[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$/ix) do |url|
+        if ($1 != 'http://')
+          uri = 'http://' + url
+          return "<a target=\"_blank\" href=\"#{uri}\">#{url}</a>"
+        else
+          return "<a target=\"_blank\" href=\"#{url}\">#{url}</a>"
+        end
+      end
+    end
+    
+    # `ExtendedMarkdownizer.youtube_embedded_videos` method converts the youtube urls into an embedded video
+    # Another way to do the same: 
+    # http://stackoverflow.com/questions/3552228/ruby-on-rails-get-url-string-parameters/3552311#3552311
+    def youtube_embedded_videos(text)
+      text.gsub(/^(http:\/\/)?(www.)?youtube.com\/watch\?v=([a-zA-Z0-9_]+)(&(.*))?$/ix) do |url|
+        iframe = '<iframe width="560" height="349" src="http://www.youtube.com/embed/' + $3.to_s + '?rel=0" frameborder="0" allowfullscreen></iframe>'
+        return iframe
+      end
+    end
+    
+    # `ExtendedMarkdownizer.vimeo_embedded_videos` method converts the vimeo urls into an embedded video
+    def vimeo_embedded_videos(text)
+      text.gsub(/^(http:\/\/)?(www.)?vimeo.com\/([a-zA-Z0-9_]+)$/ix) do |url|
+        iframe = '<iframe src="http://player.vimeo.com/video/'+ $3.to_s + '?byline=0&amp;portrait=0" width="560" height="315" frameborder="0"></iframe>'
+        return iframe
+      end
+    end
+
+    private
+
+    def extract_caption_from(code, options)
+      caption = nil
+      code.gsub!(%r[\{% caption '([^']+)' %\}]) do
+        options.merge!({:caption => $1.strip}) if $1
+        caption = $1.strip
+        ''
+      end
+      [code.strip, options, caption]
+    end
+
+    # FIXME: Find a safer way to eval code, MY LORD
+    def extract_highlights_from(code, options)
+      code.gsub!(%r[\{% highlight (.+) %\}]) do
+        enumerable = eval($1.strip)
+        enumerable = (Enumerable === enumerable)? enumerable : nil
+        options.merge!({:highlight_lines => enumerable}) if enumerable
+        ''
+      end
+      [code.strip, options]
+    end
+
+  end
+
+  #### Public interface
+  
+  # The ExtendedMarkdownizer DSL is the public interface of the gem, and can be called
+  # from any ActiveRecord model.
+  module DSL
+
+    # Calling `extended_markdownize! :attribute` (where `:attribute` can be any database
+    # attribute with type `text`) will treat this field as Markdown.
+    # You can pass an `options` hash for CodeRay. An example option would be:
+    #   
+    #   * `:line_numbers => :table` (or `:inline`)
+    #
+    # You can check other available options in CodeRay's documentation.
+    def extended_markdownize! attribute, options = {}
+      # Check that both `:attribute` and `:rendered_attribute` columns exist.
+      # If they don't, it raises an error indicating that the user should generate
+      # a migration.
+      unless self.column_names.include?(attribute.to_s) &&
+              self.column_names.include?("rendered_#{attribute}")
+        raise "#{self.name} doesn't have required attributes :#{attribute} and :rendered_#{attribute}\nPlease generate a migration to add these attributes -- both should have type :text."
+      end
+
+      # The `:hierarchy` option tells ExtendedMarkdownizer the smallest header tag that
+      # precedes the Markdown text. If you have a blogpost with an H1 (title) and
+      # an H2 (some kind of tagline), then your hierarchy is 2, and the biggest
+      # header found the markdown text will be translated directly to an H3. This
+      # allows for semantical coherence within the context where the markdown text
+      # is to be introduced.
+      hierarchy = options.delete(:hierarchy) || 0
+
+      # Create a `before_save` callback which will convert plain text to
+      # Markdownized html every time the model is saved.
+      self.before_save :"render_#{attribute}"
+
+      # Define the converter method, which will assign the rendered html to the
+      # `:rendered_attribute` field.
+      define_method :"render_#{attribute}" do
+        processed_attribute = ExtendedMarkdownizer.youtube_embedded_videos(self.send(attribute)) 
+        processed_attribute = ExtendedMarkdownizer.vimeo_embedded_videos(processed_attribute) 
+        processed_attribute = ExtendedMarkdownizer.urls_into_anchors(processed_attribute) 
+        self.send(:"rendered_#{attribute}=", ExtendedMarkdownizer.markdown(ExtendedMarkdownizer.coderay(processed_attribute, options), hierarchy))
+      end
+    end
+  end
+
+end
+
+# Finally, make our DSL available to any class inheriting from ActiveRecord::Base.
+ActiveRecord::Base.send(:extend, ExtendedMarkdownizer::DSL)
+
+# And that's it!

data/lib/extended_markdownizer/version.rb

@@ -0,0 +1,3 @@
+module ExtendedMarkdownizer
+  VERSION = "0.1.2"
+end

data/lib/generators/extended_markdownizer/install_generator.rb

@@ -0,0 +1,15 @@
+require 'rails/generators'
+
+module ExtendedMarkdownizer
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Copy ExtendedMarkdownizer code highlighting stylesheets"
+
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+
+      def copy_stylesheet_file
+        copy_file 'coderay.css', 'public/stylesheets/extended_markdownizer.css'
+      end
+    end
+  end
+end

data/lib/generators/extended_markdownizer/templates/coderay.css

@@ -0,0 +1,131 @@
+.CodeRay {
+  background-color: #f8f8f8;
+  border: 1px solid silver;
+  font-family: 'Courier New', 'Terminal', monospace;
+  color: #000;
+}
+.CodeRay pre { margin: 0px }
+
+div.CodeRay { }
+
+span.CodeRay { white-space: pre; border: 0px; padding: 2px }
+
+table.CodeRay { border-collapse: collapse; width: 100%; padding: 2px }
+table.CodeRay td { padding: 2px 4px; vertical-align: top }
+
+.CodeRay .line_numbers, .CodeRay .no {
+  background-color: #def;
+  color: gray;
+  text-align: right;
+}
+.CodeRay .line_numbers tt { font-weight: bold }
+.CodeRay .line_numbers .highlighted { color: red }
+.CodeRay .line { display: block; float: left; width: 100%; }
+.CodeRay .no { padding: 0px 4px }
+.CodeRay .code { width: 100% }
+
+ol.CodeRay { font-size: 10pt }
+ol.CodeRay li { white-space: pre }
+
+.CodeRay .code pre { overflow: auto }
+
+.CodeRay .debug { color:white ! important; background:blue ! important; }
+
+.CodeRay .af { color:#00C }
+.CodeRay .an { color:#007 }
+.CodeRay .at { color:#f08 }
+.CodeRay .av { color:#700 }
+.CodeRay .aw { color:#C00 }
+.CodeRay .bi { color:#509; font-weight:bold }
+.CodeRay .c  { color:#888; }
+
+.CodeRay .ch { color:#04D }
+.CodeRay .ch .k { color:#04D }
+.CodeRay .ch .dl { color:#039 }
+
+.CodeRay .cl { color:#B06; font-weight:bold }
+.CodeRay .cm { color:#A08; font-weight:bold }
+.CodeRay .co { color:#036; font-weight:bold }
+.CodeRay .cr { color:#0A0 }
+.CodeRay .cv { color:#369 }
+.CodeRay .de { color:#B0B; }
+.CodeRay .df { color:#099; font-weight:bold }
+.CodeRay .di { color:#088; font-weight:bold }
+.CodeRay .dl { color:black }
+.CodeRay .do { color:#970 }
+.CodeRay .dt { color:#34b }
+.CodeRay .ds { color:#D42; font-weight:bold }
+.CodeRay .e  { color:#666; font-weight:bold }
+.CodeRay .en { color:#800; font-weight:bold }
+.CodeRay .er { color:#F00; background-color:#FAA }
+.CodeRay .ex { color:#C00; font-weight:bold }
+.CodeRay .fl { color:#60E; font-weight:bold }
+.CodeRay .fu { color:#06B; font-weight:bold }
+.CodeRay .gv { color:#d70; font-weight:bold }
+.CodeRay .hx { color:#058; font-weight:bold }
+.CodeRay .i  { color:#00D; font-weight:bold }
+.CodeRay .ic { color:#B44; font-weight:bold }
+
+.CodeRay .il { background: #ddd; color: black }
+.CodeRay .il .il { background: #ccc }
+.CodeRay .il .il .il { background: #bbb }
+.CodeRay .il .idl { background: #ddd; font-weight: bold; color: #666 }
+.CodeRay .idl { background-color: #bbb; font-weight: bold; color: #666; }
+
+.CodeRay .im { color:#f00; }
+.CodeRay .in { color:#B2B; font-weight:bold }
+.CodeRay .iv { color:#33B }
+.CodeRay .la { color:#970; font-weight:bold }
+.CodeRay .lv { color:#963 }
+.CodeRay .oc { color:#40E; font-weight:bold }
+.CodeRay .of { color:#000; font-weight:bold }
+.CodeRay .op { }
+.CodeRay .pc { color:#038; font-weight:bold }
+.CodeRay .pd { color:#369; font-weight:bold }
+.CodeRay .pp { color:#579; }
+.CodeRay .ps { color:#00C; font-weight:bold }
+.CodeRay .pt { color:#074; font-weight:bold }
+.CodeRay .r, .kw  { color:#080; font-weight:bold }
+
+.CodeRay .ke { color: #808; }
+.CodeRay .ke .dl { color: #606; }
+.CodeRay .ke .ch { color: #80f; }
+.CodeRay .vl { color: #088; }
+
+.CodeRay .rx { background-color:#fff0ff }
+.CodeRay .rx .k { color:#808 }
+.CodeRay .rx .dl { color:#404 }
+.CodeRay .rx .mod { color:#C2C }
+.CodeRay .rx .fu  { color:#404; font-weight: bold }
+
+.CodeRay .s { background-color:#fff0f0; color: #D20; }
+.CodeRay .s .s { background-color:#ffe0e0 }
+.CodeRay .s .s  .s { background-color:#ffd0d0 }
+.CodeRay .s .k { }
+.CodeRay .s .ch { color: #b0b; }
+.CodeRay .s .dl { color: #710; }
+
+.CodeRay .sh { background-color:#f0fff0; color:#2B2 }
+.CodeRay .sh .k { }
+.CodeRay .sh .dl { color:#161 }
+
+.CodeRay .sy { color:#A60 }
+.CodeRay .sy .k { color:#A60 }
+.CodeRay .sy .dl { color:#630 }
+
+.CodeRay .ta { color:#070 }
+.CodeRay .tf { color:#070; font-weight:bold }
+.CodeRay .ts { color:#D70; font-weight:bold }
+.CodeRay .ty { color:#339; font-weight:bold }
+.CodeRay .v  { color:#036 }
+.CodeRay .xt { color:#444 }
+
+.CodeRay .ins { background: #afa; }
+.CodeRay .del { background: #faa; }
+.CodeRay .chg { color: #aaf; background: #007; }
+.CodeRay .head { color: #f8f; background: #505 }
+
+.CodeRay .ins .ins { color: #080; font-weight:bold }
+.CodeRay .del .del { color: #800; font-weight:bold }
+.CodeRay .chg .chg { color: #66f; }
+.CodeRay .head .head { color: #f4f; }

data/spec/extended_markdownizer_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe Markdownizer do
+  describe ".markdown(text)" do
+    let(:text) { "#My markdown text"}
+    context 'when the hierarchy is 0' do
+      it 'calls RDiscount to markdownize the text' do
+        rdiscount, html_markdown = double(:rdiscount), double(:html_markdown)
+
+        RDiscount.should_receive(:new).with(text).and_return rdiscount
+        rdiscount.should_receive(:to_html).and_return html_markdown
+        
+        subject.markdown(text).should == html_markdown
+      end
+    end
+    context 'when the hierarchy is 2' do
+      it "converts all headers into 2 levels deeper" do
+        my_text = """
+        #This is an H1
+        ##This is an H2
+        ###This is an H3
+        """
+        result = double :result, :to_html => true
+        RDiscount.should_receive(:new).with do |t|
+          t.should =~ /###This is an H1/
+          t.should =~ /####This is an H2/
+          t.should =~ /#####This is an H3/
+        end.and_return result
+        subject.markdown(my_text, 2)
+      end
+      it 'still does not convert anything that is not a header' do
+        my_text = """
+        #This is an H1
+        I am talking about my #method
+        {% code ruby %}
+          \\#My comment
+        {% endcode %}
+        ###This is an H3
+        """
+        result = double :result, :to_html => true
+        RDiscount.should_receive(:new).with do |t|
+          t.should =~ /###This is an H1/
+          t.should =~ /#method/
+          t.should_not =~ /###method/
+          t.should =~ /#My comment/
+          t.should_not =~ /###My comment/
+          t.should_not =~ /\\#My comment/
+          t.should =~ /#####This is an H3/
+        end.and_return result
+        subject.markdown(my_text, 2)
+      end
+    end
+  end
+  describe ".coderay(text)" do
+    let(:text) { """
+      #My markdown text
+
+      {% code ruby %}
+        def function(*args)
+          puts 'result'
+        end
+      {% endcode %}
+
+    """
+    }
+    let(:text_with_caption) { """
+      #My markdown text
+
+      {% code ruby %}
+      {% caption 'This will become an h5' %}
+        def function(*args)
+          puts 'result'
+        end
+      {% endcode %}
+
+    """
+    }
+    let(:text_with_weird_caption) { """
+      #My markdown text
+
+      {% code ruby %}
+      {% caption 'This will become an h5, with some/strange.characters\yo' %}
+        def function(*args)
+          puts 'result'
+        end
+      {% endcode %}
+
+    """
+    }
+    let(:text_with_array_highlights) { """
+      #My markdown text
+
+      {% code ruby %}
+      {% highlight [1,2,3] %}
+        def function(*args)
+          puts 'result'
+        end
+      {% endcode %}
+
+    """
+    }
+    let(:text_with_range_highlights) { """
+      #My markdown text
+
+      {% code ruby %}
+      {% highlight (1..3) %}
+        def function(*args)
+          puts 'result'
+        end
+      {% endcode %}
+
+    """
+    }
+    let(:text_with_comments) { """
+      #My markdown text
+
+      {% code ruby %}
+        #My comment
+        # My other comment
+        def function(*args)
+          puts 'result'
+        end
+      {% endcode %}
+
+    """
+    }
+
+    it 'calls CodeRay to parse the code inside {% code ruby %} blocks' do
+      scanned_code, html_code = double(:scanned_code), double(:html_code)
+
+      CodeRay.should_receive(:scan).with("""def function(*args)
+          puts 'result'
+        end""", 'ruby').and_return scanned_code
+
+      scanned_code.should_receive(:div).with(:css => :class, :my => :option).and_return 'parsed code'
+
+      subject.coderay(text, :my => :option).should match('parsed code')
+    end
+    it 'accepts a caption option inside the code' do
+      subject.coderay(text_with_caption).should match('<h5>This will become an h5</h5>')
+    end
+    it 'accepts a caption with weird chars inside the code' do
+      subject.coderay(text_with_weird_caption).should match('<h5>This will become an h5, with some/strange.characters\yo</h5>')
+    end
+    it 'marks ruby comments to avoid conflicts with Markdown headers' do
+      code = ''
+      code.stub(:div).and_return ''
+      CodeRay.should_receive(:scan).with do |string|
+        string.should match(/\\#My comment/)
+        string.should match(/\\# My other comment/)
+      end.and_return code
+      subject.coderay(text_with_comments)
+    end
+    it 'passes the caption to the div' do
+      parsed = double :parsed
+      CodeRay.should_receive(:scan).and_return parsed
+      parsed.should_receive(:div).with(:css => :class, :caption => 'This will become an h5').and_return 'result'
+
+      subject.coderay(text_with_caption)
+    end
+    it 'accepts highlighted lines with an array' do
+      parsed = double :parsed
+      CodeRay.should_receive(:scan).and_return parsed
+      parsed.should_receive(:div).with(:css => :class, :highlight_lines => [1,2,3]).and_return 'result'
+
+      subject.coderay(text_with_array_highlights)
+    end
+    it 'accepts highlighted lines with a range' do
+      parsed = double :parsed
+      CodeRay.should_receive(:scan).and_return parsed
+      parsed.should_receive(:div).with(:css => :class, :highlight_lines => (1..3)).and_return 'result'
+
+      subject.coderay(text_with_range_highlights)
+    end
+    it 'encloses everything in a nice class' do
+      subject.coderay(text_with_caption).should match(/div class=\"markdownizer_code\" caption=\"This will become an h5\"/)
+    end
+  end
+
+  describe Markdownizer::DSL do
+    it 'integrates with ActiveRecord::Base' do
+      (class << ActiveRecord::Base; self; end).ancestors.should include(Markdownizer::DSL)
+    end
+
+    before do
+      ActiveRecord::Base.stub(:send)
+      @klass = Class.new(ActiveRecord::Base)
+      @klass.stub(:column_names) { %{body rendered_body} }
+    end
+
+    describe "#markdownize!(attribute)" do
+      context "when either of attribute or rendered_attribute does not exist" do
+        it 'raises' do
+          expect {
+            @klass.markdownize! :some_attribute             
+          }.to raise_error
+        end
+      end
+      context "otherwise" do
+        it 'creates a before_save callback for render_attribute' do
+          @klass.should_receive(:before_save).with(:render_body)
+          @klass.markdownize! :body
+        end
+        it 'defines this render_attribute method' do
+          klass = Class.new do
+            extend Markdownizer::DSL
+            def self.column_names
+              %{body rendered_body}
+            end
+          end
+
+          klass.stub(:before_save)
+          klass.markdownize! :body
+
+          raw_body, raw_body_with_code, final_code = double(:raw_body),
+                                                      double(:raw_body_with_code),
+                                                        double(:final_code)
+
+          instance = klass.new
+          instance.should_receive(:send).with(:body).and_return raw_body
+          Markdownizer.should_receive(:coderay).with(raw_body, {}).and_return raw_body_with_code
+          Markdownizer.should_receive(:markdown).with(raw_body_with_code, 0).and_return final_code
+
+          instance.should_receive(:send).with(:rendered_body=, final_code)
+          instance.render_body
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec'
+require 'markdownizer'

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification 
+name: extended_markdownizer
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.2
+platform: ruby
+authors: 
+- "Jos\xC3\xA9 M. Gilgado"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdiscount
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: coderay
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rocco
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: git
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id006
+description: Render any text as markdown, with code highlighting, url detection and conversion of youtube/vimeo urls into embedded videos
+email: 
+- jm.gilgado@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gemtest
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- Readme.md
+- extended_markdownizer.gemspec
+- init.rb
+- lib/extended_markdownizer.rb
+- lib/extended_markdownizer/version.rb
+- lib/generators/extended_markdownizer/install_generator.rb
+- lib/generators/extended_markdownizer/templates/coderay.css
+- spec/extended_markdownizer_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/josem/extended_markdownizer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: extended_markdownizer
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Render any text as markdown, with code highlighting and all!
+test_files: 
+- spec/extended_markdownizer_spec.rb
+- spec/spec_helper.rb