sequence 0.1.0

data/lib/sequence/io.rb

@@ -0,0 +1,102 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+require 'sequence/stringlike'
+require 'fcntl'
+
+class Sequence
+
+#external iterator over data in an general IO object (a pipe, console, socket, serial port, or the like).
+#For Files, please use Sequence::File instead, as it is more capable.
+#This Sequence class can only go forward, and can only read, it cannot write to the data stream. 
+#Thus many of Sequence's usual methods will not work with this class.
+#At the moment, this even includes #scan and friends, tho I will try to make those work somewhat.
+#Also note that this is one of the few Sequence classes that might return less that the amount asked
+#for in a read, even if not at the end of file.
+#Due to use of nonblocking io, this might not work on windows.
+#The value of #size in this sequence continually increases over its lifetime, and it isn't possible to 
+#know the final value beforehand. Likewise, #eof? may return false even tho it's destined to return
+#true at the same position. This is because the 'other end' may not have closed the IO, even if there's
+#no more data to send.
+#
+#if you need to be able to scan forward and back, consider wrapping the IO in a Buffered or Shifting 
+#Sequence.
+class IO < Sequence
+  include StringLike
+  def initialize(io)
+    @io=io
+    @pos=0
+    
+    @io.fcntl(::Fcntl::F_SETFL, ::Fcntl::O_NONBLOCK)
+    #I gather this won't work on windows....
+    
+    @fragment=''
+  end
+  
+  attr :pos
+
+  undef pos=, _pos=, position, position?, holding, holding?, holding!, readback, readback1
+  undef readahead, readbehind, readahead1, readbehind1, write#, write1
+  undef goto, move, move!, subseq, reversed, <=>, +, -, succ, pred, begin, end
+  undef begin!, end!,  first, last, slice, [], modify, []=
+
+
+  def size
+    #refill fragment if needed
+    @fragment=@io.sysread(4096) if @fragment.empty?
+
+    return @pos+@fragment.size 
+  end
+
+  def more_data?
+    #refill fragment if needed
+    @fragment=@io.sysread(4096) if @fragment.empty?
+    
+    return !eof 
+  end
+  
+  def eof?; 
+    @fragment.empty? and #need to be at buffer end
+      @io.eof?  
+  end
+  
+  def read len
+    if len<= @fragment.size
+      @pos+=len
+      @fragment.slice! 0,len
+    else
+      result=@fragment
+      len-=@fragment.size
+      
+      readlen=len
+      rem=len%4096
+      rem.nonzero? and readlen+=4096-rem
+      
+      @fragment=@io.sysread(readlen) 
+      result+=@fragment.slice!(0,len)
+      @pos+=result.size
+      result
+    end
+  end
+  
+  def match pat
+    @fragment.size>=scanbuflen or @fragment<<@io.sysread(4096)
+    result=@fragment.match(pat)
+    result if result.begin(0).zero?
+  end
+  
+  def _pos=newpos
+    newpos<pos and raise ArgumentError
+    if newpos<=@pos+@fragment.size
+      len=newpos-@pos
+      @fragment.slice!(0,len)
+      @pos=newpos
+    else
+      len=newpos-(@pos+@fragment.size)
+      len > 10*4096 and raise ArgumentError
+      @fragment=''
+      tossit=@io.sysread(len)
+      @pos=newpos-(len-tossit.size)
+    end
+  end
+end
+end

data/lib/sequence/list.rb

