wads 0.1.2 → 0.2.2

data/lib/wads/data_structures.rb

@@ -4,6 +4,7 @@ module Wads
 
     SPACER = "  "
     VALUE_WIDTH = 10
+    COLOR_TAG = "color"
 
     DEG_0 = 0
     DEG_45 = Math::PI * 0.25
@@ -24,6 +25,9 @@ module Wads
     DEG_292_5 = DEG_270 + DEG_22_5
     DEG_337_5 = DEG_315 + DEG_22_5
 
+    #
+    # A convenience data structure to store multiple, named sets of key/value pairs
+    #
     class HashOfHashes 
         attr_accessor :data
 
@@ -31,6 +35,9 @@ module Wads
             @data = {}
         end
 
+        #
+        # Store the value y based on the key x for the named data set
+        #
         def set(data_set_name, x, y)
             data_set = @data[data_set_name]
             if data_set.nil? 
@@ -40,6 +47,9 @@ module Wads
             data_set[x] = y
         end
 
+        #
+        # Retrieve the value for the given key x in the named data set
+        #
         def get(data_set_name, x)
             data_set = @data[data_set_name]
             if data_set.nil? 
@@ -48,6 +58,9 @@ module Wads
             data_set[x]
         end
 
+        #
+        # Get the list of keys for the named data set
+        #
         def keys(data_set_name)
             data_set = @data[data_set_name]
             if data_set.nil? 
@@ -57,6 +70,11 @@ module Wads
         end
     end 
 
+    #
+    # Stats allows you to maintain sets of data values, identified by a key,
+    # or data set name. You can then use Stats methods to get the count, average,
+    # sum, or percentiles for these keys.
+    #
     class Stats
         attr_accessor :name
         attr_accessor :data
@@ -250,6 +268,20 @@ module Wads
         end
     end
 
+    #
+    # A node in a graph data structure. Nodes can be used independently, and you
+    # connect them to other nodes, or you can use an overarching Graph instance
+    # to help manage them. Nodes can carry arbitrary metadata in the tags map.
+    # The children are either other nodes, or an Edge instance which can be used
+    # to add information about the connection. For example, in a map graph use
+    # case, the edge may contain information about the distance between the two
+    # nodes. In other applications, metadata about the edges, or connections,
+    # may not be necessary. This class, and the Graph data structure, support
+    # children in either form. Each child connection is a one-directional 
+    # connection. The backlinks are stored and managed internally so that we can
+    # easily navigate between nodes of the graph. Nodes themselves have a name
+    # an an optional value.
+    #
     class Node
         attr_accessor :name
         attr_accessor :value
@@ -257,6 +289,7 @@ module Wads
         attr_accessor :outputs
         attr_accessor :visited
         attr_accessor :tags
+        attr_accessor :depth
 
         def id 
             # id is an alias for name
@@ -270,7 +303,20 @@ module Wads
             @outputs = []
             @visited = false
             @tags = tags
+            @depth = 1
         end 
+
+        def add(name, value = nil, tags = {})
+            add_output_node(Node.new(name, value, tags))
+        end
+
+        def children 
+            @outputs 
+        end
+
+        def number_of_links 
+            @outputs.size + @backlinks.size
+        end
         
         def add_child(name, value)
             add_output(name, value)
@@ -363,21 +409,48 @@ module Wads
             end
         end
 
-        def to_display 
-            "#{@name}: #{value}   inputs: #{@backlinks.size}  outputs: #{@outputs.size}"
-        end 
-
-        def full_display 
-            puts to_display
-            @backlinks.each do |i|
-                puts "Input:  #{i.name}"
+        def bfs(max_depth, &block)
+            node_queue = [self]
+            @depth = 1
+            until node_queue.empty?
+                node = node_queue.shift
+                yield node
+                node.visited = true
+                if node.depth < max_depth
+                    # Get the set of all outputs and backlinks
+                    h = {}
+                    node.outputs.each do |n|
+                        if n.is_a? Edge 
+                            n = n.destination 
+                        end 
+                        h[n.name] = n 
+                    end 
+                    node.backlinks.each do |n|
+                        h[n.name] = n 
+                    end 
+        
+                    h.values.each do |n|
+                        if n.visited 
+                            # ignore, don't process again
+                        else
+                            n.visited = true
+                            n.depth = node.depth + 1
+                            node_queue << n
+                        end
+                    end
+                end
             end
-            #@outputs.each do |o|
-            #    puts "Output: #{o.name}"
-            #end
+        end
+
+        def to_display 
+            "Node #{@name}: #{value}   inputs: #{@backlinks.size}  outputs: #{@outputs.size}"
         end 
     end
 
+    # 
+    # An Edge is a connection between nodes that stores additional information
+    # as arbitrary tags, or name/value pairs.
+    #
     class Edge
         attr_accessor :destination
         attr_accessor :tags
@@ -396,13 +469,30 @@ module Wads
         end
     end 
 
