parade 0.8.0

data/lib/parade/parsers/presentation_filepath_parser.rb

@@ -0,0 +1,35 @@
+require_relative 'presentation_directory_parser'
+require_relative 'presentation_file_parser'
+require_relative 'slides_file_content_parser'
+
+module Parade
+  module Parsers
+
+    class PresentationFilepathParser
+
+      def self.parse(filepath,options = {})
+        return nil unless File.exists? filepath
+
+        if File.directory? filepath
+          PresentationDirectoryParser.parse filepath, options
+        else
+
+          if presentation_file?(filepath)
+            PresentationFileParser.parse filepath, options
+          else
+            SlidesFileContentParser.parse filepath, options
+          end
+
+        end
+
+      end
+
+
+      def self.presentation_file?(filepath)
+        File.basename(filepath) == "parade"
+      end
+
+    end
+
+  end
+end

data/lib/parade/parsers/slides_file_content_parser.rb

@@ -0,0 +1,27 @@
+require_relative 'markdown_image_paths'
+require_relative 'markdown_slide_splitter'
+
+module Parade
+  module Parsers
+
+    module SlidesFileContentParser
+      def self.parse(filepath,options = {})
+        slides_content = File.read(filepath)
+        relative_path = File.dirname(filepath).gsub(options[:root_path].gsub(/\/$/,''),'')
+        slides_content = MarkdownImagePaths.parse(slides_content,:path => relative_path)
+
+        create_section_with slides_content
+      end
+
+      private
+
+      def self.create_section_with(slides_content)
+        section = Section.new
+        section.add_slides(MarkdownSlideSplitter.parse(slides_content))
+        section
+      end
+
+    end
+
+  end
+end

data/lib/parade/renderers/columns_renderer.rb

@@ -0,0 +1,68 @@
+module Parade
+  module Renderers
+
+    #
+    # With the given HTML content, search for the CSS class for the HTML element
+    # and when found generate columns for each element found. The size of the
+    # columns is a division of the number of segments.
+    #
+    class ColumnsRenderer
+
+      attr_accessor :css_class
+      attr_accessor :html_element
+      attr_accessor :segments
+
+      #
+      # @example Creating a ColumnsRenderer
+      #
+      # Creation of a column renderer that will look for slides with the class
+      # 'columns', and create columns out of all h2 elements found, dividing
+      # them across 12 elements.
+      #
+      #     ColumnsRenderer.new(:css_class => 'columns',:html_element => "h2",:segments => 12)
+      #
+      def initialize(params={})
+        params.each {|k,v| send("#{k}=",v) if respond_to? "#{k}=" }
+      end
+
+      def render(content)
+
+        html = Nokogiri::XML.fragment(content)
+        parser = CommandlineParser.new
+
+        html.css(".#{css_class}").each do |slide|
+
+          columns = []
+          slop = []
+
+          chunks = slide.children.chunk {|child| child.name == html_element }
+
+          slide.children = ""
+
+          slide['class'] += " container_#{segments}"
+          current_column = slide
+
+          column_count = chunks.find_all {|is_column,contents| is_column }.count
+
+          chunks.each do |is_column,contents|
+
+            if is_column
+              slide.add_child current_column unless current_column == slide
+              current_column = Nokogiri::XML::Node.new('div',html)
+              current_column['class'] = "grid_#{ segments / column_count }"
+            end
+
+            contents.each {|content| current_column.add_child content }
+          end
+
+          slide.add_child current_column
+
+        end
+
+        html.to_s
+
+      end
+    end
+
+  end
+end

data/lib/parade/renderers/command_line_renderer.rb

