slippery 0.0.1

data/lib/slippery/converter.rb

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+
+# Main class that does the conversion from Markdown/Kramdown to Hexp.
+# Subclass this for custom behavior.
+#
+# See https://github.com/3/blob/master/lib/kramdown/element.rb for a list of
+# types
+#
+class Slippery::Converter
+  private_attr_accessor :type, :value, :attr, :children, :options
+  undef_method :p
+
+  # Convert a Kramdown syntax tree into Hexp.
+  #
+  # @example
+  #   markdown = "# Hello!\n\nChunky *bacon*!\n"
+  #   document = Kramdown::Document.new(markdown)
+  #   hexp = converter.convert(document.root)
+  #
+  # @param el [Kramdown::Element] The root element to convert
+  # @return [Hexp::Node]
+  # @api public
+  #
+  def convert(el)
+    #Kernel.p el ; exit
+    @type, @value, @attr, @children, @options =
+      el.type, el.value, el.attr, el.children, el.options
+    send(type)
+  end
+
+  # Process a Kramdown :root type element
+  #
+  # @return [Hexp::Node]
+  # @api semipublic
+  #
+  def root
+    H[:html, [H[:head], tag!(:body)]]
+  end
+
+  # Process a Kramdown :header type element
+  #
+  # @return [Hexp::Node]
+  # @api semipublic
+  #
+  def header
+    tag! "h#{options[:level]}".intern
+  end
+
+  # Process a Kramdown :codeblock type element
+  #
+  # @return [Hexp::Node]
+  # @api semipublic
+  #
+  def codeblock
+    H[:pre, attr, H[:code, value]]
+  end
+
+  def smart_quote
+    {
+      :lsquo => '‘',
+      :rsquo => '’',
+      :ldquo => '“',
+      :rdquo => '”',
+    }[value]
+  end
+
+  def typographic_sym
+    {
+      :hellip => '…',
+      :mdash  => '—',
+      :ndash  => '–',
+      :laquo  => '«',
+      :raquo  => '»',
+      :laquo_space => '« ',
+      :raquo_space => ' »',
+    }[value]
+  end
+
+  def html_element
+    H[value.to_sym, attr, convert_children]
+  end
+
+  def entity
+    value.char
+  end
+
+  def codespan
+    H[:code, value]
+  end
+
+  def xml_comment; end
+
+  # Create a Hexp::Node from the current element
+  #
+  # Helper for when you want to turn the Kramdown element straight into a
+  # Hexp::Node with the same attributes, and a one-to-one mapping of the child
+  # elements.
+  #
+  # @param tag [Symbol] The HTML tag to generate
+  # @return [Hexp::Node]
+  # @api semipublic
+  #
+  def tag!(tag)
+    H[tag, attr, convert_children]
+  end
+
+  [:text, :blank, :raw].each do |sym|
+    define_method sym do
+      Hexp::TextNode.new(value)
+    end
+  end
+
+  [:p, :blockquote, :ul, :li, :ol, :dl, :dt, :dd, :em, :strong, :img, :a, :hr, :br].each do |sym|
+    define_method sym do
+      tag! type
+    end
+  end
+
+  # Convert the children of the Kramdown element to Hexps
+  #
+  # In other words, recurse down the tree. This will pass each
+  # child element into the converter.
+  #
+  # @return [Array<Hexp::Node>]
+  # @api private
+  #
+  def convert_children
+    children.map {|ch| convert ch }.compact
+  end
+end

data/lib/slippery/document.rb

@@ -0,0 +1,20 @@
+module Slippery
+  class Document
+    include Hexp
+
+    private_attr_accessor :processors
+
+    def initialize(markdown)
+      @markdown = markdown
+    end
+
+    def kramdown_document
+      @kramdown_document ||= Kramdown::Document.new(@markdown, input: 'GFM')
+    end
+
+    def to_hexp
+      @hexp ||= Slippery::Converter.new.convert(kramdown_document.root).to_hexp
+    end
+
+  end
+end

data/lib/slippery/presentation.rb

@@ -0,0 +1,36 @@
+module Slippery
+  class Presentation
+    include Hexp
+
+    DEFAULT_OPTIONS = {
+      type: :reveal_js
+    }.freeze
+
+    def initialize(document, options = {})
+      @document = document
+      @options = DEFAULT_OPTIONS.merge(options).freeze
+    end
+
+    def processors
+      {
+        :impress_js => [
+          HrToSections.new(H[:div, class: 'step']),
+          ImpressJs::AddImpressJs.new(js_options),
+          ImpressJs::AutoOffsets.new,
+        ],
+        :reveal_js => [
+          HrToSections.new(H[:section]),
+          RevealJs::AddRevealJs.new(js_options),
+        ]
+      }[@options[:type]]
+    end
+
+    def js_options
+      @options.reject {|key,_| [:type].include? key }
+    end
+
+    def to_hexp
+      @document.process(*processors)
+    end
+  end
+end

