laser 0.7.0.pre1

data/lib/laser/standard_library/stringio.rb

@@ -0,0 +1,2 @@
+class StringIO < Data
+end

data/lib/laser/standard_library/symbol.rb

@@ -0,0 +1,125 @@
+class Symbol
+  # builtin: true
+  # pure: true
+  # returns: Fixnum= | NilClass
+  def <=>(other)
+  end
+  # builtin: true
+  # pure: true
+  # returns: Boolean
+  def ==(other)
+  end
+  # builtin: true
+  # pure: true
+  # returns: Boolean
+  def ===(other)
+  end
+  # builtin: true
+  # pure: true
+  # returns: Fixnum= | Bignum= | NilClass
+  def =~(other)
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def [](arg1, arg2 = :__unset__)
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def capitalize
+  end
+  # builtin: true
+  # pure: true
+  # returns: Fixnum= | NilClass
+  def casecmp(other)
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def downcase
+  end
+  # builtin: true
+  # pure: true
+  # returns: Boolean
+  def empty?
+  end
+  # builtin: true
+  # pure: true
+  # returns: Encoding
+  def encoding
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def id2name
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def inspect
+  end
+  # builtin: true
+  # pure: true
+  # returns: Symbol=
+  def intern
+  end
+  # builtin: true
+  # pure: true
+  # returns: Fixnum= | Bignum=
+  def length
+  end
+  # builtin: true
+  # pure: true
+  def match(other)
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def next
+  end
+  # builtin: true
+  # pure: true
+  # returns: Fixnum= | Bignum=
+  def size
+  end
+  # builtin: true
+  # pure: true
+  def slice(arg1, arg2 = :__unset__)
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def succ
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def swapcase
+  end
+  # pure: true
+  def to_proc
+    sym = self
+    proc { |*args| args.shift.__send__(sym, *args) }
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def to_s
+  end
+  # builtin: true
+  # pure: true
+  # returns: Symbol=
+  def to_sym
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def to_yaml
+  end
+  # builtin: true
+  # pure: true
+  # returns: String=
+  def upcase
+  end
+end

data/lib/laser/standard_library/tsort.rb

