parade 0.8.0

data/lib/parade/metadata/html_id.rb

@@ -0,0 +1,35 @@
+module Parade
+  class Metadata
+
+    #
+    # Specify the HTML id of the slide through this metadata parser. This allows
+    # the id to be defined like one would reference with jQuery.
+    #
+    # @example Setting the Metadata id
+    #
+    #     metadata = Metadata.parse "transition=fade one two #id three tpl=template_name"
+    #     metadata.id # => id
+    #
+    # @see Metadata
+    #
+    class HTMLId
+
+      def match?(term)
+        term =~ /#.+/
+      end
+
+      def apply(term,hash)
+        hash[:id] = parse(term)
+        hash
+      end
+
+      private
+
+      def parse(term)
+        term[1..-1]
+      end
+
+    end
+
+  end
+end

data/lib/parade/metadata/template.rb

@@ -0,0 +1,31 @@
+module Parade
+  class Metadata
+
+    #
+    # The Template metadata allows the specification of a template to use for
+    # the slide. This is extremely similar to the {Assignment} parser, except
+    # it allows for the previously supported abbreviation *tpl* for representing
+    # template.
+    # 
+    class Template
+
+      def match?(term)
+        term =~ /^(?:tpl|template)=(.+)$/
+      end
+
+      def apply(term,hash)
+        hash[:template] = parse(term)
+        hash
+      end
+
+      private
+
+      def parse(term)
+        term =~ /^(?:tpl|template)=(.+)$/
+        template_name = Regexp.last_match(1)
+      end
+
+    end
+
+  end
+end

data/lib/parade/parsers/dsl.rb

@@ -0,0 +1,138 @@
+require_relative '../section'
+require_relative 'presentation_filepath_parser'
+
+module Parade
+  module Parsers
+
+    class Dsl
+
+      #
+      # The parade DSL parse method is used to convert the parade file contents
+      # into executable ruby code. This method is also called recursively when
+      # a section contains sub-sections to properly parse that data as well.
+      #
+      # @param [String,Section] contents the string representation of the parade
+      #   dsl contents to be parsed or the current section to be used as the
+      #   current context.
+      # @param [Hash] options additional options to provide additional
+      #   configuration to the parsing process.
+      #
+      # def self.parse(contents,options = {})
+      #   builder = new
+      #   builder.options = options
+      #
+      #   config = Proc.new { eval(contents) }
+      #   builder.instance_eval(&config)
+      #
+      #   builder.current_section
+      # end
+
+      def self.parse(contents,options = {},&config)
+        builder = new
+        builder.options = options
+
+        if contents.is_a? Section
+          builder.current_section = contents
+        else
+          config = Proc.new { eval(contents) }
+        end
+
+        builder.instance_eval(&config)
+
+        builder.current_section
+      end
+
+      #
+      # This is used within the DSL to set the title of the current section.
+      #
+      # @param [String] new_title the title for the setion.
+      #
+      def title(new_title)
+        current_section.title = new_title
+      end
+
+      #
+      # This is used within the DSL to set the description of the current section.
+      #
+      # @param [String] new_description the description for the setion.
+      #
+      def description(new_description)
+        current_section.description = new_description
+      end
+
+      #
+      # This is used by the DSL to add additional sections. Adds the specified
+      # slides or sub-sections, defined by their filepaths, as a subsection of
+      # this section.
+      #
+      def section(*filepaths,&block)
+
+        if block
+          sub_section = Section.new :title => filepaths.flatten.compact.join(" ")
+          section_content = self.class.parse sub_section, options, &block
+        else
+          section_content = Array(filepaths).flatten.compact.map do |filepath|
+            filepath = File.join(current_path,filepath)
+            PresentationFilepathParser.parse(filepath,options)
+          end
+        end
+
+        current_section.add_section section_content
+        section_content
+      end
+
+      alias_method :slides, :section
+
+      def template(template_name,template_file)
+        current_section.add_template template_name, File.join(options[:current_path], template_file)
+      end
+
+      #
+      # This is used by the DSL to specify the resources used by the presentation
+      #
+      def resources(resource_filepath)
+        current_section.add_resource File.join(options[:current_path], resource_filepath)
+      end
+
+      def pause_message(message)
+        current_section.pause_message = message
+      end
+
+      # @return [Hash] configuration options that the DSL class will use
+      #   and pass to other file and directory parsers to ensure the
+      #   path information is presevered correctly.
+      attr_accessor :options
+
+      # @return [String] the root path where the presentation is being served
+      #   from. This path is necessary to ensure that images have the correct
+      #   image path built for it.
+      def root_path
+        File.directory?(options[:root_path]) ? options[:root_path] : File.dirname(options[:root_path])
+      end
+
+      # @return [String] the current path is the path for the current section
+      #   this usually differs from the root_path when parsing sections defined
+      #   within a section (a sub-section).
+      def current_path
+        if options[:current_path]
+          File.directory?(options[:current_path]) ? options[:current_path] : File.dirname(options[:current_path])
+        else
+          root_path
+        end
+      end
+
+      attr_writer :current_section
+
+      # @return [Section] the current section being built.
+      def current_section
+        @current_section ||= begin
+          new_section = Section.new
+          new_section.add_resource current_path
+          new_section
+        end
+      end
+
+    end
+
+  end
+end