@@ -0,0 +1,142 @@
+require 'parslet'
+
+module Parade
+  module Renderers
+
+    #
+    # Slides that have been marked as 'commandline' will be processed here to
+    # ensure that the command portion is played out as if typed. Followed by
+    # the result which appears after the command is completed.
+    #
+    # @example Slide marker to denote a command-line slide
+    #
+    #     !SLIDE commandline incremental
+    #
+    #
+    # To denote the command, it needs to be prefaced with a `$`. The remaining
+    # code is considered to be the result.
+    #
+    # @example Contents of a slide to show a command and a result
+    #
+    #     ```bash
+    #     $ git commit -am 'incremental bullet points working'
+    #     [master ac5fd8a] incremental bullet points working
+    #      2 files changed, 32 insertions(+), 5 deletions(-)
+    #     ```
+    #
+    class CommandLineRenderer
+
+      #
+      # @param [String] html_content the html content of a single slide that
+      #   will have the commandline rendered correctly if it is a class on
+      #   the slide.
+      # @return [String] the same html content if there is no commandline class
+      #   or the new rendered html content with the new required HTML elements.
+      #
+      def self.render(html_content)
+
+        html = Nokogiri::XML.fragment(html_content)
+        parser = CommandlineParser.new
+
+        html.css('.commandline pre').each do |code|
+          out = code.text
+          code.content = ''
+          tree = parser.parse(out)
+          transform = Parslet::Transform.new do
+            rule(:prompt => simple(:prompt), :input => simple(:input), :output => simple(:output)) do
+              command = Nokogiri::XML::Node.new('pre', html)
+              command.set_attribute('class', 'command')
+              command.content = "#{prompt} #{input}"
+              code << command
+
+              # Add newline after the input so that users can
+              # advance faster than the typewriter effect
+              # and still keep inputs on separate lines.
+              code << "\n"
+
+              unless output.to_s.empty?
+                result = Nokogiri::XML::Node.new('pre', html)
+                result.set_attribute('class', 'result')
+                result.content = output
+                code << result
+              end
+
+            end
+          end
+          transform.apply(tree)
+        end
+
+        html.to_s
+
+      end
+
+    end
+
+    # For parsing commandline slide content.
+    class CommandlineParser < Parslet::Parser
+
+      rule(:prompt) do
+        str('$') | str('#') | str('>>')
+      end
+
+      rule(:text) do
+        match['[:print:]'].repeat
+      end
+
+      rule(:singleline_input) do
+        (str("\\\n").absent? >> match['[:print:]']).repeat
+      end
+
+      rule(:input) do
+        multiline_input | singleline_input
+      end
+
+      rule(:multiline_input) do
+
+        # some command \
+        # continued \
+        # \
+        # and stop
+        ( singleline_input >> str('\\') >> newline ).repeat(1) >> singleline_input
+      end
+
+      rule(:command) do
+
+        # $ some command
+        # some output
+        ( prompt.as(:prompt) >> space? >> input.as(:input) >> output? ).as(:command)
+      end
+
+      rule(:output) do
+
+        # output
+        prompt.absent? >> text
+      end
+
+      rule(:output?) do
+
+        #
+        # some text
+        # some text
+        #
+        # some text
+        ( newline >> ( ( output >> newline ).repeat >> output.maybe ).as(:output) ).maybe
+      end
+
+      rule(:commands) do
+        command.repeat
+      end
+
+      rule(:newline) do
+        str("\n") | str("\r\n")
+      end
+
+      rule(:space?) do
+        match['[:space:]'].repeat
+      end
+
+      root(:commands)
+    end
+
+  end
+end

data/lib/parade/renderers/html_with_pygments.rb

@@ -0,0 +1,42 @@
+require 'redcarpet'
+require 'pygments.rb'
+
+module Parade
+  module Renderers
+    class HTMLwithPygments < Redcarpet::Render::XHTML
+
+      #
+      # When rendering the markdown, the code should be rendered using the
+      # Pygments highlight which corresponds to the ghf_marked.css
+      #
+      # Additionally a class `sh_javascript` or `sh_ruby` is added that will
+      # assist in providing a system to provide live interactive elements
+      # through the javascript defined in `parade.js`.
+      #
+      # @param [String] code the fenced code to be highlighted
+      # @param [String] language the name of the fenced code
+      #
+      def block_code(code, language)
+        syntax_highlighted_html = Pygments.highlight code, :lexer => language,
+          :options => {:encoding => 'utf-8'}
+
+        syntax_highlighted_html.gsub('class="highlight"',"class=\"highlight sh_#{language}\"")
+      end
+
+      def self.render(content)
+        markdown = Redcarpet::Markdown.new(Renderers::HTMLwithPygments,
+          :fenced_code_blocks => true,
+          :no_intra_emphasis => true,
+          :autolink => true,
+          :strikethrough => true,
+          :lax_html_blocks => true,
+          :superscript => true,
+          :hard_wrap => true,
+          :tables => true,
+          :xhtml => true)
+        markdown.render(content)
+      end
+
+    end
+  end
+end

