parade 0.8.0

data/lib/parade/section.rb

@@ -0,0 +1,183 @@
+require_relative 'renderers/update_image_paths'
+
+module Parade
+
+  #
+  # A Parade presentation is composed of a Section that may also be composed
+  # of many slides and sub-sections (child sections) of slides.
+  #
+  class Section
+
+    def initialize(params = {})
+      @description = ""
+      @post_renderers = []
+      @sections = []
+
+      @templates = {}
+      params.each {|k,v| send("#{k}=",v) if respond_to? "#{k}=" }
+    end
+
+    # @param [String] title the new title of the section
+    attr_writer :title
+
+    # @return [String] the title of the section
+    def title
+      @title ? @title : (section ? section.title : "Section")
+    end
+
+    # @return [String] the description of the section
+    attr_accessor :description
+
+    # @return [Array<#slides>] returns an array of a Section objects or array
+    #   of Slide objects.
+    attr_reader :sections
+
+    # @return [Section] the parent section of this section. nil if this is a
+    #   root section.
+    attr_accessor :section
+
+    #
+    # Append sections to this section.
+    #
+    # @param [Section,Array<Section>] content this any section that you want to
+    #   add to this section.
+    #
+    def add_section(sub_sections)
+      sub_sections = Array(sub_sections).compact.flatten.map do |sub_section|
+        sub_section.section = self
+        sub_section
+      end
+      @sections = @sections + sub_sections
+      sub_sections
+    end
+
+    #
+    # Append slides to this setion.
+    #
+    # @param [Slide,Array<Slide>] content this any section that you want to
+    #   add to this section.
+    #
+    def add_slides(slides)
+      sub_slides = Array(slides).compact.flatten.map do |slide|
+        slide.section = self
+        slide
+      end
+
+      @sections = @sections + sub_slides
+      sub_slides
+    end
+
+    #
+    # @example 'opening' would be the template name and 'custom_template.erb'
+    #   would be the template filename.
+    #
+    #     section "Introduction" do
+    #       template "opening", "custom_template.erb"
+    #     end
+    #
+    # @param [String] template_name the name of the template which it is
+    #   referred to by the slides.
+    #
+    # @param [Types] template_filepath the filepath to the template to be loaded
+    #
+    def add_template(template_name,template_filepath)
+      @templates[template_name] = template_filepath
+    end
+
+    #
+    # @param [String] template_name the name of the template
+    # @param [Boolean] use_default_when_nil if while searching for the template
+    #   it should use the parent section's default template. This usually wants
+    #   to be false when looking for a specific template.
+    #
+    # @return [String] the filepath of the parent section template
+    def parent_section_template(template_name,use_default_when_nil=true)
+      section.template(template_name,use_default_when_nil) if section
+    end
+
+    #
+    # @return [String] the filepath of the default slide template.
+    def default_template
+      File.join(File.dirname(__FILE__), "..", "views", "slide.erb")
+    end
+
+    #
+    # Given the template name return the template file name associated with it.
+    # When a template is not found with the name within the section, the section
+    # traverses parent sections until it is found.
+    #
+    # A default template can be defined for a section which it will default
+    # to when no template name has been specified or the template name could
+    # not be found. Again the parent sections will be traversed if they have
+    # a default template.
+    #
+    # When there is no template specified or found within then it will default
+    # to the original slide template.
+    #
+    # @param [String] template_name the name of the template to retrieve.
+    #
+    # @return [String] the filepath to the template, given the template name.
+    #
+    def template(template_name,use_default_when_nil = true)
+      template_for_name = @templates[template_name] || parent_section_template(template_name,false)
+      template_for_name = (@templates['default'] || parent_section_template('default')) unless template_for_name and use_default_when_nil
+      template_for_name || default_template
+    end
+
+    attr_writer :pause_message
+
+    #
+    # @return [String] the pause message for the section, if none has been
+    #   specified the default pause message is returned.
+    def pause_message
+      @pause_message || default_pause_message
+    end
+
+    def default_pause_message
+      ""
+    end
+
+    def resources
+      @resources || []
+    end
+
+    def add_resource(resource_filepath)
+      @resources ||= []
+      @resources << resource_filepath
+    end
+
+    # @return [Array<Slide>] the slides contained within this section and any
+    #   sub-section.
+    def slides
+      sections_slides = sections.map do |section_or_slide|
+        section_or_slide.slides
+      end.flatten
+
+      # Update the sequence on all the slides for the entire section.
+      sections_slides.each_with_index {|slide,count| slide.sequence = (count + 1) }
+    end
+
+    # @return [Array<#render>] returns a list of Renderers that will perform
+    #   their renderering on the slides after the slides have all habe been
+    #   rendered.
+    attr_reader :post_renderers
+
+    #
+    # @param [#render] renderer add a renderer, any object responding to
+    #   #render, that will process the slides HTML content.
+    #
+    def add_post_renderer(renderer)
+      @post_renderers << renderer
+    end
+
+    # @return [String] HTML representation of the section
+    def to_html
+      slides.map do |section_or_slide|
+        post_renderers.inject(section_or_slide.to_html) do |content,renderer|
+          renderer.render(content)
+        end
+      end.join("\n")
+    end
+
+  end
+end

