crucigrama 0.1.0

data/features/crucigrama.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'crucigrama'
+
+require 'rspec/expectations'

data/lib/crucigrama/cli/generate.rb

@@ -0,0 +1,106 @@
+require 'crucigrama/cli'
+require 'optparse'
+class Crucigrama::CLI::Generate
+  Crucigrama::CLI.register 'generate', self, "Generates a crossword"
+  
+  def options_parser
+    @options_parser ||= OptionParser.new do |opts|
+      opts.banner = "Usage: #{Crucigrama::CLI.cli_command} generate options"
+      opts.separator ""
+      opts.separator "Options:"
+      opts.on("-l", "--lemary LEMARY", "Uses LEMARY as words source") do |lemary|
+        begin
+          @options[:lemary] = File.read(lemary).split("\n")
+        rescue Exception => exc
+          STDERR.puts exc.message
+        end 
+      end
+      opts.on("-d", "--dimensions DIMENSIONS", "Generates crossword of DIMENSIONS size",
+                                               "in nxn format (10x10 by default)") do |dimensions|
+        unless match = /(\d)+x(\d)+/.match(dimensions)
+          STDERR.puts "Incorrect dimensions format, it must be nxn (for example 10x11)"
+          exit 1
+        end                                        
+        @options[:dimensions] = Hash[[:horizontal, :vertical].collect.with_index do |direction, i|
+          [direction, match[i].to_i]
+        end]
+      end
+      opts.on("-o", "--output FILE", "Dumps the generated crossword to FILE") do |file|
+        @options[:file] = file
+      end
+      opts.on("--[no-]definitions", "Asks for definitions for the generated crossword") do |definitions|
+        @options[:definitions] = definitions
+      end
+      opts.on("--[no-]reverse-words", "Allow reverse words for the generated crossword") do |value|
+        @options[:allow_reverse] = value
+      end
+      opts.separator ""
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+      opts.on_tail("--version", "Show version") do
+        puts Crucigrama::VERSION
+        exit
+      end
+    end
+  end
+  
+  def extract_options(*args)
+    @options = {}
+    options_parser.parse!(args)
+    unless options[:lemary] 
+      STDERR.puts "Must specify lemary file!"
+      exit 1
+    end
+    if @options[:allow_reverse]
+      @options[:lemary] = @options[:lemary].collect{|word| [word, word.reverse]}.flatten.uniq
+    end
+  end
+  
+  def initialize(*args)
+    extract_options(*args)
+    crossword = generate_crossword
+    dump_crossword(crossword)
+  end
+  
+  private
+  
+  attr_reader :options
+  
+  def generate_crossword
+    crossword = Crucigrama::GrillBuilder.build_crossword(:valid_words => options[:lemary], :dimensions => options[:dimensions])
+    STDERR.puts "Crossword generated with #{crossword.black_positions.count} black cells (#{100*crossword.black_positions.count.to_f/crossword.dimensions.values.inject(1,&:*)}%)"
+    if options[:definitions]
+      fill_with_definitions(crossword)
+    end
+    crossword
+  end
+  
+  def dump_crossword(crossword)
+    if options[:file]
+      begin
+        File.open(options[:file],'w'){|file| file.write(crossword.to_json)}
+      rescue Exception => exc
+        STDERR.puts exc.message
+        exit 1
+      end
+    else
+      puts crossword.to_json
+    end
+  end
+  
+  def fill_with_definitions(crossword)
+    positions = Hash[ [:horizontal, :vertical].collect do |direction|
+      [direction, crossword.word_positions.keys.select{|w| w.length > 1 and crossword.word_positions[w][direction] }.collect{|w| crossword.word_positions[w][direction]}.flatten(1)]
+    end]
+    positions.each do |direction, word_positions|
+      STDERR.puts "#{direction.to_s.capitalize} definitions:"
+      word_positions.each do |position|
+        STDERR.puts "[#{position[:horizontal]+1}, #{position[:vertical]+1}] #{crossword.word_at(position, direction)}:"
+        crossword.add_definition(STDIN.readline.strip, position, direction)
+      end
+    end
+  end
+  
+end

data/lib/crucigrama/cli/print.rb

