parade 0.8.0

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rake/testtask'
+
+task :default => :example
+
+task :example do
+  `bin/parade serve example`
+end
+
+begin
+  require 'mg'
+rescue LoadError
+  abort "Please `gem install mg`"
+end
+
+MG.new("parade.gemspec")

data/bin/parade

@@ -0,0 +1,138 @@
+#! /usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'parade'
+require 'parade/version'
+require 'parade/commands/commands'
+
+require 'rubygems'
+require 'gli'
+
+include GLI
+
+version Parade::VERSION
+
+desc 'Generate assets (e.g. sections or slides) for your presentation'
+arg_name 'asset_name'
+long_desc "#{Parade::Commands.generators.map {|k,v| "#{k} - #{v.description}" }.join("\n\n")}"
+command [:g,:gen,:generate] do |c|
+
+  c.desc "Force creation of the asset, even if one already exists with a similar name"
+  c.switch [:f, :force]
+
+  c.action do |global,local,args|
+
+    asset_name = args.shift
+    key_value_args = args.map {|arg| key, value = arg.split(/:|=/) ; [ key, value ] }.flatten
+    parsed_arguments = Hash[*key_value_args]
+    all_parameters = global.merge(local).merge(parsed_arguments)
+
+    Parade::Commands.execute(:generator,asset_name,all_parameters) if asset_name
+  end
+
+end
+
+desc 'Serves the parade presentation in the specified (or current) directory'
+arg_name "[pres_dir]"
+default_value "."
+command [:s,:serve,:server] do |c|
+
+  c.desc 'Show verbose messaging'
+  c.switch :verbose
+
+  c.desc 'Port on which to run'
+  c.default_value "9090"
+  c.flag [:p,:port]
+
+  c.desc 'Host or ip to run on'
+  c.default_value "localhost"
+  c.flag [:h,:host]
+
+  c.action do |global_options,options,args|
+
+    url = "http://#{options[:h]}:#{options[:p].to_i}"
+    puts "
+-------------------------
+
+Your Parade presentation is now starting up.
+
+To view it plainly, visit [ #{url} ]
+
+-------------------------
+
+"
+    presentation_filepath = args[0]
+
+    unless File.directory?(presentation_filepath)
+      filename = File.basename(presentation_filepath)
+      presentation_filepath = File.dirname(presentation_filepath)
+    end
+
+    Parade::Server.run! :host => options[:h],
+      :port => options[:p].to_i,
+      :presentation_directory => presentation_filepath,
+      :presentation_file => filename,
+      :verbose => options[:verbose]
+
+  end
+end
+
+desc 'Output the presentation in a particular format'
+arg_name 'format_type'
+arg_name '[pres_dir]'
+long_desc "#{Parade::Commands.statics.map {|k,v| "#{k} - #{v.description}" }.join("\n\n")}"
+command [:static] do |c|
+
+  c.desc "Force creation of the asset, even if one already exists with a similar name"
+  c.switch [:f, :force]
+
+  c.action do |global,local,args|
+
+    format_type = args.shift
+    presentation_filepath = args.shift || "."
+
+    unless File.directory?(presentation_filepath)
+      filename = File.basename(presentation_filepath)
+      presentation_filepath = File.dirname(presentation_filepath)
+    end
+
+    key_value_args = args.map {|arg| key, value = arg.split(/:|=/) ; [ key, value ] }.flatten
+    parsed_arguments = Hash[*key_value_args]
+    all_parameters = global.merge(local).merge(parsed_arguments)
+
+    all_parameters.merge!('filepath' => presentation_filepath, 'parade_file' => filename)
+    Parade::Commands.execute(:static,format_type,all_parameters) if format_type
+  end
+
+end
+
+pre do |global,command,options,args|
+  # Pre logic here
+  # Return true to proceed; false to abourt and not call the
+  # chosen command
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+
+# To allow an easier command-line to launch parade, the following format
+#
+#     `parade` is converted to `parade server .`
+#     `parade [directoryname] is convereted `parade server [directoryname]`
+#
+
+parameters = ARGV
+
+parameters = [ "server", "." ] if parameters.empty?
+parameters.unshift "server" if parameters.count == 1
+
+exit GLI.run(parameters)

data/lib/parade.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'json'
+require 'nokogiri'
+require 'fileutils'
+require 'logger'
+require 'tilt'
+require 'css_parser'
+
+begin
+  require 'RMagick'
+rescue LoadError
+  $stderr.puts %{
+--------------------------------------------------------------------------------
+  Please install RMagick:
+
+  $ gem install rmagick
+
+  RMagick is required for:
+
+    * Static output to ensure images are included with the documents
+    * Web rendering, auto-re-sizing of images
+--------------------------------------------------------------------------------
+}
+end
+
+begin
+  require 'pdfkit'
+rescue LoadError
+  $stderr.puts  %{
+--------------------------------------------------------------------------------
+  Please install PDFKit and wkhtmltopdf-binary:
+
+  $ gem install pdfkit
+  $ gem install wkhtmltopdf-binary
+
+  PDFKit and wkhtmltopdf-binary are required to provide PDF output
+--------------------------------------------------------------------------------
+}
+end
+
+require_relative 'parade/helpers/encode_image'
+require_relative 'parade/server'

data/lib/parade/commands/commands.rb

@@ -0,0 +1,84 @@
+require_relative 'render_from_template'
+
+require_relative 'static_html'
+require_relative 'static_pdf'
+require_relative 'unknown'
+require_relative 'generate_presentation'
+require_relative 'generate_outline'
+require_relative 'generate_rackup'
+
+
+module Parade
+  
+  #
+  # Commands is a module that contains commands to be used through the 
+  # bin/parade utility. This module defines a number of helper methods to 
+  # define generator and static content output formats.
+  # 
+  module Commands
+
+    # @return [Hash] an empty command hash with the default, when a command is
+    #   not found, to return the Unknown command.
+    def self.commands_with_unknown_default
+      command_hash = {}
+      command_hash.default = Unknown.new
+      command_hash
+    end
+
+    # @return [Hash] a hash that contains all the avaliable static output commands
+    def self.statics
+      @statics ||= commands_with_unknown_default
+    end
+    
+    # @return [Hash] a hash that contains all the avaliable generator commands
+    def self.generators
+      @generators ||= commands_with_unknown_default
+    end
+
+    #
+    # @param [String,Symbol] type the type of command (e.g. statics or generators)
+    # @param [String] name the name which the command can be accessed
+    # @param [Object#description,Object#generate] command the command itself, which
+    #   adheres to the two methods {#description} and {#generate}
+    #
+    def self.commands(type,name,command=nil)
+      command_set = send(type)
+      if command
+        command_set[name] = command
+      else
+        command_set[name]
+      end
+    end
+
+    # Find or create a static output command. Creates a static output entry
+    # if the command is provided.
+    def self.static(name,command=nil)
+      commands :statics, name, command
+    end
+
+    # Find or create a generator command. Creates a static output entry if the 
+    # command is provided.
+    def self.generator(name,command=nil)
+      commands :generators, name, command
+    end
+
+    #
+    # @param [String,Symbol] type the typw of command (e.g. statics or generators)
+    # @param [String] name the name of the command to be found of the specified type
+    # @param [Hash] options a Hash of options that help instruct the execution
+    #   process.
+    #
+    def self.execute(type,name,options)
+      puts "Generating #{type} #{name} with #{options}"
+      send(type,name).generate(options)
+    end
+
+    static "html", StaticHtml.new
+    static "pdf", StaticPdf.new
+
+    generator "presentation", GeneratePresentation.new
+    generator "outline", GenerateOutline.new
+    generator "rackup", GenerateRackup.new
+
+  end
+end

data/lib/parade/commands/generate_outline.rb

@@ -0,0 +1,34 @@
+module Parade
+  module Commands
+    
+    # 
+    # Generate a parade outline presentation file.
+    # 
+    class GenerateOutline
+      include RenderFromTemplate
+
+      def description
+        "A generic presentation file (i.e. #{default_outline_filename})"
+      end
+
+      def generate(options)
+        outline_filename = options['outline'] || default_outline_filename
+        create_file_with_contents outline_filename, outline_template(options), options
+      end
+
+      def default_outline_filename
+        "parade"
+      end
+
+      def outline_template(options)
+        template_options = {  'erb_template_file' => File.join(default_template_path, "#{default_outline_filename}.erb"),
+                              'title' => 'My Presentation',
+                              'description' => 'The importance of unicorns!' }.merge(options)
+
+        render_template template_options
+      end
+
+    end
+
+  end
+end

data/lib/parade/commands/generate_presentation.rb

@@ -0,0 +1,34 @@
+module Parade
+  module Commands
+    
+    #
+    # Generates a presentation directory and the presentation outline if it
+    # does not already exist.
+    # 
+    class GeneratePresentation
+      include RenderFromTemplate
+
+      def description
+        "A presentation folder with outline file"
+      end
+
+      def generate(options)
+
+        directory = options['dir'] || default_presentation_dirname
+        Dir.mkdir(directory) unless File.exists?(directory)
+
+        Dir.chdir(directory) do
+          outline_generator = GenerateOutline.new
+          outline_generator.generate(options)
+        end
+
+      end
+
+      def default_presentation_dirname
+        "presentation"
+      end
+
+    end
+
+  end
+end

data/lib/parade/commands/generate_rackup.rb

@@ -0,0 +1,32 @@
+module Parade
+  module Commands
+
+    #
+    # Generates the a Rackup `config.ru` file to allow for presentations to
+    # be deployed to locations like Heroku.
+    #
+    class GenerateRackup
+      include RenderFromTemplate
+
+      def description
+        "A default rackup file (i.e. #{rackup_filename})"
+      end
+
+      def generate(options)
+        create_file_with_contents rackup_filename, rackup_template(options), options
+      end
+
+      def rackup_filename
+        "config.ru"
+      end
+
+      def rackup_template(options)
+        template_options = {  'erb_template_file' => File.join(default_template_path, "#{rackup_filename}.erb") }.merge(options)
+
+        render_template template_options
+      end
+
+    end
+
+  end
+end

data/lib/parade/commands/html_output.rb

@@ -0,0 +1,47 @@
+require_relative '../renderers/inline_images'
+
+module Parade
+  module Commands
+
+    #
+    # HtmlOuput creates an HTML representation of the presentation and returns
+    # it from the generate method. This is to be consumed by other commands
+    # that my use this output to be saved or manipulated.
+    #
+    # @see StaticHtml
+    # @see StaticPdf
+    #
+    class HtmlOutput
+      include RenderFromTemplate
+
+      def description
+        "This method returns HTML output"
+      end
+
+      def generate(options)
+        filepath = options['filepath']
+
+        return unless File.exists? filepath
+
+        if File.directory? filepath
+          root_path = filepath
+          root_node = Parsers::PresentationDirectoryParser.parse filepath, :root_path => ".",
+            :parade_file => (Array(options['parade_file']) + [ "parade", "parade.json" ]).compact.uniq
+        else
+          root_path = File.dirname filepath
+          root_node = Parsers::PresentationFileParser.parse filepath, :root_path => root_path
+        end
+
+        root_node.add_post_renderer Renderers::InlineImages
+
+        template_options = {  'erb_template_file' => File.join(default_view_path, "#{options['template']}.erb"),
+                              'custom_asset_path' => root_path,
+                              'slides' => root_node.to_html }
+
+        render_template template_options
+      end
+
+    end
+
+  end
+end

data/lib/parade/commands/render_from_template.rb

@@ -0,0 +1,50 @@
+require_relative '../helpers/template_generator'
+
+module Parade
+  module Commands
+
+    #
+    # A module that shares common methods and information.
+    #
+    module RenderFromTemplate
+
+      # @return [String] the filepath to the templates directory within this project.
+      def default_template_path
+        File.join File.dirname(__FILE__), "..", "..", "templates"
+      end
+
+      #
+      # @see HtmlOutput
+      # @see StaticPdf
+      # @return [String] the filepath to the views directory within this project
+      def default_view_path
+        File.join File.dirname(__FILE__), "..", "..", "views"
+      end
+
+      #
+      # @param [Hash] options parameters that will help create the template
+      #
+      # @return [String] the string contents from the rendered template.
+      def render_template(options)
+        template = TemplateGenerator.new options
+        template.render
+      end
+
+      #
+      # @param [String] filename the file name to save the file
+      # @param [String] contents the contents to write to the file
+      # @param [Hash] options a hash of options which may influence whether
+      #   the file should be saved or overwritten.
+      #
+      def create_file_with_contents(filename,contents,options)
+        return if (File.exists?(filename) and not options.key?(:force))
+        File.open(filename,'w+') do |file|
+          file.puts contents
+        end
+        true
+      end
+
+    end
+
+  end
+end