laser 0.7.0.pre1

data/lib/laser/support/inheritable_attributes.rb

@@ -0,0 +1,145 @@
+module Laser
+  # Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+  # their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+  # to, for example, an array without those additions being shared with either their parent, siblings, or
+  # children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+  module InheritedAttributes # :nodoc:
+    def self.extended(base)
+      return if const_defined?(:Rails)
+      base.__send__(:extend, ClassMethods)
+      class << base
+        alias inherited_without_inheritable_attributes inherited
+        alias inherited inherited_with_inheritable_attributes
+      end
+    end
+    module ClassMethods
+      def class_inheritable_reader(*syms)
+        syms.each do |sym|
+          next if sym.is_a?(Hash)
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def self.#{sym}                                # def self.after_add
+              read_inheritable_attribute(:#{sym})          #   read_inheritable_attribute(:after_add)
+            end                                            # end
+                                                           #
+            def #{sym}                                     # def after_add
+              self.class.#{sym}                            #   self.class.after_add
+            end                                            # end
+          EOS
+        end
+      end
+
+      def class_inheritable_writer(*syms)
+        syms.each do |sym|
+          next if sym.is_a?(Hash)
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def self.#{sym}=(obj)                          # def self.color=(obj)
+              write_inheritable_attribute(:#{sym}, obj)    #   write_inheritable_attribute(:color, obj)
+            end                                            # end
+                                                           #
+            def #{sym}=(obj)                               # def color=(obj)
+              self.class.#{sym} = obj                      #   self.class.color = obj
+            end                                            # end
+          EOS
+        end
+      end
+
+      def class_inheritable_array_writer(*syms)
+        syms.each do |sym|
+          next if sym.is_a?(Hash)
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def self.#{sym}=(obj)                          # def self.levels=(obj)
+              write_inheritable_array(:#{sym}, obj)        #   write_inheritable_array(:levels, obj)
+            end                                            # end
+                                                           #
+            def #{sym}=(obj)                               # def levels=(obj)
+              self.class.#{sym} = obj                      #   self.class.levels = obj
+            end                                            # end
+          EOS
+        end
+      end
+
+      def class_inheritable_hash_writer(*syms)
+        syms.each do |sym|
+          next if sym.is_a?(Hash)
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def self.#{sym}=(obj)                          # def self.nicknames=(obj)
+              write_inheritable_hash(:#{sym}, obj)         #   write_inheritable_hash(:nicknames, obj)
+            end                                            # end
+                                                           #
+            def #{sym}=(obj)                               # def nicknames=(obj)
+              self.class.#{sym} = obj                      #   self.class.nicknames = obj
+            end                                            # end
+          EOS
+        end
+      end
+
+      def class_inheritable_accessor(*syms)
+        class_inheritable_reader(*syms)
+        class_inheritable_writer(*syms)
+      end
+
+      def class_inheritable_array(*syms)
+        class_inheritable_reader(*syms)
+        class_inheritable_array_writer(*syms)
+      end
+
+      def class_inheritable_hash(*syms)
+        class_inheritable_reader(*syms)
+        class_inheritable_hash_writer(*syms)
+      end
+
+      def inheritable_attributes
+        @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+      end
+
+      def write_inheritable_attribute(key, value)
+        if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+          @inheritable_attributes = {}
+        end
+        inheritable_attributes[key] = value
+      end
+
+      def write_inheritable_array(key, elements)
+        write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+        write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+      end
+
+      def write_inheritable_hash(key, hash)
+        write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+        write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+      end
+
+      def read_inheritable_attribute(key)
+        inheritable_attributes[key]
+      end
+
+      def reset_inheritable_attributes
+        @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      end
+
+      private
+        # Prevent this constant from being created multiple times
+        EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+        def duplicable?(x)
+          ![NilClass, FalseClass, TrueClass, Module, ::Symbol, Numeric].any? do |klass|
+            x.is_a?(klass)
+          end
+        end
+
+        def inherited_with_inheritable_attributes(child)
+          inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+
+          if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+            new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+          else
+            new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+              memo.update(key => duplicable?(value) ? value.dup : value)
+            end
+          end
+
+          child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+        end
+    end
+  end
+end

data/lib/laser/support/module_extensions.rb

@@ -0,0 +1,94 @@
+module Laser
+  # These are extensions to Laser modules. This module should be
+  # extended by any Laser modules seeking to take advantage of them.
+  # This prevents conflicts with other libraries defining extensions
+  # of the same name.
+  module ModuleExtensions
+    # Creates a new method that returns the boolean negation of the
+    # specified method.
+    def opposite_method(new_name, old_name)
+      define_method new_name do |*args, &blk|
+        !send(old_name, *args, &blk)
+      end
+    end
+    
+    # Creates an attr_accessor that defaults to a certain value.
+    def attr_accessor_with_default(name, val)
+      ivar_sym = "@#{name}"
+      define_method name do
+        unless instance_variable_defined?(ivar_sym)
+          instance_variable_set(ivar_sym, val)
+        end
+        instance_variable_get ivar_sym
+      end
+      attr_writer name
+    end
+
+    # Creates a reader for the given instance variables on the class object.
+    def cattr_reader(*attrs)
+      attrs.each do |attr|
+        instance_eval("def #{attr}; @#{attr}; end")
+      end
+    end
+
+    # Creates a writer for the given instance variables on the class object.
+    def cattr_writer(*attrs)
+      attrs.each do |attr|
+        instance_eval("def #{attr}=(val); @#{attr} = val; end")
+      end
+    end
+
+    # Creates readers and writers for the given instance variables.
+    def cattr_accessor(*attrs)
+      cattr_reader(*attrs)
+      cattr_writer(*attrs)
+    end
+
+    def cattr_accessor_with_default(attr, default)
+      varname = "@#{attr}".to_sym
+      singleton_class.instance_eval do
+        define_method attr do
+          if instance_variable_defined?(varname)
+            instance_variable_get(varname)
+          else
+            default = default.dup unless Fixnum === default || default.singleton_class == default.class
+            instance_variable_set(varname, default)
+            instance_variable_get(varname)
+          end
+        end
+      end
+      cattr_writer(attr)
+    end
+
+    # Creates a DSL-friendly set-and-getter method. The method, when called with
+    # no arguments, acts as a getter. When called with arguments, it acts as a
+    # setter. Uses class instance variables - this is not for generating
+    # instance methods.
+    #
+    # @example
+    #   class A
+    #     cattr_get_and_setter :type
+    #   end
+    #   class B < A
+    #     type :silly
+    #   end
+    #   p B.type  # => :silly
+    def cattr_get_and_setter(*attrs)
+      attrs.each do |attr|
+        cattr_accessor attr
+        singleton_class.instance_eval do
+          alias_method "#{attr}_old_get".to_sym, attr
+          define_method attr do |*args, &blk|
+            if args.size > 0
+              send("#{attr}=", *args)
+            elsif blk != nil
+              send("#{attr}=", blk)
+            else
+              send("#{attr}_old_get")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/laser/support/placeholder_object.rb

@@ -0,0 +1,13 @@
+module Laser
+  # Class that's just a name. Substitute for symbols, which can overlap
+  # with user-code values.
+  class PlaceholderObject
+    def initialize(name)
+      @name = name
+    end
+    def inspect
+      @name
+    end
+    alias_method :to_s, :inspect
+  end
+end

data/lib/laser/third_party/rgl/adjacency.rb

@@ -0,0 +1,221 @@
+# adjacency.rb
+# 
+# $Id: adjacency.rb,v 1.12 2008/08/23 05:37:05 javanthropus Exp $
+# 
+# The DirectedAdjacencyGraph class implements a generalized adjacency list
+# graph structure.  An AdjacencyGraph is basically a two-dimensional structure
+# (ie, a list of lists).  Each element of the first dimension represents a
+# vertex.  Each of the vertices contains a one-dimensional structure that is
+# the list of all adjacent vertices.
+#
+# The class for representing the adjacency list of a vertex is, by default, a
+# Set.  This can be configured by the client, however, when an AdjacencyGraph
+# is created.
+
+require 'laser/third_party/rgl/mutable'
+require 'set'
+
+module RGL
+  class DirectedAdjacencyGraph
+
+    include MutableGraph
+
+    # Shortcut for creating a DirectedAdjacencyGraph:
+    #
+    #  RGL::DirectedAdjacencyGraph[1,2, 2,3, 2,4, 4,5].edges.to_a.to_s =>
+    #    "(1-2)(2-3)(2-4)(4-5)"
+
+    def self.[] (*a)
+      result = new
+      0.step(a.size-1, 2) { |i| result.add_edge(a[i], a[i+1]) }
+      result
+    end
+
+    # Returns a new empty DirectedAdjacencyGraph which has as its edgelist
+    # class the given class.  The default edgelist class is Set, to ensure
+    # set semantics for edges and vertices.
+    #
+    # If other graphs are passed as parameters their vertices and edges are
+    # added to the new graph.
+    def initialize (edgelist_class = Set, *other_graphs)
+      @edgelist_class = edgelist_class
+      @vertex_dict   = Hash.new
+      @predecessor_dict = Hash.new
+      
+      add_graphs(*other_graphs)
+    end
+
+    # Copy internal vertice_dict
+    def initialize_copy(orig)
+      @vertex_dict = orig.instance_eval{@vertex_dict}.dup
+      @vertex_dict.keys.each do |v|
+        @vertex_dict[v] = @vertex_dict[v].dup
+      end
+      @predecessor_dict = orig.instance_eval{@predecessor_dict}.dup
+      @predecessor_dict.keys.each do |v|
+        @predecessor_dict[v] = @predecessor_dict[v].dup
+      end
+    end
+
+    # Iterator for the keys of the vertice list hash.
+
+    def each_vertex (&b)
+      @vertex_dict.each_key(&b)
+    end
+
+    def each_adjacent (v, &b)			# :nodoc:
+      adjacency_list = (@vertex_dict[v] or
+        raise NoVertexError, "No vertex #{v}.")
+      adjacency_list.each(&b)
+    end
+    
+    def each_predecessor(v, &b)
+      predecessor_dict = (@predecessor_dict[v] or
+        raise NoVertexError, "No vertex #{v}.")
+      predecessor_dict.each(&b)
+    end
+
+    # Returns true.
+
+    def directed?
+      true
+    end
+
+    # Complexity is O(1), because the vertices are kept in a Hash containing
+    # as values the lists of adjacent vertices of _v_.
+
+    def has_vertex? (v)
+      @vertex_dict.has_key?(v)
+    end
+
+    # Complexity is O(1), if a Set is used as adjacency list.  Otherwise,
+    # complexity is O(out_degree(v)).
+    #
+    # ---
+    # MutableGraph interface.
+
+    def has_edge? (u, v)
+      has_vertex?(u) and @vertex_dict[u].include?(v)
+    end
+
+    # See MutableGraph#add_vertex.
+    #
+    # If the vertex is already in the graph (using eql?), the method does
+    # nothing.
+
+    def add_vertex (v)
+      @vertex_dict[v] ||= @edgelist_class.new
+      @predecessor_dict[v] ||= @edgelist_class.new
+    end
+
+    # See MutableGraph#add_edge.
+
+    def add_edge (u, v)
+      add_vertex(u)                         # ensure key
+      add_vertex(v)                         # ensure key
+      basic_add_edge(u, v)
+    end
+
+    # See MutableGraph#remove_vertex.
+
+    def remove_vertex (v)
+      @vertex_dict.delete(v)
+      @predecessor_dict.delete(v)
+      # remove v from all adjacency lists
+
+      @vertex_dict.each_value { |adjList| adjList.delete(v) }
+      @predecessor_dict.each_value { |predlist| predlist.delete(v) }
+    end
+
+    # See MutableGraph::remove_edge.
+
+    def remove_edge (u, v)
+      @vertex_dict[u].delete(v) unless @vertex_dict[u].nil?
+      @predecessor_dict[v].delete(u) unless @predecessor_dict[v].nil?
+    end
+
+    # Converts the adjacency list of each vertex to be of type _klass_. The
+    # class is expected to have a new contructor which accepts an enumerable as
+    # parameter.
+    def edgelist_class=(klass)
+      @vertex_dict.keys.each do |v|
+        @vertex_dict[v] = klass.new @vertex_dict[v].to_a
+      end
+      @predecessor_dict.keys.each do |v|
+        @predecessor_dict[v] = klass.new @predecessor_dict[v].to_a
+      end
+    end
+
+    protected
+
+    def basic_add_edge (u, v)
+      @vertex_dict[u].add(v)
+      @predecessor_dict[v].add(u)
+    end
+
+  end		# class DirectedAdjacencyGraph
+
+  # AdjacencyGraph is an undirected Graph.  The methods add_edge and
+  # remove_edge are reimplemented:  If an edge (u,v) is added or removed,
+  # then the reverse edge (v,u) is also added or removed.
+
+  class AdjacencyGraph < DirectedAdjacencyGraph 
+
+    def directed?				# Always returns false.
+      false
+    end
+        
+    # Also removes (v,u)
+
+    def remove_edge (u, v)
+      super
+      @vertex_dict[v].delete(u) unless @vertex_dict[v].nil?
+    end
+
+    protected
+
+    def basic_add_edge (u,v)
+      super
+      @vertex_dict[v].add(u)			# Insert backwards edge
+    end
+
+  end		# class AdjacencyGraph
+
+  module Graph
+
+    # Convert a general graph to an AdjacencyGraph.  If the graph is directed,
+    # returns a DirectedAdjacencyGraph; otherwise, returns an AdjacencyGraph.
+
+    def to_adjacency
+      result = (directed? ? DirectedAdjacencyGraph : AdjacencyGraph).new
+      each_vertex { |v| result.add_vertex(v) }
+      each_edge { |u,v| result.add_edge(u, v) }
+      result
+    end
+
+    # Return a new DirectedAdjacencyGraph which has the same set of vertices.
+    # If (u,v) is an edge of the graph, then (v,u) is an edge of the result.
+    #
+    # If the graph is undirected, the result is self.
+
+    def reverse
+      return self unless directed?
+      result = DirectedAdjacencyGraph.new
+      each_vertex { |v| result.add_vertex v }
+      each_edge { |u,v| result.add_edge(v, u) }
+      result
+    end
+
+    # Return a new AdjacencyGraph which has the same set of vertices.  If (u,v)
+    # is an edge of the graph, then (u,v) and (v,u) (which are the same edges)
+    # are edges of the result.
+    #
+    # If the graph is undirected, the result is self.
+
+    def to_undirected
+      return self unless directed?
+      AdjacencyGraph.new(Set, self)
+    end
+
+  end		# module Graph
+end		# module RGL