@@ -0,0 +1,70 @@
+require 'crucigrama/cli'
+require 'optparse'
+class Crucigrama::CLI::Print
+  Crucigrama::CLI.register 'print', self, "Prints a crossword to a PDF file"
+  
+  def options_parser
+    @options_parser ||= OptionParser.new do |opts|
+      opts.banner = "Usage: #{Crucigrama::CLI.cli_command} print options"
+      opts.separator ""
+      opts.separator "Options:"
+      opts.on("-o", "--output PDF_FILE", "Prints the crossword to PDF_FILE") do |file|
+        @options[:output_file] = file
+      end
+      opts.on("-i", "--input JSON_FILE", "Extracts the crossword from the JSON_FILE file") do |file|
+        begin
+          @options[:json_crossword] = File.read(file)
+        rescue Exception => exc
+          STDERR.puts exc.message
+        end
+      end
+      opts.on("--[no-]solution", "Prints a reduced and inverted solution for the crossword next to it") do |value|
+        @options[:include_solution] = value
+      end
+      opts.separator ""
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+      opts.on_tail("--version", "Show version") do
+        puts Crucigrama::VERSION
+        exit
+      end
+    end
+  end
+  
+  def extract_options(*args)
+    @options = {}
+    options_parser.parse!(args)
+    unless options[:json_crossword]
+      STDERR.puts "Must specify input file!"
+      exit 1
+    end
+    unless options[:output_file] 
+      STDERR.puts "Must specify output file!"
+      exit 1
+    end
+  end
+  
+  def initialize(*args)
+    extract_options(*args)
+    crossword = begin
+      Crucigrama::Crossword.new(MultiJson.decode(options[:json_crossword]))
+    rescue Exception => exc
+      STDERR.puts exc.message
+      STDERR.puts "Could not parse input crossword!"
+      exit 1
+    end
+    begin
+      crossword.to_pdf(options[:output_file], :include_solution => options[:include_solution])
+    rescue Exception => exc
+      STDERR.puts exc.message
+      STDERR.puts "Could not print crossword!"
+      exit 1
+    end
+  end
+  
+  private
+  
+  attr_reader :options
+end

data/lib/crucigrama/cli.rb

@@ -0,0 +1,39 @@
+require 'crucigrama'
+
+module Crucigrama::CLI
+  @@commands = {}
+  @@cli_command =  nil
+  
+  def self.cli_command
+    @@cli_command
+  end
+  
+  def self.cli_command=(value)
+    @@cli_command = value
+  end
+  
+  def self.register(command, command_handler, description)
+    @@commands[command] = {:command_handler => command_handler, :description => description}
+  end
+  
+  def self.deregister(command)
+    @@commands.delete(command)
+  end
+  
+  def self.run(*args)
+    command = args.delete_at(0)
+    if command = @@commands[command]
+      command[:command_handler].new(*args)
+    else
+      show_banner
+    end
+  end
+  
+  def self.show_banner
+    puts "\nUsage: #{self.cli_command} command [options]\n
+where command can be one of the following:\n
+#{@@commands.collect do |key, value| 
+      "#{key}: #{value[:description]}"
+    end.join("\n")}\n\n"
+  end
+end

data/lib/crucigrama/crossword/definitions.rb