data/lib/parade/parsers/dsl_file_parser.rb

@@ -0,0 +1,17 @@
+module Parade
+  module Parsers
+
+    #
+    # Given a DSL defined file, load the contents and then parse the contents
+    # with the DSL parser.
+    #
+    class DslFileParser
+
+      def self.parse(filepath,options = {})
+        Dsl.parse File.read(filepath), options
+      end
+
+    end
+
+  end
+end

data/lib/parade/parsers/json_file_parser.rb

@@ -0,0 +1,67 @@
+module Parade
+  module Parsers
+
+    #
+    # Load the JSON format of a presentation, convert it to the DSL format,
+    # and then send it to the DSL parser. This parser is to provide backwards
+    # compatabiliy to the previously defined JSON format of a Parade presentation.
+    #
+    # @example parade.json format
+    #
+    #     {
+    #       "name": "Something",
+    #       "description": "Example Presentation",
+    #       "templates" : { "default" : "custom.tpl" },
+    #       "sections": [
+    #         {"section":"one"},
+    #         {"section":"two"},
+    #         {"section":"three"}
+    #       ]
+    #     }
+    #
+    class JsonFileParser
+
+      def self.parse(filepath,options = {})
+        parade_json = JSON.parse File.read(filepath)
+
+        dsl_content = convert_to_parade_dsl parade_json
+        Dsl.parse dsl_content, options
+      end
+
+      private
+
+      def self.convert_to_parade_dsl(content)
+
+        dsl_content = ""
+
+        dsl_content << "title '#{content['name']}'\n" if content['name']
+        dsl_content << "description %{#{content['description']}}\n" if content['description']
+        dsl_content << "pause_message %{#{content['pause_msg']}}" if content['pause_msg']
+
+        templates = content['templates'] || {}
+
+        templates.each do |template_name,template_file|
+          dsl_content << "template '#{template_name}', '#{template_file}'\n"
+        end
+
+        Array(content['sections']).each do |section|
+
+          if section.is_a?(Hash)
+            filename_or_folder = section['section']
+          else
+            filename_or_folder = section
+          end
+
+          Array(filename_or_folder).each do |file_or_folder|
+            dsl_content << "slides '#{file_or_folder}'\n"
+          end
+        end
+
+        dsl_content
+
+      end
+
+    end
+
+  end
+end

data/lib/parade/parsers/markdown_image_paths.rb

