minicomic 0.0.1

data/README

@@ -0,0 +1,106 @@
+= minicomic
+
++minicomic+ is a library providing a set of rake rules for building
+print and web-ready files for minicomics from a set of SVG files.
+
+Currently, it is hard-coded for generating 5.5x8.5in format black-and-white
+comics of the sort most suitable for inexpensive photocopying.
+
+== requirements
+
+In addition to the obvious requirements for Ruby and Rake, +minicomic+
+requires the following software to be installed and available on your
+shell's path:
+
+* Inkscape
+* psutils
+* Ghostscript
+* ImageMagick
+* pngcrush
+
+If you're on Ubuntu, these correspond to the +inkscape+, +psutils+,
++gs-gpl+, +imagemagick+ and +pngcrush+ packages, respectively.
+
+== usage
+
+The simplest way to use +minicomic+ is to create a +Rakefile+ as follows:
+
+  require 'minicomic'
+
+  minicomic '.'
+
++minicomic+ will look for pages in a +pages/+ folder in the given directory
+(in this particular case, '.' meaning the directory where the +Rakefile+ lives).
+
++minicomic+ looks for SVG files in +pages/+ named according to the following
+conventions:
+
++page-NN.svg+:: page NN
++front-cover.svg+:: the front cover of the comic (optional)
++back-cover.svg+:: the back cover of the comic (optional)
++inside-front.svg+:: the inside front cover of the comic (optional)
++inside-back.svg+:: the inside back cover of the comic (optional)
+
+It is also possible to have two-page spreads in single files:
+
++pages-NN-MM.svg+:: the spread spanning pages NN-MM
++cover.svg+:: the cover (back and front together in one file; optional)
+
+Page numbers start at 1 (page 1 is a right-handed page, and the first
+interior page).  Page documents should be 5.5x8.5in or smaller for single
+pages, and 11x8.5in for two-page spreads.
+
+== print output
+
+When generating output for print, +minicomic+ will round the number of
+interior pages up to the next multiple of four, padding with blank pages
+as needed.  The page graphics will be scaled down slightly from their full
+size, and smaller graphics will be centered.
+
+To generate a "proof" PDF that you can examine to see what spreads will
+look like in the assembled comic, use:
+
+ +rake proof+
+
+The PDF will be created as +print/proof.pdf+.  Since I rarely use the
+inside covers for anything, +minicomic+ places the front and back covers
+opposite the first and last interior pages respectively.
+
+To generate a set of PDFs suitable for printing and assembly, use:
+
+ +rake print+
+
+This will generate a set of three PDFs:
+
++print/duplex.pdf+:: suitable for duplex printing
++print/front.pdf+ and +print/back.pdf+:: front and back sides for single-sided printing
+
+If you are using a duplex printer, if you're lucky it will deposit its
+output pages face-up and they will be ready for assembly (this is the norm).
+Otherwise if it deposits its pages face-down, you will have reverse them before
+you can assemble the comic.
+
+When using the single-sided PDFs, _you will need to experiment_ to find the
+correct order to use them in, and the correct way to flip the paper.  For my
+printer, I print +back.pdf+ first, then flip the stack the long way before
+printing +front.pdf+ on it.  Other printers will differ depending on how the
+paper is loaded in the tray, and how it is stacked on output.
+
+== web output
+
+You can generate files for web upload via:
+
+ +rake web+
+
+When generating output for the web, +minicomic+ will generate a set of 4-bit
+greyscale PNGs, and a corresponding set of JPEG thumbnails:
+
++web/page-NN.png+:: page NN
++web/thumbnail-NN.jpeg:: thumbnail of page NN
+
+== cleanup
+
+You can easily get rid of the temporary and output files with:
+
+ +rake clean+
+

data/Rakefile

