spruz 0.1.0

data/Rakefile

@@ -0,0 +1,85 @@
+begin
+  require 'rake/gempackagetask'
+rescue LoadError
+end
+require 'rake/clean'
+CLEAN.include 'coverage', 'doc'
+require 'rbconfig'
+include Config
+
+PKG_NAME = 'spruz'
+PKG_VERSION = File.read('VERSION').chomp
+PKG_FILES = FileList['**/*'].exclude(/(CVS|\.svn|pkg|coverage|doc)/)
+
+desc "Installing library"
+task :install  do
+  ruby 'install.rb'
+end
+
+desc "Creating documentation"
+task :doc do
+  ruby 'make_doc.rb'
+end
+
+desc "Testing library"
+task :test  do
+  ruby '-Ilib tests/test_spruz.rb'
+end
+
+desc "Testing library with coverage"
+task :coverage  do
+  sh "rcov -Ilib -x 'tests/.*\.rb' tests/test_spruz.rb"
+end
+
+if defined? Gem
+  spec = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.summary = "Useful stuff."
+    s.description = "All the stuff that isn't good/big enough for a real library."
+
+    s.files = PKG_FILES
+
+    s.require_path = 'lib'
+
+    s.bindir = "bin"
+    s.executables << "enum"
+
+    s.has_rdoc = true
+    s.extra_rdoc_files << 'README'
+    s.rdoc_options << '--title' <<  'Spruz' << '--main' << 'README'
+    s.test_files << 'tests/test_spruz.rb'
+
+    s.author = "Florian Frank"
+    s.email = "flori@ping.de"
+    s.homepage = "http://flori.github.com/spruz"
+  end
+
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+    pkg.package_files += PKG_FILES
+  end
+end
+
+desc m = "Writing version information for #{PKG_VERSION}"
+task :version do
+  puts m
+  File.open(File.join('lib', PKG_NAME, 'version.rb'), 'w') do |v|
+    v.puts <<EOT
+module Spruz
+  # Spruz version
+  VERSION         = '#{PKG_VERSION}'
+  VERSION_ARRAY   = VERSION.split(/\\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end
+EOT
+  end
+end
+
+desc "Default task: write version and test"
+task :default => [ :version, :test ]
+
+desc "Prepare a release"
+task :release => [ :clean, :version, :package ]

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/enum

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+
+require 'spruz'
+include Spruz
+include Spruz::GO
+
+class CompoundRange
+  def initialize
+    @ranges = []
+  end
+
+  def concat(range)
+    @ranges << range
+    self
+  end
+
+  def each(&block)
+    @ranges.each { |r| r.each(&block) }
+  end
+end
+
+class Step
+  def initialize(a, b, step = 1, exclusive = false)
+    @a = a
+    @b = b
+    @step = step
+    if exclusive
+      if step < 0
+        @b += 1
+      else
+        @b -= 1
+      end
+    end
+  end
+
+  def each(&block)
+    @a.step(@b, @step, &block)
+  end
+end
+
+class StringRange
+  def initialize(a, b, exclusive = false)
+    @range = if a > b
+      if exclusive
+        (b.succ..a).to_a.reverse
+      else
+        (b..a).to_a.reverse
+      end
+    else
+      Range.new(a, b, exclusive)
+    end
+  end
+
+  def each(&block)
+    @range.each(&block)
+  end
+end
+
+class IntegerRange < Step
+  def initialize(a, b, exclusive = false)
+    @a = a
+    @b = b
+    super(a, b, a > b ? -1 : 1, exclusive)
+  end
+end
+
+def parse_range(range)
+  case range
+  when /,/
+    range.split(/,/).inject(CompoundRange.new) do |a,x|
+      a.concat(parse_range(x))
+    end
+  when /\A(-?\d+)\Z/
+    ($1.to_i)..($1.to_i)
+  when /\A(\w+)\Z/
+    $1..$1
+  when /\A(-?\d+)..(-?\d+)\Z/
+    IntegerRange.new($1.to_i, $2.to_i)
+  when /\A(-?\d+)...(-?\d+)\Z/
+    IntegerRange.new($1.to_i, $2.to_i, true)
+  when /\A(-?\d+)..(-?\d+)([+-]\d+)\Z/
+    Step.new($1.to_i, $2.to_i, $3.to_i)
+  when /\A(-?\d+)...(-?\d+)([+-]\d+)\Z/
+    Step.new($1.to_i, $2.to_i, $3.to_i, true)
+  when /\A(\w+)..(\w+)\Z/
+    StringRange.new($1, $2)
+  when /\A(\w+)...(\w+)\Z/
+    StringRange.new($1, $2, true)
+  else
+    fail "parsing range failed due to '#{range}'"
+  end
+end
+
+def parse_ranges(pattern)
+  pattern.split(/:/).map { |range| parse_range(range) }
+end
+
+def execute_command(command, format, tuple)
+  formatted = (format % tuple).split(/:/)
+  if $limited
+    $limited.execute do
+      system sprintf(command, *formatted)
+    end
+  else
+    system sprintf(command, *formatted)
+  end
+end
+
+def usage
+  puts <<EOT    
+Usage: #{File.basename($0)} [OPTIONS] RANGES 
+
+RANGES has to be a string of the from R1:R2:...Rn, where R1 to Rn are ranges of
+values for each dimension. A range can be specified like in one of
+those examples:
+  2
+  1..3
+  3..1
+  1...3
+  1,2,4
+  1..2,4
+  b
+  a..c
+  a...c
+  c..a
+  c...a
+  a,b,d
+  a..b,d
+
+
+OPTIONS are
+
+  -p PARALLEL       how many threads in parallel should be forked to handle the
+                    execution of commands.
+
+  -e COMMAND        this command is executed for every created tuple of values.
+                    The tuple values can be fetch by using %s in order,
+                    e. g. COMMAND = "a=%s;b=%s;echo a is $a. b is $b."
+
+  -f FORMAT         format the created values with FORMAT = F1:F2:...:Fn each
+                    format is a sprintf percent format, e. g. %02u.
+
+  -h this help      display this help
+
+EOT
+  exit 1
+end
+
+$opts = {
+}.update(go('p:e:f:h')) do |o,default,set|
+  set || default
+end
+usage if $opts['h'] || ARGV.size != 1
+$ranges = ARGV.shift
+$limited = $opts['p'] ? Limited.new($opts['p']) : nil
+ranges = parse_ranges($ranges)
+generator = Generator.new(ranges)
+$opts['f'] ||= %w[ %s ] * generator.size * ':'
+
+generator.each do |tuple|
+  if $opts['e']
+    execute_command($opts['e'], $opts['f'], tuple)
+  else
+    puts $opts['f'] % tuple
+  end
+end
+exit 0

data/install.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'rbconfig'
+include Config
+require 'fileutils'
+include FileUtils::Verbose
+
+if $DEBUG
+  def install(*a)
+    p [ :install ] + a
+  end
+
+  def mkdir_p(*a)
+    p [ :mkdir_p ] + a
+  end
+end
+
+file = File.join('lib', 'spruz.rb')
+dst = CONFIG["sitelibdir"]
+install file, File.join(dst, File.join('lib/spruz.rb'))
+src = File.join(*%w[lib spruz *.rb])
+dst = File.join(CONFIG["sitelibdir"], 'spruz')
+mkdir_p dst
+for file in Dir[src]
+  install file, File.join(dst, file)
+end
+src = File.join(*%w[lib spruz xt *.rb])
+dst = File.join(CONFIG["sitelibdir"], 'spruz', 'xt')
+mkdir_p dst
+for file in Dir[src]
+  install file, File.join(dst, file)
+end
+install 'bin/enum', File.join(CONFIG['bindir'], 'enum')

data/lib/spruz.rb

@@ -0,0 +1,22 @@
+module Spruz
+  require 'spruz/version'
+  require 'spruz/bijection'
+  require 'spruz/count_by'
+  require 'spruz/generator'
+  require 'spruz/go'
+  require 'spruz/hash_union'
+  require 'spruz/limited'
+  require 'spruz/memoize'
+  require 'spruz/minimize'
+  require 'spruz/module_group'
+  require 'spruz/null'
+  require 'spruz/once'
+  require 'spruz/p'
+  require 'spruz/partial_application'
+  require 'spruz/round'
+  require 'spruz/shuffle'
+  require 'spruz/subhash'
+  require 'spruz/time_dummy'
+  require 'spruz/to_proc'
+  require 'spruz/uniq_by'
+end

data/lib/spruz/bijection.rb

@@ -0,0 +1,31 @@
+module Spruz
+  class Bijection < Hash
+    def initialize(inverted = Bijection.new(self))
+      @inverted = inverted
+    end
+
+    def fill
+      if empty?
+        yield self
+        freeze
+      end
+      self
+    end
+
+    def freeze
+      r = super
+      unless @inverted.frozen?
+        @inverted.freeze
+      end
+      r
+    end
+
+    def []=(key, value)
+      return if key?(key)
+      super
+      @inverted[value] = key
+    end
+
+    attr_reader :inverted
+  end
+end

data/lib/spruz/count_by.rb

@@ -0,0 +1,8 @@
+module Spruz
+  module CountBy
+    def count_by(&b)
+      b ||= lambda { |x| true }
+      inject(0) { |s, e| s += 1 if b[e]; s }
+    end
+  end
+end

data/lib/spruz/generator.rb

@@ -0,0 +1,66 @@
+module Spruz
+  # This class can create generator objects, that can produce all tuples, that
+  # would be created by as many for-loops as dimensions were given.
+  #
+  # The generator
+  #  g = Spruz::Generator[1..2, %w[a b c]]
+  # produces
+  #  g.to_a # => [[1, "a"], [1, "b"], [1, "c"], [2, "a"], [2, "b"], [2, "c"]]
+  #
+  # The 'each' method can be used to iterate over the tuples
+  #  g.each { |a, b| puts "#{a} #{b}" }
+  # and Spruz::Generator includes the Enumerable module, so
+  # Enumerable.instance_methods can be used as well:
+  #  g.select { |a, b| %w[a c].include? b  } # => [[1, "a"], [1, "c"], [2, "a"], [2, "c"]]
+  #
+  class Generator
+    include Enumerable
+
+    # Create a new Generator object from the enumberables _enums_.
+    def self.[](*enums)
+      new(enums)
+    end
+
+    # Create a new Generator instance. Use the objects in the Array _enums_
+    # as dimensions. The should all respond to the :each method (see module
+    # Enumerable in the core ruby library).
+    def initialize(enums)
+      @enums, @iterators, @n = [], [], 0
+      enums.each { |e| add_dimension(e) }
+    end
+
+    # Iterate over all tuples produced by this generator and yield to them.
+    def each(&block) # :yield: tuple
+      recurse(&block)
+      self
+    end
+
+    def recurse(tuple = [ nil ] * @n, i = 0, &block)
+      if i < @n - 1 then
+        @enums[i].__send__(@iterators[i]) do |x|
+          tuple[i] = x
+          recurse(tuple, i + 1, &block)
+        end
+      else
+        @enums[i].__send__(@iterators[i]) do |x|
+          tuple[i] = x
+          yield tuple.dup
+        end
+      end
+    end
+    private :recurse
+
+    # Add another dimension to this generator. _enum_ is an object, that ought
+    # to respond to the _iterator_ method (defaults to :each).
+    def add_dimension(enum, iterator = :each)
+      @enums << enum
+      @iterators << iterator
+      @n += 1
+    end
+
+    # Return the size of this generator, that is the number of its dimensions.
+    def size
+      @enums.size
+    end
+  end
+end

data/lib/spruz/go.rb

@@ -0,0 +1,37 @@
+module Spruz
+  module GO
+    module_function
+
+    # Parses the argument array _args_, according to the pattern _s_, to
+    # retrieve the single character command line options from it. If _s_ is
+    # 'xy:' an option '-x' without an option argument is searched, and an
+    # option '-y foo' with an option argument ('foo').
+    #
+    # An option hash is returned with all found options set to true or the
+    # found option argument.
+    def go(s, args = ARGV)
+      b,v = s.scan(/(.)(:?)/).inject([{},{}]) { |t,(o,a)|
+        a = a == ':'
+        t[a ? 1 : 0][o] = a ? nil : false
+        t
+      }
+      while a = args.shift
+        a !~ /\A-(.+)/ and args.unshift a and break
+        p = $1
+        until p == ''
+          o = p.slice!(0, 1)
+          if v.key?(o)
+            v[o] = if p == '' then args.shift or break 1 else p end
+            break
+          elsif b.key?(o)
+            b[o] = true
+          else
+            args.unshift a
+            break 1
+          end
+        end and break
+      end
+      b.merge(v)
+    end
+  end
+end