casegen 2.0.0 → 3.0.0

data/lib/agents/sets/enum/tree.rb

@@ -1,442 +0,0 @@
-#!/usr/bin/env ruby
-
-module Enumerable
-
-  class TreeDelegator
-    include Enumerable
-    
-    attr_reader :root, :child_name, :child_map,
-                :args, :output_type
-    
-    def initialize root, child_spec = nil, *args, &child_proc
-      @root = root
-      @args = args
-      @output_type = :nodes
-      
-      case child_spec
-      when Symbol
-        @child_name = child_spec
-      when String
-        @child_name = child_spec.intern
-      when nil
-        @child_map = child_proc
-      else
-        unless child_spec.respond_to? :[]
-          raise ArgumentError,
-            "child_spec must be a method name or respond to []."
-        end
-        @child_map = child_spec
-      end
-      
-      unless @child_name or @child_map
-        raise ArgumentError,
-          "no child-getter specified."
-      end
-    end
-    
-    def get_children cur
-     (if @child_name
-        cur.send @child_name, *@args
-      else
-        @child_map[cur, *@args]
-      end).to_a
-    end
-    
-  end
-  
-  class ByBreadthDelegator < TreeDelegator
-  
-    def each level = [@root], &block
-    
-      children = []
-      for node in level
-        yield node
-        children |= get_children(node) || []
-      end
-      
-      if children and not children.empty?
-        each children, &block
-      end
-
-      self
-    end
-  
-  end
-  
-  class ByDepthDelegator < TreeDelegator
-    
-    def with_ancestors
-      @output_type = :with_ancestors
-      self
-    end
-    
-    def branches
-      @output_type = :branches
-      self
-    end
-
-    def each(*args, &block)
-      case @output_type
-      when :nodes
-        each_node *args, &block
-      when :with_ancestors
-        each_with_ancestors *args, &block
-      when :branches
-        each_branch *args, &block
-      end
-    end
-    
-  protected
-    def each_node cur = @root, &block
-    
-      result = catch (:prune) do
-        yield cur
-      
-        children = get_children cur
-
-        if children
-          for child in children
-            each_node child, &block
-          end
-        end
-      
-        false
-      end
-
-      if result and result > 0
-        throw :prune, result - 1
-      end
-
-      self
-    end
-    
-    def each_with_ancestors cur = @root, ancestors = [], &block
-
-      result = catch (:prune) do
-        yield cur, ancestors
-
-        children = get_children cur
-
-        if children
-          for child in children
-            each_with_ancestors child, ancestors + [cur], &block
-          end
-        end
-        
-        false
-      end
-
-      if result and result > 0
-        throw :prune, result - 1
-      end
-
-      self
-    end
-    
-    def each_branch branch = [@root], &block
-      cur = branch[-1]
-      
-      children = get_children cur
-      
-      if children and not children.empty?
-        for child in children
-          each_branch branch + [child], &block
-        end
-      else
-        yield branch
-      end
-
-      self
-    end
-        
-  end
-  
-end
-
-class Object
-  def by_depth child_spec = nil, *args, &child_proc
-    Enumerable::ByDepthDelegator.new self, child_spec, *args, &child_proc
-  end
-  def by_breadth child_spec = nil, *args, &child_proc
-    Enumerable::ByBreadthDelegator.new self, child_spec, *args, &child_proc
-  end
-end
-
-
-=begin
-
-==class Object
-===instance methods
----Object#by_depth child_spec = nil, *args, &child_proc
----Object#by_breadth child_spec = nil, *args, &child_proc
-
-Allows use of (({Enumerable})) methods, such as (({each})), (({collect})),
-(({select})), etc., to iterate over objects which have a caller-specified tree
-structure (or, more generally, directed acyclic graph structure). The caller
-defines this structure by providing a way of calculating the children of each
-object, such as an accessor method for the array of children of a node in a
-tree.
-
-In order to yield a sequence of objects, the nonlinear structure of the tree is
-linearized in either a depth-first or a breadth-first way, depending on the
-method used, (({by_depth})) or (({by_breadth})). In a depth-first
-linearization, the iteration visits a node's children before continuing with
-the node's successive siblings. In a breadth-first linearization, the iteration
-visits all siblings before visiting any of their children. In either case, the
-parent is visited before its children, and the children are visited in an order
-consistent with their order in the sequence of children provided by their
-parent.
-
-Speaking loosely, one can think of a depth-first iteration as working branch by
-branch and a breadth-first iteration as working level by level, where a level
-consists of nodes of equal depth.
-
-====usage 
-
-  require 'enum/tree'
-  
-  for node in root.by_depth :a_method, ...
-  
-  for node in root.by_depth a_proc, ...
-  
-  for node in root.by_depth { |node| ... return children }
-  
-  # by_breadth has the same form
-
-====arguments
-
-The means of accessing the children of each node is specified in the
-argument list with a method name, a block, or an object that responds to
-(({[]})), such as a proc or a hash. In any case, the value returned must be an
-(({Enumerable})) object, typically an array.
-
-If (({child_spec})) is a string or symbol, (({child_proc})) is ignored and
-(({child_spec})) is treated as a method name. This method name is sent, along
-with arguments (({args})), to each node to generate the children. The node is
-considered childless when the method returns (({nil})) or (({false})) or an empty collection.
-
-If (({child_spec})) is anything else, except (({nil})), (({child_proc})) is
-ignored and (({child_spec})) is required to be an object that responds to
-(({[]})), such as a proc or a hash. The (({[]})) method of (({child_spec})) is
-called with each node as an argument, along with (({args})), to generate the
-children. The node is considered childless when (({[]})) returns (({nil})) or
-(({false})) or an empty collection.
-
-If (({child_spec})) is not given, or is (({nil})), a block is required. In this
-case, the block is converted to a proc and iteration proceeds as in the
-preceding paragraph.
-
-====return value
-
-The return value is not an array, but an (({Enumerable})) object that refers
-to the original objects. In this sense, (({Object#by_depth})) and
-(({Object#by_breadth})) are ((*delegators*)). Typically, (({by_depth})) and
-(({by_breadth})) are used with the (({for ... in ...})) construct, or
-(equivalently) with (({each})), or with (({collect})), (({select})), and so on.
-In these cases, the dependence on the original data structure does not matter.
-To get the array of entries produced by (({by_depth})) or (({by_breadth})) as
-an independent data structure, use (({Enumerable#entries})) or
-(({Enumerable#to_a})).
-
-====directed acyclic graphs
-
-If a node occurs as the child of two different parent nodes, the structure is
-not a tree. As long as no node is its own ancestor, these methods still produce
-a useful interation (it is the caller's responsibility to avoid cycles). The
-structure in this case is sometimes called a ((*directed acyclic graph*)). In a
-depth-first iteration, a node with two parents will be reached twice. In a
-breadth-first iteration, a node with two parents will be reaced once if the
-parents are at the same depth in the graph, but twice otherwise.
-
-====modifiers
-
-The (({Object#by_depth})) method accepts two modifiers that affect the yielded
-values, but not the order of iteration:
-
-  for node, ancestors in tree.by_depth(...).with_ancestors
-  
-  for branch in tree.by_depth(...).branches
-
-The (({with_ancestors})) modifier results in the same linearization, but
-returns, along with each node, the node's array of ancestors, starting with the
-root of the tree and ending with the immediate parent. In the non-tree case, the
-ancestor list doesn't contain all ancestors, but just one path from the root to
-the node. Each such path will occur once during the (({by_depth})) iteration.
-
-With the (({branches})) modifier, the iteration yields all branches of the tree
-(or directed acyclic graph). A ((*branch*)) is a path from the root to a leaf
-node.
-
-Note that a (({with_ancestors})) iteration yields at every node, but a
-(({branches})) iteration yields only at leaf nodes.
-
-====prune
-
-Pruning the iteration means skipping a node and its descendants and continuing
-with the nodes that would normally follow them in the iteration. This can be
-done anywhere in dynamic scope during the iteration by simply throwing the
-(({:prune})) symbol:
-
-  throw :prune
-  
-If an additional integer argument is supplied:
-
-  throw :prune, n
-  
-then the pruning occurs not at the current node, but at the node (({n})) levels
-above the current node in the current ancestor list.
-
-Note that (({prune})) cannot used with the (({each_branch})) modifier discussed
-above; (({prune})) simply has no useful meaning in this context.
-
-====examples
-
-  require 'enum/tree'
-  
-  # Define a proc to compute the subclasses of a class
-  # It would probably be better to make this a method of Class
-  # and to implement it more efficiently, but for illustration...
-
-  subclasses = proc { |cl|
-    subs = []
-    ObjectSpace.each_object(Class) { |sub|
-      if sub.superclass == cl then subs << sub end
-    }
-    subs
-  }
-  
-  print "Subclasses of Numeric:\n"
-  for node in Numeric.by_depth subclasses
-    print node, " "
-  end
-  
-    # prints:
-    # Subclasses of Numeric:
-    # Numeric Float Integer Bignum Fixnum 
-
-  puts "\n\nBranches:"
-  for branch in Numeric.by_depth(subclasses).branches
-    p branch
-  end
-  
-    # prints:
-    # Branches:
-    # [Numeric, Float]
-    # [Numeric, Integer, Bignum]
-    # [Numeric, Integer, Fixnum]
-  
-  puts "\nNodes with ancestors:"
-  for x, a in Numeric.by_depth(subclasses).with_ancestors
-    print "\t"*a.size, "node is #{x}, ancestors is #{a.inspect}.\n"
-  end
-  
-    # prints:
-    # Nodes with ancestors:
-    # node is Numeric, ancestors is [].
-    #	 node is Float, ancestors is [Numeric].
-    #	 node is Integer, ancestors is [Numeric].
-    #		 node is Bignum, ancestors is [Numeric, Integer].
-    #		 node is Fixnum, ancestors is [Numeric, Integer].
-    
-See the end of the source file for more examples.
-
-===version
-
-Enumerable tools 1.6
-
-The current version of this software can be found at 
-((<"http://redshift.sourceforge.net/enum
-"|URL:http://redshift.sourceforge.net/enum>)).
-
-===license
-This software is distributed under the Ruby license.
-See ((<"http://www.ruby-lang.org"|URL:http://www.ruby-lang.org>)).
-
-===author
-Joel VanderWerf,
-((<vjoel@users.sourceforge.net|URL:mailto:vjoel@users.sourceforge.net>))
-
-=end
-
-
-if __FILE__ == $0
-
-  tree = [ [1,2,[3]], [4, [], 5] ]
-  for x in tree.by_depth { |x| x.kind_of?(Array) ? x : [] }
-    p x
-  end
-  puts
-  
-  class Node
-
-    attr_reader :value, :children
-
-    def initialize value, children = nil
-      @value = value
-      @children = children
-      unless not children or children.respond_to? :each
-        raise ArgumentError, "children must be nil or have an each method."
-      end
-    end
-
-  end
-
-  tree = Node.new(0,
-    [Node.new(1,
-      [Node.new(2,
-        [Node.new(3)]),
-       Node.new(4),
-       Node.new(5)]),
-     Node.new(6)])
-
-  for node in tree.by_depth :children
-    if node.value == 4
-      throw :prune, 1
-    end
-    print node.value
-  end
-  puts
-  
-  for node in tree.by_breadth :children
-    print node.value
-  end
-  puts
-  
-  # Define a proc to compute the subclasses of a Class
-  # It would probably be better to make this a method of Class
-  # and to implement it more efficiently, but for illustration...
-  subclasses = proc { |cl|
-    subs = []
-    ObjectSpace.each_object(Class) { |sub|
-      if sub.superclass == cl then subs << sub end
-    }
-    subs
-  }
-  
-  print "\nSubclasses of Numeric:\n"
-  for node in Numeric.by_depth subclasses
-    print node, " "
-  end
-  print "\n\n"
-  
-  puts "Branches:"
-  for branch in Numeric.by_depth(subclasses).branches
-    p branch
-  end
-  puts
-  
-  puts "Nodes with ancestors:"
-  for x, a in Numeric.by_depth(subclasses).with_ancestors
-    print "\t"*a.size, "node is #{x}, ancestors is #{a.inspect}.\n"
-  end
-  puts
-  
-  # print the inheritance hierarchy of a given class
-  if ARGV[0]
-    root = Object.const_get(ARGV[0])
-    for x, a in root.by_depth(subclasses).with_ancestors
-      print "\t"*a.size, x, "\n"
-    end
-  end
-  
-end

data/lib/agents/sets.rb

@@ -1,313 +0,0 @@
-require "#{File.dirname(__FILE__)}/../casegen"
-$LOAD_PATH << "#{File.expand_path(File.join(File.dirname(__FILE__), 'sets'))}"
-require 'enum/op'
-require 'tablesmith'
-
-class String
-  def to_u
-    self.gsub(/ /, '_')
-  end
-end
-
-module CLabs::CaseGen
-  class Set
-    attr_reader :name, :data
-
-    def initialize(name, data_array)
-      @name = name
-      @data = data_array
-      strip_data
-    end
-
-    def strip_data
-      @data.collect! do |datum| datum.strip end
-    end
-
-    def values
-      @data
-    end
-  end
-
-  class Sets < Agent
-    attr_accessor :sets, :combinations, :set_titles
-
-    def Sets.agent_id
-      "casegen:sets"
-    end
-
-    def initialize(data, reference_agents=nil)
-      @data = data
-      @sets = []
-      parse_sets
-    end
-
-    def parse_sets
-      set_names = @data.scan(/^\s*(\w.*):/)
-      set_data = @data.scan(/:(.*)/)
-      sets = set_names.flatten.zip(set_data.flatten)
-      sets.each do |set_array|
-        @sets << Set.new(set_array[0], set_array[1].split(/, /))
-      end
-      generate_combinations
-    end
-
-    def generate_combinations
-      arrays = []
-      @set_titles = []
-      @sets.each do |set| arrays << set.data; @set_titles << set.name end
-      @combinations = all(*arrays)
-    end
-
-    def titles
-      @set_titles
-    end
-
-    def all(*args)
-      result = []
-      EnumerableOperator::Product.new(*args).each { |tuple|
-        result << tuple
-      }
-      result
-    end
-
-    def set_names
-      names = []
-      @sets.each do |set| names << set.name end
-      names
-    end
-
-    def set_by_name(setname)
-      @sets.detect do |set| set.name =~ /#{Regexp.escape(setname)}/ end
-    end
-
-  end
-
-  class Criteria
-    attr_reader :set_names, :set_values, :equalities
-
-    def initialize(data)
-      @data = data
-      @equalities = {}
-      parse
-    end
-
-    def parse
-      @data.split(/AND/).each do |bit|
-        set_name, set_value = bit.split(/==|=/)
-        set_name.strip!; set_value.strip!
-        if @equalities.keys.include?(set_name)
-          raise ParserException.new("Rule cannot have the same set <#{set_name}> equal to different values <#{@equalities[set_name]}, #{set_value}>")
-        end
-        @equalities[set_name] = set_value
-      end
-      @set_names = @equalities.keys
-      @set_values = @equalities.values
-    end
-
-    # hash keys should be valid set names and hash values should be valid
-    # set values in the named set
-    def match(hash)
-      # must match all equalities
-      @equalities.each_pair do |eq_name, eq_value|
-        actual_value = hash[eq_name]
-        return false if actual_value.nil?
-        return false if actual_value != eq_value
-      end
-      return true
-    end
-
-    def to_s
-      @data
-    end
-  end
-
-  class Rule
-    attr_reader :criteria, :description, :data
-
-    def initialize(rule_data)
-      @data = rule_data
-      parse_rule
-    end
-
-    def parse_rule
-      data = @data.sub(self.class.regexp, '')
-      criteria_data, *@description = data.split(/\n/)
-      criteria_data.strip!
-      @criteria = Criteria.new(criteria_data)
-      @description = (@description.join("\n") + "\n").outdent.strip
-    end
-  end
-
-  class ExcludeRule < Rule
-    def type_description
-      "exclude"
-    end
-
-    def ExcludeRule.regexp
-      /^exclude/i
-    end
-
-    def ExcludeRule.create(rule_data)
-      return ExcludeRule.new(rule_data) if rule_data =~ regexp
-      return nil
-    end
-  end
-
-  class Rules < Agent
-    def Rules.agent_id
-      "casegen:rules"
-    end
-
-    def initialize(data, reference_agents=[])
-      @data = data
-      @agents = reference_agents
-      @rules = []
-      @rule_classes = []
-      ObjectSpace.each_object(Class) do |obj|
-        @rule_classes << obj if obj.ancestors.include?(Rule) && obj != Rule
-      end
-      parse_data
-    end
-
-    def parse_data
-      raw_rules = @data.split(/(?=^\S)/)
-
-      raw_rules.each do |rule|
-        @rule_classes.each do |rule_class|
-          @rules << rule_class.create(rule.strip)
-        end
-      end
-      @rules.compact!
-      @rules.flatten!
-      validate_rules
-    end
-
-    def validate_rules
-      @agents.each do |agent|
-        if agent.class == Sets
-          @rules.each do |rule|
-            rule.criteria.equalities.each_pair do |set_name, set_value|
-              set = agent.set_by_name(set_name)
-              if set.nil?
-                raise ParserException.new("Invalid set name <#{set_name}> " +
-                  "in rule <#{rule.criteria}>. Valid set names are <#{agent.set_names.join(', ')}>.")
-              end
-              if !set.values.include?(set_value)
-                raise ParserException.new("Invalid set value <#{set_value}> " +
-                  "in rule <#{rule.criteria}>. Valid set values for <#{set.name}> " +
-                  "are <#{set.values.join(', ')}>.")
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def length
-      @rules.length
-    end
-
-    def [](index)
-      return @rules[index]
-    end
-
-    def each(&block)
-      @rules.each(&block)
-    end
-
-    def combinations
-      return @combinations if !@combinations.nil?
-      if @agents[0].class == Sets
-        agent = @agents[0]
-        @combinations = []
-        agent.combinations.each do |combo|
-          delete = false
-          combo_hash = {}
-          i = 0
-          # combo is an array of values, in the same order of the set_titles.
-          # combo_hash will have set names matched with set values
-          agent.set_titles.each do |title|
-            combo_hash[title] = combo[i]
-            i += 1
-          end
-          @rules.each do |rule|
-            delete |= rule.criteria.match(combo_hash)
-          end
-          @combinations << combo if !delete
-        end
-        return @combinations
-      end
-      return []
-    end
-
-    def titles
-      @agents[0].titles
-    end
-
-    def to_s
-      puts @agents[0].combinations.inspect if !@agents[0].nil?
-      puts
-      puts @rules.inspect
-    end
-  end
-
-  class ConsoleOutput < Agent
-    def ConsoleOutput.agent_id
-      "casegen:console"
-    end
-
-    def initialize(data, reference_agents, io=STDOUT)
-      @data = data
-      @agents = reference_agents
-      table = [@agents[0].titles] + @agents[0].combinations
-      io.puts table.to_table.pretty_inspect
-      io.puts
-      @agents[0].each do |rule|
-        io.puts rule.data
-        io.puts
-      end if @agents[0].is_a?(Rules)
-    end
-  end
-
-  class RubyArrayOutput < Agent
-    def self.agent_id
-      "casegen:ruby_array"
-    end
-
-    def initialize(data, reference_agents, io=STDOUT)
-      @io = io
-      @struct_name = "Case"
-      @struct_name = data if !data.empty?
-      @agents = reference_agents
-      @agents.each do |agent| execute(agent) end
-    end
-
-    def execute(agent)
-      struct_header = "#{@struct_name} = Struct.new("
-      struct = ''
-      agent.titles.each do |title|
-        struct << ', ' if !struct.empty?
-        struct << ":#{title.to_u.downcase}"
-      end
-      struct << ')'
-
-      guts_header = 'cases = ['
-      guts = ''
-      agent.combinations.each do |combo|
-        guts << ",\n#{' ' * guts_header.length}" if !guts.empty?
-        guts << "#{@struct_name}.new#{combo.inspect.gsub(/\[/, '(').gsub(/\]/, ')')}"
-      end
-      @io.print(struct_header)
-      @io.print(struct)
-      @io.print("\n\n")
-      @io.print(guts_header)
-      @io.print(guts)
-      @io.print("]\n")
-    end
-  end
-end
-
-if __FILE__ == $0
-  sets = CLabs::CaseGen::Sets.new("a: 1, 2\nb: 3, 4")
-  puts sets.combinations
-end