RubyGems - pangrid - Versions diffs - 0.2.1 - Mend

pangrid 0.2.1

Files changed (17) hide show

checksums.yaml +7 -0
data/LICENSE +21 -0
data/README +22 -0
data/bin/pangrid +5 -0
data/lib/deps/trollop.rb +838 -0
data/lib/pangrid.rb +69 -0
data/lib/pangrid/frontend/webrick.rb +74 -0
data/lib/pangrid/plugin.rb +105 -0
data/lib/pangrid/plugins/acrosslite.rb +466 -0
data/lib/pangrid/plugins/csv.rb +83 -0
data/lib/pangrid/plugins/excel.rb +66 -0
data/lib/pangrid/plugins/reddit.rb +62 -0
data/lib/pangrid/plugins/text.rb +34 -0
data/lib/pangrid/utils.rb +9 -0
data/lib/pangrid/version.rb +3 -0
data/lib/pangrid/xw.rb +152 -0
metadata +62 -0

data/lib/pangrid.rb ADDED

@@ -0,0 +1,69 @@
+require_relative 'deps/trollop'
+require_relative 'pangrid/version'
+require_relative 'pangrid/plugin'
+require_relative 'pangrid/frontend/webrick'
+module Pangrid
+  def self.run_command_line
+    # command line options
+    p = Trollop::Parser.new do
+      version "pangrid #{VERSION}"
+      opt :from, "Format to convert from", :type => :string
+      opt :to, "Format to convert to", :type => :string
+      opt :in, "Input file", :type => :string
+      opt :out, "Output file", :type => :string
+      opt :list, "List available format plugins"
+      opt :web, "Launch webserver"
+    end
+    Trollop::with_standard_exception_handling p do
+      opts = p.parse ARGV
+      if opts[:web]
+        run_webserver 1234
+      elsif opts[:list] || [:from, :to, :in, :out].all? {|k| opts[k]}
+        run opts
+      else
+        p.educate
+      end
+    end
+  end
+  def self.run(opts)
+    Plugin.load_all
+    if opts[:list]
+      Plugin.list_all
+      return
+    end
+    # run the converter
+    #
+    from = Plugin.get(opts[:from])
+    to = Plugin.get(opts[:to])
+    if !from or !from.method_defined? :read
+      $stderr.puts "No reader for #{opts[:from]}"
+      return
+    end
+    if !to or !to.method_defined? :write
+      $stderr.puts "No writer for #{opts[:to]}"
+      return
+    end
+    if !File.exist? opts[:in]
+      $stderr.puts "Cannot find file #{opts[:in]}"
+      return
+    end
+    reader = from.new
+    writer = to.new
+    input = IO.read(opts[:in])
+    output = writer.write(reader.read(input))
+    File.open(opts[:out], "w") do |f|
+      f.print output
+    end
+  end
+end

data/lib/pangrid/frontend/webrick.rb ADDED

@@ -0,0 +1,74 @@
+require "webrick"
+module Pangrid
+FORM = <<HERE
+<html>
+	<body>
+    <form method="POST" enctype="multipart/form-data">
+			<input type="file" name="filedata" />
+			<select name="from">
+				<option value="across-lite-binary">AcrossLite binary (.puz)</option>
+				<option value="across-lite-text">AcrossLite text</option>
+			</select>
+			&rarr;
+      <select name="to">
+				<option value="reddit-blank">Reddit (blank)</option>
+				<option value="reddit-filled">Reddit (filled)</option>
+				<option value="text">Text</option>
+			</select>
+			<input type="submit" />
+    </form>
+    <hr>
+    <div>
+      <pre>%s</pre>
+    </div>
+	</body>
+</html>
+HERE
+class Servlet < WEBrick::HTTPServlet::AbstractServlet
+	def do_GET (request, response)
+		response.status = 200
+		response.content_type = "text/html"
+		response.body = FORM % ""
+	end
+	def do_POST(request, response)
+		input = request.query["filedata"]
+		from = Plugin.get(request.query["from"])
+		to = Plugin.get(request.query["to"])
+		reader = from.new
+		writer = to.new
+    out = nil
+		begin
+			out = writer.write(reader.read(input))
+		rescue Exception => e
+			out = e.inspect
+		end
+		response.status = 200
+		response.content_type = "text/html"
+		response.body = FORM % WEBrick::HTMLUtils.escape(out)
+	end
+end
+def self.run_webserver(port)
+  puts "-------------------------------------------"
+  puts "Open your web browser and load"
+  puts "  http://localhost:#{port}"
+  puts "-------------------------------------------"
+	Plugin.load_all
+	log_stream = File.open('pangrid-webrick-access.log', 'w+')
+	log = [ [log_stream, WEBrick::AccessLog::COMMON_LOG_FORMAT] ]
+	server = WEBrick::HTTPServer.new(:Port => port, :AccessLog => log)
+	server.mount "/", Servlet
+	trap("INT") { server.shutdown }
+	server.start
+end
+end # module Pangrid

