slideshow 0.8.5 → 0.9

data/lib/slideshow/filters/text_filter.rb

@@ -0,0 +1,143 @@
+# builtin text filters
+# called before text_to_html
+#
+# use web filters for processing html/hypertext
+
+module TextFilter
+
+  def comments_percent_style( content )
+    # remove comments
+    # % comments
+    # %begin multiline comment
+    # %end multiline comment
+
+    # track statistics
+    comments_multi  = 0
+    comments_single = 0
+    comments_end    = 0
+
+    # remove multi-line comments
+    content.gsub!(/^%begin.*?%end/m) do |match|
+      comments_multi += 1
+      ""
+    end
+    
+     # remove everyting starting w/ %end (note, can only be once in file) 
+    content.sub!(/^%end.*/m) do |match|
+      comments_end += 1
+      ""
+    end
+
+    # remove single-line comments    
+    content.gsub!(/^%.*/ ) do |match|
+      comments_single += 1
+      ""
+    end
+    
+    puts "  Removing comments (#{comments_single} %-lines, " +
+       "#{comments_multi} %begin/%end-blocks, #{comments_end} %end-blocks)..."
+    
+    content    
+  end
+
+  def skip_end_directive( content )
+    # codex-style __SKIP__, __END__ directive
+    # ruby note: .*? is non-greedy (shortest-possible) regex match
+    content.gsub!(/__SKIP__.*?__END__/m, '')
+    content.sub!(/__END__.*/m, '')
+    content
+  end
+  
+  def include_helper_hack( content )
+    # note: include is a ruby keyword; rename to __include__ so we can use it 
+    
+    include_counter = 0
+    
+    content.gsub!( /<%=[ \t]*include/ ) do |match|
+      include_counter += 1
+      '<%= __include__' 
+    end
+
+    puts "  Patching embedded Ruby (erb) code aliases (#{include_counter} include)..."
+
+    content
+  end
+  
+  # allow plugins/helpers; process source (including header) using erb    
+  def erb( content )
+    puts "  Running embedded Ruby (erb) code/helpers..."
+    
+    content =  ERB.new( content ).result( binding() )
+    content
+  end
+
+  def erb_django_style( content )
+
+    # replace expressions (support for single lines only)
+    #  {{ expr }}  ->  <%= expr %>
+    #  {% stmt %}  ->  <%  stmt %>   !! add in do if missing (for convenience)
+
+    erb_expr = 0
+    erb_stmt_beg = 0
+    erb_stmt_end = 0
+
+    content.gsub!( /\{\{([^{}\n]+?)\}\}/ ) do |match|
+      erb_expr += 1
+      "<%= #{$1} %>"
+    end
+
+    content.gsub!( /\{%[ \t]*end[ \t]*%\}/ ) do |match|
+      erb_stmt_end += 1
+      "<% end %>"
+    end
+
+    content.gsub!( /\{%([^%\n]+?)%\}/ ) do |match|
+      erb_stmt_beg += 1
+      if $1.include?('do') 
+        "<% #{$1} %>"
+      else
+        "<% #{$1} do %>"
+      end
+    end
+
+    puts "  Patching embedded Ruby (erb) code Django-style (#{erb_expr} {{-expressions," +
+       " #{erb_stmt_beg}/#{erb_stmt_end} {%-statements)..."
+         
+    content        
+  end
+
+  def code_block_curly_style( content )
+    # replace {{{  w/ <pre class='code'>
+    # replace }}}  w/ </pre>
+    
+    # track statistics
+    code_begin = 0
+    code_end   = 0    
+    
+    content.gsub!( "{{{{{{", "<pre class='code'>_S9BEGIN_" )
+    content.gsub!( "}}}}}}", "_S9END_</pre>" )  
+    
+    content.gsub!( "{{{" ) do |match|
+      code_begin += 1
+      "<pre class='code'>"
+    end    
+    
+    content.gsub!( "}}}" ) do |match|
+      code_end += 1
+      "</pre>"
+    end
+    
+    # restore escaped {{{}}} 
+    content.gsub!( "_S9BEGIN_", "{{{" )
+    content.gsub!( "_S9END_", "}}}" )
+    
+    puts "  Patching code blocks (#{code_begin}/#{code_end} {{{/}}}-lines)..."    
+    
+    content
+  end
+
+end
+
+class Slideshow::Gen
+  include TextFilter
+end