@@ -0,0 +1,292 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+class Sequence
+  class Circular < Sequence; end
+  class List < Sequence
+    def initialize(seqs)
+      seqs.empty? and raise ArgumentError
+      @list=seqs
+      @current_idx=0
+      @pos=0
+      @start_pos=[0]
+      _rebuild_idxs
+      
+      @list=@list.inject([]){|li,seq|
+        Circular===seq and raise 'no circular seqs in lists'
+        Sequence===seq or raise ArgumentError
+        if List===seq then li+seq.list else li<<seq end
+      }
+      @list.each{|seq| seq.on_change_notify(self) }
+      
+      extend seqs.first.like
+    end
+    
+    def change_notification(cu,first,oldsize,newsize)
+      idx=@list.each_with_index{|item,i| cu.equal? item and break i}
+      diff=newsize-oldsize
+      (idx+1...@start_pos.size).each{|i|
+        @start_pos[i]+=diff
+      }
+      @pos=_adjust_pos_on_change(@pos, first,oldsize,newsize)
+      @current_idx=_lookup_idx @pos
+      notify_change(self,@start_pos[idx]+first,oldsize,newsize)
+    end
+    
+    def _rebuild_idxs(start=1)
+      seed=@start_pos[0...start]
+      seed.empty? and seed=[0]
+      start==0 and start=1
+      @start_pos=(start..@list.size).inject(seed){|arr,i| 
+        arr<<arr.last+@list[i-1].size
+      }
+      #@start_pos.pop
+      
+      #maybe update @current_idx too?
+    end
+=begin    
+    def _lookup_idx(pos)
+      low=0;high=@start_pos.size-1
+      while(high>low+1) 
+        mid=(low+high)/2
+        this_pos,next_pos=*@start_pos[mid,2]
+        if pos<this_pos
+          high=mid # - 1 ??
+        elsif pos<next_pos
+          return mid
+        elsif pos==next_pos 
+          return mid+1
+        else
+          low=mid + 1
+        end
+      end
+      low
+    end
+=end
+    def _lookup_idx(pos)
+      pos==size and return @list.size-1
+      assert((0...size)===pos)
+      assert @start_pos.size==@list.size+1
+      low=0;high=@start_pos.size-1
+        assert @start_pos[low]<=pos
+        assert @start_pos[high]>pos
+      while(high>low+1)
+        assert @start_pos[low]<=pos
+        assert @start_pos[high]>pos
+        mid=(low+high)/2
+        case pos<=>@start_pos[mid]
+        when -1: high=mid
+        when  0: break low=mid
+        when  1: low=mid
+        end
+      end
+      assert @start_pos[low]<=pos
+      assert @start_pos[low+1]>pos 
+      low
+    end
+    
+    def readahead(len)
+      idx=_lookup_idx(pos)
+      result=@list[idx][pos-@start_pos[idx],len] || new_data
+      len-=result.size
+      assert len>=0 
+      i=nil
+      (idx+1).upto(@list.size-1){|i| 
+         break(result+=@list[i][0,len]) if len<@list[i].size          
+         result+=@list[i].all_data
+         len-=@list[i].size
+      }
+      result
+    end
+    
+    def read(len)
+      result=readahead(len)
+      move result.size
+      result
+    end
+    
+    def holding
+      oldpos,oldidx=@pos,@current_idx
+      begin
+        yield self
+      ensure
+        @pos,@current_idx=oldpos,oldidx
+      end
+    end
+
+    #like #holding, but position is reset only if block returns false or nil (or
+    #raises an exception).
+    def holding?
+      oldpos,oldidx=@pos,@current_idx
+      begin
+        result=yield self
+      ensure
+        (@pos,@current_idx=oldpos,oldidx) unless result
+      end
+    end
+
+    #like #holding, but block is instance_eval'd in the seq.
+    def holding! &block
+      oldpos,oldidx=@pos,@current_idx
+      begin
+        instance_eval self, &block
+      ensure
+        @pos,@current_idx=oldpos,oldidx
+      end
+    end
+
+    attr :pos
+    
+    def _pos=pos
+      @pos=pos
+      assert((0..size)===pos)
+      @current_idx= _lookup_idx(pos)
+    end
+    
+    def size
+      @start_pos.last
+    end
+    
+    def eof?
+      @pos>=size
+    end
+
+    def + other
+      return super unless ::Sequence===other
+      return List[*@list+[other]]
+    end
+    
+    def _fragment_discard_after(pos)
+      idx=_lookup_idx(pos)
+      pos-=@start_pos[idx]
+      @list[idx]=@list[idx].subseq(0...pos)
+      return idx
+    end
+    
+    def _fragment_discard_before(pos)
+      idx=_lookup_idx(pos)
+      pos-=@start_pos[idx]
+      @list[idx]=@list[idx].subseq(pos..-1)
+      return idx
+    end
+    
+
+    Overlaid =proc do
+      class<<self
+        def overlaid?; true end
+        def subseq(*)
+          result=super
+          result.instance_eval(& Overlaid)
+        end
+      end
+    end
+
+    def modify(*args)
+      result=repldata=args.pop
+            
+      repllen=repldata.size
+#      unless repldata.empty?
+        repldata=repldata.dup.to_sequence 
+
+      
+        #mark replacement data as overlaid
+        repldata.instance_eval(&Overlaid)
+#      end
+      replseqs=[repldata]
+
+      first,len,only1=_parse_slice_args(*args)
+      
+      f_idx=first.zero?? 0 : _lookup_idx(first-1) 
+      l_idx=_lookup_idx(first+len)
+
+      assert f_idx <= l_idx
+
+      fragrest_f=first-@start_pos[i=_lookup_idx(first)]
+      fragrest_l=first+len-@start_pos[l_idx]
+
+      #@list[i] can be nil here... maybe because i==@list.size?
+      assert fragrest_f < @list[i].size
+      assert fragrest_l <= @list[l_idx].size unless l_idx == @list.size and fragrest_l.zero?
+
+      #merge replacement data with adjacent seq(s) if also overlaid
+      if fragrest_f.nonzero?
+        replseqs.unshift( item=@list[i].subseq(0...fragrest_f) )
+        if item.respond_to? :overlaid?
+          repldata.prepend item.all_data
+          replseqs.shift
+        end
+      end
+         
+      if  fragrest_l.nonzero?
+        replseqs.push( item=@list[l_idx].subseq(fragrest_l..-1) )
+        if item.respond_to? :overlaid?
+          repldata.append item.all_data
+          replseqs.pop
+        end
+      end
+
+      
+      replseqs.delete_if{|cu| cu.empty? }
+
+      #now remove those elements in between and
+      #insert replacement data at the same point
+      assert f_idx >= 0
+      assert l_idx >= 0
+      assert f_idx < @list.size
+      assert l_idx <= @list.size
+      assert f_idx <= l_idx
+      @list[i...l_idx]=replseqs
+      #base=f_idx.zero?? 0 :  @start_idx[f_idx-1]
+      #@start_idx[f_idx...l_idx]=[base+repldata.size]
+      
+
+      
+      
+      #rebuild indeces after altered part
+      _rebuild_idxs(f_idx)
+      @pos=_adjust_pos_on_change(@pos, first,len,result.size)
+      @current_idx=_lookup_idx @pos
+
+      notify_change(self,first,len,repllen)
+      result
+    end
+    
+   
+    def append(data)
+        if @list.last.overlaid?
+          @list.last.append data
+          return self
+        end
+        data=data.dup.to_sequence
+        data.instance_eval(&Overlaid)
+        @list<<data
+        @start_pos<<@start_pos.last+data.size  
+        notify_change(self,@start_pos[-2], 0, data.size)
+        self
+    end
+    def prepend(data)
+        if @list.first.overlaid?
+          @list.first.prepend data
+          return self
+        end
+        data=data.dup.to_sequence
+        data.instance_eval(&Overlaid)
+        @list[0,0]=data
+
+        #insert data.size into beginning of @start_pos
+        sz=data.size
+        @start_pos=@start_pos.map{|n| n+sz} 
+        @start_pos[0,0]=0
+        
+        notify_change(self,0, 0, data.size)
+        self
+    end
+  end
+  
+#  class Indexed
+#    def subseq(*args)
+#      result=super
+#      result and respond_to? :overlaid? and def result.overlaid?; true end
+#      result
+#    end
+#  end
+end

