bracket_notation 1.0.5 → 1.1.0

data/lib/bracket_notation/parser.rb

@@ -23,7 +23,7 @@
 # and small portions of his code have been incorporated in the parser.
 #
 # Author:: Cody Brimhall (mailto:brimhall@somuchwit.com)
-# Copyright:: Copyright (c) 2010 Cody Brimhall
+# Copyright:: Copyright (c) 2010-2011 Cody Brimhall
 # License:: Distributed under the terms of the GNU General Public License, v. 3
 
 module BracketNotation # :nodoc:

data/lib/bracket_notation/scanner.rb

@@ -23,7 +23,7 @@
 # and small portions of his code have been incorporated in the parser.
 #
 # Author:: Cody Brimhall (mailto:brimhall@somuchwit.com)
-# Copyright:: Copyright (c) 2010 Cody Brimhall
+# Copyright:: Copyright (c) 2010-2011 Cody Brimhall
 # License:: Distributed under the terms of the GNU General Public License, v. 3
 
 module BracketNotation # :nodoc:

data/lib/bracket_notation/token.rb

@@ -23,7 +23,7 @@
 # and small portions of his code have been incorporated in the parser.
 #
 # Author:: Cody Brimhall (mailto:brimhall@somuchwit.com)
-# Copyright:: Copyright (c) 2010 Cody Brimhall
+# Copyright:: Copyright (c) 2010-2011 Cody Brimhall
 # License:: Distributed under the terms of the GNU General Public License, v. 3
 
 module BracketNotation # :nodoc:

data/lib/bracket_notation/version.rb

@@ -23,14 +23,14 @@
 # and small portions of his code have been incorporated in the parser.
 #
 # Author:: Cody Brimhall (mailto:brimhall@somuchwit.com)
-# Copyright:: Copyright (c) 2010 Cody Brimhall
+# Copyright:: Copyright (c) 2010-2011 Cody Brimhall
 # License:: Distributed under the terms of the GNU General Public License, v. 3
 
 module BracketNotation # :nodoc:
   module Version # :nodoc:
     MAJOR = 1
-    MINOR = 0
-    MAINT = 5
+    MINOR = 1
+    MAINT = 0
     
     # Returns the current version string.
     def self.to_s;

data/lib/bracket_notation/views.rb

@@ -0,0 +1,33 @@
+#--
+# This file is part of BracketNotation.
+# 
+# BracketNotation is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# BracketNotation is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with BracketNotation.  If not, see <http://www.gnu.org/licenses/>.
+#++
+# BracketNotation is a parser for generating syntax trees from sentences
+# annotated with the kind of bracket notation that is commonly used by
+# linguists. The result is a tree structure with nodes that describe the phrases
+# and constituents of the sentence.
+#
+# BracketNotation was inspired by Yoichiro Hasebe's RSyntaxTree[http://yohasebe.com/rsyntaxtree/],
+# and small portions of his code have been incorporated in the parser.
+#
+# Author:: Cody Brimhall (mailto:brimhall@somuchwit.com)
+# Copyright:: Copyright (c) 2010-2011 Cody Brimhall
+# License:: Distributed under the terms of the GNU General Public License, v. 3
+
+require 'rmagick'
+require 'bracket_notation/views/node'
+require 'bracket_notation/views/branch'
+require 'bracket_notation/views/leaf'
+require 'bracket_notation/views/tree'

data/lib/bracket_notation/views/branch.rb

@@ -0,0 +1,40 @@
+#--
+# This file is part of BracketNotation.
+# 
+# BracketNotation is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# BracketNotation is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with BracketNotation.  If not, see <http://www.gnu.org/licenses/>.
+#++
+# BracketNotation is a parser for generating syntax trees from sentences
+# annotated with the kind of bracket notation that is commonly used by
+# linguists. The result is a tree structure with nodes that describe the phrases
+# and constituents of the sentence.
+#
+# BracketNotation was inspired by Yoichiro Hasebe's RSyntaxTree[http://yohasebe.com/rsyntaxtree/],
+# and small portions of his code have been incorporated in the parser.
+#
+# Author:: Cody Brimhall (mailto:brimhall@somuchwit.com)
+# Copyright:: Copyright (c) 2010-2011 Cody Brimhall
+# License:: Distributed under the terms of the GNU General Public License, v. 3
+
+module BracketNotation # :nodoc:
+  module View # :nodoc:
+    class Branch < Node
+      attr_accessor :roll_up
+      
+      def initialize(tree, content)
+        super
+        @roll_up = false
+      end
+    end
+  end
+end