@@ -0,0 +1,39 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+Rake::TestTask.new do |task|
+  task.libs << 'lib'
+  task.libs << 'test'
+  task.test_files = [ "test/test_all.rb" ]
+  task.verbose = true
+end
+
+Rake::RDocTask.new do |task|
+  task.rdoc_files.include "README"
+  task.main = "README"
+end
+
+gemspec = Gem::Specification.new do |gemspec|
+  gemspec.platform = Gem::Platform::RUBY
+  gemspec.name = "minicomic"
+  gemspec.version = "0.0.1"
+  gemspec.author = "MenTaLguY <mental@rydia.net>"
+  gemspec.summary = "Rake rules for minicomic impressions"
+  gemspec.test_file = 'test/test_all.rb'
+  gemspec.files = FileList[ 'Rakefile', 'test/*.rb', 'lib/**/*.rb' ]
+  gemspec.require_paths = [ 'lib' ]
+  gemspec.has_rdoc = true
+  gemspec.extra_rdoc_files = %w(README)
+  gemspec.rdoc_options = %w(--main README)
+end
+
+task :package => [ :test ]
+Rake::GemPackageTask.new( gemspec ) do |task|
+  task.gem_spec = gemspec
+  task.need_tar = true
+end
+
+task :default => [ :package ]
+

data/lib/minicomic.rb