data/lib/slideshow/gen.rb

@@ -1,38 +1,15 @@
-
-
-
 module Slideshow
 
-class Slide < Struct.new(:header, :content)
-end
-
 class Gen
-
-  KNOWN_TEXTILE_EXTNAMES  = [ '.textile', '.t' ]
-  KNOWN_MARKDOWN_EXTNAMES = [ '.markdown', '.m', '.mark', '.mkdn', '.md', '.txt', '.text' ]
-  KNOWN_EXTNAMES = KNOWN_TEXTILE_EXTNAMES + KNOWN_MARKDOWN_EXTNAMES
-
-  # note: only kramdown is listed as a dependency in gem specs (because it's Ruby only and, thus, easy to install)
-  #  if you want to use other markdown libs install the required/desired lib e.g.
-  #  use  gem install rdiscount for rdiscount and so on
-  #
-  # also note for now the first present markdown library gets used
-  #  the search order is first come, first serve, that is: rdiscount, rpeg-markdown, maruku, bluecloth, kramdown (fallback, always present)
-  KNOWN_MARKDOWN_LIBS = [
-    [ 'rdiscount',      lambda { |content| RDiscount.new( content ).to_html } ],
-    [ 'rpeg-markdown',  lambda { |content| PEGMarkdown.new( content ).to_html } ],
-    [ 'maruku',         lambda { |content| Maruku.new( content, {:on_error => :raise} ).to_html }  ],
-    [ 'bluecloth',      lambda { |content| BlueCloth.new( content ).to_html } ],
-    [ 'kramdown',       lambda { |content| Kramdown::Document.new( content ).to_html } ]
-  ] 
   
   def initialize
     @logger = Logger.new(STDOUT)
     @logger.level = Logger::INFO
-    @opts = Opts.new
+    @opts   = Opts.new
+    @config = Config.new
   end
 
-  attr_reader :logger, :opts
+  attr_reader :logger, :opts, :config
   attr_reader :session      # give helpers/plugins a session-like hash
   
   def headers
@@ -47,42 +24,47 @@ class Gen
     # try to require each lib and remove any not installed
     @markdown_libs = []
 
-    KNOWN_MARKDOWN_LIBS.each do |lib|
+    config.known_markdown_libs.each do |lib|
       begin
-        require lib[0]
+        require lib
         @markdown_libs << lib
       rescue LoadError => ex
-        logger.debug "Markdown library #{lib[0]} not found. Use gem install #{lib[0]} to install."
+        logger.debug "Markdown library #{lib} not found. Use gem install #{lib} to install."
       end
     end
 
-    logger.debug "Installed Markdown libraries: #{@markdown_libs.map{ |lib| lib[0] }.join(', ')}"
-    logger.debug "Using Markdown library #{@markdown_libs.first[0]}."
+    puts "  Found #{@markdown_libs.length} Markdown libraries: #{@markdown_libs.join(', ')}"
   end
+ 
   
-  # todo: move to filter (for easier reuse)
   def markdown_to_html( content )
-    @markdown_libs.first[1].call( content )
-  end
-
-  # todo: move to filter (for easier reuse)  
-  def textile_to_html( content )
+    # call markdown filter; turn markdown lib name into method_name (mn)
+    # eg. rpeg-markdown =>  rpeg_markdown_to_html
     
-    # JRuby workaround for RedCloth 4 multi-byte character bug
-    #  see http://jgarber.lighthouseapp.com/projects/13054/tickets/149-redcloth-4-doesnt-support-multi-bytes-content
-    # basically convert non-ascii chars (>127) to html entities
-    
-    if RedCloth::EXTENSION_LANGUAGE == "Java"
-      content = content.chars.map{ |x| x.size > 1 ? "&##{x.unpack("U*")};" : x }.join 
+    puts "  Converting Markdown-text (#{content.length} bytes) to HTML using library '#{@markdown_libs.first}'..."
+        
+    mn = @markdown_libs.first.downcase.tr( '-', '_' )
+    mn = "#{mn}_to_html".to_sym
+    send mn, content   # call 1st configured markdown engine e.g. kramdown_to_html( content )
+  end
+
+  # uses configured markup processor (textile,markdown) to generate html
+  def text_to_html( content )
+    content = case @markup_type
+      when :markdown
+        markdown_to_html( content )
+      when :textile
+        textile_to_html( content )
     end