data/lib/bracket_notation/views/leaf.rb

@@ -0,0 +1,34 @@
+#--
+# This file is part of BracketNotation.
+# 
+# BracketNotation is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# BracketNotation is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with BracketNotation.  If not, see <http://www.gnu.org/licenses/>.
+#++
+# BracketNotation is a parser for generating syntax trees from sentences
+# annotated with the kind of bracket notation that is commonly used by
+# linguists. The result is a tree structure with nodes that describe the phrases
+# and constituents of the sentence.
+#
+# BracketNotation was inspired by Yoichiro Hasebe's RSyntaxTree[http://yohasebe.com/rsyntaxtree/],
+# and small portions of his code have been incorporated in the parser.
+#
+# Author:: Cody Brimhall (mailto:brimhall@somuchwit.com)
+# Copyright:: Copyright (c) 2010-2011 Cody Brimhall
+# License:: Distributed under the terms of the GNU General Public License, v. 3
+
+module BracketNotation # :nodoc:
+  module View # :nodoc:
+    class Leaf < Node
+    end
+  end
+end

data/lib/bracket_notation/views/node.rb

@@ -0,0 +1,152 @@
+#--
+# This file is part of BracketNotation.
+# 
+# BracketNotation is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# BracketNotation is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with BracketNotation.  If not, see <http://www.gnu.org/licenses/>.
+#++
+# BracketNotation is a parser for generating syntax trees from sentences
+# annotated with the kind of bracket notation that is commonly used by
+# linguists. The result is a tree structure with nodes that describe the phrases
+# and constituents of the sentence.
+#
+# BracketNotation was inspired by Yoichiro Hasebe's RSyntaxTree[http://yohasebe.com/rsyntaxtree/],
+# and small portions of his code have been incorporated in the parser.
+#
+# Author:: Cody Brimhall (mailto:brimhall@somuchwit.com)
+# Copyright:: Copyright (c) 2010-2011 Cody Brimhall
+# License:: Distributed under the terms of the GNU General Public License, v. 3
+
+require 'bracket_notation/geometry'
+
+module BracketNotation # :nodoc:
+  module View # :nodoc:
+    class Node
+      attr_accessor :tree, :content, :parent, :children, :rect, :align_to_grid
+      
+      def initialize(tree, content)
+        @tree = tree
+        @content = content
+        @parent = nil
+        @children = []
+        @rect = BracketNotation::Geometry::Rect.new
+        @align_to_grid = true
+      end
+      
+      # Custom setter for the node rect. If @align_to_grid is true, rect co-
+      # ordinates and dimensions will be rounded to the nearest integer.
+      def rect=(rvalue)
+        return if @rect == rvalue
+        
+        @rect = if @align_to_grid
+          adjusted_origin = BracketNotation::Geometry::Point.new(rvalue.origin.x.round, rvalue.origin.y.round)
+          adjusted_size = BracketNotation::Geometry::Size.new(rvalue.size.width.round, rvalue.size.height.round)
+          BracketNotation::Geometry::Rect.new(adjusted_origin, adjusted_size)
+        else
+          rvalue
+        end
+      end
+    
+      # Return the node's left sibling, or nil if the node is the leftmost child of
+      # its parent.
+      def left_sibling
+        return nil if @parent.nil?
+        
+        left_sibling = nil
+        self_index = @parent.children.index(self)
+        left_sibling = @parent.children[self_index - 1] if self_index > 0
+        
+        return left_sibling
+      end
+    
+      # Return the node's right sibling, or nil if the node is the rightmost child
+      # of its parent.
+      def right_sibling
+        return nil if @parent.nil?
+        
+        self_index = @parent.children.index(self)
+        right_sibling = @parent.children[self_index + 1]
+        
+        return right_sibling
+      end
+      
+      # Return the list of nodes leading from the current node to the tree root,
+      # starting with the current node's parent.
+      def ancestors
+        node_list = []
+        next_up = self
+        node_list << next_up while next_up = next_up.parent
+        
+        return node_list
+      end      
+      
+      # Return the dimensions of the rect that contains the nod and all of its
+      # descendants
+      def subtree_size
+        return @rect.size if kind_of? Leaf or @children.count == 0
+        
+        new_subtree_size = BracketNotation::Geometry::Size.new(0, @rect.size.height)
+        subtree_widths = []
+        subtree_heights = []
+        
+        @children.each do |child|
+          child_subtree_size = child.subtree_size
+          new_subtree_size = new_subtree_size.size_by_adding_to_width(child_subtree_size.width)
+          subtree_heights << child_subtree_size.height
+        end
+        
+        new_subtree_size = new_subtree_size.size_by_adding_to_width_and_height(@tree.node_h_margin * (children.count - 1), @tree.node_v_margin + subtree_heights.sort.last)
+        return BracketNotation::Geometry::Size.new(@rect.size.width > new_subtree_size.width ? @rect.size.width : new_subtree_size.width, new_subtree_size.height)
+      end
+      
+      # Return the coordinates of the node's top left corner.
+      def corner_top_left
+        @rect.origin
+      end
+      
+      # Return the coordinates of the node's top right corner.
+      def corner_top_right
+        BracketNotation::Geometry::Point.new(@rect.origin.x + @rect.size.width, @rect.origin.y)
+      end
+      
+      # Return the coordinates of the node's bottom right corner.
+      def corner_bottom_right
+        BracketNotation::Geometry::Point.new(@rect.origin.x + @rect.size.width, @rect.origin.y + @rect.size.height)
+      end
+      
+      # Return the coordinates of the node's bottom left corner.
+      def corner_bottom_left
+        BracketNotation::Geometry::Point.new(@rect.origin.x, @rect.origin.y + @rect.size.height)
+      end
+      
+      # Return the coordinates of the middle of the node's top side.
+      def side_middle_top
+        BracketNotation::Geometry::Point.new(@rect.origin.x + (@rect.size.width / 2), @rect.origin.y)
+      end
+      
+      # Return the coordinates of the middle of the node's right side.
+      def side_middle_right
+        BracketNotation::Geometry::Point.new(@rect.origin.x + @rect.size.width, @rect.origin.y + (@rect.size.height / 2))
+      end
+      
+      # Return the coordinates of the middle of the node's bottom side.
+      def side_middle_bottom
+        BracketNotation::Geometry::Point.new(@rect.origin.x + (@rect.size.width / 2), @rect.origin.y + @rect.size.height)
+      end
+      
+      # Return the coordinates of the middle of the node's left side.
+      def side_middle_left
+        BracketNotation::Geometry::Point.new(@rect.origin.x, @rect.origin.y + (@rect.size.height / 2))
+      end
+    end
+  end
+end