data/lib/parade/server.rb

@@ -0,0 +1,139 @@
+require_relative "parsers/dsl"
+require_relative 'renderers/update_image_paths'
+
+require_relative 'features/live_ruby'
+require_relative 'features/pdf_presentation'
+require_relative 'features/preshow'
+
+module Parade
+
+  class Server < Sinatra::Application
+
+    def initialize(app=nil)
+      super(app)
+      require_ruby_files
+    end
+
+    def require_ruby_files
+      Dir.glob("#{settings.presentation_directory}/*.rb").map { |path| require path }
+    end
+
+    set :views, File.dirname(__FILE__) + '/../views'
+    set :public_folder, File.dirname(__FILE__) + '/../public'
+
+    set :verbose, false
+
+    set :presentation_directory do
+      File.expand_path Dir.pwd
+    end
+
+    set :presentation_file, 'parade'
+
+    set :default_presentation_files, [ 'parade', 'parade.json' ]
+
+    def presentation_files
+      (Array(settings.presentation_file) + settings.default_presentation_files).compact.uniq
+    end
+
+    def load_presentation
+      root_node = Parsers::PresentationDirectoryParser.parse settings.presentation_directory,
+        :root_path => settings.presentation_directory, :parade_file => presentation_files
+
+      root_node.add_post_renderer Renderers::UpdateImagePaths.new :root_path => settings.presentation_directory
+      root_node
+    end
+
+    helpers do
+
+      #
+      # A shortcut to define a CSS resource file within a view template
+      #
+      def css(filepath)
+        %{<link rel="stylesheet" href="#{File.join "css", filepath}" type="text/css"/>}
+      end
+
+      #
+      # A shortcut to define a Javascript resource file within a view template
+      #
+      def js(filepath)
+        %{<script type="text/javascript" src="#{File.join "js", filepath}"></script>}
+      end
+
+      def custom_resource(resource_extension)
+        load_presentation.resources.map do |resource_path|
+          Dir.glob("#{resource_path}/*.#{resource_extension}").map do |path|
+            relative_path = path.sub(settings.presentation_directory,'')
+            yield relative_path if block_given?
+          end.join("\n")
+        end.join("\n")
+      end
+
+      #
+      # Create resources links to all the CSS files found at the root of
+      # presentation directory.
+      #
+      def custom_css_files
+        custom_resource "css" do |path| 
+          css path
+        end
+      end
+
+      #
+      # Create resources links to all the Javascript files found at the root of
+      # presentation directory.
+      #
+      def custom_js_files
+        custom_resource "js" do |path| 
+          js path
+        end
+      end
+
+      def presentation
+        load_presentation
+      end
+
+      def title
+        presentation.title
+      end
+
+      def slides
+        presentation.to_html
+      end
+
+      def pause_message
+        presentation.pause_message
+      end
+    end
+
+    #
+    # Path requests for files that match the prefix will be returned.
+    #
+    get %r{(?:image|file|js|css)/(.*)} do
+      path = params[:captures].first
+      full_path = File.join(settings.presentation_directory, path)
+      send_file full_path
+    end
+
+    #
+    # The request for slides is used by the client-side javascript presentation
+    # and returns all the slides HTML.
+    #
+    get "/slides" do
+      slides
+    end
+
+    get "/" do
+      erb :index
+    end
+
+    get "/onepage" do
+      erb :onepage
+    end
+
+    include LiveRuby
+    include PDFPresentation
+    include Preshow
+
+  end
+
+end