data/lib/pangrid/plugin.rb ADDED

@@ -0,0 +1,105 @@
+require_relative 'xw'
+require_relative 'utils'
+module Pangrid
+class PluginDependencyError < StandardError
+  attr_accessor :name, :gems
+  def initialize(name, gems)
+    @name, @gems = name, gems
+  end
+end
+# Load all the gem dependencies of a plugin
+def self.require_for_plugin(name, gems)
+  missing = []
+  gems.each do |gem|
+    begin
+      require gem
+    rescue LoadError => e
+      # If requiring a gem raises something other than LoadError let it
+      # propagate upwards.
+      missing << gem
+    end
+  end
+  if !missing.empty?
+    raise PluginDependencyError.new(name, missing)
+  end
+end
+class Plugin
+  include PluginUtils
+  REGISTRY = {}
+  FAILED = []
+  MISSING_DEPS = {}
+  def self.inherited(subclass)
+    name = class_to_name(subclass.name)
+    #puts "Registered #{subclass} as #{name}"
+    REGISTRY[name] = subclass
+  end
+  def self.load_all
+    REGISTRY.clear
+    FAILED.clear
+    plugins = Dir.glob(File.dirname(__FILE__) + "/plugins/*.rb")
+    plugins.each do |f|
+      load_plugin f
+    end
+  end
+  def self.load_plugin(filename)
+    begin
+      require filename
+    rescue PluginDependencyError => e
+      MISSING_DEPS[e.name] = e.gems
+    rescue StandardError => e
+      FAILED << "#{File.basename(filename)}: #{e}"
+    end
+  end
+  def self.list_all
+    puts "-------------------------------------------------------"
+    puts "Available plugins:"
+    puts "-------------------------------------------------------"
+    REGISTRY.keys.sort.each do |name|
+      plugin = REGISTRY[name]
+      provides = [:read, :write].select {|m| plugin.method_defined? m}
+      provides = provides.map {|m| {read: 'from', write: 'to'}[m]}
+      puts "  " + name + " [" + provides.join(", ") + "]"
+    end
+    if !MISSING_DEPS.empty?
+      puts
+      puts "-------------------------------------------------------"
+      puts "Missing dependencies for plugins:"
+      puts "-------------------------------------------------------"
+      MISSING_DEPS.keys.sort.each do |name|
+        puts "  " + name + ": gem install " + MISSING_DEPS[name].join(" ")
+      end
+    end
+    if !FAILED.empty?
+      puts
+      puts "The following plugins could not load due to errors:"
+      puts "-------------------------------------------------------"
+      FAILED.each do |error|
+        puts "  " + error
+      end
+    end
+  end
+  def self.get(name)
+    REGISTRY[name]
+  end
+  # utility functions
+  def self.class_to_name(str)
+    str.gsub(/.*:/, '').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1-\2').
+      gsub(/([a-z\d])([A-Z])/,'\1-\2').
+      downcase
+  end
+end
+end # module Pangrid

data/lib/pangrid/plugins/acrosslite.rb ADDED

