facets 1.4.0 → 1.4.1

data/forge/more/range.rb

@@ -0,0 +1,383 @@
+=begin rdoc
+
+= Descrete Range Class
+
+This is the Range class slightly modified to be truly desecrete in nature.
+Use the Interval class (see interval.rb) for a truly continuious range class.
+
+== Synopsis
+
+The following code uses class +Xs+, which is defined in the
+class-level documentation.
+
+  require 'trix/range'
+
+  range = Xs.new(1)..Xs.new(10)
+  range.step(2) {|x| puts x}
+  range.step(3) {|x| puts x}
+
+_produces:_
+
+  1 x
+  3 xxx
+  5 xxxxx
+  7 xxxxxxx
+  9 xxxxxxxxx
+  1 x
+  4 xxxx
+  7 xxxxxxx
+  10 xxxxxxxxxx
+
+== Notes
+
+Range is not quite have descrete behavior becasue it also performs 
+double-duty as a continious interval class. Its just a bit too overloaded
+and this limits its full potential. To remedy, a separate Interval class
+has been created to handle true interval functionality. And here we 
+adjust Range to be truely discrete.
+ 
+Range originally dependened on two methods: #succ and #<=>. If numeric
+ranges were the only concern, those could just as well be #+ and #<=>,
+but esoteric forms make that unfeasible --the obvious example being a 
+String range. To properly handle this, Range fully seperates and extends
+the parallel methods: #succ for #+, #cmp for #<=> ( in the future we may
+add #pred for #- ). It also adds the option of #distance to properly
+calculate the difference between the sentinals. This is neccessary
+to ensure congruent bahavior. For instance, presently String Range's
+can give bad results because #<=> does not measure order in the same
+manner that #succ generates order.
+
+== Todo List
+
+* Add skip parameter, to allow skip-ranges, i.e. skipping successive iterations.
+
+== Author
+
+* Thomas Sawyer
+
+=end
+
+require 'carat/infinity'
+require 'carat/interval'
+
+
+class Range
+
+  alias_method :initialize_simple, :initialize
+  private :initialize_simple
+
+  def initialize( first, halt, exclude_last=false, &succ )
+    @first = first
+    @last = halt.kind_of?(Proc) ? nil : halt
+    @halt = @last ? nil : halt
+    #@exclude_first = exclude_first
+    @exclude_last = exclude_last
+    @direction = (@last <=> @first)
+    #@direction = 1 if @direction == 0
+    @succ = succ || nil #@first.method(:succ).to_proc
+    #@halt = nil #exclude_last? ? proc{ |x| x.cmp(@last) != -1 } : proc{ |x| x.cmp(@last) == 1 }
+    initialize_simple(@first, @last, @exclude_last)
+  end
+
+  def succ ; @succ ; end
+  
+  def succ!(s)
+   if @succ
+     @succ.call(s)
+   else
+     s.succ
+   end
+  end
+  
+  def succ=(succ_proc)
+    raise ArgumentError unless Proc === succ_proc
+    @succ = succ_proc
+  end
+  
+  def halt ; @halt ; end
+  
+  def halt?(s)
+    if @halt
+      @halt.call(s)
+    else
+     if @exclude_last
+       s.cmp(@last) != -1
+     else
+       s.cmp(@last) == 1
+     end
+    end
+  end
+  
+  def halt=(halt_proc)
+    raise ArgumentError unless Proc === halt_proc
+    @halt = halt_proc
+  end
+  
+  #def first ; @first ; end
+  #def last ; @last ; end    
+  #def exclude_first? ; @exclude_first ; end
+  #def exclude_last? ; @exclude_last ; end
+  alias exclude_last? exclude_end?
+  
+  def direction
+   @direction ||= (@last <=> @first)
+  end
+  
+  # poor names
+  #undef_method :begin
+  #undef_method :end
+  #undef_method :exclude_end?
+  
+  def -@ ;  Range.new( @first, @last, true, &@succ ) ; end
+  
+  def distance
+    return @last.distance(@first) if @last and @last.respond_to?(:distance)
+    self.to_a.length # should it just be nil instead?
+  end
+  alias_method( :length, :distance )
+  alias_method( :size, :distance )
+      
+  def min
+    (@first.cmp(@last) == -1) ? @first : @last
+  end
+  
+  def max
+    (@first.cmp(@last) == 1) ? @first : @last
+  end
+  
+  # +between?+ simply tests whether the given value falls
+  # between the sentinels by comparison. It does not 
+  # verify that the value is acutally in the range's sequence.
+  def between?(x)
+    #tf = exclude_first? ? 1 : 0
+    tl = exclude_last? ? -1 : 0
+    # if other classes handled Infinity in their <=> method
+    # (which probably they should) this clause would not be required
+    if first.kind_of?(InfinityClass)
+      ft = ((first <=> x) <= tf)
+    else
+      ft = (x <=> first) >= tf
+    end
+    if last.kind_of?(InfinityClass)
+      fl = ((last <=> x) >= tl)
+    else
+      fl = (x <=> last) <= tl
+    end
+    ft && fl
+  end
+  
+  # Is this proper alias of +===+?
+  alias_method( :===, :between? )
+  
+  # +include?+ is an alias for +member?+. It is like between
+  # but makes sure that the value is in the range sequence.
+  alias_method( :include?, :member? )
+
+  # Compares two ranges to see if they are equal
+  def eql?(other)
+    return false unless @first == other.first
+    other_last = other.exclude_last? ? other.last : other.last
+    if self.exclude_last? and not other.exclude_last?
+      return false unless self.last == other.last.succ
+    elsif other.exclude_last? and not self.exclude_last?
+      return false unless self.last.succ == other.last
+    else
+      return false unless @last == other.last
+    end
+    true
+  end
+
+  alias each_succ each
+  def each( &blk )
+    return each_succ( &blk ) unless @succ or @halt
+    if @halt
+      halt_proc = @halt
+    else
+      halt_proc = exclude_last? ? proc{ |x| x.cmp(@last) != -1 } : proc{ |x| x.cmp(@last) == 1 }
+    end   
+    #t = exclude_last? ? -1 : 0
+    s = @first
+    if @succ
+      #while (s <=> @last) == -1 or (s <=> @last) == t
+      until halt_proc.call(s)
+        yield(s)
+        @succ.call(s)
+      end
+    else
+      #while (s <=> @last) == -1 or (s <=> @last) == t
+      until halt_proc.call(s)
+        yield(s)
+        s.succ
+      end      
+    end
+  end
+  
+#   # each(n) where n is steps, if n is negative it is nth
+#   # I know, it's a neg num trick :( but I think it's
+#   # better then having another method like #each_nth,
+#   # cause then you'd need #to_a_nth, too, etc.
+#   def each(n=1)  # :yield:
+#     n = (length / n.abs) if n < 0
+#     n = n * direction
+#     i = first; i.succ(n) if exclude_first?
+#     t = exclude_last? ? -1 : 0
+#     while (i <=> last) == -1 or (i <=> last) == t
+#       yield(i)
+#       i.succ(n)
+#     end
+#   end
+    
+#   # each(n) where n is steps, if n is negative it is nth
+#   # I know, it's a neg num trick :( but I think it's
+#   # better then having another method like #each_nth,
+#   # cause then you'd need #to_a_nth, too, etc.
+#   def reverse_each(n=1)  # :yield:
+#     n = (length / n.abs) if n < 0
+#     n = n * direction
+#     i = last; i -= n if exclude_first?
+#     t = exclude_first? ? 1 : 0
+#     while (i <=> first) == 1 or (i <=> first) == t
+#       yield(i)
+#       i += n
+#     end
+#   end
+    
+#   def to_a(n=1)
+#     a=[]; each(n){|e| a << e}
+#     a
+#   end
+    
+    # Is this even desirable at this point?
+    # Sequences depend on #succ rather then #+
+    # so don't expect the same results from each!
+  # def to_seq
+  #   seed = exclude_first? ? first.succ : first
+  #   halt = exclude_last? ? proc{|x| (x <=> last) >= 0} : proc{|x| (x <=> last) > 0}
+  #   Sequence.new( seed, &halt )
+  # end
+    
+end
+
+
+
+=begin test
+
+
+  require 'test/unit'
+
+  class GeneralTest < Test::Unit::TestCase
+
+    def test_include_001
+      a = Range.new(1,10)
+      assert_equal(false, a.include?(0))
+      assert_equal(true, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(true, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+    def test_include_002
+      a = Range.new(1,10,false,true)
+      assert_equal(false, a.include?(0))
+      assert_equal(true, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(false, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+    def test_include_003
+      a = Range.new(1,10,true,false)
+      assert_equal(false, a.include?(0))
+      assert_equal(false, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(true, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+    def test_include_004
+      a = Range.new(1,10,true,true)
+      assert_equal(false, a.include?(0))
+      assert_equal(false, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(false, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+  end
+  
+  class LrgNumericTest < Test::Unit::TestCase
+    def test_include
+      a = Range.new(0,100000000)
+      assert_equal(true, a.include?(0))
+      assert_equal(true, a.include?(1000))
+      assert_equal(true, a.include?(1000000))
+      assert_equal(true, a.include?(100000000))
+      assert_equal(false, a.include?(INFINITY))
+    end
+    def test_include_with_step
+      a = Range.new(0,100000000)
+      assert_equal(true, a.include?(0))
+      assert_equal(true, a.include?(5))
+      assert_equal(true, a.include?(70007))
+      assert_equal(true, a.include?(5000005))
+      assert_equal(false, a.include?(INFINITY))
+    end
+  end
+  
+  class InfTest < Test::Unit::TestCase
+    def test_include?
+      a = Range.new(-INFINITY,-3)
+      assert_equal(true, a.include?(-INFINITY))
+      assert_equal(true, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(false, a.include?(-2))
+      assert_equal(false, a.include?(INFINITY))
+      a = Range.new(-INFINITY,-3,false,true)
+      assert_equal(true, a.include?(-INFINITY))
+      assert_equal(true, a.include?(-4))
+      assert_equal(false, a.include?(-3))
+      assert_equal(false, a.include?(-2))
+      assert_equal(false, a.include?(INFINITY))
+      a = Range.new(-3,INFINITY)
+      assert_equal(false, a.include?(-INFINITY))
+      assert_equal(false, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(true, a.include?(-2))
+      assert_equal(true, a.include?(INFINITY))
+      a = Range.new(-INFINITY,INFINITY)
+      assert_equal(true, a.include?(-INFINITY))
+      assert_equal(true, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(true, a.include?(-2))
+      assert_equal(true, a.include?(INFINITY))
+      a = Range.new(-3,-2)
+      assert_equal(false, a.include?(-INFINITY))
+      assert_equal(false, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(true, a.include?(-2))
+      assert_equal(false, a.include?(INFINITY))
+    end
+  end 
+  
+  class OrdinalTest < Test::Unit::TestCase
+    def test_include
+      a = Range.new('a','g')
+      #assert_equal(false, a.include?(-INFINITY))
+      assert_equal(true, a.include?('a'))
+      assert_equal(true, a.include?('c'))
+      assert_equal(false, a.include?('z'))
+      #assert_equal(false, a.include?(INFINITY))
+    end
+    #def test_error
+    #  assert_raises(ArgumentError) {
+    #    a = (-INFINITY..'z')
+    #  }
+    #end
+  end
+
+=end
+

data/forge/more/sanitize.rb

@@ -0,0 +1,48 @@
+# Code from rubyonrails project (http://www.rubyonrails.com)
+# Temporarily here.
+
+require 'html/tokenizer'
+require 'html/node'
+
+VERBOTEN_TAGS = %w(form script) unless defined?(VERBOTEN_TAGS)
+VERBOTEN_ATTRS = /^on/i unless defined?(VERBOTEN_ATTRS)
+
+class String
+  # Sanitizes the given HTML by making form and script tags into regular
+  # text, and removing all "onxxx" attributes (so that arbitrary Javascript
+  # cannot be executed). Also removes href attributes that start with
+  # "javascript:".
+  #
+  # Returns the sanitized text.
+  def self.sanitize(html)
+    # only do this if absolutely necessary
+    if html.index("<")
+      tokenizer = HTML::Tokenizer.new(html)
+      new_text = ""
+
+      while token = tokenizer.next
+        node = HTML::Node.parse(nil, 0, 0, token, false)
+        new_text << case node
+          when HTML::Tag
+            if VERBOTEN_TAGS.include?(node.name)
+              node.to_s.gsub(/</, "&lt;")
+            else
+              if node.closing != :close
+                node.attributes.delete_if { |attr,v| attr =~ VERBOTEN_ATTRS }
+                if node.attributes["href"] =~ /^javascript:/i
+                  node.attributes.delete "href"
+                end
+              end
+              node.to_s
+            end
+          else
+            node.to_s.gsub(/</, "&lt;")
+        end
+      end
+
+      html = new_text
+    end
+
+    html
+  end
+end

data/forge/more/service.rb

@@ -0,0 +1,266 @@
+
+require 'nano/unboundmethod/name'
+require 'nano/enumerable/uniq_by'
+require 'nano/hash/keys_to_sym'
+
+class NoServiceError < NoMethodError ; end
+
+# In general the term 'service' is just another name for method
+# (in Ruby also an attribute). Here it takes on slightly more meaning
+# in that it is a managed first class object.
+#
+class Service
+
+  def initialize( klass, name, allow_virtual=false )
+    unless allow_virtual
+      raise NoServiceError, "#{klass} service ##{name} does not exist" unless klass.method_defined?(name)
+    end
+    @name = name.to_s
+    @class = klass
+    @bindings={}
+    service
+  end
+
+  def name ; @name ; end
+  def for_class ; @class ; end
+
+  def service
+    if @class.instance_methods(false).include?(@name)
+      @method = @class.instance_method(@name)
+    else
+      if @class.method_defined?(@name)
+        @class.instance_method(@name)
+      end
+    end
+  end
+
+  def virtual?
+    service ? false : true
+  end
+
+  #--
+  # do about virtual here ?
+  #++
+  def super_service?
+    # recall method_defined looks at all ancestors too
+    @class.ancestors[1] and @class.ancestors[1].method_defined?(name.to_sym)
+  end
+
+  def super_service
+    super_service? ? @class.ancestors[1].service(name) : nil
+  end
+
+  def service_ancestors
+    return [@class] unless super_service?
+    [@class].concat super_service.service_ancestors
+  end
+
+# TODO
+  #def hash
+  #
+  #end
+
+  #def ===(other)
+  #  @name == other.name and @class.ancestors.include?(other.for_class)
+  #end
+
+  def inspect
+    if virtual?
+      %{#<Virtual#{self.class}:#{@class}##{@name}>}
+    else
+      if @class.instance_methods(false).include?(@name)
+        %{#<#{self.class}:#{@class}##{@name}>}
+      else
+        %{#<#{self.class}:#{@class}(#{service_ancestors.slice(1..-1).join(',')})##{@name}>}
+      end
+    end
+  end
+
+  def <=>(other)
+    return c = @name <=> other.name if c != 0
+    return c = @class <=> other.for_class if c != 0
+    0
+  end
+
+  # Returns metadata merged with ancestor's metadata.
+  def super_metadata
+    return super_service.super_metadata.merge(metadata) if super_service?
+    return metadata
+  end
+  alias :open_metadata :super_metadata
+
+  # This is here to ensure open_metadata works
+  # even when nano/object/metadata isn't loaded.
+  def metadata
+    @_metadata ||= {}
+  end
+
+  # Bind service to an instance of it's for-class.
+  def bind(obj)
+    raise 'virtual service has no target method' if virtual?
+    @bindings[obj] ||= @method.bind(obj)
+  end
+
+  # Unbind service to an instance of it's for-class.
+  def unbind(obj)
+    @bindings.delete(obj).unbind if @bindings.include?(obj)
+  end
+
+  # Returns arity of service.
+  def arity
+    return nil if virtual?
+    @method.arity
+  end
+
+  # Call services on all bound instances.
+  def call(*args,&blk)
+    raise 'virtual service has no target method' if virtual?
+    @bindings.each{|b| b.call(*args,&blk)}
+  end
+
+  # Call the service's (method's) super service (method).
+  def super_call(*args,&blk)
+    super_service.call(*args,&blk) if super_service?
+  end
+
+end
+
+
+class Object
+  def service(name)
+    self.class.service(name)
+  end
+  def has_service?(name)
+    self.class.method_defined?(name)
+  end
+end
+
+
+class Module
+
+  # Returns the hash of local _instantiated_ services.
+  def __service__
+    @__service__ ||= Hash.new{ |h,k| h[k.to_sym]=Service.new( self, k, true ) }
+    @__service__
+  end
+
+  # Returns a service by name.
+  def service( name )
+    raise NoServiceError unless has_service?(name) unless virtual_service?(name)
+    __service__[name.to_sym]
+  end
+
+  # Returns a service by name, if doesn't exist creates it.
+  def virtual_service(name)
+    __service__[name.to_sym]
+  end
+
+  # Returns a list of names of the currently instantiated services.
+  def services
+    __service__.keys | ( ancestors[1] ? ancestors[1].services : [] )
+  end
+  alias :open_services :services
+
+  def virtual_services
+    a = []
+    __service__.each{ |k,s| a << k if s.virtual? } #unless ancestors[1]
+    a
+  end
+
+  # This will instantiate all possible services.
+  # This is an expensive operation, use sparingly.
+  def all_services(include_ancestors=false)
+    instance_methods(include_ancestors).collect{ |m| service(m) }
+  end
+
+  # Does this module/class have a service?
+  def service?(name)
+    method_defined?(name)
+  end
+  alias :has_service? :service?
+
+  # Does this module/class have a virtual service?
+  def virtual_service?(name)
+    virtual_services.include?(name)
+  end
+  alias :has_virtual_service? :virtual_service?
+
+  # Simply a wrapper around instance_methods, but converts to symbols
+  def services_available(include_ancestors=true)
+    instance_methods(include_ancestors).collect{ |m| m.to_sym }
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'mega/quicktest'
+
+  class X
+    def name; "X.name" ; end
+    def bang; "X.bang" ; end
+  end
+
+  class Y < X
+    def name; "Y.name" ; end
+    def jump; "Y.jump" ; end
+  end
+
+  #test { assert_equal( X.instance_methods(true), X.services ) }
+  #test { assert_equal( Y.instance_methods(true), Y.services ) }
+  #test { assert_equal( ["jump"], Y.services - X.services ) }
+
+  test do
+    X.service(:name)
+    assert_equal( [:name], X.services )
+    assert_equal( [:name], Y.services )
+  end
+
+  test do
+    Y.service(:name)
+    assert_equal( [:name], X.services )
+    assert_equal( [:name], Y.services )
+  end
+
+  test do
+    assert( Y.service(:name).super_service? )
+  end
+
+  test do
+    Y.service(:jump)
+    assert_equal( [:name], X.services )
+    assert( [:name,:jump].each { |s| Y.services.include?(s) } )
+  end
+
+  test do
+    assert( ! Y.service(:jump).super_service? )
+  end
+
+  test do
+    Y.service(:bang)
+    assert( [:name,:bang].each { |s| X.services.include?(s) } )
+    assert( [:name,:jump,:bang].each { |s| Y.services.include?(s) } )
+  end
+
+  test do
+    assert_raises( NoServiceError ){ Y.service(:noop) }
+  end
+
+  test do
+    Y.virtual_service(:noop)
+    assert_equal( [:noop], Y.virtual_services )
+    assert( [:name,:jump,:bang,:noop].each { |s| Y.services.include?(s) } )
+    assert( Y.service(:noop).virtual? )
+    assert( ! Y.service(:jump).virtual? )
+  end
+
+=end