@@ -0,0 +1,61 @@
+# This module provides the behaviour related to crosswords' definitions
+module Crucigrama::Crossword::Definitions
+  
+  # Initializes the definitions of a crossword if given
+  # @param [Hash<Symbol,Integer>, optional] options the options of the crossword
+  # @option options [Hash] :definitions the definitions for the word in the crossword as returned by method #definitions
+  def initialize(options={})
+    super(options)
+    self.definitions = (options[:definitions]||{})
+  end
+  
+  # @return [Hash<Symbol,Hash<Integer,Hash<Integer,String>>>] the definitions in the crossword, in a hash to be accessed
+  # with keys direction (:horizontal or :vertical), the other direction coordinate and the given direction coordinate
+  def definitions
+    @definitions
+  end
+  
+  # Sets the definitions for the crossword words
+  # @param [Hash<String|Symbol,Hash<String|Integer,Hash<String|Integer,String>>>] defs the definitions
+  def definitions=(defs)
+    @definitions = Hash[defs.collect do |key,value|
+      [key.to_sym, Hash[value.collect do |key, val|
+          [key.to_i, Hash[val.collect{|k,v| [k.to_i, v]}]]
+        end]]
+    end]
+  end
+  
+  # Adds a crossword definition for the given position and direction
+  # @param [String] definition the definition to add
+  # @param [Hash<Symbol, Integer>] position a hash with the horizontal and vertical
+  #   coordinates of the cell where the defined word starts
+  # @param [Symbol] direction the direction of the defined word, :horizontal or :vertical
+  def add_definition(definition, position, direction)
+    definitions[direction]||={}
+    definitions[direction][position[direction_other_than(direction)]]||={}
+    definitions[direction][position[direction_other_than(direction)]][position[direction]] = definition
+  end
+  
+  # Removes a crossword definition for the given position and direction
+  # @return [String,nil] the removed definition if found, nil otherwise
+  # @param [Hash<Symbol, Integer>] position a hash with the horizontal and vertical
+  #   coordinates of the cell where the word whose definition is to be removed starts
+  # @param [Symbol] direction the direction of the word whose definition is to be removed,
+  #   :horizontal or :vertical 
+  def remove_definition(position, direction)
+    if definitions[direction] and definitions[direction][position[direction_other_than(direction)]]
+      definition = definitions[direction][position[direction_other_than(direction)]].delete(position[direction]) 
+      definitions[direction].delete(position[direction_other_than(direction)]) if definitions[direction][position[direction_other_than(direction)]].empty?
+      definition
+    end
+  end
+  
+  # @return [String,nil] the definition for the word at the given position and direction
+  # @param [Hash<Symbol, Integer>] position a hash with the horizontal and vertical
+  #   coordinates of the cell where the queried word starts
+  # @param [Symbol] direction the direction of the queried word, :horizontal or :vertical
+  def definition_for(position, direction)
+    return nil unless definitions[direction] and definitions[direction][position[direction_other_than(direction)]]
+    definitions[direction][position[direction_other_than(direction)]][position[direction]]
+  end
+end

data/lib/crucigrama/crossword/grid.rb