data/lib/parade/slide.rb

@@ -0,0 +1,128 @@
+require_relative 'metadata'
+require_relative 'renderers/html_with_pygments'
+require_relative 'renderers/command_line_renderer'
+require_relative 'renderers/special_paragraph_renderer'
+require_relative 'renderers/columns_renderer'
+
+module Parade
+
+  #
+  # The Slide is the core class of the Presentation. The slide aggregates the
+  # markdown content, the slide metadata, and the slide template to create the
+  # HTML representation of the slide for Parade.
+  #
+  class Slide
+
+    # TODO: Previously this was #{name}#{sequence}, this is likely needing to be set
+    # by the slideshow itself to ensure that the content is unique and displayed
+    # in the correct order.
+    attr_accessor :sequence
+
+    attr_accessor :section
+
+    def title
+      section ? section.title : "Slide"
+    end
+
+    def reference
+      "#{section ? section.title : 'slide'}/#{sequence}"
+    end
+
+    #
+    # @param [Hash] params contains the parameters to help create the slide
+    #   that is going to be displayed.
+    #
+    def initialize(params={})
+      @content = ""
+      @metadata = Metadata.new
+      params.each {|k,v| send("#{k}=",v) if respond_to? "#{k}=" }
+    end
+
+    # The raw, unformatted slide content.
+    attr_reader :content
+
+    #
+    # @param [String] value this is the new content initially is set or overrides
+    #   the existing content within the slide
+    #
+    def content=(value)
+      @content = "#{value}\n"
+    end
+
+    #
+    # @param [String] append_raw_content this is additional raw content to add
+    #   to the slide.
+    #
+    def <<(append_raw_content)
+      @content << "#{append_raw_content}\n"
+    end
+
+    #
+    # @return [Boolean] true if the slide has no content and false if the slide
+    #   has content.
+    def empty?
+      @content.to_s.strip == ""
+    end
+
+    #
+    # A slide can contain various metadata to help define additional information
+    # about it.
+    #
+    # @param [Parade::Metadata] value metadata object which contains
+    #   information for the slide
+    #
+    attr_accessor :metadata
+    
+    # @return [String] the CSS classes for the slide
+    def slide_classes
+      title.downcase.gsub(' ','-')
+    end
+
+    # @return [String] the CSS classes for the content section of the slide
+    def content_classes
+      metadata.classes.join(" ")
+    end
+
+    # @return [String] the transition style for the slide
+    def transition
+      metadata.transition || "none"
+    end
+
+    # @return [String] an id for the slide
+    def id
+      metadata.id.to_s
+    end
+
+    def pre_renderers
+      [ Renderers::HTMLwithPygments ]
+    end
+
+    def post_renderers
+      [ Renderers::SpecialParagraphRenderer,
+        Renderers::CommandLineRenderer,
+        Renderers::ColumnsRenderer.new(:css_class => 'columns',:html_element => "h2",:segments => 12) ]
+    end
+
+    # @return [String] HTML rendering of the slide's raw contents.
+    def content_as_html
+      pre_renderers.inject(content) {|content,renderer| renderer.render(content) }
+    end
+
+    def slides
+      self
+    end
+
+    # @return [ERB] an ERB template that this slide will be rendered into
+    def template_file
+      erb_template_file = section.template metadata.template
+      ERB.new File.read(erb_template_file)
+    end
+
+    # @return [String] the HTML representation of the slide
+    def to_html
+      content = template_file.result(binding)
+      post_renderers.inject(content) {|content,renderer| renderer.render(content) }
+    end
+
+  end
+end