-    
-    # turn off hard line breaks
-    # turn off span caps (see http://rubybook.ca/2008/08/16/redcloth)
-    red = RedCloth.new( content, [:no_span_caps] )
-    red.hard_breaks = false
-    content = red.to_html
+    content
   end
-  
+ 
+  def guard_text( text )
+    # todo/fix: remove wrap_markup; replace w/ guard_text
+    #   why: text might be css, js, not just html      
+    wrap_markup( text )
+  end
+   
   def wrap_markup( text )    
     if markup_type == :textile
       # saveguard with notextile wrapper etc./no further processing needed
@@ -97,7 +79,7 @@ class Gen
   end
 
   def win32_cache_dir
-    unless File.exists?(home = ENV['HOMEDRIVE'] + ENV['HOMEPATH'])
+    unless ENV['HOMEDRIVE'] && ENV['HOMEPATH'] && File.exists?(home = ENV['HOMEDRIVE'] + ENV['HOMEPATH'])
       puts "No HOMEDRIVE or HOMEPATH environment variable.  Set one to save a" +
            "local cache of stylesheets for syntax highlighting and more."
       return false
@@ -277,9 +259,14 @@ class Gen
       logger.debug "using direct net http access; no proxy configured"
       proxy = OpenStruct.new   # all fields return nil (e.g. proxy.host, etc.)
     end
+  
+    # same as short-cut: http_proxy.get_respone( uri )
+    # use full code for easier changes
     
-    http = Net::HTTP::Proxy( proxy.host, proxy.port, proxy.user, proxy.password )
-    response = http.get_response( uri )  
+    http_proxy = Net::HTTP::Proxy( proxy.host, proxy.port, proxy.user, proxy.password )
+    http       = http_proxy.new( uri.host, uri.port )
+    request    = Net::HTTP::Get.new( uri.request_uri )
+    response   = http.request( request )  
   
     unless response.code == '200'   # note: responsoe.code is a string
       msg = "#{response.code} #{response.message}" 
@@ -306,7 +293,21 @@ class Gen
   def fetch_slideshow_templates
     logger.debug "fetch_uri=#{opts.fetch_uri}"
     
-    src = opts.fetch_uri 
+    src = opts.fetch_uri
+    
+    ## check for builtin shortcut (assume no / or \) 
+    if src.index( '/' ).nil? && src.index( '\\' ).nil?
+      shortcut = src.clone
+      src = config.map_fetch_shortcut( src )
+      
+      if src.nil?
+        puts "** Error: No mapping found for fetch shortcut '#{shortcut}'."
+        return
+      end
+      puts "  Mapping fetch shortcut '#{shortcut}' to: #{src}"
+    end
+    
+    
     # src = 'http://github.com/geraldb/slideshow/raw/d98e5b02b87ee66485431b1bee8fb6378297bfe4/code/templates/fullerscreen.txt'
     # src = 'http://github.com/geraldb/sandbox/raw/13d4fec0908fbfcc456b74dfe2f88621614b5244/s5blank/s5blank.txt'
     uri = URI.parse( src )
@@ -409,6 +410,11 @@ class Gen
   def create_slideshow( fn )
 
     manifest_path_or_name = opts.manifest
+    
+    # add .txt file extension if missing (for convenience)
+    manifest_path_or_name << ".txt"   if File.extname( manifest_path_or_name ).empty?
+
+  
     logger.debug "manifest=#{manifest_path_or_name}"
     
     # check if file exists (if yes use custom template package!) - allows you to override builtin package with same name 
@@ -455,7 +461,7 @@ class Gen
   if extname.empty? then
     extname  = ".textile"   # default to .textile 
     
-    KNOWN_EXTNAMES.each do |e|
+    config.known_extnames.each do |e|
        logger.debug "File.exists? #{dirname}/#{basename}#{e}"
        if File.exists?( "#{dirname}/#{basename}#{e}" ) then         
           extname = e
@@ -465,7 +471,7 @@ class Gen
     end     
   end
 
-  if KNOWN_MARKDOWN_EXTNAMES.include?( extname )
+  if config.known_markdown_extnames.include?( extname )
     @markup_type = :markdown
   else
     @markup_type = :textile
@@ -482,113 +488,94 @@ class Gen
 
   logger.debug "inname=#{inname}"
     