+    #
+    # A Graph helps manage nodes by providing high level methods to 
+    # add or connect nodes to the graph. It also maintains a list of
+    # nodes and supports having multiple root nodes, i.e. nodes with
+    # no incoming connections.
+    # This class also supports constructing the graph from data stored
+    # in a file.
+    #
     class Graph 
         attr_accessor :node_list
         attr_accessor :node_map
 
-        def initialize 
+        def initialize(root_node = nil)
             @node_list = []
             @node_map = {}
+            if root_node 
+                if root_node.is_a? Node
+                    root_node.visit do |n|
+                        add_node(n)
+                    end
+                elsif root_node.is_a? String 
+                    read_graph_from_file(root_node)
+                end
+            end
         end
 
         def add(name, value = nil, tags = {}) 
@@ -450,6 +540,37 @@ module Wads
             source.add_output_edge(target, tags)
         end
 
+        def node_with_most_connections 
+            max_node = nil
+            max = -1
+            @node_list.each do |node|
+                num_links = node.number_of_links
+                if num_links > max 
+                    max = num_links 
+                    max_node = node
+                end
+            end 
+            max_node
+        end 
+
+        def get_number_of_connections_range 
+            # Find the min and max
+            min = 1000
+            max = 0
+            @node_list.each do |node|
+                num_links = node.number_of_links
+                if num_links < min 
+                    min = num_links 
+                end 
+                if num_links > max 
+                    max = num_links 
+                end
+            end 
+            
+            # Then create the scale
+            DataRange.new(min - 0.1, max + 0.1)
+        end
+
         def find_node(name) 
             @node_map[name]
         end 
@@ -461,6 +582,7 @@ module Wads
         def reset_visited 
             @node_list.each do |node|
                 node.visited = false 
+                node.depth = 0
             end 
         end
 
@@ -496,7 +618,7 @@ module Wads
             false
         end
 
-        def traverse_and_collect_nodes(node, max_depth, current_depth = 1)
+        def traverse_and_collect_nodes(node, max_depth = 0, current_depth = 1)
             if max_depth > 0
                 if current_depth > max_depth 
                     return {}
@@ -504,21 +626,25 @@ module Wads
             end
             map = {}
             if node.visited 
+                if current_depth < node.depth 
+                    node.depth = current_depth 
+                end
                 return {} 
             else
                 map[node.name] = node
+                node.depth = current_depth
                 node.visited = true
             end
-            node.backlinks.each do |child|
+            node.outputs.each do |child|
+                if child.is_a? Edge 
+                    child = child.destination 
+                end
                 map_from_child = traverse_and_collect_nodes(child, max_depth, current_depth + 1)
                 map_from_child.each do |key, value|
                     map[key] = value 
                 end
             end 
-            node.outputs.each do |child|
-                if child.is_a? Edge 
-                    child = child.destination 
-                end
+            node.backlinks.each do |child|
                 map_from_child = traverse_and_collect_nodes(child, max_depth, current_depth + 1)
                 map_from_child.each do |key, value|
                     map[key] = value 
@@ -526,8 +652,76 @@ module Wads
             end 
             map
         end
+
+        def process_tag_string(tags, tag_string) 
+            parts = tag_string.partition("=")
+            tag_name = parts[0]
+            tag_value = parts[2]
+            if tag_name == COLOR_TAG
+                begin
+                    value = eval(tag_value)
+                    puts "Adding tag #{tag_name} = #{value}"
+                    tags[tag_name] = value 
+                rescue => e
+                    puts "Ignoring tag #{tag_name} = #{tag_value}"
+                end
+            else
+                puts "Adding tag #{tag_name} = #{tag_value}"
+                tags[tag_name] = tag_value 
+            end
+        end 
+
+        # The format is a csv file as follows:
+        # N,name,value            --> nodes
+        # C,source,destination    --> connections (also called edges)
+        #
+        # Optionally, each line type can be followed by comma-separated tag=value
+        def read_graph_from_file(filename)
+            puts "Read graph data from file #{filename}"
+            File.readlines(filename).each do |line|
+                line = line.chomp  # remove the carriage return
+                values = line.split(",")
+                type = values[0]
+                tags = {}
+                if type == "N" or type == "n"
+                    name = values[1]
+                    if values.size > 2
+                        value = values[2]
+                        # The second position can be a tag or the node value
+                        if value.include? "="
+                            process_tag_string(tags, value)
+                            value = nil 
+                        end 
+                    else 
+                        value = nil 
+                    end
+                    if values.size > 3
+                        values[3..-1].each do |tag_string|
+                            process_tag_string(tags, tag_string) 
+                        end
+                    end
+                    add(name, value, tags)
+                elsif type == "E" or type == "e" or type == "L" or type == "l" or type == "C" or type == "c"
+                    source_name = values[1]
+                    destination_name = values[2]
+                    if values.size > 3
+                        values[3..-1].each do |tag_string|
+                            process_tag_string(tags, tag_string) 
+                        end
+                    end
+                    connect(source_name, destination_name, tags)
+                else 
+                    puts "Ignoring line: #{line}"
+                end
+            end
+        end
     end
 