@@ -0,0 +1,242 @@
+#--
+# tsort.rb - provides a module for topological sorting and strongly connected components.
+#++
+#
+
+#
+# TSort implements topological sorting using Tarjan's algorithm for
+# strongly connected components.
+#
+# TSort is designed to be able to be used with any object which can be
+# interpreted as a directed graph.
+#
+# TSort requires two methods to interpret an object as a graph,
+# tsort_each_node and tsort_each_child.
+#
+# * tsort_each_node is used to iterate for all nodes over a graph.
+# * tsort_each_child is used to iterate for child nodes of a given node.
+#
+# The equality of nodes are defined by eql? and hash since
+# TSort uses Hash internally.
+#
+# == A Simple Example
+#
+# The following example demonstrates how to mix the TSort module into an
+# existing class (in this case, Hash). Here, we're treating each key in
+# the hash as a node in the graph, and so we simply alias the required
+# #tsort_each_node method to Hash's #each_key method. For each key in the
+# hash, the associated value is an array of the node's child nodes. This
+# choice in turn leads to our implementation of the required #tsort_each_child
+# method, which fetches the array of child nodes and then iterates over that
+# array using the user-supplied block.
+#
+#   require 'tsort'
+#
+#   class Hash
+#     include TSort
+#     alias tsort_each_node each_key
+#     def tsort_each_child(node, &block)
+#       fetch(node).each(&block)
+#     end
+#   end
+#
+#   {1=>[2, 3], 2=>[3], 3=>[], 4=>[]}.tsort
+#   #=> [3, 2, 1, 4]
+#
+#   {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}.strongly_connected_components
+#   #=> [[4], [2, 3], [1]]
+#
+# == A More Realistic Example
+#
+# A very simple `make' like tool can be implemented as follows:
+#
+#   require 'tsort'
+#
+#   class Make
+#     def initialize
+#       @dep = {}
+#       @dep.default = []
+#     end
+#
+#     def rule(outputs, inputs=[], &block)
+#       triple = [outputs, inputs, block]
+#       outputs.each {|f| @dep[f] = [triple]}
+#       @dep[triple] = inputs
+#     end
+#
+#     def build(target)
+#       each_strongly_connected_component_from(target) {|ns|
+#         if ns.length != 1
+#           fs = ns.delete_if {|n| Array === n}
+#           raise TSort::Cyclic.new("cyclic dependencies: #{fs.join ', '}")
+#         end
+#         n = ns.first
+#         if Array === n
+#           outputs, inputs, block = n
+#           inputs_time = inputs.map {|f| File.mtime f}.max
+#           begin
+#             outputs_time = outputs.map {|f| File.mtime f}.min
+#           rescue Errno::ENOENT
+#             outputs_time = nil
+#           end
+#           if outputs_time == nil ||
+#              inputs_time != nil && outputs_time <= inputs_time
+#             sleep 1 if inputs_time != nil && inputs_time.to_i == Time.now.to_i
+#             block.call
+#           end
+#         end
+#       }
+#     end
+#
+#     def tsort_each_child(node, &block)
+#       @dep[node].each(&block)
+#     end
+#     include TSort
+#   end
+#
+#   def command(arg)
+#     print arg, "\n"
+#     system arg
+#   end
+#
+#   m = Make.new
+#   m.rule(%w[t1]) { command 'date > t1' }
+#   m.rule(%w[t2]) { command 'date > t2' }
+#   m.rule(%w[t3]) { command 'date > t3' }
+#   m.rule(%w[t4], %w[t1 t3]) { command 'cat t1 t3 > t4' }
+#   m.rule(%w[t5], %w[t4 t2]) { command 'cat t4 t2 > t5' }
+#   m.build('t5')
+#
+# == Bugs
+#
+# * 'tsort.rb' is wrong name because this library uses
+#   Tarjan's algorithm for strongly connected components.
+#   Although 'strongly_connected_components.rb' is correct but too long.
+#
+# == References
+#
+# R. E. Tarjan, "Depth First Search and Linear Graph Algorithms",
+# <em>SIAM Journal on Computing</em>, Vol. 1, No. 2, pp. 146-160, June 1972.
+#
+
+module TSort
+  class Cyclic < StandardError
+  end
+
+  #
+  # Returns a topologically sorted array of nodes.
+  # The array is sorted from children to parents, i.e.
+  # the first element has no child and the last node has no parent.
+  #
+  # If there is a cycle, TSort::Cyclic is raised.
+  #
+  def tsort
+    result = []
+    tsort_each {|element| result << element}
+    result
+  end
+
+  #
+  # The iterator version of the #tsort method.
+  # <tt><em>obj</em>.tsort_each</tt> is similar to <tt><em>obj</em>.tsort.each</tt>, but
+  # modification of _obj_ during the iteration may lead to unexpected results.
+  #
+  # #tsort_each returns +nil+.
+  # If there is a cycle, TSort::Cyclic is raised.
+  #
+  def tsort_each # :yields: node
+    each_strongly_connected_component {|component|
+      if component.size == 1
+        yield component.first
+      else
+        raise Cyclic.new("topological sort failed: #{component.inspect}")
+      end
+    }
+  end
+
+  #
+  # Returns strongly connected components as an array of arrays of nodes.
+  # The array is sorted from children to parents.
+  # Each elements of the array represents a strongly connected component.
+  #
+  def strongly_connected_components
+    result = []
+    each_strongly_connected_component {|component| result << component}
+    result
+  end
+
+  #
+  # The iterator version of the #strongly_connected_components method.
+  # <tt><em>obj</em>.each_strongly_connected_component</tt> is similar to
+  # <tt><em>obj</em>.strongly_connected_components.each</tt>, but
+  # modification of _obj_ during the iteration may lead to unexpected results.
+  #
+  #
+  # #each_strongly_connected_component returns +nil+.
+  #
+  def each_strongly_connected_component # :yields: nodes
+    id_map = {}
+    stack = []
+    tsort_each_node {|node|
+      unless id_map.include? node
+        each_strongly_connected_component_from(node, id_map, stack) {|c|
+          yield c
+        }
+      end
+    }
+    nil
+  end
+
+  #
+  # Iterates over strongly connected component in the subgraph reachable from
+  # _node_.
+  #
+  # Return value is unspecified.
+  #
+  # #each_strongly_connected_component_from doesn't call #tsort_each_node.
+  #
+  def each_strongly_connected_component_from(node, id_map={}, stack=[]) # :yields: nodes
+    minimum_id = node_id = id_map[node] = id_map.size
+    stack_length = stack.length
+    stack << node
+
+    tsort_each_child(node) {|child|
+      if id_map.include? child
+        child_id = id_map[child]
+        minimum_id = child_id if child_id && child_id < minimum_id
+      else
+        sub_minimum_id =
+          each_strongly_connected_component_from(child, id_map, stack) {|c|
+            yield c
+          }
+        minimum_id = sub_minimum_id if sub_minimum_id < minimum_id
+      end
+    }
+
+    if node_id == minimum_id
+      component = stack.slice!(stack_length .. -1)
+      component.each {|n| id_map[n] = nil}
+      yield component
+    end
+
+    minimum_id
+  end
+
+  #
+  # Should be implemented by a extended class.
+  #
+  # #tsort_each_node is used to iterate for all nodes over a graph.
+  #
+  def tsort_each_node # :yields: node
+    raise NotImplementedError.new
+  end
+
+  #
+  # Should be implemented by a extended class.
+  #
+  # #tsort_each_child is used to iterate for child nodes of _node_.
+  #
+  def tsort_each_child(node) # :yields: child
+    raise NotImplementedError.new
+  end
+end