data/lib/slippery/processor_helpers.rb

@@ -0,0 +1,43 @@
+module Slippery
+  module ProcessorHelpers
+    def self.included(klz)
+      klz.extend ClassMethods
+    end
+
+    def include_local_javascript(element, relative_path)
+      element.add javascript_include_tag(asset_uri(relative_path))
+    end
+
+    def include_local_css(element, relative_path)
+      element.add stylesheet_link_tag(asset_uri(relative_path))
+    end
+
+    def asset_uri(path)
+      'file://' + File.expand_path('../../../assets/'+ path, __FILE__)
+    end
+
+    def javascript_include_tag(path)
+      H[:script, {src: path, type: 'text/javascript'}]
+    end
+
+    def stylesheet_link_tag(path)
+      H[:link, {href: path, rel: 'stylesheet'}]
+    end
+
+    def data_attributes(attrs)
+      Hash[*attrs.flat_map {|k,v| ["data-#{k}", v]}]
+    end
+
+    module ClassMethods
+      def processor(name, selector = nil, &blk)
+        if selector
+          define_method name do
+            ->(node) { node.replace(selector) {|node| instance_exec(node, &blk) } }
+          end
+        else
+          define_method name { ->(node) { blk.call(node) } }
+        end
+      end
+    end
+  end
+end

data/lib/slippery/processors/add_google_font.rb

@@ -0,0 +1,27 @@
+require 'cgi'
+
+module Slippery
+  module Processors
+    class AddGoogleFont
+      def initialize(font_name, variants = [])
+        @font_name = font_name.freeze
+        @variants  = variants.freeze
+      end
+
+      def call(doc)
+        doc.rewrite('head', &add_font_link)
+      end
+
+      def add_font_link
+        ->(head) {
+          head << H[:link, {rel: 'stylesheet', type: 'text/css', href: href}]
+        }
+      end
+
+      def href
+        'http://fonts.googleapis.com/css?family=' +
+          CGI.escape(@font_name) + (@variants.empty? ? '' : ':' + @variants.join(','))
+      end
+    end
+  end
+end

data/lib/slippery/processors/graphviz_dot.rb

@@ -0,0 +1,46 @@
+require 'tempfile'
+
+module Slippery
+  module Processors
+    # Turn embedded dot files into embedded SVGs
+    class GraphvizDot
+      def initialize(selector = '.language-dot')
+        @selector = selector
+      end
+
+      def self.call(doc)
+        self.new.call(doc)
+      end
+
+      def call(doc)
+        doc
+          .rewrite(@selector, &create_svg_from_dot)
+          .rewrite('polygon[fill=white][stroke=white]') { [] }
+      end
+
+      def create_svg_from_dot
+        ->(node) do
+          dot_to_hexp(node.text).process(copy_width_height(node))
+        end
+      end
+
+      def dot_to_hexp(dot_source)
+        file = Tempfile.new(['slippery','.dot'])
+        file << dot_source
+        file.close
+        Hexp.parse(`dot #{file.path} -Tsvg`)
+      end
+
+      def copy_width_height(node)
+        ->(svg) do
+          return svg unless node[:width] || node[:height]
+          [:width, :height].each do |attr|
+            svg = svg.remove_attr(attr)
+            svg = svg.attr(attr, node[attr]) if node[attr]
+          end
+          svg
+        end
+      end
+    end
+  end
+end

data/lib/slippery/processors/hr_to_sections.rb

@@ -0,0 +1,36 @@
+module Slippery
+  module Processors
+    # Take a flat list of elements, and wrap elements between <hr> lines into
+    # a sections.
+    #
+    # @example
+    #   HrToSections.new('body', H[:section]).call(doc)
+    #
+    class HrToSections
+      def self.call(doc)
+        self.new.call(doc)
+      end
+
+      def initialize(wrapper = H[:section], selector = 'body')
+        @selector, @wrapper = selector, wrapper
+      end
+
+      def call(doc)
+        doc.replace(@selector) { |element| hr_to_section(element) }
+      end
+
+      def hr_to_section(element)
+        sections = [@wrapper]
+        element.children.each do |child|
+          if child.tag == :hr
+            sections << @wrapper.merge_attrs(child)
+          else
+            sections[-1] = sections.last << child
+          end
+        end
+        element.set_children(sections)
+      end
+
+    end
+  end
+end

data/lib/slippery/processors/impress_js/add_impress_js.rb

