mattmatt-showoff 0.2.3

data/lib/showoff.rb

@@ -0,0 +1,346 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'json'
+require 'nokogiri'
+require 'showoff_utils'
+require 'princely'
+require 'ftools'
+
+begin
+  require 'RMagick'
+rescue LoadError
+  puts 'image sizing disabled - install RMagick'
+end
+
+begin
+  require 'princely'
+rescue LoadError
+  puts 'pdf generation disabled - install princely'
+end
+
+begin
+  require 'rdiscount'
+rescue LoadError
+  require 'bluecloth'
+  Markdown = BlueCloth
+end
+require 'pp'
+
+class ShowOff < Sinatra::Application
+
+  attr_reader :cached_image_size
+
+  set :views, File.dirname(__FILE__) + '/../views'
+  set :public, File.dirname(__FILE__) + '/../public'
+  set :pres_dir, 'example'
+
+  def initialize(app=nil)
+    super(app)
+    puts dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    if Dir.pwd == dir
+      options.pres_dir = dir + '/example'
+      @root_path = "."
+    else
+      options.pres_dir = Dir.pwd
+      @root_path = ".."
+    end
+    @cached_image_size = {}
+    puts options.pres_dir
+    @pres_name = options.pres_dir.split('/').pop
+  end
+
+  helpers do
+    def load_section_files(section)
+      section = File.join(options.pres_dir, section)
+      files = Dir.glob("#{section}/**/*").sort
+      pp 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 process_markdown(name, content, static=false)
+      slides = content.split(/^!SLIDE/)
+      slides.delete('')
+      final = ''
+      if slides.size > 1
+        seq = 1
+      end
+      slides.each do |slide|
+        md = ''
+        # extract content classes
+        lines = slide.split("\n")
+        content_classes = lines.shift.split rescue []
+        slide = lines.join("\n")
+        # add content class too
+        content_classes.unshift "content"
+        # extract transition, defaulting to none
+        transition = 'none'
+        content_classes.delete_if { |x| x =~ /^transition=(.+)/ && transition = $1 }
+        puts "classes: #{content_classes.inspect}"
+        puts "transition: #{transition}"
+        # create html
+        md += "<div 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).to_html
+        sl = update_image_paths(name, sl, static)
+        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)
+      paths = path.split('/')
+      paths.pop
+      path = paths.join('/')
+      replacement_prefix = static ?
+        %(img src="file://#{options.pres_dir}/static/#{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
+          cached_image_size[path] = [img.columns, img.rows]
+        end
+        cached_image_size[path]
+      end
+    else
+      def get_image_size(path)
+      end
+    end
+
+    def update_commandline_code(slide)
+      html = Nokogiri::XML.parse(slide)
+
+      html.css('pre').each do |pre|
+        pre.css('code').each do |code|
+          out = code.text
+          lines = out.split("\n")
+          if lines.first[0, 3] == '@@@'
+            lang = lines.shift.gsub('@@@', '').strip
+            pre.set_attribute('class', 'sh_' + lang)
+            code.content = lines.join("\n")
+          end
+        end
+      end
+
+      html.css('.commandline > pre > code').each do |code|
+        out = code.text
+        lines = out.split(/^\$(.*?)$/)
+        lines.delete('')
+        code.content = ''
+        while(lines.size > 0) do
+          command = lines.shift
+          result = lines.shift
+          c = Nokogiri::XML::Node.new('code', html)
+          c.set_attribute('class', 'command')
+          c.content = '$' + command
+          code << c
+          c = Nokogiri::XML::Node.new('code', html)
+          c.set_attribute('class', 'result')
+          c.content = result
+          code << c
+        end
+      end
+      html.root.to_s
+    end
+
+    def get_slides_html(static=false)
+      sections = ShowOffUtils.showoff_sections(options.pres_dir)
+      files = []
+      if sections
+        sections.each do |section|
+          files << load_section_files(section)
+        end
+        files = files.flatten
+        files = files.select { |f| f =~ /.md/ }
+        data = ''
+        files.each do |f|
+          fname = f.gsub(options.pres_dir + '/', '').gsub('.md', '')
+          data += process_markdown(fname, File.read(f),static)
+        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 index(static=false)
+      if static
+        @slides = get_slides_html(static)
+        @asset_path = "."
+      end
+      erb :index
+    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
+
+      assets.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=false)
+      @slides = get_slides_html(static)
+      @no_js = true
+      html = erb :onepage
+      p = Princely.new
+      # TODO make a random filename
+      p.pdf_from_string_to_file(html, '/tmp/preso.pdf')
+      File.new('/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)
+        File.cp(data.path, "#{name}.pdf")
+      else
+        out  = "#{path}/#{name}/static"
+        # First make a directory
+        File.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}")
+        }
+      end
+    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