data/lib/laser/support/acts_as_struct.rb

@@ -0,0 +1,66 @@
+module Laser
+  # Lets a class act as a struct by extending the module and using acts_as_struct.
+  # This is useful if you need to inherit from another class so you can't subclass
+  # Struct.new. However, reads will be slower due to optimizations that the C version
+  # of Struct that comes with the standard library can do.
+  module ActsAsStruct
+    # Mixes in struct behavior to the current class.
+    def acts_as_struct(*members)
+      include Comparable
+      extend InheritedAttributes
+      class_inheritable_array :current_members unless respond_to?(:current_members)
+      
+      self.current_members ||= []
+      self.current_members.concat members
+      all_members = self.current_members
+      # Only add new members
+      attr_accessor *members
+      # NOT backwards compatible with a Struct's initializer. If you
+      # try to initialize the first argument to a Hash and don't provide
+      # other arguments, you trigger the hash extraction initializer instead
+      # of the positional initializer. That's a bad idea.
+      define_method :initialize do |*args|
+        if args.size == 1 && Hash === args.first
+          initialize_hash(args.first)
+        else
+          if args.size > all_members.size
+            raise ArgumentError.new("#{self.class} has #{all_members.size} members " +
+                                    "- you provided #{args.size}")
+          end
+          initialize_positional(args)
+        end
+      end
+      
+      # Initializes by treating the input as key-value assignments.
+      define_method :initialize_hash do |hash|
+        hash.each { |k, v| send("#{k}=", v) }
+      end
+      private :initialize_hash
+      
+      # Initialize by treating the input as positional arguments that
+      # line up with the struct members provided to acts_as_struct.
+      define_method :initialize_positional do |args|
+        args.each_with_index do |value, idx|
+          key = all_members[idx]
+          send("#{key}=", value)
+        end
+      end
+      private :initialize_positional
+      
+      # Helper methods for keys/values.
+      define_method(:keys_and_values) { keys.zip(values) }
+      define_method(:values) { keys.map { |member| send member } }
+      define_method(:keys) { all_members }
+      define_method(:each) { |&blk| keys_and_values.each { |k, v| blk.call([k, v]) } }
+      define_method(:'<=>') do |other|
+        each do |key, value|
+          res = (value <=> other.send(key))
+          if res != 0
+            return res
+          end
+        end
+        0
+      end
+    end
+  end
+end

data/lib/laser/support/frequency.rb

@@ -0,0 +1,55 @@
+module Laser
+  class Frequency
+    include Comparable
+    attr_reader :name, :val
+    def initialize(name, val)
+      @name = name
+      @val = val
+    end
+    
+    def ===(other)
+      equal? other
+    end
+    
+    def to_s
+      @name.to_s
+    end
+    alias inspect to_s
+    
+    def <=>(other)
+      @val <=> other.val
+    end
+    
+    NEVER = self.new(:never, 0)
+    MAYBE = self.new(:maybe, 1)
+    ALWAYS = self.new(:always, 2)
+    
+    LOOKUP = {never: NEVER, maybe: MAYBE, always: ALWAYS}
+    def self.[](sym)
+      LOOKUP[sym]
+    end
+
+    def self.combine_samples(samples)
+      return NEVER if samples.empty?
+      base = samples.first
+      samples[1..-1].each do |sample|
+        return MAYBE if sample > base || sample < base
+      end
+      base
+    end   
+
+    def self.for_samples(yes, no)
+      if no && !yes
+        NEVER
+      elsif no && yes
+        MAYBE
+      else  # !no && yes
+        ALWAYS
+      end
+    end
+
+    class << self
+      undef new
+    end
+  end
+end