casegen 1.3.0

data/bin/casegen

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+  gem 'casegen'
+rescue LoadError
+end
+
+require 'casegen'
+
+CLabs::CaseGen::Console.new

data/src/agents/sets.rb

@@ -0,0 +1,336 @@
+require "#{File.dirname(__FILE__)}/../casegen"
+$LOAD_PATH << "#{File.expand_path(File.join(File.dirname(__FILE__), 'sets'))}"
+require 'enum/op'
+
+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)
+      @data = data
+      @agents = reference_agents
+      table = formatted_table([@agents[0].titles] + @agents[0].combinations)
+      table.each do |ary|
+        puts ary.join(' | ')
+      end
+      puts
+      @agents[0].each do |rule|
+        puts rule.data
+        puts
+      end if @agents[0].is_a?(Rules)
+    end
+    
+    def formatted_table(combinations)
+      col_widths = []
+      formatted_tuples = []
+      combinations.each do |tuple|
+        col = 0
+        tuple.each do |item| 
+          col_widths[col] = item.to_s.length if col_widths[col].to_i < item.to_s.length
+          col += 1
+        end
+      end
+      
+      combinations.each do |tuple|
+        col = 0
+        formatted_tuples << tuple.collect { |item| 
+          formatted = item.to_s.ljust(col_widths[col]) if !col_widths[col].nil?
+          col += 1
+          formatted
+        }
+      end
+      formatted_tuples
+    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

data/src/agents/sets/enum/by.rb