data/lib/sequence/ofhash.rb

@@ -0,0 +1,38 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+require 'sequence'
+require 'sequence/indexed'
+
+class Sequence
+  class OfHash < OfArray
+    def initialize(hash,exceptions=[],include_default=false,modifiable=false)
+      @hash=hash
+      hash=hash.dup
+      exceptions.each{|exc| hash.delete exc }
+      @data=hash.inject([]){|l,pair| l+pair}
+      @data<<hash.default if include_default
+      @data.freeze unless modifiable
+    end  
+    
+    def modify(*args)
+      repldata=args.pop
+      start,len,only1=_parse_slice_args(*args)
+      len==1 or raise "scalar modifications to hashes only!"
+      if @data.size.%(2).nonzero? and @data.size.-(1)==start
+        @hash.default=repldata.first
+      elsif start.%(2).zero? #key 
+        @hash[repldata.first]=@hash.delete @data[start]
+      else #value
+        @hash[@data[start-1]]=repldata.first
+      end
+      @data[first]=repldata.first
+      repldata
+    end
+  end
+end
+
+class Hash
+  def to_sequence(include_default=false)
+    Sequence::OfHash.new(self,include_default)
+  end
+end

data/lib/sequence/ofobjectivars.rb

@@ -0,0 +1,29 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+require 'sequence'
+require 'sequence/indexed'
+
+
+class Sequence
+  class OfObjectIvars < OfArray
+    def initialize(obj,exceptions=[],modifiable=false)
+      @obj=obj
+      ivars=obj.instance_variables - exceptions
+      @data=ivars.inject([]){|l,name| l.push name,obj.instance_variable_get(name)}
+      @data.freeze unless modifiable
+    end
+    
+    def modify(*args)
+      repldata=args.pop
+      start,len,only1=_parse_slice_args(*args)
+      len==1 or raise "scalar modifications to objects only!"
+      assert start.%(2).nonzero? #not a name 
+      
+      @obj.instance_variable_set(@data[start-1],repldata.first)
+      @data[start]=repldata.first 
+      repldata
+      
+    end
+    
+  end
+end

