mg_showoff 0.5.1

data/bin/showoff

@@ -0,0 +1,145 @@
+#! /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])
+  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|
+    ShowOffUtils.github
+  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?
+    ShowOffUtils.heroku(args[0],options[:f],options[:p],options[:g])
+  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.action do |global_options,options,args|
+    ShowOff.run! :host => options[:h], :port => options[:p].to_i, :pres_file => options[:f], :pres_dir => args[0], :verbose => options[:verbose]
+  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/princely.rb

@@ -0,0 +1,84 @@
+# PrinceXML Ruby interface. 
+# http://www.princexml.com
+#
+# Library by Subimage Interactive - http://www.subimage.com
+#
+#
+# USAGE
+# -----------------------------------------------------------------------------
+#   princely = Princely.new()
+#   html_string = render_to_string(:template => 'some_document')
+#   send_data(
+#     princely.pdf_from_string(html_string),
+#     :filename => 'some_document.pdf'
+#     :type => 'application/pdf'
+#   )
+#
+$:.unshift(File.dirname(__FILE__))
+
+class Princely
+  VERSION = "1.0.0" unless const_defined?("VERSION")
+  
+  attr_accessor :exe_path, :style_sheets, :log_file
+
+  # Initialize method
+  #
+  def initialize()
+    # Finds where the application lives, so we can call it.
+    @exe_path = `which prince`.chomp
+    raise "Cannot find prince command-line app in $PATH" if @exe_path.length == 0
+  	@style_sheets = ''
+  	@log_file = "/tmp/prince.log"
+  end
+  
+  # Sets stylesheets...
+  # Can pass in multiple paths for css files.
+  #
+  def add_style_sheets(*sheets)
+    for sheet in sheets do
+      @style_sheets << " -s #{sheet} "
+    end
+  end
+  
+  # Returns fully formed executable path with any command line switches
+  # we've set based on our variables.
+  #
+  def exe_path
+    # Add any standard cmd line arguments we need to pass
+    @exe_path << " --input=html --server --log=#{@log_file} "
+    @exe_path << @style_sheets
+    return @exe_path
+  end
+  
+  # Makes a pdf from a passed in string.
+  #
+  # Returns PDF as a stream, so we can use send_data to shoot
+  # it down the pipe using Rails.
+  #
+  def pdf_from_string(string, output_file = '-')
+    path = self.exe_path()
+    # Don't spew errors to the standard out...and set up to take IO 
+    # as input and output
+    path << ' --silent - -o -'
+
+    # Actually call the prince command, and pass the entire data stream back.
+    pdf = IO.popen(path, "w+")
+    pdf.puts(string)
+    pdf.close_write
+    result = pdf.gets(nil)
+    pdf.close_read
+    return result
+  end
+
+  def pdf_from_string_to_file(string, output_file)
+    path = self.exe_path()
+    # Don't spew errors to the standard out...and set up to take IO 
+    # as input and output
+    path << " --silent - -o '#{output_file}' >> '#{@log_file}' 2>> '#{@log_file}'"
+
+    # Actually call the prince command, and pass the entire data stream back.
+    pdf = IO.popen(path, "w+")
+    pdf.puts(string)
+    pdf.close
+  end
+end