RubyGems - pangrid - Versions diffs - 0.2.1 - Mend

pangrid 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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