data/lib/sequence/ofobjectmethods.rb

@@ -0,0 +1,87 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+require 'sequence'
+require 'sequence/indexed'
+reuqire 'sequence/functional'
+require 'set'
+
+
+class Sequence
+  class OfObjectMethods < OfArray
+    def initialize obj, exceptions=[], extras=[] #,modifiable=false
+      @obj=obj
+      methods=obj.public_methods.-(Functional.nonfunctions_of(obj)).-(exceptions)
+      methods.reject!{|name| /[!=]$/==name }
+      @data.concat extras.map{|x| Symbol===x ? x.to_s : x }
+      @data=methods.inject([]){|l,name| l+[name,nil]}
+      #@data.freeze unless modifiable      
+      
+      @is_exception=0
+      @is_reified=0
+    end
+    
+    def is_exception?(index) @is_exception&(1<<index/2) == 0 end    
+    def set_exception!(index) @is_exception|= 1<<index/2 end
+    
+    def is_reified?(index) @is_reified&(1<<index/2) == 0 end    
+    def set_reified!(index) @is_reified|= 1<<index/2 end
+ 
+    def modify(*args)
+      repldata=args.pop
+      start,len,only1=_parse_slice_args(*args)
+      len==1 or raise ArgumentError,"scalar modifications to objects only!"
+      start.%(2).nonzero? or raise ArgumentError, "OfObjectMethods#modify will not change method names!"
+      
+      if Array===@data[start-1]
+        if @data[start-1].first.to_s=='[]'
+          @obj.send(:[]=, @data[1..-1],repldata)
+        else raise ArgumentError, "trying to call settor with extra args"
+        end
+      else        
+      
+        @obj.send(@data[start-1]+"=",repldata.first)
+        @data[start]=repldata.first
+      end
+      repldata
+    end
+ 
+    def reify_from_index(i)
+        #if the call raises an exception, store the exception instead of the result 
+        #and remember (in @is_exception) that this particular result is an exception
+        if is_reified? i
+          raise @data[i+1] if is_exception? i
+          return 
+        end
+        set_reified! i
+          begin 
+            @data[i+1]=
+              if Array===@data[i]
+                @obj.send(*@data[i])
+              else
+                @obj.send(@data[i]) 
+              end
+          rescue Exception=>exc
+            set_exception!(i)
+            @data[i+1]=exc
+            raise
+          end    
+    end
+    
+    def reify(itemref)
+    
+      if itemref.is_a? String or itemref.is_a? Symbol
+        i=0
+        begin 
+          i=@data.index(itemref.to_s,i)  
+          i or @data.push itemref.to_s, nil
+        end while i and i%2!=0
+        reify_from_index(i)
+      elsif itemref.is_a? Integer and itemref>=0 and itemref%2==0
+        reify_from_index(itemref)
+      else
+        raise ArgumentError
+      end
+      return nil
+    end
+  end
+end