@@ -0,0 +1,244 @@
+#!/usr/bin/env ruby
+
+module Enumerable
+
+  class LinkedListDelegator
+    include Enumerable
+    
+    attr_reader :first, :next_name, :next_map, :args
+
+    def initialize first, next_spec = nil, *args, &next_proc
+      @first = first
+      @args = args
+      
+      case next_spec
+      when Symbol
+        @next_name = next_spec
+      when String
+        @next_name = next_spec.intern
+      when nil
+        @next_map = next_proc
+      else
+        unless next_spec.respond_to? :[]
+          raise ArgumentError,
+            "next_spec must be a method name or respond to []."
+        end
+        @next_map = next_spec
+      end
+      
+      unless @next_name or @next_map
+        raise ArgumentError,
+          "no next-getter specified."
+      end
+    end
+
+    def each
+      cur = @first
+      if @next_name
+        next_name = @next_name
+        message = next_name, *@args
+        while cur
+          yield cur
+          cur = cur.send *message
+        end
+      elsif @next_map
+        next_map = @next_map
+        args = @args
+        while cur
+          yield cur
+          cur = next_map[cur, *args]
+        end
+      end
+
+      self
+    end
+    
+  end
+  
+end
+
+class Object
+  def by next_spec = nil, *args, &next_proc
+    Enumerable::LinkedListDelegator.new self, next_spec, *args, &next_proc
+  end
+end
+
+
+=begin
+
+==class Object
+===instance method
+---Object#by next_spec = nil, *args, &next_proc
+
+Allows use of (({Enumerable})) methods, such as (({each})), (({collect})),
+(({select})), etc., to iterate over arbitrary objects. The caller supplies a
+way of calculating the successor of each object, such as an accessor method for
+the next element of a linked list.
+
+Object#by returns an (({Enumerable})) object whose (({each})) method
+iterates over the sequence beginning with (({self})) and continuing as
+specified by the arguments. Only the current element of the sequence is
+kept in memory. No attempt is made to avoid cycles.
+
+If (({next_spec})) is a string or symbol, (({next_proc})) is ignored and
+(({next_spec})) is treated as a method name. This method name is sent, along
+with arguments (({args})), to each element of the sequence to generate the next
+element. The sequence terminates at the first element for which the method
+returns (({nil})) or (({false})).
+
+If (({next_spec})) is anything else, except (({nil})), (({next_proc})) is
+ignored and (({next_spec})) is required to be an object that responds to
+(({[]})), such as a proc or a hash. The (({[]})) method of (({next_spec}))
+is called with each element of the sequence in turn as an argument, along
+with (({args})), to generate the next element. The sequence terminates at
+the first element for which (({[]})) returns (({nil})) or (({false})).
+
+If (({next_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.
+
+The return value is not an array, but an (({Enumerable})) object that refers
+to the original objects. In this sense, (({Object#by})) is a ((*delegator*)).
+Typically, (({by})) is 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 sequence does not matter. To get
+the array of entries produced by (({by})) as an independent data structure, use
+(({Enumerable#entries})) or (({Enumerable#to_a})).
+
+===examples
+
+  require 'enum/by'
+
+  class A; end
+  class B < A; end
+  class C < B; end
+
+  for cl in C.by :superclass
+    print cl, " "
+  end
+
+  # prints: C B A Object
+
+  steps = proc { |x, incr, limit| y = x + incr; y <= limit ? y : nil }
+  p 0.by(steps, 10, 50).to_a
+
+  # prints: [0, 10, 20, 30, 40, 50]
+  
+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>))
+
+==acknowledgement
+Thanks to David Alan Black for his helpful comments on the Ruby mailing
+list
+((<"http://blade.nagaokaut.ac.jp/ruby/ruby-talk
+"|URL:http://blade.nagaokaut.ac.jp/ruby/ruby-talk>)).
+
+=end
+
+
+if __FILE__ == $0
+
+  class Foo
+    attr_reader :value, :next_foo
+
+    def initialize value, next_foo = nil
+      @value = value
+      @next_foo = next_foo
+    end
+  end
+
+  list = Foo.new(0, Foo.new(1, Foo.new(2, Foo.new(3))))
+
+  puts "Iterating over a linked list by method next_foo:"
+  for foo in list.by :next_foo
+    print "#{foo.value} "
+  end
+  print "\n\n"
+
+  puts "By proc { |foo| foo.next_foo.next_foo }:"
+  for foo in list.by { |foo| foo.next_foo.next_foo }
+    print "#{foo.value} "
+  end
+  print "\n\n"
+
+  puts "Down a tree, taking a random branch at each node:"
+  puts "First, with a proc:"
+  tree = [[0, [1, 2]], 3, [4, 5, [6, 7, 8]], 9]
+  at_random = proc { |x| x.kind_of?(Array) && x.at(rand(x.size)) }
+  for node in tree.by at_random
+    p node
+  end
+  puts "Second, with methods:"
+  class Object
+    def at_random
+      nil
+    end
+  end
+  class Array
+    def at_random
+      at(rand(size))
+    end
+  end
+  for node in tree.by :at_random
+    p node
+  end
+  puts
+
+  puts "With numbers (but watch out for cycles!):"
+  p 0.by { |x| x<10 ? x+1 : nil }.to_a
+  puts
+
+  puts "With numbers using a proc and an argument:"
+  steps = proc { |x, incr, limit| y = x + incr; y <= limit ? y : nil }
+  p 0.by(steps, 10, 50).to_a
+  puts
+
+  puts "Up the superclass relation:"
+  class A; end
+  class B < A; end
+  class C < B; end
+  for cl in C.by :superclass
+   print cl, " "
+  end
+  puts "\n\n"
+
+  puts "Popping down a stack:"
+  p [0,1,2,3,4].by { |y| y.pop; y != [] && y.dup }.entries
+  puts
+
+  puts "#by behaves correctly with self==nil"
+  p nil.by(:something).entries
+  puts
+
+  puts "By hash, or other class responding to []:"
+  h = { :a => :b, :b => :c, :c => :d }
+  p :a.by {|x| h[x]}.entries
+  puts "The same effect, but simpler:"
+  p :a.by(h).entries
+  puts
+
+  puts "Around and around we go..."
+  n = 0;
+  for x in 0.by([1,2,3,4,0])
+    n += 1
+    print x, " "
+    break if n > 12
+  end
+  puts "..."
+
+end