-  content_with_headers = File.read( inname )
+  content = File.read( inname )
 
-  # todo: read headers before command line options (lets you override options using commandline switch)?
-  
-  # read source document; split off optional header from source
-  # strip leading optional headers (key/value pairs) including optional empty lines
+  # fix: add to comment text filter as first rule!!
+  # check for !SLIDE alias %slide (needs to get coverted to ! otherwise
+  #   it gets removed as a comment)
+  content.gsub!(/^%slide/, '!SLIDE' )
 
-  read_headers = true
-  content = ""
+  # run text filters
   
-   # fix: allow comments in header too (#)
-
-  content_with_headers.each_line do |line|
-    if read_headers && line =~ /^\s*(\w[\w-]*)[ \t]*:[ \t]*(.*)/
-      key = $1.downcase
-      value = $2.strip
-    
-      logger.debug "  adding option: key=>#{key}< value=>#{value}<"
-      opts.put( key, value )
-    elsif line =~ /^\s*$/
-      content << line  unless read_headers
-    else
-      read_headers = false
-      content << line
-    end
+  config.text_filters.each do |filter|
+    mn = filter.tr( '-', '_' ).to_sym  # construct method name (mn)
+    content = send( mn, content )   # call filter e.g.  include_helper_hack( content )  
   end
 
-  opts.set_defaults  
-    
-  # ruby note: .*? is non-greedy (shortest-possible) regex match
-  content.gsub!(/__SKIP__.*?__END__/m, '')
-  content.sub!(/__END__.*/m, '')
-  
-  # allow plugins/helpers; process source (including header) using erb
+  # check for !SLIDE markers; change to HTML comments
   
-  # note: include is a ruby keyword; rename to __include__ so we can use it 
-  content.gsub!( /<%=[ \t]*include/, '<%= __include__' )
+  # -- slide marker stats
+  slide_markers = 0
   
-  content =  ERB.new( content ).result( binding )
+  ## todo: use html processing instruction <?s9 slide ?>
+  content.gsub!(/^!SLIDE(.*)/ ) do |match|
+    slide_markers += 1
+    "<!-- _S9SLIDE_ #{$1} -->"
+  end
   
-  # run pre-filters (built-in macros)
-  # o replace {{{  w/ <pre class='code'>
-  # o replace }}}  w/ </pre>
-  content.gsub!( "{{{{{{", "<pre class='code'>_S9BEGIN_" )
-  content.gsub!( "}}}}}}", "_S9END_</pre>" )  
-  content.gsub!( "{{{", "<pre class='code'>" )
-  content.gsub!( "}}}", "</pre>" )
-  # restore escaped {{{}}} I'm sure there's a better way! Rubyize this! Anyone?
-  content.gsub!( "_S9BEGIN_", "{{{" )
-  content.gsub!( "_S9END_", "}}}" )
+  puts "  Processing directives (#{slide_markers} !SLIDE-directives)..."
+
 
   # convert light-weight markup to hypertext
  
-  content = case @markup_type
-     when :markdown
-      markdown_to_html( content )
-    when :textile
-      textile_to_html( content )
-  end  
-
+  content = text_to_html( content )
+ 
   # post-processing
 
   slide_counter = 0
-  content2 = ''
-  
-  ## todo: move this to a filter (for easier reuse)
 
   slides       = []
   slide_source = ""
      
   # wrap h1's in slide divs; note: use just <h1 since some processors add ids e.g. <h1 id='x'>
   content.each_line do |line|
-     if line.include?( '<h1' ) then
+     if line.include?( '<h1' ) || line.include?( '<!-- _S9SLIDE_' )  then
         if slide_counter > 0 then   # found start of new slide (and, thus, end of last slide)
-          content2 << "</div>\n"       
           slides   << slide_source  # add slide to slide stack
-          slide_source = ""            # reset slide source buffer
+          slide_source = ""         # reset slide source buffer
         end
-        content2 << "<div class='slide'>\n"
         slide_counter += 1
      end
-     content2      << line
      slide_source  << line
   end
   
   if slide_counter > 0 then
-    content2 << "</div>\n"
     slides   << slide_source     # add slide to slide stack
     slide_source = ""            # reset slide source buffer 
   end
 
   ## split slide source into header (optional) and content/body