@@ -0,0 +1,106 @@
+# This module implements the behaviour associated to the crossword grid
+module Crucigrama::Crossword::Grid
+  
+  # Initializes an empty crossword (without words) of the given dimensions
+  # @param [Hash<Symbol,Integer>, optional] options the dimensions of the crossword
+  # @option options [Integer] :horizontal the horizontal size of the crossword, that is, how many columns it has
+  # @option options [Integer] :vertical the vertical size of the crossword, that is, how many rows it has
+  # @option options [Hash] :dimensions a Hash with the :horizontal and :vertical options described above
+  # @option options [String] :grid a raw representation of the crossword grid as described in #grid
+  # @option options [Hash] :definitions the definitions for the word in the crossword as returned by method #definitions
+  # @todo :dimensions option must be able to accept [x,y] representation according to Crucigrama::Positionable#position
+  # @todo if accept options as array of two integers [x,y]
+  def initialize(options={})
+    super(options)
+    options.to_options!
+    @grid = {}
+    if options[:grid]
+      self.grid = options[:grid]
+    else
+      dimensions = {:horizontal => 10, :vertical => 10}.merge(options[:dimensions]||options)
+      @grid[:horizontal] = Array.new(dimensions[:vertical].to_i){ Array.new(dimensions[:horizontal].to_i){self.class::BLACK}}
+      @grid[:vertical] = Array.new(dimensions[:horizontal].to_i){ Array.new(dimensions[:vertical].to_i){self.class::BLACK}}
+    end
+  end
+  
+  # Builds the crossword grid specified
+  # @param [String] grid a raw representation for the crossword grid to build
+  def grid=(grid)
+    @grid[:horizontal] = grid.split("\n").collect do |row|
+      row.chars.to_a
+    end
+    @grid[:vertical] = @grid[:horizontal].collect.with_index do |row, i|
+      row.collect.with_index do |char, j|
+        @grid[:horizontal][j][i]
+      end
+    end
+    grid_modified!
+  end
+  
+  # @return [String] a raw representation for the crossword grid
+  def grid
+    @grid[:horizontal].collect do |row|
+      "#{row.join}\n"
+    end.join
+  end
+  
+  
+  # It adds a word to the crossword setting it on the given coordinates and direction, if it can be set.
+  # @param [String] word the word to add to the crossword
+  # @param [Hash<Symbol,Integer>] coordinates the coordinates of the crossword cell where the word must start
+  # @option coordinates [Integer] :horizontal a number between 0 and the horizontal dimension of the
+  #   crossword minus one specifying the row of the cell where the word must start
+  # @option coordinates [Integer] :vertical a number between 0 and the vertical dimension of the 
+  #   crossword minus one specifying the column of the cell where the word must start
+  # @param [:horizontal, :vertical] direction the direction for the word to be set on the crossword
+  # @return [Boolean] if the word can be set
+  def add(word, coordinates, direction)
+    constant_coordinate = direction_other_than(direction)
+    word.chars.with_index do |char, word_position|
+      @grid[direction][coordinates[constant_coordinate]][coordinates[direction]+word_position] = char
+      @grid[constant_coordinate][coordinates[direction]+word_position][coordinates[constant_coordinate]] = char
+    end
+    grid_modified!
+    true
+  end
+  
+  # @return [Hash<Symbol,Integer>] the horizontal and vertical dimensions of the crossword
+  def dimensions
+    @dimensions ||={:horizontal =>@grid[:vertical].count, :vertical => @grid[:horizontal].count}
+  end
+  
+  # @return [String] the char in the crossword at the given coordinates
+  # @param [Hash<Symbol,Integer>] coordinates the coordinates for the crossword cell being queried
+  # @option coordinates [Integer] :horizontal a number between 0 and the horizontal dimension of the
+  #   crossword minus one specifying the row of the cell being queried
+  # @option coordinates [Integer] :vertical a number between 0 and the vertical dimension of the 
+  #   crossword minus one specifying the column of the cell being queried
+  def char_at(coordinates)
+    @grid[:horizontal][coordinates[:vertical]][coordinates[:horizontal]]
+  end
+  
+  # @return [String] the line in the crossword in the given direction
+  #   (row for :horizontal, column for :vertical) with the specified number
+  # @param [Integer] coordinate a number between 0 and the horizontal dimension of the
+  #   crossword minus one specifying the queried line
+  # @param [:horizontal, :vertical] direction the direction of the line being queried
+  def line(coordinate, direction)
+    @grid[direction][coordinate].join
+  end
+  
+  # @return [Array<String>] an array of lines in the given direction, that is, an array with the results
+  # of calling {line(coordinate, direction)} on every line in the given dimension
+  # @param [:horizontal, :vertical] direction the direction of the lines being queried
+  def lines(direction)
+    @grid[direction].collect(&:join)
+  end
+  
+  private
+  
+  # It notifies the crossword that its internal grid changed, so that cached structure information may be discarded.
+  # Every module included after this should provide an implementation that
+  #  * Discards information depending on the grid
+  #  * Calls super to allow the execution of other modules implementations of this method
+  def grid_modified!
+  end
+end

data/lib/crucigrama/crossword/line_query.rb

@@ -0,0 +1,16 @@
+#This module provides methods for querying lines (rows or columns) on a crossword
+module Crucigrama::Crossword::LineQuery
+  # @return [String] the row with the specified number
+  # @param [Integer] coordinate a number between 0 and the horizontal dimension of the
+  #   crossword minus one specifying the queried row
+  def row(coordinate)
+    line(coordinate, :horizontal)
+  end
+  
+  # @return [String] the column with the specified number
+  # @param [Integer] coordinate a number between 0 and the vertical dimension of the
+  #   crossword minus one specifying the queried column
+  def column(coordinate)
+    line(coordinate, :vertical)
+  end
+end

data/lib/crucigrama/crossword/pdf_printable.rb