data/lib/bracket_notation/views/tree.rb

@@ -0,0 +1,181 @@
+#--
+# This file is part of BracketNotation.
+# 
+# BracketNotation is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# BracketNotation is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with BracketNotation.  If not, see <http://www.gnu.org/licenses/>.
+#++
+# BracketNotation is a parser for generating syntax trees from sentences
+# annotated with the kind of bracket notation that is commonly used by
+# linguists. The result is a tree structure with nodes that describe the phrases
+# and constituents of the sentence.
+#
+# BracketNotation was inspired by Yoichiro Hasebe's RSyntaxTree[http://yohasebe.com/rsyntaxtree/],
+# and small portions of his code have been incorporated in the parser.
+#
+# Author:: Cody Brimhall (mailto:brimhall@somuchwit.com)
+# Copyright:: Copyright (c) 2010-2011 Cody Brimhall
+# License:: Distributed under the terms of the GNU General Public License, v. 3
+
+module BracketNotation # :nodoc:
+  module View # :nodoc:
+    class Tree
+      attr_accessor :input, :root, :font_name, :font_point_size, :tree_padding, :node_h_margin, :node_v_margin, :node_padding, :color_bg, :color_fg, :color_line, :color_branch, :color_leaf
+      
+      # Throws :prune, which is caught by #traverse, signaling that method to cease
+      # visiting nodes on the current branch.
+      def self.prune
+        throw(:prune)
+      end
+      
+      def initialize(input)
+        @input = input
+        @font_name = "Helvetica"
+        @font_point_size = 40
+        @tree_padding = 20
+        @node_h_margin = 50
+        @node_v_margin = 30
+        @node_padding = 10
+        @color_bg = "white"
+        @color_fg = "black"
+        @color_line = "red"
+        @color_branch = "blue"
+        @color_leaf = "green"
+      end
+      
+      # Traverse the tree, passing each visited node and the current depth to the
+      # given block.
+      #
+      # Options are:
+      # * <tt>:depth</tt> - The starting value of the depth counter. The default is
+      #   +0+.
+      # * <tt>:order</tt> - The traversal order to follow. Allowed values are:
+      #   +:preorder+ (or +:pre+), +:postorder+ (or +:post+), +:breadthfirst+ (or
+      #   +:breadth+). The default is +:preorder+.
+      # * <tt>:root</tt> - The root node of the subtree to be traversed. The default
+      #   is the root node of the entire tree.
+      #
+      def traverse(options = {}, &block)
+        options[:order] ||= :preorder
+        options[:depth] ||= 0
+        options[:root] ||= @root
+        
+        return if @root.nil?
+        
+        if [:breadth, :breadthfirst].include? options[:order]
+          node_queue = [options[:root]]
+          
+          while node = node_queue.shift
+            yield node, node.ancestors.length
+            node_queue += node.children
+          end
+        else
+          catch(:prune) do
+            case options[:order]
+              when :pre, :preorder
+                yield options[:root], options[:depth]
+                options[:root].children.each {|child| traverse({:order => :pre, :root => child, :depth => options[:depth] + 1}, &block) }
+              when :post, :postorder
+                options[:root].children.each {|child| traverse({:order => :post, :root => child, :depth => options[:depth] + 1}, &block) }
+                yield options[:root], options[:depth]
+            end
+          end
+        end
+      end
+      
+      # Computes the node tree layout, setting the correct origin and dimensions
+      # for each node.
+      def compute_layout
+        layout_nodes
+        
+        old_root_origin_x = @root.rect.origin.x
+        new_root_origin_x = ((@root.subtree_size.width + (@tree_padding * 2)) / 2) - (@root.rect.size.width / 2)
+        delta = new_root_origin_x - old_root_origin_x
+        
+        traverse {|node, depth| node.rect = BracketNotation::Geometry::Rect.new(node.rect.origin.point_by_adding_to_x(delta), node.rect.size) }
+      end
+        
+      def inspect
+        leaf_content = []
+        traverse {|node, depth| leaf_content << node.content if node.kind_of? Leaf }
+        return "#{@input} >> \"#{leaf_content.join(" ")}\""
+      end
+      
+      alias :to_s :inspect
+      
+      def pretty_print
+        traverse do |node, depth|
+          depth.times { print "--" }
+          print " " if depth > 0
+          puts node.to_s
+        end
+      end
+      
+      private
+      
+      # Walks the node tree, setting origins and dimensions
+      def layout_nodes(node = @root, depth = 0)
+        compute_node_dimensions(node)
+        compute_node_origin_y(node)
+        
+        node.children.each {|child| layout_nodes(child, depth + 1) }
+        
+        compute_subtree_origin_x(node)
+      end
+      
+      def compute_node_dimensions(node)
+        background = Magick::Image.new(500, 250)
+        gc = Magick::Draw.new
+        font = @font_name
+        pointsize = @font_point_size
+        
+        # Write the node content in a scratch image to calculate the text metrics
+        gc.annotate(background, 0, 0, 0, 0, node.content) do |gc|
+          gc.font = font
+          gc.pointsize = pointsize
+          gc.gravity = Magick::CenterGravity
+          gc.stroke = "none"
+        end
+        
+        metrics = gc.get_type_metrics(background, node.content)
+        node.rect = BracketNotation::Geometry::Rect.new(node.rect.origin, BracketNotation::Geometry::Size.new(metrics.width, @font_point_size + (@node_padding * 2)))
+      end
+      
+      def compute_node_origin_y(node)
+        adjusted_origin_y = node.parent.nil? ? @tree_padding : node.parent.rect.origin.y + node.parent.rect.size.height + @node_v_margin
+        new_origin = BracketNotation::Geometry::Point.new(node.rect.origin.x, adjusted_origin_y)
+        node.rect = BracketNotation::Geometry::Rect.new(BracketNotation::Geometry::Point.new(node.rect.origin.x, adjusted_origin_y), node.rect.size)
+      end
+      
+      def compute_subtree_origin_x(node)
+        return if node.kind_of? Leaf or node.children.count == 0
+        
+        node_middle = node.side_middle_top.x
+        children_subtree_widths = node.children.collect {|child| child.subtree_size.width}
+        max_subtree_width = children_subtree_widths.sort.last
+        subtree_width = (max_subtree_width * children_subtree_widths.count) + (@node_h_margin * (node.children.count - 1))
+        subtree_origin_x = node_middle - (subtree_width / 2)
+        
+        node.children.each do |child|
+          child_subtree_width = max_subtree_width
+          child_node_middle = child.side_middle_top.x
+          old_subtree_origin_x = child_node_middle - (child_subtree_width / 2)
+          delta = subtree_origin_x - old_subtree_origin_x
+          
+          traverse(:root => child) {|node, depth| node.rect = BracketNotation::Geometry::Rect.new(node.rect.origin.point_by_adding_to_x(delta), node.rect.size) }
+          
+          subtree_origin_x += max_subtree_width + @node_h_margin
+        end
+      end
+    end
+  end
+end