data/lib/sequence/position.rb

@@ -0,0 +1,100 @@
+# $Id$
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+
+require 'sequence'
+require 'sequence/usedata'
+
+class Sequence
+# Objects in this class are mainly used to simply mark/remember the location
+# of a parent sequence.  But, this class also has the fully functionality of the
+# parent.  When this child wants to do an operation, it uses the parent to
+# do it and returns the parent to where it was.
+class Position < UseData # :nodoc:
+    def initialize(parent,pos=parent.pos)
+        Position===parent and raise ArgumentError
+        @data = parent
+        @pos = _normalize_pos pos
+        extend parent.like
+        prop(nil,parent.prop)
+        @data.on_change_notify self
+    end
+    
+    def change_notification data,first,oldsize,newsize
+      assert @data==data 
+      @pos=_adjust_pos_on_change @pos,first,oldsize,newsize
+      
+      notify_change self,first,oldsize,newsize 
+    end
+    
+    
+    
+
+
+    def _pos=(p)
+            @pos = p
+    end
+    def position(pos=@pos)
+      @data.position(pos)
+    end
+
+#    undef_method(:_delete_position)
+
+    def_delegators :@data, :size, :data_class, :[], :[]=, :slice
+    def_delegators :@data, :new_data, :all_data, :pos?, :position?
+    def_delegators :@data, :begin, :end, :empty?, :index, :rindex, :slice!
+    def_delegators :@data, :modify, :append, :prepend, :overwrite
+    def_delegators :@data, :insert, :delete, :push, :pop, :shift, :unshift
+    
+    alias dup position
+
+   def nearbegin(len,at=pos)
+     @data.nearbegin(len,at)
+   end
+
+   def nearend(len,at=pos)
+     @data.nearend(len,at)
+   end
+
+    
+    
+    def eof?; @pos>=size end
+
+    attr_reader :data,:pos
+
+     
+    def closed?
+      super or @data.closed?
+    end
+    
+   def close
+        @data._delete_position(self)
+        super
+    end
+=begin ***
+    protected
+    def _deletion(pos,len=1,reverse=false,dummy=nil)
+        if @pos==pos
+            @anchor_after = false
+        elsif @pos>pos
+            @pos -= len
+            if @pos<pos
+                @pos = pos
+                @anchor_after = !reverse
+            elsif @pos==pos
+                @anchor_after = true
+            end
+        end
+        nil
+    end
+    def _insertion(pos,len=1,dummmy=nil)
+        if @pos>=pos+(@anchor_after ? 0 : 1)
+            @pos += len
+        end
+        nil
+    end
+=end
+end
+end
+
+