@@ -0,0 +1,447 @@
+#
+# minicomic.rb: Rake tasks for minicomics using Inkscape and other tools
+#
+# Copyright 2007  MenTaLguY <mental@rydia.net>
+#
+# This library is made available under the same terms as Ruby.
+#
+
+require 'set'
+require 'rake'
+
+module Minicomic
+extend self
+
+private
+
+# in PostScript points
+FORMAT_WIDTH = ( 5.5 * 72 ).to_i
+FORMAT_HEIGHT = ( 8.5 * 72 ).to_i
+PAGE_SCALE = 0.932
+
+# other constants
+LEFT = 0
+RIGHT = 1
+PHI = ( 1 + Math.sqrt( 5 ) ) / 2
+
+def eps_from_svg( eps_file, svg_file )
+  file eps_file => [ svg_file ] do
+    sh 'inkscape', '-T', '-B', '-E', eps_file, svg_file
+  end
+end
+
+def back_eps( out_file, in_file )
+  file out_file => [ in_file ] do
+    sh 'psselect', '-e', in_file, out_file
+  end
+end
+
+def front_eps( out_file, in_file )
+  file out_file => [ in_file ] do
+    sh 'psselect', '-o', in_file, out_file
+  end
+end
+
+def make2up( in_file, out_file )
+  sh 'psnup', "-W#{ FORMAT_WIDTH }", "-H#{ FORMAT_HEIGHT }", "-h#{ FORMAT_WIDTH * 2 }", "-w#{ FORMAT_HEIGHT }", '-2', in_file, out_file
+end
+
+def duplex_eps( out_file, in_file )
+  temp_file = "#{ out_file }.temp"
+  file out_file => [ in_file ] do
+    sh 'psbook', in_file, temp_file
+    begin
+      make2up temp_file, out_file
+    ensure
+      rm temp_file
+    end
+  end
+end
+
+def proof_eps( out_file, in_file )
+  temp_file = "#{ out_file }.temp"
+  file out_file => [ in_file ] do
+    sh 'psselect', '-p1,3-_3,_1', in_file, temp_file
+    begin
+      make2up temp_file, out_file
+    ensure
+      rm temp_file
+    end
+  end
+end
+
+def pdf_from_eps( pdf_file, eps_file )
+  file pdf_file => [ eps_file ] do
+    sh 'ps2pdf', '-sPAPERSIZE=letter', eps_file, pdf_file
+  end
+end
+
+def png_from_svg( png_file, svg_file )
+  temp_png_file = "#{ png_file }.temp"
+  file png_file => [ svg_file ] do
+    sh 'inkscape', '-d', '80', '-C', '-y', '1.0', '-e', temp_png_file, svg_file
+    begin
+      sh 'pngcrush', '-force', '-bit_depth', '4', '-c', '0', '-q', temp_png_file, png_file
+    ensure
+      rm temp_png_file
+    end
+  end
+end
+
+def thumbnail_jpeg_from_image( jpeg_file, image_file )
+  file jpeg_file => [ image_file ] do
+    sh 'convert', '-filter', 'sinc', '-resize', "x96", image_file, jpeg_file
+  end
+end
+
+class BookletLayout
+  def initialize( stream, *pages )
+    @bboxes = {}
+    @stream = stream
+
+    pages.push nil if pages.size % 2 != 0 # pad to even number of pages
+
+    # move the back cover to the beginning, to be paired with the front cover
+    pages.unshift pages.pop
+
+    # pair up adjacent pages into spreads
+    spreads = (0...(pages.size/2)).map { |i| [ pages[i*2], pages[i*2+1] ] }
+
+    # format each spread, breaking spreads back into invdividual pages after
+    pages = spreads.inject( [] ) do |acc, spread|
+      is_cover = acc.empty?
+      acc.push *format_pages( is_cover, *spread )
+    end
+
+    # return the back cover to the end
+    pages.push pages.shift
+
+    emit_document pages
+  end
+
+  def format_pages( is_cover, *pages )
+    spread = pages.map do |page|
+      if page
+        [ bbox(*page), page[2] ]
+      else
+        nil
+      end
+    end.map do |page|
+      if page
+        bbox, document = page
+        dims = (0..1).map { |d| ( bbox[d].end - bbox[d].begin ) * PAGE_SCALE }
+        [ bbox, dims, document ]
+      else
+        nil
+      end
+    end
+
+    if spread.all? # i.e. both?
+      spread_dims = spread.map { |page| page[1] }
+      left_document = spread[LEFT][2]
+      right_document = spread[RIGHT][2]
+      if left_document == right_document
+        tx = translate_spread( *spread_dims )
+      elsif is_cover
+        tx = spread_dims.map { |dims| translate_single( dims ) }
+      else
+        tx = translate_facing( *spread_dims )
+      end
+      [ [ spread[LEFT][0], tx[LEFT], left_document ],
+        [ spread[RIGHT][0], tx[RIGHT], right_document ] ]
+    else
+      spread.map do |page|
+        if page
+          [ page[0], translate_single( page[1] ), page[2] ]
+        else
+          nil
+        end
+      end
+    end
+  end
+
+  def bbox( i, n, document )
+    rx, ry = @bboxes[document] ||= (
+      rx, ry = 0.0..(FORMAT_WIDTH.to_f * n), 0.0..(FORMAT_HEIGHT.to_f)
+      File.open( document, "r" ) do |stream|
+        stream.each_line do |line|
+          case line
+          when /^%%BoundingBox: (\d+) (\d+) (\d+) (\d+)/
+            rx, ry = ($1.to_f)..($3.to_f), ($2.to_f)..($4.to_f)
+            break
+          when /^%%EndComments/
+            break
+          end
+        end
+      end
+      [ rx, ry ]
+    )
+    width = rx.end - rx.begin
+    [ ( rx.begin + width * i / n )..( rx.begin + width * ( i + 1 ) / n ), ry ]
+  end
+
+  def bottom_margin( height )
+    ( FORMAT_HEIGHT.to_f - height ) / PHI
+  end
+
+  def horizontal_margin( width )
+    ( FORMAT_WIDTH.to_f - width ) / 2
+  end
+
+  def translate_single( dims )
+    [ horizontal_margin( dims[0] ), bottom_margin( dims[1] ) ]
+  end
+
+  def translate_facing( left, right )
+    left_margin = horizontal_margin( left[0] )
+    right_margin = horizontal_margin( right[0] )
+    gutter = [ [ left_margin, right_margin ].min, 0 ].max
+    [ [ left_margin + ( gutter / 3 ), bottom_margin( left[1] ) ],
+      [ right_margin - ( gutter / 3 ), bottom_margin( right[1] ) ] ]
+  end
+
+  def translate_spread( left, right )
+    [ [ FORMAT_WIDTH.to_f - left[0], bottom_margin( left[1] ) ],
+      [ 0, bottom_margin( right[1] ) ] ]
+  end
+
+  def emit_dsc( name, value=nil )
+    if value
+      @stream.puts "%%#{ name }: #{ value }"
+    else
+      @stream.puts "%%#{ name }"
+    end
+  end
+
+  def emit_document( pages )
+    @stream.puts "%!PS-Adobe-3.0"
+    emit_dsc 'Creator', 'minicomic'
+    emit_dsc 'Pages', pages.size
+    #emit_dsc 'Orientation', 'Portrait'
+    #bbox = "0 0 #{ FORMAT_WIDTH } #{ FORMAT_HEIGHT }"
+    #emit_dsc 'BoundingBox', bbox
+    #emit_dsc 'HiResBoundingBox', bbox
+    emit_dsc 'EndComments'
+    pages.each_with_index do |page, n|
+      if page
+        emit_page( n, *page )
+      else
+        emit_empty_page( n )
+      end
+    end
+    emit_dsc 'EOF'
+  end
+
+  def emit_clip_rect( x0, y0, x1, y1 )
+    @stream.puts "newpath"
+    @stream.puts "#{ x0 } #{ y0 } moveto"
+    @stream.puts "#{ x0 } #{ y1 } lineto"
+    @stream.puts "#{ x1 } #{ y1 } lineto"
+    @stream.puts "#{ x1 } #{ y0 } lineto"
+    @stream.puts "closepath eoclip newpath"
+  end
+
+  def emit_page( n, bbox, translate, document )
+    emit_dsc 'Page', "#{ n } #{ n }"
+
+    @stream.puts "save"
+
+    emit_clip_rect( 0, 0, FORMAT_WIDTH, FORMAT_HEIGHT )
+
+    @stream.puts <<EOS
+#{ bbox.map { |r| -r.begin }.join( ' ' ) } translate 
+#{ PAGE_SCALE } #{ PAGE_SCALE } scale
+#{ translate.join( ' ' ) } translate
+EOS
+
+    emit_clip_rect( bbox[0].begin, bbox[1].begin, bbox[0].end, bbox[1].end )
+
+    emit_dsc 'BeginDocument', File.basename( document )
+    File.open( document, 'r' ) do |input|
+      input.each_line do |line|
+        @stream.puts line
+      end
+    end
+    emit_dsc 'EndDocument'
+    emit_dsc 'PageTrailer'
+    @stream.puts "restore"
+  end
+
+  def emit_empty_page( n )
+    emit_dsc 'Page', "#{ n } #{ n }"
+    @stream.puts "showpage"
+  end
+end
+
+def layout_booklet( layout_ps, *pages )
+  file layout_ps => pages.compact.map { |i, n, file| file } do
+    begin
+      File.open( layout_ps, 'w' ) do |stream|
+        BookletLayout.new( stream, *pages )
+      end
+    rescue
+      rm layout_ps
+      raise
+    end
+  end
+end
+
+def special_name_re( name )
+  Regexp.new( Regexp.quote( name ).gsub( /-/, "\\W*" ), "i" )
+end
+
+def normalize_special_name( name )
+  name = name.gsub( /[a-z](?=[A-Z])/, '\&-' )
+  name.gsub!( /\W+/, '-' )
+  name.downcase!
+  name
+end
+
+SPECIAL_NAMES = %w(front-cover back-cover cover inside-front inside-back)
+SPECIAL_NAME_RES = SPECIAL_NAMES.map { |n| special_name_re( n ) }
+
+public
+
+def minicomic( dir )
+  pages_dir = File.join( dir, 'pages' )
+
+  scratch_dir = File.join( dir, 'scratch' )
+  directory scratch_dir
+
+  web_dir = File.join( dir, 'web' )
+  directory web_dir
+
+  print_dir = File.join( dir, 'print' )
+  directory print_dir
+
+  layout_ps = File.join( scratch_dir, 'layout.ps' )
+
+  specials = Set.new
+  pages = []
+
+  FileList[File.join( pages_dir, '*.svg' )].each do |page_svg|
+    name = File.basename( page_svg )
+    name.sub!( /\.svg$/, '' )
+
+    min = max = nil
+    print_name = name
+    case name
+    when *SPECIAL_NAME_RES
+      name = normalize_special_name( name )
+      next unless SPECIAL_NAMES.include? name # warning?
+      next if specials.include? name # warning?
+      specials.add name
+      if name == 'front-cover'
+        web_name = "page-00"
+      else
+        web_name = nil
+      end
+    when /^page\W*(\d+)$/i
+      min = max = $1.to_i
+      suffix = "%02d" % [ min ]
+      print_name = "page-#{ suffix }"
+      web_name = print_name
+    when /^pages?\W*(\d+)\D+(\d+)$/i
+      min, max = $1.to_i, $2.to_i
+      min, max = max, min if max < min
+      suffix = "%02d-%02d" % [ min, max ]
+      print_name = "pages-#{ suffix }"
+      web_name = print_name
+    else
+      # warning?
+      next
+    end
+
+    page_eps = File.join( scratch_dir, "#{ print_name }.eps" )
+
+    if min and min > 0
+      size = max - min + 1
+      (0...size).each do |n|
+        pages[n+min-1] = [ n, size, page_eps ]
+      end
+    end
+
+    eps_from_svg( page_eps, page_svg )
+    task page_eps => [ scratch_dir ]
+
+    if web_name
+      page_png = File.join( web_dir, "#{ web_name }.png" )
+      png_from_svg( page_png, page_svg )
+      task page_png => [ web_dir ]
+      
+      thumbnail_name = web_name.sub( /^page/, 'thumbnail' )
+      thumbnail_jpeg = File.join( web_dir, "#{ thumbnail_name }.jpeg" )
+      thumbnail_jpeg_from_image( thumbnail_jpeg, page_png )
+      task thumbnail_jpeg => [ web_dir ]
+
+      task :web => [ page_png, thumbnail_jpeg ]
+    end
+  end
+
+  pages = [ nil, nil ] + pages + [ nil ] * ( pages.size % 4 ) + [ nil, nil ]
+
+  specials.each do |name|
+    filename = File.join( scratch_dir, "#{ name }.eps" )
+    case name
+    when 'front-cover'
+      pages[0] ||= [ 0, 1, filename ] # 'cover' takes precedence
+    when 'back-cover'
+      pages[-1] ||= [ 0, 1, filename ] # 'cover' takes precedence
+    when 'cover'
+      pages[-1] = [ 0, 2, filename ]
+      pages[0] = [ 1, 2, filename ]
+    when 'inside-front'
+      pages[1] = [ 0, 1, filename ]
+    when 'inside-back'
+      pages[-2] = [ 0, 1, filename ]
+    end
+  end
+
+  layout_booklet( layout_ps, *pages )
+
+  duplex_eps = File.join( scratch_dir, "duplex.eps" )
+
+  %w(proof back front duplex).each do |kind|
+    case kind
+    when 'duplex', 'proof'
+      source = layout_ps
+    else
+      source = duplex_eps
+    end 
+    kind_eps = File.join( scratch_dir, "#{ kind }.eps" )
+    send( "#{ kind }_eps", kind_eps, source )
+    task kind_eps => [ scratch_dir ]
+    kind_pdf = File.join( print_dir, "#{ kind }.pdf" )
+    pdf_from_eps( kind_pdf, kind_eps )
+    task kind_pdf => [ print_dir ]
+    task kind => [ kind_pdf ]
+  end
+
+  desc "Generate PDF files for printing"
+  task :print => [ :duplex, :front, :back ]
+
+  desc "Generate a proof PDF for review"
+  task :proof
+
+  desc "Remove all output and intermediate files"
+  task :clean do
+    rm_rf print_dir
+    rm_rf web_dir
+    rm_rf scratch_dir
+  end
+
+  desc "Generate graphics for the web"
+  task :web
+
+  desc "Generate web and print output"
+  task :both => [ :print, :web ]
+
+  task :default => [ :both ]
+end
+
+end
+
+def minicomic( dir )
+  Minicomic.minicomic( dir )
+end
+

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: minicomic
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-03-29 00:00:00 -04:00
+summary: Rake rules for minicomic impressions
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- MenTaLguY <mental@rydia.net>
+files: 
+- Rakefile
+- test/test_all.rb
+- lib/minicomic.rb
+- README
+test_files: 
+- test/test_all.rb
+rdoc_options: 
+- --main
+- README
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+