data/lib/showoff_utils.rb

@@ -0,0 +1,259 @@
+class ShowOffUtils
+  SHOWOFF_JSON_FILE = 'showoff.json'
+
+  def self.create(dirname,create_samples,dir='one')
+    Dir.mkdir(dirname) if !File.exists?(dirname)
+    Dir.chdir(dirname) do
+      if create_samples
+        # create section
+        Dir.mkdir(dir)
+
+        # create markdown file
+        File.open("#{dir}/01_slide.md", 'w+') do |f|
+          f.puts make_slide("My Presentation")
+          f.puts make_slide("Bullet Points","bullets incremental",["first point","second point","third point"])
+        end
+      end
+
+      # create showoff.json
+      File.open(SHOWOFF_JSON_FILE, 'w+') do |f|
+        f.puts "{ \"name\": \"My Preso\", \"sections\": [ {\"section\":\"#{dir}\"} ]}"
+      end
+
+      if create_samples
+        puts "done. run 'showoff serve' in #{dirname}/ dir to see slideshow"
+      else
+        puts "done. add slides, modify #{SHOWOFF_JSON_FILE} and then run 'showoff serve' in #{dirname}/ dir to see slideshow"
+      end
+    end
+  end
+
+  def self.heroku(name)
+    if !File.exists?(SHOWOFF_JSON_FILE)
+      puts "fail. not a showoff directory"
+      return false
+    end
+    # create .gems file
+    File.open('.gems', 'w+') do |f|
+      f.puts "bluecloth"
+      f.puts "nokogiri"
+      f.puts "showoff"
+      f.puts "gli"
+    end if !File.exists?('.gems')
+
+    # create config.ru file
+    File.open('config.ru', 'w+') do |f|
+      f.puts 'require "showoff"'
+      f.puts 'run ShowOff.new'
+    end if !File.exists?('config.ru')
+
+    puts "herokuized. run something like this to launch your heroku presentation:
+
+      heroku create #{name}
+      git add .gems config.ru
+      git commit -m 'herokuized'
+      git push heroku master
+    "
+  end
+
+  # Makes a slide as a string.
+  # [title] title of the slide
+  # [classes] any "classes" to include, such as 'smaller', 'transition', etc.
+  # [content] slide content.  Currently, if this is an array, it will make a bullet list.  Otherwise
+  #           the string value of this will be put in the slide as-is
+  def self.make_slide(title,classes="",content=nil)
+    slide = "!SLIDE #{classes}\n"
+    slide << "# #{title} #\n"
+    slide << "\n"
+    if content
+      if content.kind_of? Array
+        content.each { |x| slide << "* #{x.to_s}\n" }
+      else
+        slide << content.to_s
+      end
+    end
+    slide
+  end
+
+  TYPES = {
+    :default => lambda { |t,size,source,type| make_slide(t,"#{size} #{type}",source) },
+    'title' => lambda { |t,size,dontcare| make_slide(t,size) },
+    'bullets' => lambda { |t,size,dontcare| make_slide(t,"#{size} bullets incremental",["bullets","go","here"])},
+    'smbullets' => lambda { |t,size,dontcare| make_slide(t,"#{size} smbullets incremental",["bullets","go","here","and","here"])},
+    'code' => lambda { |t,size,src| make_slide(t,size,blank?(src) ? "    @@@ Ruby\n    code_here()" : src) },
+    'commandline' => lambda { |t,size,dontcare| make_slide(t,"#{size} commandline","    $ command here\n    output here")},
+    'full-page' => lambda { |t,size,dontcare| make_slide(t,"#{size} full-page","![Image Description](image/ref.png)")},
+  }
+
+
+  # Adds a new slide to a given dir, giving it a number such that it falls after all slides
+  # in that dir.
+  # Options are:
+  # [:dir] - dir where we put the slide (if omitted, slide is output to $stdout)
+  # [:name] - name of the file, without the number prefix. (if omitted, a default is used)
+  # [:title] - title in the slide.  If not specified the source file name is
+  #            used.  If THAT is not specified, uses the value of +:name+.  If THAT is not
+  #            specified, a suitable default is used
+  # [:code] - path to a source file to use as content (force :type to be 'code')
+  # [:number] - true if numbering should be done, false if not
+  # [:type] - the type of slide to create
+  def self.add_slide(options)
+
+    add_new_dir(options[:dir]) if options[:dir] && !File.exists?(options[:dir])
+
+    options[:type] = 'code' if options[:code]
+
+    title = determine_title(options[:title],options[:name],options[:code])
+
+    options[:name] = 'new_slide' if !options[:name]
+
+    size,source = determine_size_and_source(options[:code])
+    type = options[:type] || :default
+    slide = TYPES[type].call(title,size,source)
+
+    if options[:dir]
+      filename = determine_filename(options[:dir],options[:name],options[:number])
+      write_file(filename,slide)
+    else
+      puts slide
+      puts
+    end
+
+  end
+
+  # Adds the given directory to this presentation, appending it to
+  # the end of showoff.json as well
+  def self.add_new_dir(dir)
+    puts "Creating #{dir}..."
+    Dir.mkdir dir
+
+    showoff_json = JSON.parse(File.read(SHOWOFF_JSON_FILE))
+    showoff_json << { "section" => dir }
+    File.open(SHOWOFF_JSON_FILE,'w') do |file|
+      file.puts JSON.generate(showoff_json)
+    end
+    puts "#{SHOWOFF_JSON_FILE} updated"
+  end
+
+  def self.blank?(string)
+    string.nil? || string.strip.length == 0
+  end
+
+  def self.determine_size_and_source(code)
+    size = ""
+    source = ""
+    if code
+      source,lines,width = read_code(code)
+      size = adjust_size(lines,width)
+    end
+    [size,source]
+  end
+
+  def self.write_file(filename,slide)
+    File.open(filename,'w') do |file|
+      file.puts slide
+    end
+    puts "Wrote #{filename}"
+  end
+
+  def self.determine_filename(slide_dir,slide_name,number)
+    filename = "#{slide_dir}/#{slide_name}.md"
+    if number
+      max = find_next_number(slide_dir)
+      filename = "#{slide_dir}/#{max}_#{slide_name}.md"
+    end
+    filename
+  end
+
+  # Finds the next number in the given dir to
+  # name a slide as the last slide in the dir.
+  def self.find_next_number(slide_dir)
+    max = 0
+    Dir.open(slide_dir).each do |file|
+      if file =~ /(\d+).*\.md/
+        num = $1.to_i
+        max = num if num > max
+      end
+    end
+    max += 1
+    max = "0#{max}" if max < 10
+    max
+  end
+
+  def self.determine_title(title,slide_name,code)
+    if blank?(title)
+      title = slide_name
+      title = File.basename(code) if code
+    end
+    title = "Title here" if blank?(title)
+    title
+  end
+
+  # Determines a more optimal value for the size (e.g. small vs. smaller)
+  # based upon the size of the code being formatted.
+  def self.adjust_size(lines,width)
+    size = ""
+    # These values determined empircally
+    size = "small" if width > 50
+    size = "small" if lines > 15
+    size = "smaller" if width > 57
+    size = "smaller" if lines > 19
+    puts "warning, some lines are too long and the code may be cut off" if width > 65
+    puts "warning, your code is too long and the code may be cut off" if lines > 23
+    size
+  end
+
+  # Reads the code from the source file, returning
+  # the code, indented for markdown, as well as the number of lines
+  # and the width of the largest line
+  def self.read_code(source_file)
+    code = "    @@@ #{lang(source_file)}\n"
+    lines = 0
+    width = 0
+    File.open(source_file) do |code_file|
+      code_file.readlines.each do |line|
+        code += "    #{line}"
+        lines += 1
+        width = line.length if line.length > width
+      end
+    end
+    [code,lines,width]
+  end
+
+  def self.showoff_sections(dir = '.')
+    index = File.join(dir, ShowOffUtils::SHOWOFF_JSON_FILE )
+    order = nil
+    if File.exists?(index)
+      data = JSON.parse(File.read(index))
+      pp data
+      if data.is_a?(Hash)
+        order = data['sections']
+      else
+        order = data
+      end
+      order = order.map { |s| s['section'] }
+    end
+    order
+  end
+
+  def self.showoff_title(dir = '.')
+    index = File.join(dir, ShowOffUtils::SHOWOFF_JSON_FILE )
+    order = nil
+    if File.exists?(index)
+      data = JSON.parse(File.read(index))
+      data.is_a?(Hash) && data['name'] || "Presentation"
+    end
+  end
+
+  EXTENSIONS =  {
+    'pl' => 'perl',
+    'rb' => 'ruby',
+    'erl' => 'erlang',
+    # so not exhaustive, but probably good enough for now
+  }
+
+  def self.lang(source_file)
+    ext = File.extname(source_file).gsub(/^\./,'')
+    EXTENSIONS[ext] || ext
+  end
+end