facets 1.4.5 → 1.7.0

data/snip/more/range.rb

@@ -1,383 +0,0 @@
-=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/snip/more/sanitize.rb

@@ -1,48 +0,0 @@
-# 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/snip/more/service.rb

@@ -1,266 +0,0 @@
-
-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