+  ## plus check for classes
 
   slides2 = []
   slides.each do |slide_source|
     slide = Slide.new
-    if slide_source =~ /^\s*(<h.+?>.*?<\/h\d>)\s+(.*)/m  # try to cut off header using non-greedy .+? pattern; tip test regex online at rubular.com
+    
+    ## check for css style class
+    if slide_source =~ /<!-- _S9SLIDE_(.*?)-->/
+      slide.classes = $1.strip
+      logger.debug "  adding css classes: #{slide.classes}"
+    end
+       
+    if slide_source =~ /^\s*(<h1.+?>.*?<\/h\d>)\s*(.*)/m  # try to cut off header using non-greedy .+? pattern; tip test regex online at rubular.com
       slide.header  = $1
-      slide.content = $2
+      slide.content = ($2 ? $2 : "")
       logger.debug "  adding slide with header:\n#{slide.header}"
-  else
+    else
       slide.content = slide_source
       logger.debug "  adding slide with *no* header"
     end
     slides2 << slide
   end
 
+   # for convenience create a string w/ all in-one-html
+   #  no need to wrap slides in divs etc.
+   
+   content2 = ""
+   slides2.each do |slide|         
+      content2 << slide.to_classic_html
+   end
+   
   # make content2 and slide2 available to erb template
   # -- todo: cleanup variable names and use attr_readers for content and slide
   
@@ -653,19 +640,13 @@ def run( args )
     
     cmd.on( '-o', '--output PATH', 'Output Path' ) { |s| opts.put( 'output', s ) }
 
-    cmd.on( '-g', '--generate',  'Generate Slide Show Templates' ) { opts.put( 'generate', true ) }
+    cmd.on( '-g', '--generate',  'Generate Slide Show Templates (Using Built-In S6 Pack)' ) { opts.put( 'generate', true ) }
     
     cmd.on( "-t", "--template MANIFEST", "Template Manifest" ) do |t|
       # todo: do some checks on passed in template argument
       opts.put( 'manifest', t )
     end
 
-    # shortcut: same as -t s5.txt
-    cmd.on( '--s5', 'S5-Compatible Slide Show (same as -t s5.txt)' ) { opts.put( 's5', true ); opts.put( 'manifest', 's5.txt' ) }
-    
-    # shortcut: same as -t fullerscreen.txt
-    cmd.on( '--fullerscreen', 'FullerScreen-Compatible Slide Show (same as -t fullerscreen.txt)' ) { opts.put( 'fuller', true ); opts.put( 'manifest', 'fullerscreen.txt' ) }
-
     # ?? opts.on( "-s", "--style STYLE", "Select Stylesheet" ) { |s| $options[:style]=s }
     # ?? opts.on( "--version", "Show version" )  {}
         
@@ -695,19 +676,16 @@ def run( args )
          puts
          puts "Examples:"
          puts "  slideshow microformats"
-         puts "  slideshow microformats.textile"
+         puts "  slideshow microformats.textile         # Process slides using Textile"
+         puts "  slideshow microformats.text            # Process slides using Markdown"
          puts "  slideshow -o slides microformats       # Output slideshow to slides folder"
-         puts "  slideshow --s5 microformats            # Use S5-compatible slide show templates"
-         puts "  slideshow --fullerscreen microformats  # Use FullerScreen-compatible slide show templates"
          puts
          puts "More examles:"
-         puts "  slideshow -g                           # Generate slide show templates"
-         puts "  slideshow -g --s5                      # Generate S5 compatible slide show templates"
-         puts "  slideshow -g --fullerscreen            # Generate FullerScreen compatible slide show templates"
+         puts "  slideshow -g                           # Generate slide show templates using built-in S6 pack"
          puts
          puts "  slideshow -l                           # List installed slide show templates"
          puts "  slideshow -f s5blank                   # Fetch (install) S5 blank starter template from internet"
-         puts "  slideshow -t s5blank.txt microformats  # Use your own slide show templates (e.g. s5blank.txt)"
+         puts "  slideshow -t s5blank microformats      # Use your own slide show templates (e.g. s5blank)"
          puts
          puts "Further information:"
          puts "  http://slideshow.rubyforge.org" 
@@ -716,6 +694,8 @@ def run( args )
   end
 
   opt.parse!( args )
+  
+  config.load
 
   puts "Slide Show (S9) Version: #{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"