@@ -0,0 +1,30 @@
+module Slippery
+  module Processors
+    module ImpressJs
+     class AddImpressJs
+       include ProcessorHelpers
+
+       def self.call(doc)
+         self.new.call(doc)
+       end
+
+       attr_reader :attributes
+
+       DEFAULT_ATTRS = {'transition-duration' => 1000}.freeze
+
+       def initialize(attributes = {})
+         @attributes = DEFAULT_ATTRS.merge(attributes).freeze
+       end
+
+       def call(doc)
+         doc.replace('body') do |body|
+           include_local_javascript(body, 'impress.js/js/impress.js')
+             .set_attributes({id: 'impress'}.merge(data_attributes(attributes)))
+             .add H[:script, "impress().init();"]
+         end
+       end
+
+     end
+   end
+ end
+end

data/lib/slippery/processors/impress_js/auto_offsets.rb

@@ -0,0 +1,25 @@
+module Slippery
+  module Processors
+    module ImpressJs
+      class AutoOffsets
+        def initialize(offset_x = 1000, offset_y = 0)
+          @offsets  = [offset_x, offset_y]
+          @position = [0,0]
+        end
+
+        def call(doc)
+          doc.replace('.step') do |step|
+            ['data-x', 'data-y'].each_with_index do |axis, idx|
+              if step.attr?(axis)
+                @position[idx] = step[axis].to_i
+              else
+                @position[idx] += @offsets[idx]
+              end
+            end
+            step % { 'data-x' => @position[0], 'data-y' => @position[1] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slippery/processors/reveal_js/add_reveal_js.rb

@@ -0,0 +1,78 @@
+module Slippery
+  module Processors
+    module RevealJs
+      class AddRevealJs
+        include ProcessorHelpers
+
+        def self.call(doc)
+          self.new.call(doc)
+        end
+
+        attr_reader :attributes
+
+        DEFAULT_OPTIONS = {theme: 'default'}.freeze
+
+        def initialize(options = {})
+          @options = DEFAULT_OPTIONS.merge(options).freeze
+        end
+
+        def call(doc)
+          doc.process(
+            reveal_wrap,
+            add_reveal_js,
+            add_reveal_css,
+            add_theme,
+            add_settings
+          )
+        end
+
+        processor :add_reveal_js, 'body' do |body|
+          body = include_local_javascript(body, 'reveal.js/lib/js/head.min.js')
+          include_local_javascript(body, 'reveal.js/js/reveal.js')
+        end
+
+        processor :add_reveal_css, 'head' do |head|
+          include_local_css(head, 'reveal.js/css/reveal.min.css')
+        end
+
+        processor :add_theme, 'head' do |head|
+          include_local_css(head, "reveal.js/css/theme/#{@options[:theme]}.css")
+        end
+
+        processor :add_settings, 'body' do |body|
+          body.add(H[:script, "Reveal.initialize({ #{plugin_settings}, #{settings.map {|k,v| "#{k}:#{v.inspect}"}.join(',')} });"])
+        end
+
+        processor :reveal_wrap, 'body' do |body|
+          body.set_children(
+            H[:div, {class: 'reveal'}, [
+                H[:div, {class: 'slides'}, body.children]
+              ]
+            ]
+          )
+        end
+
+        def settings
+          @options.reject{|key,_| [:theme, :plugins].include? key }
+        end
+
+        def plugin_settings
+          "dependencies: [" +
+          Array(@options.fetch(:plugins, [])).map do |name|
+            plugin_config name
+          end.join(',') + "]"
+        end
+
+        def plugins(name)
+          {
+            notes: 'plugin/notes/notes.js'
+          }[name]
+        end
+
+        def plugin_config(plugin)
+          "{ src: #{plugins(plugin).inspect}, async: true, condition: function() { return !!document.body.classList; } }"
+        end
+      end
+    end
+  end
+end

data/lib/slippery/processors/self_contained.rb

@@ -0,0 +1,62 @@
+require 'base64'
+require 'open-uri'
+
+module Slippery
+  module Processors
+    class SelfContained
+      def self.call(doc)
+        self.new.call(doc)
+      end
+
+      def call(doc)
+        doc
+          .rewrite('link[rel=stylesheet]', &convert_stylesheet_to_inline)
+          .rewrite('script[src]',          &convert_script_to_inline)
+          .rewrite('img',                  &convert_image_to_data_uri)
+          #.rewrite('style',                &convert_style_uri_to_data_uri)
+      end
+
+      def convert_stylesheet_to_inline
+        ->(link) { H[:style, { type: 'text/css' }, read_uri(link[:href])] }
+      end
+
+      def convert_script_to_inline
+        ->(script) do
+          attrs = script.attributes.reject { |k,v| k=='src' }
+          H[:script, attrs, read_uri(script[:src])]
+        end
+      end
+
+      def convert_image_to_data_uri
+        ->(img) { H[:img, img.attributes.merge(src: data_uri(img[:src]))] }
+      end
+
+      # def convert_style_uri_to_data_uri
+      #   ->(style) {
+      #     H[:style, style.attributes, style.children.first.gsub(/url\(['"]?[^'"\)]+['"]?\)/) {|url| "url('#{data_uri url[/url\(['"]?([^'"\)]+)/,1] }')"} ] }
+      # end
+
+      def read_uri(uri)
+        @@download_cache ||= {}
+        if uri =~ /http/
+          @@download_cache[uri] ||= open(uri.sub('file://', '')).read
+        else
+          open(uri.sub('file://', '')).read
+        end
+      end
+
+      def data_uri(uri)
+        base64 = Base64.encode64(read_uri uri)
+        ext    = File.extname(uri)
+        type   = {
+          '.jpg'  => 'image/jpeg',
+          '.jpeg' => 'image/jpeg',
+          '.png'  => 'image/png',
+          '.gif'  => 'image/gif',
+        }[ext.downcase]
+
+        "data:#{type};base64,#{base64}"
+      end
+    end
+  end
+end

data/lib/slippery/version.rb

@@ -0,0 +1,3 @@
+module Slippery
+  VERSION = '0.0.1'
+end

data/lib/slippery.rb

@@ -0,0 +1,42 @@
+require 'kramdown'
+require 'hexp'
+
+# Slippery namespace module
+module Slippery
+  def self.convert(element)
+    Slippery::Converter.new.convert(element)
+  end
+end
+
+# Core extension
+class Class
+  unless defined?(private_attr_accessor)
+    # Like attr_accessor, but only available inside the class
+    #
+    # @param args [Array<Symbol>] The attributes to define
+    # @api private
+    #
+    def private_attr_accessor(*args)
+      attr_accessor(*args)
+      private(*args)
+      private(*args.map {|method| "#{method}=".intern })
+    end
+  end
+end
+
+require 'slippery/version'
+require 'slippery/converter'
+require 'slippery/document'
+require 'slippery/presentation'
+
+require 'slippery/processor_helpers'
+
+require 'slippery/processors/add_google_font'
+require 'slippery/processors/graphviz_dot'
+require 'slippery/processors/hr_to_sections'
+require 'slippery/processors/self_contained'
+
+require 'slippery/processors/impress_js/add_impress_js'
+require 'slippery/processors/impress_js/auto_offsets'
+
+require 'slippery/processors/reveal_js/add_reveal_js'

data/slippery.gemspec

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/slippery/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'slippery'
+  gem.version     = Slippery::VERSION
+  gem.authors     = [ 'Arne Brasseur' ]
+  gem.email       = [ 'arne@arnebrasseur.net' ]
+  gem.description = 'Make presentations with Markdown'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/plexus/slippery'
+  gem.license     = 'MIT'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split($/)
+  gem.test_files       = `git ls-files -- spec`.split($/)
+  gem.extra_rdoc_files = %w[README.md LICENSE]
+
+  gem.add_runtime_dependency 'hexp'         , '~> 0.0'
+  gem.add_runtime_dependency 'kramdown'     , '~> 1.1'
+
+  gem.add_development_dependency 'rake',  '~> 10.1'
+  gem.add_development_dependency 'rspec', '~> 2.14'
+end

data/spec/fixtures/blockquotes.md

@@ -0,0 +1,6 @@
+> This is a block quote
+>
+> With two paragraphs
+
+> This is a second block quote
+that is hand-wrapped

data/spec/fixtures/code_blocks.md

@@ -0,0 +1,9 @@
+    an indented code block
+
+~~~
+a fenced code block
+~~~
+
+~~~ ruby
+code block with language specifier
+~~~

data/spec/fixtures/definition_lists.md

@@ -0,0 +1,2 @@
+Jabberwocky
+: mythical beast of poetic proportions

data/spec/fixtures/header_and_paragraph.md

@@ -0,0 +1,2 @@
+# Hello, World!
+This is a paragraph.

data/spec/fixtures/headers.md

@@ -0,0 +1,13 @@
+Level 1
+========
+
+Level 2
+-------
+
+### Level 3
+
+# Level 1 again
+
+## Level 2
+
+###### Level 6

data/spec/fixtures/ordered_list.md

@@ -0,0 +1,3 @@
+1. ninjas
+2. pirates
+3. sales people

data/spec/fixtures/unordered_list.md

@@ -0,0 +1,3 @@
+* banana
+* apple
+* guava