data/lib/parade/renderers/inline_images.rb

@@ -0,0 +1,31 @@
+
+module Parade
+  module Renderers
+
+    #
+    # This Renderer will inline the images into content output. Allowing you
+    # to create portable documents.
+    #
+    module InlineImages
+
+      def self.render(content,options = {})
+
+        content.gsub(/img src=["']\/?([^\/].*?)["']/) do |image_source|
+          image_name = Regexp.last_match(1)
+
+          base64_data = image_path_to_base64(image_name)
+
+          if base64_data
+            %{img src="#{base64_data}"}
+          else
+            image_source
+          end
+        end
+
+      end
+
+      extend Parade::Helpers::EncodeImage
+
+    end
+  end
+end

data/lib/parade/renderers/special_paragraph_renderer.rb

@@ -0,0 +1,23 @@
+module Parade
+  module Renderers
+
+    #
+    # Within the markdown you are able to add additional formatting by starting
+    # a new line with a period followed by the class name. This is commonly
+    # used for writing presenter notes.
+    #
+    # @example Adding a presenter note within the markdown
+    #
+    #     ## This Slide has important details
+    #     * Detail 1
+    #     * Detail 2
+    #     .notes Ensure that you talk about detail 1 the most!
+    #
+    class SpecialParagraphRenderer
+      def self.render(html_content)
+        html_content.gsub(/<p>\.(.*?) /, '<p class="\1">')
+      end
+    end
+
+  end
+end

data/lib/parade/renderers/update_image_paths.rb

@@ -0,0 +1,75 @@
+module Parade
+  module Renderers
+
+    #
+    # UpdateImagePaths is used to ensure the img source paths in the HTML
+    # content is properly prefaced with the "image" path as that is necessary
+    # for the Sinatra server to properly know that it is to return an image.
+    #
+    # Additional processing of the image is provided if RMagick has been
+    # installed. Namely it sets the size correctly.
+    #
+    class UpdateImagePaths
+
+      attr_accessor :root_path
+
+      def initialize(params = {})
+        params.each {|k,v| send("#{k}=",v) if respond_to? "#{k}=" }
+      end
+
+      #
+      # @param [String] content HTML content that is parsed for image srcs
+      # @param [Hash] options additional parameters, at the moment it is unused.
+      #
+      def self.render(content,options = {})
+        self.new(options).render(content)
+      end
+
+      def render(content,options = {})
+        render_root_path = options[:root_path] || root_path || "."
+
+        content.gsub(/img src=["'](?!https?:\/\/)\/?([^\/].*?)["']/) do |image_source|
+          image_name = Regexp.last_match(1)
+          
+          html_image_path = File.join("/","image",image_name)
+          updated_image_source = %{img src="#{html_image_path}"}
+
+          html_asset_path = File.join(render_root_path,image_name)
+          width, height = get_image_size(html_asset_path)
+          updated_image_source << %( width="#{width}" height="#{height}") if width and height
+
+          updated_image_source
+        end
+      end
+
+      def get_image_size(path) ; end
+
+      if defined?(Magick)
+
+        def get_image_size(path)
+          unless cached_image_size.key?(path)
+
+            image = Magick::Image.ping(path).first
+
+            # # don't set a size for svgs so they can expand to fit their container
+            if image.mime_type == 'image/svg+xml'
+              cached_image_size[path] = [nil, nil]
+            else
+              cached_image_size[path] = [image.columns, image.rows]
+            end
+
+          end
+          cached_image_size[path]
+        end
+
+        def cached_image_size
+          @cached_image_size ||= {}
+        end
+
+
+      end
+
+    end
+
+  end
+end