showoff-alexch 0.7.0.1

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rake/testtask'
+
+begin
+  require 'mg'
+rescue LoadError
+  abort "Please `gem install mg`"
+end
+
+MG.new("showoff-alexch.gemspec")
+
+#
+# Tests
+#
+
+task :default => :test
+
+desc "Run tests"
+task :turn do
+  suffix = "-n #{ENV['TEST']}" if ENV['TEST']
+  sh "turn test/*_test.rb #{suffix}"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end

data/bin/showoff

@@ -0,0 +1,197 @@
+#! /usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'showoff'
+require 'rubygems'
+require 'gli'
+
+include GLI
+
+version ShowOff::Version
+
+desc 'Create new showoff presentation'
+arg_name 'dir_name'
+long_desc 'This command helps start a new showoff presentation by setting up the proper directory structure for you.  It takes the directory name you would like showoff to create for you.'
+command [:create,:init] do |c|
+
+  c.desc 'Don''t create sample slides'
+  c.switch [:n,:nosamples]
+
+  c.desc 'sample slide directory name'
+  c.default_value 'one'
+  c.flag [:d,:slidedir]
+
+  c.action do |global_options,options,args|
+    raise "dir_name is required" if args.empty?
+    ShowOffUtils.create(args[0],!options[:n],options[:d])
+    if !options[:n]
+      puts "done. run 'showoff serve' in #{options[:d]}/ dir to see slideshow"
+    else
+      puts "done. add slides, modify #{ShowOffUtils.presentation_config_file} and then run 'showoff serve' in #{dirname}/ dir to see slideshow"
+    end
+  end
+end
+
+desc 'Puts your showoff presentation into a gh-pages branch'
+long_desc 'Generates a static version of your presentation into your gh-pages branch for publishing to GitHub Pages'
+command :github do |c|
+  c.action do |global_options,options,args|
+    puts "Generating static content"
+    ShowOffUtils.github
+    puts "I've updated your 'gh-pages' branch with the static version of your presentation."
+    puts "Push it to GitHub to publish it. Probably something like:"
+    puts
+    puts "  git push origin gh-pages"
+    puts
+  end
+end
+
+desc 'Serves the showoff presentation in the current directory'
+desc 'Setup your presentation to serve on Heroku'
+arg_name 'heroku_name'
+long_desc 'Creates the Gemfile and config.ru file needed to push a showoff pres to heroku.  It will then run ''heroku create'' for you to register the new project on heroku and add the remote for you.  Then all you need to do is commit the new created files and run ''git push heroku'' to deploy.'
+command :heroku do |c|
+
+  c.desc 'add password protection to your heroku site'
+  c.flag [:p,:password]
+
+  c.desc 'force overwrite of existing Gemfile/.gems and config.ru files if they exist'
+  c.switch [:f,:force]
+
+  c.desc 'Use older-style .gems file instead of bundler-style Gemfile'
+  c.switch [:g,:dotgems]
+
+  c.action do |global_options,options,args|
+    raise "heroku_name is required" if args.empty?
+    if ShowOffUtils.heroku(args[0],options[:f],options[:p],options[:g])
+      puts "herokuized. run something like this to launch your heroku presentation:
+
+      heroku create #{args[0]}"
+
+      if options[:g]
+      puts "        git add .gems config.ru"
+      else
+      puts "      bundle install"
+      puts "      git add Gemfile Gemfile.lock config.ru"
+      end
+      puts "      git commit -m 'herokuized'
+      git push heroku master
+      "
+
+      if options[:p]
+        puts "CAREFUL: you are commiting your access password - anyone with read access to the repo can access the preso\n\n"
+      end
+    end
+  end
+end
+
+desc 'Serves the showoff presentation in the specified (or current) directory'
+arg_name "[pres_dir]"
+default_value "."
+command :serve 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.desc 'JSON file used to describe presentation'
+  c.default_value "showoff.json"
+  c.flag [:f, :pres_file]
+
+  c.desc 'every H1 (lone #) in the markdown file will become a new slide'
+  c.default_value false
+  c.switch [:s, :split]
+
+  c.action do |global_options,options,args|
+
+    url = "http://#{options[:h]}:#{options[:p].to_i}"
+    puts "
+-------------------------
+
+Your ShowOff presentation is now starting up.
+
+To view it plainly, visit [ #{url} ]
+
+To run it from presenter view, go to: [ #{url}/presenter ]
+
+-------------------------
+
+"
+    ShowOff.run! :host => options[:h],
+      :port => options[:p].to_i,
+      :pres_file => options[:f],
+      :pres_dir => args[0],
+      :verbose => options[:verbose],
+      :split_all => options[:split_all]
+  end
+end
+
+desc 'Add a new slide at the end in a given dir'
+arg_name '[title]'
+long_desc 'Outputs or creates a new slide.  With -d and -n, a new slide is created in the given dir, numbered to appear as the last slide in that dir (use -u to avoid numbering).  Without those, outputs the slide markdown to stdout (useful for shelling out from your editor). You may also specify a source file to use for a code slide'
+command [:add,:new] do |c|
+  c.desc 'Don''t number the slide, use the given name verbatim'
+  c.switch [:u,:nonumber]
+
+  c.desc 'Include code from the given file as the slide body'
+  c.arg_name 'path to file'
+  c.flag [:s,:source]
+
+  c.desc 'Slide Type/Style'
+  c.arg_name 'valid showoff style/type'
+  c.default_value 'title'
+  c.flag [:t,:type,:style]
+
+  c.desc 'Slide dir (where to put a new slide file)'
+  c.arg_name 'dir'
+  c.flag [:d,:dir]
+
+  c.desc 'Slide name (name of the new slide file)'
+  c.arg_name 'basename'
+  c.flag [:n,:name]
+
+  c.action do |global_options,options,args|
+    title = args.join(" ")
+    ShowOffUtils.add_slide(:dir => options[:d],
+                           :name => options[:n],
+                           :title => title,
+                           :number => !options[:u],
+                           :code => options[:s],
+                           :type => options[:t])
+  end
+end
+
+desc 'Generate static version of presentation'
+arg_name 'name'
+long_desc 'Creates a static, one page version of the presentation as {name}.html'
+command [:static] do |c|
+  c.action do |global_options,options,args|
+    ShowOff.do_static(args[0])
+  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
+
+exit GLI.run(ARGV)

data/lib/commandline_parser.rb

@@ -0,0 +1,67 @@
+require 'parslet'
+
+# For parsing commandline slide content.
+class CommandlineParser < Parslet::Parser
+
+  rule(:prompt) do
+    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

data/lib/showoff.rb

@@ -0,0 +1,510 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'json'
+require 'nokogiri'
+require 'fileutils'
+require 'logger'
+
+here = File.expand_path(File.dirname(__FILE__))
+require "#{here}/showoff_utils"
+require "#{here}/commandline_parser"
+
+begin
+  require 'RMagick'
+rescue LoadError
+  $stderr.puts 'image sizing disabled - install rmagick'
+end
+
+begin
+  require 'pdfkit'
+rescue LoadError
+  $stderr.puts 'pdf generation disabled - install pdfkit'
+end
+
+begin
+  require 'rdiscount'
+rescue LoadError
+  require 'bluecloth'
+  Object.send(:remove_const,:Markdown)
+  Markdown = BlueCloth
+end
+
+class ShowOff < Sinatra::Application
+
+  Version = VERSION = '0.7.0.1'
+
+  attr_reader :cached_image_size
+
+  set :views, File.dirname(__FILE__) + '/../views'
+  set :public, File.dirname(__FILE__) + '/../public'
+
+  set :verbose, false
+  set :pres_dir, '.'
+  set :pres_file, 'showoff.json'
+  set :split_all, false
+
+  def initialize(app=nil)
+    super(app)
+    @logger = Logger.new(STDOUT)
+    @logger.formatter = proc { |severity,datetime,progname,msg| "#{progname} #{msg}\n" }
+    @logger.level = options.verbose ? Logger::DEBUG : Logger::WARN
+
+    dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    @logger.debug(dir)
+
+    showoff_dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    options.pres_dir ||= Dir.pwd
+    @root_path = "."
+
+    options.pres_dir = File.expand_path(options.pres_dir)
+    if (options.pres_file)
+      ShowOffUtils.presentation_config_file = options.pres_file
+    end
+    @cached_image_size = {}
+    @logger.debug options.pres_dir
+    @pres_name = options.pres_dir.split('/').pop
+    require_ruby_files
+  end
+
+  def self.pres_dir_current
+    opt = {:pres_dir => Dir.pwd}
+    ShowOff.set opt
+  end
+
+  def require_ruby_files
+    Dir.glob("#{options.pres_dir}/*.rb").map { |path| require path }
+  end
+
+  helpers do
+    def load_section_files(section)
+      section = File.join(options.pres_dir, section)
+      files = if File.directory? section
+        Dir.glob("#{section}/**/*").sort
+      else
+        [section]
+      end
+      @logger.debug files
+      files
+    end
+
+    def css_files
+      Dir.glob("#{options.pres_dir}/*.css").map { |path| File.basename(path) }
+    end
+
+    def js_files
+      Dir.glob("#{options.pres_dir}/*.js").map { |path| File.basename(path) }
+    end
+
+    def preshow_files
+      Dir.glob("#{options.pres_dir}/_preshow/*").map { |path| File.basename(path) }.to_json
+    end
+
+    class Slide
+
+      # given a chunk of Markdown text, splits it into an array of Slide objects
+      def self.split content, options = {}
+        split_all_the_h1s = options[:split_all_the_h1s]
+
+        unless content =~ /^\<?!SLIDE/m
+          content = content.gsub(/^# /m, "<!SLIDE>\n# ")
+        end
+
+        lines = content.split("\n")
+        slides = []
+        slides << (slide = Slide.new)
+        until lines.empty?
+          line = lines.shift
+          if line =~ /^<?!SLIDE(.*)>?/
+            slides << (slide = Slide.new($1))
+
+          elsif split_all_the_h1s and line =~ /^# / and !slide.empty?
+            # every H1 defines a new slide, unless there's a !SLIDE before it
+            slides << (slide = Slide.new())
+            slide << line
+
+          else
+            slide << line
+          end
+        end
+
+        slides.delete_if {|slide| slide.empty? }
+
+        slides
+      end
+
+      ####
+
+      attr_reader :classes, :text
+      def initialize classes = ""
+        @classes = ["content"] + classes.strip.chomp('>').split
+        @text = ""
+      end
+      def <<(s)
+        @text << s
+        @text << "\n"
+      end
+      def empty?
+        @text.strip == ""
+      end
+    end
+
+    def process_markdown(name, content, static=false, pdf=false)
+      lines = content.split("\n")
+      @logger.debug "#{name}: #{lines.length} lines"
+
+      slides = Slide.split content, :split_all_the_h1s => options.split_all
+
+      final = ''
+      if slides.size > 1
+        seq = 1
+      end
+      slides.each do |slide|
+        md = ''
+        content_classes = slide.classes
+
+        # extract transition, defaulting to none
+        transition = 'none'
+        content_classes.delete_if { |x| x =~ /^transition=(.+)/ && transition = $1 }
+        # extract id, defaulting to none
+        id = nil
+        content_classes.delete_if { |x| x =~ /^#([\w-]+)/ && id = $1 }
+        @logger.debug "id: #{id}" if id
+        @logger.debug "classes: #{content_classes.inspect}"
+        @logger.debug "transition: #{transition}"
+        # create html
+        md += "<div"
+        md += " id=\"#{id}\"" if id
+        md += " class=\"slide\" data-transition=\"#{transition}\">"
+        if seq
+          md += "<div class=\"#{content_classes.join(' ')}\" ref=\"#{name}/#{seq.to_s}\">\n"
+          seq += 1
+        else
+          md += "<div class=\"#{content_classes.join(' ')}\" ref=\"#{name}\">\n"
+        end
+        sl = Markdown.new(slide.text).to_html
+        sl = update_image_paths(name, sl, static, pdf)
+        md += sl
+        md += "</div>\n"
+        md += "</div>\n"
+        final += update_commandline_code(md)
+        final = update_p_classes(final)
+      end
+      final
+    end
+
+    # find any lines that start with a <p>.(something) and turn them into <p class="something">
+    def update_p_classes(markdown)
+      markdown.gsub(/<p>\.(.*?) /, '<p class="\1">')
+    end
+
+    def update_image_paths(path, slide, static=false, pdf=false)
+      paths = path.split('/')
+      paths.pop
+      path = paths.join('/')
+      replacement_prefix = static ?
+        ( pdf ? %(img src="file://#{options.pres_dir}/#{path}) : %(img src="./file/#{path}) ) :
+        %(img src="/image/#{path})
+      slide.gsub(/img src=\"([^\/].*?)\"/) do |s|
+        img_path = File.join(path, $1)
+        w, h     = get_image_size(img_path)
+        src      = %(#{replacement_prefix}/#{$1}")
+        if w && h
+          src << %( width="#{w}" height="#{h}")
+        end
+        src
+      end
+    end
+
+    if defined?(Magick)
+      def get_image_size(path)
+        if !cached_image_size.key?(path)
+          img = Magick::Image.ping(path).first
+          # don't set a size for svgs so they can expand to fit their container
+          if img.mime_type == 'image/svg+xml'
+            cached_image_size[path] = [nil, nil]
+          else
+            cached_image_size[path] = [img.columns, img.rows]
+          end
+        end
+        cached_image_size[path]
+      end
+    else
+      def get_image_size(path)
+      end
+    end
+
+    def update_commandline_code(slide)
+      html = Nokogiri::XML.parse(slide)
+      parser = CommandlineParser.new
+
+      html.css('pre').each do |pre|
+        pre.css('code').each do |code|
+          out = code.text
+          lines = out.split("\n")
+          if lines.first.strip[0, 3] == '@@@'
+            lang = lines.shift.gsub('@@@', '').strip
+            pre.set_attribute('class', 'sh_' + lang.downcase)
+            code.content = lines.join("\n")
+          end
+        end
+      end
+
+      html.css('.commandline > pre > code').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('code', 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('code', html)
+              result.set_attribute('class', 'result')
+              result.content = output
+              code << result
+            end
+          end
+        end
+        transform.apply(tree)
+      end
+      html.root.to_s
+    end
+
+    def get_slides_html(static=false, pdf=false)
+      sections = ShowOffUtils.showoff_sections(options.pres_dir, @logger)
+      files = []
+      if sections
+        data = ''
+        sections.each do |section|
+          if section =~ /^#/
+            name = section.each_line.first.gsub(/^#*/,'').strip
+            data << process_markdown(name, "<!SLIDE subsection>\n" + section, static, pdf)
+          else
+            files = []
+            files << load_section_files(section)
+            files = files.flatten
+            files = files.select { |f| f =~ /.md$/ }
+            files.each do |f|
+              fname = f.gsub(options.pres_dir + '/', '').gsub('.md', '')
+              data << process_markdown(fname, File.read(f), static, pdf)
+            end
+          end
+        end
+      end
+      data
+    end
+
+    def inline_css(csses, pre = nil)
+      css_content = '<style type="text/css">'
+      csses.each do |css_file|
+        if pre
+          css_file = File.join(File.dirname(__FILE__), '..', pre, css_file)
+        else
+          css_file = File.join(options.pres_dir, css_file)
+        end
+        css_content += File.read(css_file)
+      end
+      css_content += '</style>'
+      css_content
+    end
+
+    def inline_js(jses, pre = nil)
+      js_content = '<script type="text/javascript">'
+      jses.each do |js_file|
+        if pre
+          js_file = File.join(File.dirname(__FILE__), '..', pre, js_file)
+        else
+          js_file = File.join(options.pres_dir, js_file)
+        end
+        js_content += File.read(js_file)
+      end
+      js_content += '</script>'
+      js_content
+    end
+
+    def inline_all_js(jses_directory)
+       inline_js(Dir.entries(File.join(File.dirname(__FILE__), '..', jses_directory)).find_all{|filename| filename.length > 2 }, jses_directory)
+    end
+
+    def index(static=false)
+      if static
+        @title = ShowOffUtils.showoff_title
+        @slides = get_slides_html(static)
+        @asset_path = "./"
+      end
+      erb :index
+    end
+
+    def presenter
+      erb :presenter
+    end
+
+    def clean_link(href)
+      if href && href[0, 1] == '/'
+        href = href[1, href.size]
+      end
+      href
+    end
+
+    def assets_needed
+      assets = ["index", "slides"]
+
+      index = erb :index
+      html = Nokogiri::XML.parse(index)
+      html.css('head link').each do |link|
+        href = clean_link(link['href'])
+        assets << href if href
+      end
+      html.css('head script').each do |link|
+        href = clean_link(link['src'])
+        assets << href if href
+      end
+
+      slides = get_slides_html
+      html = Nokogiri::XML.parse("<slides>" + slides + "</slides>")
+      html.css('img').each do |link|
+        href = clean_link(link['src'])
+        assets << href if href
+      end
+
+      css = Dir.glob("#{options.public}/**/*.css").map { |path| path.gsub(options.public + '/', '') }
+      assets << css
+
+      js = Dir.glob("#{options.public}/**/*.js").map { |path| path.gsub(options.public + '/', '') }
+      assets << js
+
+      assets.uniq.join("\n")
+    end
+
+    def slides(static=false)
+      get_slides_html(static)
+    end
+
+    def onepage(static=false)
+      @slides = get_slides_html(static)
+      erb :onepage
+    end
+
+    def pdf(static=true)
+      @slides = get_slides_html(static, true)
+      @no_js = false
+      html = erb :onepage
+      # TODO make a random filename
+
+      # PDFKit.new takes the HTML and any options for wkhtmltopdf
+      # run `wkhtmltopdf --extended-help` for a full list of options
+      kit = PDFKit.new(html, :page_size => 'Letter', :orientation => 'Landscape')
+
+      # Save the PDF to a file
+      file = kit.to_file('/tmp/preso.pdf')
+    end
+
+  end
+
+
+   def self.do_static(what)
+      what = "index" if !what
+
+      # Nasty hack to get the actual ShowOff module
+      showoff = ShowOff.new
+      while !showoff.is_a?(ShowOff)
+        showoff = showoff.instance_variable_get(:@app)
+      end
+      name = showoff.instance_variable_get(:@pres_name)
+      path = showoff.instance_variable_get(:@root_path)
+      data = showoff.send(what, true)
+      if data.is_a?(File)
+        FileUtils.cp(data.path, "#{name}.pdf")
+      else
+        out = File.expand_path("#{path}/static")
+        # First make a directory
+        FileUtils.makedirs(out)
+        # Then write the html
+        file = File.new("#{out}/index.html", "w")
+        file.puts(data)
+        file.close
+        # Now copy all the js and css
+        my_path = File.join( File.dirname(__FILE__), '..', 'public')
+        ["js", "css"].each { |dir|
+          FileUtils.copy_entry("#{my_path}/#{dir}", "#{out}/#{dir}")
+        }
+        # And copy the directory
+        Dir.glob("#{my_path}/#{name}/*").each { |subpath|
+          base = File.basename(subpath)
+          next if "static" == base
+          next unless File.directory?(subpath) || base.match(/\.(css|js)$/)
+          FileUtils.copy_entry(subpath, "#{out}/#{base}")
+        }
+
+        # Set up file dir
+        file_dir = File.join(out, 'file')
+        FileUtils.makedirs(file_dir)
+        pres_dir = showoff.options.pres_dir
+
+        # ..., copy all user-defined styles and javascript files
+        Dir.glob("#{pres_dir}/*.{css,js}").each { |path|
+          FileUtils.copy(path, File.join(file_dir, File.basename(path)))
+        }
+
+        # ... and copy all needed image files
+        data.scan(/img src=\".\/file\/(.*?)\"/).flatten.each do |path|
+          dir = File.dirname(path)
+          FileUtils.makedirs(File.join(file_dir, dir))
+          FileUtils.copy(File.join(pres_dir, path), File.join(file_dir, path))
+        end
+        # copy images from css too
+        Dir.glob("#{pres_dir}/*.css").each do |css_path|
+          File.open(css_path) do |file|
+            data = file.read
+            data.scan(/url\((.*)\)/).flatten.each do |path|
+              @logger.debug path
+              dir = File.dirname(path)
+              FileUtils.makedirs(File.join(file_dir, dir))
+              FileUtils.copy(File.join(pres_dir, path), File.join(file_dir, path))
+            end
+          end
+        end
+      end
+    end
+
+   def eval_ruby code
+     eval(code).to_s
+   rescue => e
+     e.message
+   end
+
+  get '/eval_ruby' do
+    return eval_ruby(params[:code]) if ENV['SHOWOFF_EVAL_RUBY']
+
+    return "Ruby Evaluation is off. To turn it on set ENV['SHOWOFF_EVAL_RUBY']"
+  end
+
+  get %r{(?:image|file)/(.*)} do
+    path = params[:captures].first
+    full_path = File.join(options.pres_dir, path)
+    send_file full_path
+  end
+
+  get %r{/(.*)} do
+    @title = ShowOffUtils.showoff_title
+    what = params[:captures].first
+    what = 'index' if "" == what
+    if (what != "favicon.ico")
+      data = send(what)
+      if data.is_a?(File)
+        send_file data.path
+      else
+        data
+      end
+    end
+  end
+end