+    #
+    # An internally used data structure that facilitates walking from the leaf nodes
+    # up to the top of the graph, such that a node is only visited once all of its
+    # descendants have been visited.
+    #
     class GraphReverseIterator
         attr_accessor :output
         def initialize(graph) 
@@ -553,6 +747,42 @@ module Wads
         end    
     end 
 
+    #
+    # A single dimension range, going from min to max. 
+    # This class has helper methods to create bins within the given range.
+    #
+    class DataRange 
+        attr_accessor :min
+        attr_accessor :max
+        attr_accessor :range
+
+        def initialize(min, max)
+            if min < max
+                @min = min 
+                @max = max 
+            else 
+                @min = max 
+                @max = min
+            end
+            @range = @max - @min
+        end
+
+        def bin_max_values(number_of_bins)
+            bin_size = @range / number_of_bins.to_f 
+            bins = []
+            bin_start_value = @min
+            number_of_bins.times do 
+                bin_start_value = bin_start_value + bin_size 
+                bins << bin_start_value
+            end 
+            bins
+        end
+    end 
+
+    #
+    # A two dimensional range used by Plot to determine the visible area
+    # which can be a subset of the total data range(s)
+    #
     class VisibleRange
         attr_accessor :left_x
         attr_accessor :right_x

data/lib/wads/textinput.rb

@@ -1,5 +1,7 @@
 require 'gosu'
 
+module Wads
+
 class TextField < Gosu::TextInput
   # Some constants that define our appearance.
   INACTIVE_COLOR  = 0xcc666666
@@ -12,10 +14,12 @@ class TextField < Gosu::TextInput
   attr_accessor :base_z
   attr_accessor :old_value
   
-  def initialize(window, font, x, y, original_text, default_width)
+  def initialize(x, y, original_text, default_width)
     super()
     
-    @window, @font, @x, @y = window, font, x, y
+    @x = x
+    @y = y
+    @font = WadsConfig.instance.current_theme.font
     @default_width = default_width
     @base_z = 0
     self.text = original_text
@@ -25,15 +29,15 @@ class TextField < Gosu::TextInput
   def draw
     # Depending on whether this is the currently selected input or not, change the
     # background's color.
-    if @window.text_input == self then
+    if WadsConfig.instance.get_window.text_input == self then
       background_color = ACTIVE_COLOR
     else
       background_color = INACTIVE_COLOR
     end
-    @window.draw_quad(x - PADDING,         y - PADDING,          background_color,
-                      x + width + PADDING, y - PADDING,          background_color,
-                      x - PADDING,         y + height + PADDING, background_color,
-                      x + width + PADDING, y + height + PADDING, background_color, @base_z + 9)
+    WadsConfig.instance.get_window.draw_quad(x - PADDING,         y - PADDING,          background_color,
+                                             x + width + PADDING, y - PADDING,          background_color,
+                                             x - PADDING,         y + height + PADDING, background_color,
+                                             x + width + PADDING, y + height + PADDING, background_color, @base_z + 9)
     
     # Calculate the position of the caret and the selection start.
     pos_x = x + @font.text_width(self.text[0...self.caret_pos])
@@ -41,15 +45,15 @@ class TextField < Gosu::TextInput
     
     # Draw the selection background, if any; if not, sel_x and pos_x will be
     # the same value, making this quad empty.
-    @window.draw_quad(sel_x, y,          SELECTION_COLOR,
-                      pos_x, y,          SELECTION_COLOR,
-                      sel_x, y + height, SELECTION_COLOR,
-                      pos_x, y + height, SELECTION_COLOR, @base_z + 10)
+    WadsConfig.instance.get_window.draw_quad(sel_x, y,          SELECTION_COLOR,
+                                             pos_x, y,          SELECTION_COLOR,
+                                             sel_x, y + height, SELECTION_COLOR,
+                                             pos_x, y + height, SELECTION_COLOR, @base_z + 10)
 
     # Draw the caret; again, only if this is the currently selected field.
-    if @window.text_input == self then
-      @window.draw_line(pos_x, y,          CARET_COLOR,
-                        pos_x, y + height, CARET_COLOR, @base_z + 10)
+    if WadsConfig.instance.get_window.text_input == self then
+      WadsConfig.instance.get_window.draw_line(pos_x, y,          CARET_COLOR,
+                                               pos_x, y + height, CARET_COLOR, @base_z + 10)
     end
 
     # Finally, draw the text itself!
@@ -130,3 +134,5 @@ class TextField < Gosu::TextInput
       # empty base implementation
   end
 end
+
+end # end wads module

data/lib/wads/version.rb

@@ -1,3 +1,3 @@
 module Wads
-    VERSION = "0.1.2"
+    VERSION = "0.2.2"
 end