@@ -0,0 +1,152 @@
+require 'prawn'
+
+
+# This module provides a to_pdf method that allows the printing of a crossword in PDF format
+module Crucigrama::Crossword::PdfPrintable 
+  
+  # @return [Integer] the size in PDF points of a cell side
+  PDF_CELL_SIZE = 20
+  
+  # Prints the crossword on the given file in PDF format
+  # @param [String, Prawn::Document] file the name of the file (if a String) or the PDF document
+  #   (if a Prawn::Document) where the crossword must be printed
+  # @params [Hash<Symbol,Object>] options a set of options governing the PDF printing:
+  # @option options [Boolean] :include_solution whether or not to print a reduced and inverted
+  #  solved crossword next to the actual one (false by default)
+  def to_pdf(file, options = {})
+    drawing_block = Proc.new do |pdf|
+      draw_crossword(pdf, :solved => false, :indexes => true)
+      pdf.move_down PDF_CELL_SIZE
+      if options[:include_solution]
+        cursor = pdf.cursor
+        draw_crossword(pdf, :solved => true, 
+                            :at => [pdf.bounds.width - PDF_CELL_SIZE*(dimensions[:horizontal])/2, 
+                                    pdf.cursor + PDF_CELL_SIZE*(dimensions[:vertical])/2],
+                            :scale => 0.5,
+                            :inverted => true)
+        
+        pdf.move_cursor_to cursor #- PDF_CELL_SIZE
+      end
+      pdf.move_down PDF_CELL_SIZE
+      draw_definitions(pdf)
+    end
+    if file.is_a?(Prawn::Document)
+      drawing_block.call(file)
+    else
+      Prawn::Document.generate(file, &drawing_block)
+    end
+  end
+  
+  private
+  
+  # Draws the crossword grid on the given Prawn::Document
+  # @param [Prawn::Document] pdf the pdf on which to print the crossword grid
+  # @param [Hash] options a set of options governing the crossword grid printing
+  # @option options [Boolean] :indexes whether or not to draw column and row indexes (false by default)
+  # @option options [Boolean] :inverted whether or not to draw the grid inverted (false by default)
+  # @option options [Float] :scale a scaling factor for the crossword grid, to reduce or increase its size.
+  #   The value by default, 1, will print it with cell sizes of {{Crucigrama::Crossword::PdfPrintable::PDF_CELL_SIZE}}
+  # @option options [Array<Integer>] :at a 2-dimensional array indicating horizontal and vertical document coordinates
+  #   where the upper left corner of the grid will be placed
+  # @option options [Boolean] :solved whether or not to show the content for non-black crossword cells
+  #   grid cells (false by default)
+  def draw_crossword(pdf, options={})
+    space_for_indexes = options[:indexes] ? 1 : 0
+    options = options.merge(:height => PDF_CELL_SIZE*(dimensions[:vertical] + space_for_indexes), 
+                            :width =>  PDF_CELL_SIZE*(dimensions[:horizontal] + space_for_indexes),
+                            :rotation => options[:inverted] ? 180 : 0)
+    options = { :at => [0, pdf.cursor], 
+                :scale => 1}.merge(options)
+    crossword_center = [options[:at][0]+options[:width]/2, options[:at][1]-options[:height]/2]
+                
+    # pdf.stroke_axis
+    pdf.scale(options[:scale], :origin => options[:at]) do            
+      pdf.rotate(options[:rotation], :origin => crossword_center) do
+        pdf.bounding_box options[:at], options do
+          dimensions[:horizontal].times do |x|
+            dimensions[:vertical].times do |y|
+              draw_cell(pdf,x,y,options)
+            end
+          end
+          if options[:indexes]
+            draw_indexes(pdf,options)
+          end
+        end
+      end
+    end
+  end
+  
+  # Draws the crossword grid cell corresponding to the given coordinates on the given Prawn::Document
+  # @param [Prawn::Document] pdf the pdf on which to print the crossword grid cell
+  # @param [Integer] x The horizontal coordinate for the crossword cell to be printed
+  # @param [Integer] y The vertical coordinate for the crossword cell to be printed
+  # @param [Hash] options a set of options governing the crossword grid cell printing
+  # @option options [Boolean] :indexes whether or not column and row indexes are being drawn (false by default)
+  # @option options [Boolean] :solved whether or not to show the content for non-black crossword cells
+  #   grid cells (false by default)
+  def draw_cell(pdf, x, y, options={})
+    index_space = options[:indexes] ? 1 : 0
+    graphic_y = dimensions[:vertical]- y - index_space
+    graphic_x = x + index_space
+    pdf.stroke_rectangle *pdf_cell_box(graphic_x, graphic_y)
+    cell_content = char_at(position(x,y))#@panel[:horizontal][y][x]
+    if cell_content == self.class::BLACK
+      pdf.fill_rectangle *pdf_cell_box(graphic_x, graphic_y)
+    elsif options[:solved]
+      pdf.text_box cell_content.upcase, :at => [graphic_x*PDF_CELL_SIZE, graphic_y*PDF_CELL_SIZE], 
+                                 :height => PDF_CELL_SIZE, 
+                                 :width => PDF_CELL_SIZE, 
+                                 :align => :center, 
+                                 :valign => :center
+    end
+  end
+  
+  # Draws the crossword grid indexes for a crossword grid on the given Prawn::Document
+  # @param [Prawn::Document] pdf the pdf on which to print the crossword grid cell
+  # @param [Hash] options a set of options governing the crossword grid cell printing (not yet used)
+  def draw_indexes(pdf, options={})
+    dimensions[:horizontal].times do |x|
+      draw_index(pdf, x+1, dimensions[:vertical] , x+1)
+    end
+    dimensions[:vertical].times do |y|
+      draw_index(pdf, 0, dimensions[:vertical] - (y+1), y+1)
+    end
+  end
+  
+  # Draws an index for a column or row on the given Prawn::Document
+  # @param [Prawn::Document] pdf the pdf on which to print the crossword grid cell
+  # @param [Integer] x The horizontal coordinate in {{PDF_CELL_SIZE}} units indicating where to place the index
+  # @param [Integer] y The vertical coordinate in {{PDF_CELL_SIZE}} units indicating where to place the index
+  # @param [Integer] n The index to be drawn
+  def draw_index(pdf,x,y,n)
+    pdf.text_box "#{n}", :at => [x*PDF_CELL_SIZE, y*PDF_CELL_SIZE], 
+                               :height => PDF_CELL_SIZE, 
+                               :width => PDF_CELL_SIZE, 
+                               :align => :center, 
+                               :valign => :center
+  end
+  
+  # Draws the definitions for a crossword on the given Prawn::Document
+  # @param [Prawn::Document] pdf the pdf on which to print the crossword grid cell
+  # @param [Hash] options a set of options governing the crossword definition printing
+  # @option options [Hash<Symbol, #to_s>] :headers Headers or titles for the horizontal and vertical definitions sections. 
+  #  "Horizontal" and "Vertical" by default
+  def draw_definitions(pdf, options={})
+    options = {:headers => {}}.merge(options)
+    cursor = pdf.cursor
+    definitions_text = [:horizontal, :vertical].collect do |direction|
+      "<b>#{(options[:headers][direction]||direction.to_s.capitalize)}</b>\n" + 
+      Hash[(definitions[direction]||{}).sort].collect do |line, defs|
+        "<b>#{line+1}</b>.- #{defs.values.join(". ")}"
+      end.join(". ")
+    end.join(".\n\n")
+    pdf.text definitions_text, :inline_format => true
+  end
+  
+  # @return [Array] A crossword cell box complying to {{Prawn::Document#fill_rectangle}} and {{Prawn::Document#stroke_rectangle}} interface
+  # @param [Integer] x the horizontal coordinate for the cell box in PDF_CELL_SIZE units
+  # @param [Integer] y the vertical coordinate for the cell box in PDF_CELL_SIZE units
+  def pdf_cell_box(x,y)
+    [[x*PDF_CELL_SIZE, y*PDF_CELL_SIZE], PDF_CELL_SIZE, PDF_CELL_SIZE]
+  end
+end

data/lib/crucigrama/crossword/serializable.rb

@@ -0,0 +1,31 @@
+require 'multi_json'
+
+# This module provides methods to serialize a crossword
+module Crucigrama::Crossword::Serializable
+  
+  # @return [Hash] a hash with the dimensions, grid and serialized definitions of a crossword
+  def attributes
+    {
+      :dimensions => dimensions,
+      :grid => grid,
+      :definitions => serialized_definitions
+    }
+  end
+  
+  # @return [Hash] the definitions of a crossword in a JSON-compatible format
+  def serialized_definitions 
+    Hash[definitions.collect do |direction, defs|
+      [direction, Hash[defs.collect do |line_number, line_defs|
+        [line_number.to_s, Hash[line_defs.collect do |pos_number, definition|
+          [pos_number.to_s, definition]
+        end]]
+      end]]
+    end]
+  end
+  
+  # @return [String] the attributes of the crossword as returned by #attributes in a JSON string
+  def to_json
+    MultiJson.encode(attributes)
+  end 
+  
+end