@@ -0,0 +1,44 @@
+module Parade
+  module Parsers
+
+    #
+    # Within the markdown file the image paths are relative to the markdown
+    # file. This parser will convert any image paths specified within the
+    # markdown and convert them to relative to the presentation root.
+    #
+    # This parsing functionality ensures that the image path when this is
+    # later rendered to HTML will have the correct path.
+    #
+    # @example ![octocat](octocat.png)
+    #
+    #     "![octocat](octocat.png)" # => "![octocat](section/octocat.png)"
+    #
+    class MarkdownImagePaths
+
+      #
+      # Convert all the image paths within the markdown content with the
+      # specified path parameter.
+      #
+      # @example Update all image paths to be prefixed with 'section'
+      #
+      #     MarkdownImagePaths.parse(markdown_content, :path => 'section')
+      #
+      #
+      # @param [String] content markdown content that may or may not contain
+      #   image tags.
+      # @param [Hash] options that contains parameters to help to properly
+      #   convert the image path.
+      #
+      def self.parse(content,options = {})
+        return content unless options[:path]
+
+        content.gsub(/!\[([^\]]*)\]\((?!https?:\/\/)(.+)\)/) do |match|
+          updated_image_path = File.join(options[:path],$2)
+          %{![#{$1}](#{updated_image_path})}
+        end
+
+      end
+    end
+
+  end
+end

data/lib/parade/parsers/markdown_slide_splitter.rb

@@ -0,0 +1,63 @@
+require_relative '../slide'
+
+module Parade
+  module Parsers
+
+    #
+    # As multiple slides are contained within a markdown file, this parser
+    # will split the markdown along the specified slide marker.
+    #
+    # @todo this currently does too much at the moment. It should simply split
+    #   the markdown file along the slide markers and allow another parser
+    #   perform the work of creating the actual slide objects.
+    #
+    class MarkdownSlideSplitter
+
+      #
+      # Splits the markdown content into separate slide files based on the
+      # separator defined by this class.
+      #
+      # @param [String] content content that is markdown format
+      # @return [Array] slides parsed from the markdown content
+      def self.parse(content,options = {})
+
+        # if there are no !SLIDE markers, then make every H1 define a new slide
+        unless content =~ /^\<?!SLIDE/m
+          content = content.gsub(/^# /m, "<!SLIDE>\n# ")
+        end
+
+        lines = content.split("\n")
+
+        # Break the markdown apart into separate markdown files based on the
+        # separator
+
+        slides = []
+        current_slide = Slide.new
+        slides << current_slide
+
+        until lines.empty?
+          line = lines.shift
+
+          if line =~ /^<?!SLIDE(.*)>?/
+
+            # Remove the trailing > from the metadata
+            metadata_string = Regexp.last_match(1).gsub(/>$/,'')
+
+            metadata = Metadata.parse metadata_string
+
+            current_slide = Slide.new(:metadata => metadata)
+            slides << current_slide
+          else
+            current_slide << line
+          end
+
+        end
+
+        slides.delete_if {|slide| slide.empty? }
+        slides.each_with_index {|slide,index| slide.sequence = (index + 1) }
+
+      end
+    end
+
+  end
+end

data/lib/parade/parsers/presentation_directory_parser.rb

@@ -0,0 +1,36 @@
+require_relative 'presentation_file_parser'
+require_relative 'slides_file_content_parser'
+
+module Parade
+  module Parsers
+
+    module PresentationDirectoryParser
+
+      SLIDE_SEARCH_PATTERN = File.join('**','*.md')
+
+      def self.parse(filepath,options = {})
+
+        parade_file = Array(options[:parade_file]).find do |relative_filepath|
+          parade_file = File.join(filepath,relative_filepath)
+          File.exists? parade_file
+        end
+        
+        if parade_file
+          PresentationFileParser.parse File.join(filepath,parade_file), options
+        else
+
+          slides = Dir[File.join(filepath,SLIDE_SEARCH_PATTERN)].map do |slide_filepath|
+            SlidesFileContentParser.parse slide_filepath, options
+          end
+
+          section = Section.new
+          section.add_section slides
+          section
+
+        end
+      end
+
+    end
+
+  end
+end

data/lib/parade/parsers/presentation_file_parser.rb

@@ -0,0 +1,27 @@
+require_relative 'dsl_file_parser'
+require_relative 'json_file_parser'
+
+module Parade
+  module Parsers
+    
+    #
+    # The Presentation File Parser allows for the JSON formatted file or the
+    # DSL formatted files. The determination of which to use is solely based
+    # on the file extension.
+    # 
+    class PresentationFileParser
+
+      def self.parse(filepath,options = {})
+        options = options.merge(:current_path => File.dirname(filepath))
+        
+        if File.extname(filepath) == ".json"
+          JsonFileParser.parse(filepath,options)
+        else
+          DslFileParser.parse(filepath,options)
+        end
+      end
+
+    end
+
+  end
+end