@@ -0,0 +1,466 @@
+# AcrossLite is a file format used by the New York Times to distribute crosswords.
+#
+# Binary format: http://code.google.com/p/puz/
+# Text format: http://www.litsoft.com/across/docs/AcrossTextFormat.pdf
+#
+# provides:
+#   AcrossLiteBinary : read, write
+#   AcrossLiteText : read, write
+require 'ostruct'
+module Pangrid
+GRID_CHARS = {:black => '.', :null => '.'}
+# CRC checksum for binary format
+class Checksum
+  attr_accessor :sum
+  def self.of_string s
+    c = self.new(0)
+    c.add_string s
+    c.sum
+  end
+  def initialize(seed)
+    @sum = seed
+  end
+  def add_char(b)
+    low = sum & 0x0001
+    @sum = sum >> 1
+    @sum = sum | 0x8000 if low == 1
+    @sum = (sum + b) & 0xffff
+  end
+  def add_string(s)
+    s.bytes.map {|b| add_char b}
+  end
+  def add_string_0(s)
+    add_string (s + "\0") unless s.empty?
+  end
+end
+module AcrossLiteUtils
+  # String -> Cell[][]
+  def unpack_solution(xw, s)
+    s.each_char.map {|c|
+      Cell.new(:solution => c == '.' ? :black : c)
+    }.each_slice(xw.width).to_a
+  end
+  # {xw | solution = Cell[][]} -> String
+  def pack_solution(xw)
+    # acrosslite doesn't support non-rectangular grids, so map null squares to
+    # black too
+    xw.to_array(GRID_CHARS).map(&:join).join
+  end
+  # {xw | solution = Cell[][]} -> String
+  def empty_fill(xw)
+    # when converting from another format -> binary we won't typically have fill
+    # information, since that is an internal property of the acrosslite player
+    grid = xw.to_array(GRID_CHARS) {|c| '-'}
+    grid.map(&:join).join
+  end
+end
+# Binary format
+class AcrossLiteBinary < Plugin
+  include AcrossLiteUtils
+  # crossword, checksums
+  attr_accessor :xw, :cs
+  HEADER_FORMAT = "v A12 v V2 A4 v2 A12 c2 v3"
+  HEADER_CHECKSUM_FORMAT = "c2 v3"
+  EXT_HEADER_FORMAT = "A4 v2"
+  EXTENSIONS = %w(LTIM GRBS RTBL GEXT)
+  FILE_MAGIC = "ACROSS&DOWN\0"
+  def initialize
+    @xw = XWord.new
+    @cs = OpenStruct.new
+    @xw.extensions = []
+  end
+  def read(data)
+    s = data.force_encoding("ISO-8859-1")
+    i = s.index(FILE_MAGIC)
+    check("Could not recognise AcrossLite binary file") { i }
+    # read the header
+    h_start, h_end = i - 2, i - 2 + 0x34
+    header = s[h_start .. h_end]
+    cs.global, _, cs.cib, cs.masked_low, cs.masked_high,
+      xw.version, _, cs.scrambled, _,
+      xw.width, xw.height, xw.n_clues, xw.puzzle_type, xw.scrambled_state =
+      header.unpack(HEADER_FORMAT)
+    # solution and fill = blocks of w*h bytes each
+    size = xw.width * xw.height
+    xw.solution = unpack_solution xw, s[h_end, size]
+    xw.fill = s[h_end + size, size]
+    s = s[h_end + 2 * size .. -1]
+    # title, author, copyright, clues * n, notes = zero-terminated strings
+    xw.title, xw.author, xw.copyright, *xw.clues, xw.notes, s =
+      s.split("\0", xw.n_clues + 5)
+    # extensions: 8-byte header + len bytes data + \0
+    while (s.length > 8) do
+      e = OpenStruct.new
+      e.section, e.len, e.checksum = s.unpack(EXT_HEADER_FORMAT)
+      check("Unrecognised extension #{e.section}") { EXTENSIONS.include? e.section }
+      size = 8 + e.len + 1
+      break if s.length < size
+      e.data = s[8 ... size]
+      self.send(:"read_#{e.section.downcase}", e)
+      xw.extensions << e
+      s = s[size .. -1]
+    end
+    # verify checksums
+    check("Failed checksum") { checksums == cs }
+    process_extensions
+    unpack_clues
+    xw
+  end
+  def write(xw)
+    @xw = xw
+    # fill in some fields that might not be present (checksums needs this)
+    pack_clues
+    xw.n_clues = xw.clues.length
+    xw.fill ||= empty_fill(xw)
+    xw.puzzle_type ||= 1
+    xw.scrambled_state ||= 0
+    xw.version = "1.3"
+    xw.notes ||= ""
+    xw.extensions ||= []
+    # extensions
+    xw.encode_rebus!
+    if not xw.rebus.empty?
+      # GRBS
+      e = OpenStruct.new
+      e.section = "GRBS"
+      e.grid = xw.to_array({:black => 0, :null => 0}) {|s|
+        s.rebus? ? s.solution.symbol.to_i : 0
+      }.flatten
+      xw.extensions << e
+      # RTBL
+      e = OpenStruct.new
+      e.section = "RTBL"
+      e.rebus = {}
+      xw.rebus.each do |long, (k, short)|
+        e.rebus[k] = [long, short]
+      end
+      xw.extensions << e
+    end
+    # calculate checksums
+    @cs = checksums
+    h = [cs.global, FILE_MAGIC, cs.cib, cs.masked_low, cs.masked_high,
+         xw.version + "\0", 0, cs.scrambled, "\0" * 12,
+         xw.width, xw.height, xw.n_clues, xw.puzzle_type, xw.scrambled_state]
+    header = h.pack(HEADER_FORMAT)
+    strings = [xw.title, xw.author, xw.copyright] + xw.clues + [xw.notes]
+    strings = strings.map {|x| x + "\0"}.join
+    [header, pack_solution(xw), xw.fill, strings, write_extensions].map {|x|
+      x.force_encoding("ISO-8859-1")
+    }.join
+  end
+  private
+  # sort incoming clues in xw.clues -> across and down
+  def unpack_clues
+    across, down = xw.number
+    clues = across.map {|x| [x, :a]} + down.map {|x| [x, :d]}
+    clues.sort!
+    xw.across_clues = []
+    xw.down_clues = []
+    clues.zip(xw.clues).each do |(n, dir), clue|
+      if dir == :a
+        xw.across_clues << clue
+      else
+        xw.down_clues << clue
+      end
+    end
+  end
+  # combine across and down clues -> xw.clues
+  def pack_clues
+    across, down = xw.number
+    clues = across.map {|x| [x, :a]} + down.map {|x| [x, :d]}
+    clues.sort!
+    ac, dn = xw.across_clues.dup, xw.down_clues.dup
+    xw.clues = []
+    clues.each do |n, dir|
+      if dir == :a
+        xw.clues << ac.shift
+      else
+        xw.clues << dn.shift
+      end
+    end
+    check("Extra across clue") { ac.empty? }
+    check("Extra down clue") { dn.empty? }
+  end
+  def get_extension(s)
+    return nil unless xw.extensions
+    xw.extensions.find {|e| e.section == s}
+  end
+  def process_extensions
+    # record these for file inspection, though they're unlikely to be useful
+    if (ltim = get_extension("LTIM"))
+      xw.time_elapsed = ltim.elapsed
+      xw.paused
+    end
+    # we need both grbs and rtbl
+    grbs, rtbl = get_extension("GRBS"), get_extension("RTBL")
+    if grbs and rtbl
+      grbs.grid.each_with_index do |n, i|
+        if n > 0 and (v = rtbl.rebus[n])
+          x, y = i % xw.width, i / xw.width
+          cell = xw.solution[y][x]
+          cell.solution = Rebus.new(v[0])
+        end
+      end
+    end
+  end
+  def read_ltim(e)
+    m = e.data.match /^(\d+),(\d+)\0$/
+    check("Could not read extension LTIM") { m }
+    e.elapsed = m[1].to_i
+    e.stopped = m[2] == "1"
+  end
+  def write_ltim(e)
+    e.elapsed.to_s + "," + (e.stopped ? "1" : "0") + "\0"
+  end
+  def read_rtbl(e)
+    rx = /(([\d ]\d):(\w+);)/
+    m = e.data.match /^#{rx}*\0$/
+    check("Could not read extension RTBL") { m }
+    e.rebus = {}
+    e.data.scan(rx).each {|_, k, v|
+      e.rebus[k.to_i] = [v, '-']
+    }
+  end
+  def write_rtbl(e)
+    e.rebus.keys.sort.map {|x|
+      x.to_s.rjust(2) + ":" + e.rebus[x][0] + ";"
+    }.join
+  end
+  def read_gext(e)
+    e.grid = e.data.bytes
+  end
+  def write_gext(e)
+    e.grid.map(&:chr).join
+  end
+  def read_grbs(e)
+    e.grid = e.data.bytes.map {|b| b == 0 ? 0 : b - 1 }
+  end
+  def write_grbs(e)
+    e.grid.map {|x| x == 0 ? 0 : x + 1}.map(&:chr).join
+  end
+  def write_extensions
+    xw.extensions.map {|e|
+      e.data = self.send(:"write_#{e.section.downcase}", e)
+      e.len = e.data.length
+      e.data += "\0"
+      e.checksum = Checksum.of_string(e.data)
+      [e.section, e.len, e.checksum].pack(EXT_HEADER_FORMAT) +
+        e.data
+    }.join
+  end
+  # checksums
+  def text_checksum(seed)
+    c = Checksum.new(seed)
+    c.add_string_0 xw.title
+    c.add_string_0 xw.author
+    c.add_string_0 xw.copyright
+    xw.clues.each {|cl| c.add_string cl}
+    if (xw.version == '1.3')
+      c.add_string_0 xw.notes
+    end
+    c.sum
+  end
+  def header_checksum
+    h = [xw.width, xw.height, xw.n_clues, xw.puzzle_type, xw.scrambled_state]
+    Checksum.of_string h.pack(HEADER_CHECKSUM_FORMAT)
+  end
+  def global_checksum
+    c = Checksum.new header_checksum
+    c.add_string pack_solution(xw)
+    c.add_string xw.fill
+    text_checksum c.sum
+  end
+  def magic_checksums
+    mask = "ICHEATED".bytes
+    sums = [
+      text_checksum(0),
+      Checksum.of_string(xw.fill),
+      Checksum.of_string(pack_solution(xw)),
+      header_checksum
+    ]
+    l, h = 0, 0
+    sums.each_with_index do |sum, i|
+      l = (l << 8) | (mask[3 - i] ^ (sum & 0xff))
+      h = (h << 8) | (mask[7 - i] ^ (sum >> 8))
+    end
+    [l, h]
+  end
+  def checksums
+    c = OpenStruct.new
+    c.masked_low, c.masked_high = magic_checksums
+    c.cib = header_checksum
+    c.global = global_checksum
+    c.scrambled = 0
+    c
+  end
+end
+# Text format
+class AcrossLiteText < Plugin
+  include AcrossLiteUtils
+  attr_accessor :xw, :rebus
+  def initialize
+    @xw = XWord.new
+  end
+  def read(data)
+    s = data.each_line.map(&:strip)
+    # first line must be <ACROSS PUZZLE> or <ACROSS PUZZLE V2>
+    xw.version = { "<ACROSS PUZZLE>" => 1, "<ACROSS PUZZLE V2>" => 2 }[s.shift]
+    check("Could not recognise Across Lite text file") { !xw.version.nil? }
+    header, section = "START", []
+    s.each do |line|
+      if line =~ /^<(.*)>/
+        process_section header, section
+        header = $1
+        section = []
+      else
+        section << line
+      end
+    end
+    process_section header, section
+    xw
+  end
+  def write(xw)
+    @xw = xw
+    # scan the grid for rebus squares and replace them with lookup keys
+    xw.encode_rebus!
+    sections = [
+      ['TITLE', [xw.title]],
+      ['AUTHOR', [xw.author]],
+      ['COPYRIGHT', [xw.copyright]],
+      ['SIZE', ["#{xw.height}x#{xw.width}"]],
+      ['GRID', write_grid],
+      ['REBUS', write_rebus],
+      ['ACROSS', xw.across_clues],
+      ['DOWN', xw.down_clues],
+      ['NOTEPAD', xw.notes.to_s.split("\n")]
+    ]
+    out = ["<ACROSS PUZZLE V2>"]
+    sections.each do |h, s|
+      next if s.nil? || s.empty?
+      out << "<#{h}>"
+      s.each {|l| out << " #{l}"}
+    end
+    out.join("\n") + "\n"
+  end
+  private
+  def process_section(header, section)
+    case header
+    when "START"
+      return
+    when "TITLE", "AUTHOR", "COPYRIGHT"
+      check { section.length == 1 }
+      xw[header.downcase] = section[0]
+    when "NOTEPAD"
+      xw.notes = section.join("\n")
+    when "SIZE"
+      check { section.length == 1 && section[0] =~ /^\d+x\d+/ }
+      xw.height, xw.width = section[0].split('x').map(&:to_i)
+    when "GRID"
+      check { xw.width && xw.height }
+      check { section.length == xw.height }
+      check { section.all? {|line| line.length == xw.width } }
+      xw.solution = unpack_solution xw, section.join
+    when "REBUS"
+      check { section.length > 0 }
+      check("Text format v1 does not support <REBUS>") {xw.version == 2}
+      # flag list (currently MARK or nothing)
+      xw.mark = section[0] == "MARK;"
+      section.shift if xw.mark
+      section.each do |line|
+        check { line =~ /^.+:.+:.$/ }
+        sym, long, short = line.split(':')
+        xw.each_cell do |c|
+          if c.solution == sym
+            c.solution = Rebus.new(long, short)
+          end
+        end
+      end
+      xw.encode_rebus!
+    when "ACROSS"
+      xw.across_clues = section
+    when "DOWN"
+      xw.down_clues = section
+    else
+      raise PuzzleFormatError, "Unrecognised header #{header}"
+    end
+  end
+  def write_grid
+    xw.to_array(GRID_CHARS).map(&:join)
+  end
+  def write_rebus
+    out = []
+    out << "MARK;" if xw.mark
+    xw.rebus.keys.sort.each do |long|
+      key, short = xw.rebus[long]
+      out << "#{key}:#{long}:#{short}"
+    end
+    out
+  end
+end
+end # module Pangrid