bitstream 0.0.2 → 0.1.0

data/README.en

@@ -65,6 +65,10 @@ gzip-viewer.rb: A viewer of the original file name of a gzip file.
     puts "The gzip does not contain its original file name."
   end
 
+== Documentation
+
+In preparation.
+
 == License
 
 This library is distributed under the dual license of the Ruby license (in the narrow sense) and the 2-clause BSD license. Please see http://www.ruby-lang.org and BSDL.

data/lib/bitstream.rb

@@ -1,22 +1,31 @@
 # Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
-# Copyright:: Copyright 2011 Natsuki Kawai
+# Copyright:: Copyright (c) 2011, 2012 Natsuki Kawai
 # License:: 2-clause BSDL or Ruby's
 
 require 'random-accessible'
+require 'lazy-string'
 
 require 'types/integer'
 require 'types/string'
 require 'types/cstring'
 require 'types/character'
 
+require 'bitstream/utils'
+
 module BitStream
 
   class BitStreamError < Exception
   end
 
   Properties = Struct.new(
-    :curr_offset, :fields, :mode, :raw_data,
-    :initial_offset, :user_props, :eval_queue
+    :curr_offset,
+    :fields,
+    :mode,
+    :raw_data,
+    :initial_offset,
+    :user_props,
+    :eval_queue,
+    :substreams
   )
 
   class ArrayProxy
@@ -43,9 +52,6 @@ module BitStream
     def read_access(pos)
       unless @updated[pos]
         field = @fields[pos]
-        unless field.has_read?
-          BitStream.read_one_field(field, @instance)
-        end
         @values[pos] = field.value
         @fields[pos] = nil
         @updated[pos] = true
@@ -78,6 +84,8 @@ module BitStream
 
     alias :enq :push
     alias :deq :shift
+    alias :peek_front :first
+    alias :peek_back :last
 
   end
 
@@ -104,59 +112,69 @@ module BitStream
     #end
   end
 
-  module Utils
+  class SubStreamPacket
 
-    def self.class2symbol(type)
-      name = type.name.split("::").last
-      name = self.camel2snake(name).intern
+    def self.instance(length)
+      new length
+    end
+
+    def initialize(length)
+      if length % 8 != 0
+        raise NotImplementedError, "non-aligned substream has not been supported."
+      end
+      @length = length
     end
 
-    def self.camel2snake(camel)
-      snake = camel.dup
-      snake[0] = snake[0].downcase
-      snake.gsub(/[A-Z]/) do |s|
-        "_" + s.downcase
+    attr_reader :length
+
+    def read(s, offset)
+      if offset % 8 != 0
+        raise NotImplementedError, "non-aligned substream has not been supported."
       end
+      return [LazyString.new(s, offset / 8, @length / 8), @length]
     end
 
   end
 
-  def self.read_one_field(value, instance)
-    props = instance.bitstream_properties
-    queue = props.eval_queue
+  class ReaderArray
 
-    while value.offset.nil?
-      field = queue.deq
-      field.offset = props.curr_offset
-      length = field.length
-      length = field.decide_length if length.nil?
-      props.curr_offset += length
+    def initialize
+      @array = []
+      @read  = []
     end
-    value.read
-  end
-  
-  def self.index_all_fields(instance)
-    props = instance.bitstream_properties
-    queue = props.eval_queue
-    
-    queue.each do |field|
-      field.offset = props.curr_offset
-      length = field.length
-      length = field.decide_length if length.nil?
-      props.curr_offset += length
+
+    def [](pos)
+      unless @read[pos]
+        @read[pos] = true
+        reader = @array[pos]
+        if reader.value.nil?
+          reader.read
+        end
+        @array[pos] = reader.value
+      end
+      return @array[pos]
     end
-    queue.clear
+
+    def <<(reader)
+      @array << reader
+    end
+
   end
-  
-  class Value
+
+  class FieldReader
     
-    def initialize(type, raw_data)
+    def initialize(type, instance)
       @type = type
-      @raw_data = raw_data
+      @instance = instance
       @length = @type.length if @type.respond_to? :length
       @has_read = false
     end
 
+    def props
+      @instance.bitstream_properties
+    end
+    private :props
+    
     def has_read?
       @has_read
     end
@@ -164,29 +182,40 @@ module BitStream
     def read
       unless @has_read
         if @offset.nil?
-          raise "Has not been set offset."
-        else
-          @value, @length = @type.read(@raw_data, @offset)
-          @has_read = true
+          index
         end
+        @value, @length = @type.read(props.raw_data, @offset)
+        @has_read = true
       end
       return @value
     end
+    
+    alias :value :read
 
-    def decide_length
+    def length
       # @length must not be nil if @has_read.
       if @length.nil?
         if @offset.nil?
-          raise "Has not been set offset."
+          index
         else
-          @value, @length = @type.read(@raw_data, @offset)
+          @value, @length = @type.read(props.raw_data, @offset)
           @has_read = true
         end
       end
       return @length
     end
 
-    attr_reader :length, :value
+    def index
+      queue = props.eval_queue
+  
+      while @offset.nil?
+        field = queue.deq
+        field.offset = props.curr_offset
+        length = field.length
+        props.curr_offset += length
+      end
+    end
+
     attr_accessor :offset
 
   end
@@ -198,10 +227,33 @@ module BitStream
       @fields = {}
       @types = types.dup
       @index = 0
+      @singleton_props = {}
       @class_props = {}
+      @class_props_chain = [@class_props]
       @bitstream_mutex = Mutex.new
     end
 
+    # Currently BitStream does not support inheritance.
+    if false
+      def on_inherit(types, chain, fields, mutex)
+        @field_defs = []
+        @fields = fields
+        @types = types
+        @index = 0
+        @class_props = {}
+        @class_props_chain = [@class_props]
+        @class_props_chain.concat(chain)
+        @bitstream_mutex = mutex
+      end
+      
+      def inherited(subclass)
+        subclass.on_inherit(@types, @class_props_chain, @fields, @bitstream_mutex)
+        def subclass.fields
+          raise NameError, "Cannot define fields on a subclass of a class includes BitStream."
+        end
+      end
+    end
+
     def fields(&field_def)
       @field_defs << field_def
     end
@@ -209,7 +261,14 @@ module BitStream
     def initialize_instance(raw_data, instance)
       props = instance.bitstream_properties
       props.mode = :field_def
-      props.user_props.merge!(@class_props)
+      
+      user_props = props.user_props
+      
+      @class_props_chain.each do |class_props|
+        user_props.merge!(class_props)
+      end
+      user_props[:nest_chain] = user_props[:nest_chain] + [instance]
+      
       @bitstream_mutex.synchronize do
         @instance = instance
 
@@ -217,9 +276,16 @@ module BitStream
           field_def.call
         end
       end
+      substream_types = @singleton_props[:substream_types]
+      substreams = props.substreams
+      unless substream_types.nil?
+        substreams.keys.each do |id|
+          # TODO: Support multi type substreams.
+          substreams[id] = substream_types[0].instance.read(substreams[id])
+        end
+      end
     end
 
-
     def self.types
       @types
     end
@@ -254,6 +320,10 @@ module BitStream
       @class_props[:byte_order] = order.intern
     end
 
+    def substream_types(*types)
+      @singleton_props[:substream_types] = types
+    end
+
     def self.add_type(type, name = nil, bs = self)
       bs.instance_eval do
         define_method(name) do |*args|
@@ -274,18 +344,13 @@ module BitStream
             else
               type_instance = type.instance(user_props, *args)
             end
-            field = Value.new(type_instance, props.raw_data)
+            field = FieldReader.new(type_instance, @instance)
             queue.enq(field)
-            @instance.bitstream_properties.fields[name] = field
 
             name_in_method = name
 
             @instance.singleton_class.instance_eval do
               define_method name do
-                field = bitstream_properties.fields[name_in_method]
-                if field.value.nil?
-                  BitStream.read_one_field(field, self)
-                end
                 field.value
               end
             end
@@ -325,10 +390,21 @@ module BitStream
       case props.mode
       when :field_def
         field = ArrayProxy.new(@instance)
-        size.times do
-          field_element = Value.new(type_instance, props.raw_data)
-          field.add_field(field_element)
-          queue.enq(field_element)
+        if size.respond_to?(:to_int) && size >= 0
+          size.times do
+            field_element = FieldReader.new(type_instance, @instance)
+            field.add_field(field_element)
+            queue.enq(field_element)
+          end
+        else
+          queue.peek_back.index unless queue.empty?
+          while props.curr_offset < props.raw_data.bytesize * 8
+            field_element = FieldReader.new(type_instance, @instance)
+            field.add_field(field_element)
+            queue.enq(field_element)
+            field_element.index
+            #puts "curr_offset:#{props.curr_offset} bytesize:#{props.raw_data.bytesize}"
+          end
         end
 
         @instance.singleton_class.instance_eval do
@@ -374,7 +450,7 @@ module BitStream
         if fields[name].nil?
           fields[name] = ArrayProxy.new(@instance)
         end
-        field = Value.new(type_instance, props.raw_data)
+        field = FieldReader.new(type_instance, @instance)
         fields[name].add_field(field)
         queue.enq(field)
 
@@ -394,6 +470,34 @@ module BitStream
         end
       end
     end
+    
+    def substream(name, id, length)
+      name = name.intern
+      props = @instance.bitstream_properties
+      user_props = props.user_props
+      raw_data = props.raw_data
+      queue = props.eval_queue
+      top_stream = @instance.bitstream_properties.user_props[:nest_chain].first
+      substreams = top_stream.bitstream_properties.substreams
+      
+      case props.mode
+      when :field_def
+        type_instance = SubStreamPacket.instance(length)
+        field = FieldReader.new(type_instance, @instance)
+        queue.enq(field)
+        field.read
+        
+        substreams[id] << LazyString.new if substreams[id].empty?
+        substreams[id].last << field.value
+      end
+    end
+
+    def separate_substream(id)
+      # TODO: Refactor here.
+      top_stream = @instance.bitstream_properties.user_props[:nest_chain].first
+      substreams = top_stream.bitstream_properties.substreams
+      substreams[id] << LazyString.new
+    end
 
     def add_type(type, name = nil)
       if name.nil?
@@ -412,17 +516,29 @@ module BitStream
     end
 
     def create_with_offset(s, offset, props = {})
+      props[:nest_chain] = [] unless props.include?(:nest_chain)
       klass = Class.new(self)
-      instance = klass.new(s, offset)
+      instance = klass.new
+      instance.initialize_properties(s, offset)
       instance.bitstream_properties.user_props = props
       initialize_instance(s, instance)
+      instance.initialize_with_fields
       return instance
     end
 
-    #def method_missing(name, *args)
-      # TODO: Support methods like "int16" "uint1"
-    #  super name, args
-    #end
+    def method_missing(name, *args)
+      name_s = name.to_s
+      field_name = args.shift
+      if name_s =~ /^uint(\d+)$/
+        bit_width = Regexp.last_match[1].to_i
+        unsigned field_name, bit_width, *args
+      elsif name_s =~ /^int(\d+)$/
+        bit_width = Regexp.last_match[1].to_i
+        signed field_name, bit_width, *args
+      else
+        super name, args
+      end
+    end
 
     def instance(inherited_props, user_props = {})
       NestWrapper.new(self, inherited_props, user_props)
@@ -435,22 +551,35 @@ module BitStream
     obj.initialize_for_class_methods(ClassMethods.types)
   end
 
-  def initialize(s, offset = 0)
+  def initialize_with_fields
+    # Nothing to do.
+    # Override me if you want to do anything after all fields has been defined.
+  end
+
+  def initialize_properties(s, offset = 0)
     props = Properties.new
     props.curr_offset = offset
     props.fields = {}
     props.raw_data = s
     props.initial_offset = offset
     props.eval_queue = Queue.new
+    props.substreams = Hash.new do |hash, key|
+      hash[key] = []
+    end
     @bitstream_properties = props
   end
 
   def length
-    BitStream.index_all_fields(self)
     props = @bitstream_properties
+    queue = props.eval_queue
+    queue.peek_back.index unless queue.empty?
     props.curr_offset - props.initial_offset
   end
 
+  def substreams
+    @bitstream_properties.substreams.values
+  end
+
   #def properties=(props)
     # Method to override.
   #end

data/lib/lazy-string.rb

@@ -0,0 +1,117 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright (c) 2012 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+class LazyString
+
+  # TODO: change name of SubString.
+  SubString = Struct.new(:start, :value)
+
+  class LazySubString
+
+    def initialize(value, start, size)
+      @start = start
+      @size = size
+      @value = value
+    end
+
+    def [](*args)
+      if args.size == 2
+        start = args[0]
+        length = args[1]
+        return @value[@start + start, length]
+      else
+        raise NotImplementedError
+      end
+    end
+    
+    def to_str
+      @value[@start, @size].to_str
+    end
+    alias :to_s :to_str
+
+    attr_reader :size
+    alias :length :size
+
+  end
+
+  def initialize(*args)
+    @size = 0
+    @chain = []
+
+    if args.size == 3
+      @chain << SubString.new(0, LazySubString.new(*args))
+      @size = args[2]
+    end
+  end
+
+  # TODO: Add 'add' method to add a substring of a String.
+  def <<(other)
+    if other.respond_to?(:to_int)
+      return self << ('' << other)
+    end
+    
+    @chain << SubString.new(@size, other)
+    @size += other.size
+  end
+
+  def [](*args)
+    if args.size == 2
+      start = args[0]
+      last  = start + args[1]
+      length = args[1]
+      e = @chain.each
+      
+      curr = nil
+      begin
+        curr = e.next
+      end while curr.start + curr.value.size < start
+      
+      value = curr.value
+      sub_start = start - curr.start
+      sub_length = value.size - sub_start
+      if sub_length >= length
+        return LazyString.new(value, sub_start, length)
+      else
+        res = LazyString.new(value, sub_start, sub_length)
+        length -= sub_length
+        while length > 0
+          curr = e.next
+          if length < curr.value.length
+            res << LazyString.new(curr.value, 0, length)
+            length = 0
+          else
+            res << curr.value
+            length -= curr.value.length
+          end
+        end
+        return res
+      end
+    elsif args.respond_to?(:to_int)
+      warn "#{self.class.name}#[pos] has not implemented yet. Calling #{self.class.name}#to_str."
+      to_str[*args]
+    else # args is one Range object.
+      warn "#{self.class.name}#[range] has not implemented yet. Calling #{self.class.name}#to_str."
+      to_str[*args]
+    end
+  end
+  
+  def unpack(template)
+    # TODO: Optimize here.
+    # (Stop concat the front strings if template start with "x".)
+    to_str.unpack(template)
+  end
+    
+  def to_str
+    res = ''
+    @chain.each do |substr|
+      res << substr.value
+    end
+    return res
+  end
+  alias :to_s :to_str
+  
+  attr_reader :size
+  alias :length :size
+
+end

data/test/test-array.rb

@@ -1,5 +1,5 @@
 # Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
-# Copyright:: Copyright 2011 Natsuki Kawai
+# Copyright:: Copyright (c) 2011, 2012 Natsuki Kawai
 # License:: 2-clause BSDL or Ruby's
 
 
@@ -16,18 +16,60 @@ class ArraySample
 
 end
 
+class InfiniteArraySample
+
+  include BitStream
+
+  fields do
+    array :a1, nil, :unsigned_int, 16
+  end
+
+end
+
+class VarlenArraySample
+
+  include BitStream
+
+  fields do
+    array :a1, nil, :cstring
+  end
+
+end
+
 class TestArray < Test::Unit::TestCase
 
   def setup
     @spec = ArraySample.create "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a"
+    @spec_inf = InfiniteArraySample.create "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a"
+    @spec_var = VarlenArraySample.create "foo\0quux\0baz\0"
   end
 
   def test_a1
+    assert_equal(5, @spec.a1.size)
     assert_equal(0x0102, @spec.a1[0])
     assert_equal(0x0304, @spec.a1[1])
     assert_equal(0x0506, @spec.a1[2])
     assert_equal(0x0708, @spec.a1[3])
     assert_equal(0x090a, @spec.a1[4])
+    assert_equal(nil, @spec.a1[5])
+  end
+
+  def test_infinite
+    assert_equal(5, @spec_inf.a1.size)
+    assert_equal(0x0102, @spec_inf.a1[0])
+    assert_equal(0x0304, @spec_inf.a1[1])
+    assert_equal(0x0506, @spec_inf.a1[2])
+    assert_equal(0x0708, @spec_inf.a1[3])
+    assert_equal(0x090a, @spec_inf.a1[4])
+    assert_equal(nil, @spec_inf.a1[5])
+  end
+
+  def test_varlen
+    assert_equal(3, @spec_var.a1.size)
+    assert_equal("foo", @spec_var.a1[0])
+    assert_equal("quux", @spec_var.a1[1])
+    assert_equal("baz", @spec_var.a1[2])
+    assert_equal(nil, @spec_var.a1[3])
   end
 
 end

data/test/test-lazy-string.rb

@@ -0,0 +1,36 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright (c) 2012 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+require 'test/unit'
+require 'lazy-string'
+
+class TestLazyString < Test::Unit::TestCase
+
+  def setup
+    @sample = LazyString.new
+    @sample << "foo"
+    @sample << "bar"
+    @sample << "quux"
+    @sample << "baz"
+  end
+
+  def test_head
+    assert_equal("fo", @sample[0, 2].to_str)
+    assert_equal("foo", @sample[0, 3].to_str)
+    assert_equal("foob", @sample[0, 4].to_str)
+  end
+
+  def test_im
+    assert_equal("a", @sample[4, 1].to_str)
+    assert_equal("bar", @sample[3, 3].to_str)
+    assert_equal("obarq", @sample[2, 5].to_str)
+  end
+
+  def test_last
+    assert_equal("az", @sample[11, 2].to_str)
+    assert_equal("baz", @sample[10, 3].to_str)
+    assert_equal("xbaz", @sample[9, 4].to_str)
+  end
+
+end

data/test/test-overload.rb

@@ -0,0 +1,69 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright (c) 2012 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+require 'test/unit'
+require 'bitstream'
+
+class OverloadSample1
+
+  include BitStream
+
+  fields do
+    unsigned :a, 32
+    unsigned :a, 32
+  end
+
+end
+
+class OverloadSample2
+
+  include BitStream
+
+  fields do
+    unsigned :a, 8
+    if a == 1
+      cstring :a
+    else
+      string :a, 1
+    end
+  end
+
+end
+
+class OverloadSampleArray
+
+  include BitStream
+
+  fields do
+    array :a, 3, :unsigned, 8
+    unsigned :a, 16
+    unsigned :b, 16
+    array :b, 2, :unsigned, 8
+  end
+
+end
+
+class TestOverload < Test::Unit::TestCase
+
+  def setup
+    @spec1 = OverloadSample1.create "\x00\x00\x00\x01\x00\x00\x00\x02"
+    @spec2 = OverloadSample2.create "\x01foo\0"
+    @spec_array = OverloadSampleArray.create "abc\x01\x01\x02\x02\x03\x03"
+  end
+
+  def test_a1
+    assert_equal(2, @spec1.a)
+  end
+
+  def test_a2
+    assert_equal("foo", @spec2.a)
+  end
+
+  def test_array
+    assert_equal(0x0101, @spec_array.a)
+    assert_equal([3, 3], @spec_array.b)
+  end
+
+end
+

data/test/test-primitives.rb

@@ -13,12 +13,12 @@ class SimpleIntBe
   byte_order :big_endian
 
   fields {
-    unsigned_int "u1", 32
-    unsigned_int :u2, 32
-    cstring      "cs1"
-    unsigned_int "u3", 1
-    unsigned_int "u4", 7
-    string       :s1, 3
+    unsigned "u1", 32
+    uint32   :u2
+    cstring  "cs1"
+    unsigned "u3", 1
+    uint7    "u4"
+    string   :s1, 3
   }
 
 end

data/test/test-suite.rb

@@ -1,5 +1,5 @@
 # Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
-# Copyright:: Copyright 2011 Natsuki Kawai
+# Copyright:: Copyright (c) 2011, 2012 Natsuki Kawai
 # License:: 2-clause BSDL or Ruby's
 
 
@@ -7,6 +7,7 @@ require 'test/test-primitives'
 require 'test/test-array'
 require 'test/test-dynarray'
 require 'test/test-nesting'
+require 'test/test-overload'
 require 'test/test-simple-properties'
 require 'test/types/test-character'
 require 'test/types/test-integer'

metadata

@@ -1,89 +1,107 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: bitstream
-version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
-authors:
+authors: 
 - Natsuki Kawai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-02-12 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: random-accessible
-  requirement: &71448960 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
         version: 0.2.0
   type: :runtime
-  prerelease: false
-  version_requirements: *71448960
-description: ! 'BitStream is a mixin to write data structures of bit streams such
-  as picture, music, movie files, and e.t.c.. You can refer contents of bit streams
-  even when you are defining the data structures. With the function, you can write
-  a data structure easily that the header contains the data length of the body field.
+  version_requirements: *id001
+description: |
+  BitStream is a mixin to write data structures of bit streams such as picture, music, movie files, and e.t.c.. You can refer contents of bit streams even when you are defining the data structures. With the function, you can write a data structure easily that the header contains the data length of the body field.
 
-'
 email: natsuki.kawai@gmail.com
 executables: []
+
 extensions: []
-extra_rdoc_files:
+
+extra_rdoc_files: 
 - README.en
-files:
+files: 
 - lib/bitstream.rb
+- lib/lazy-string.rb
 - lib/types/string.rb
-- lib/types/utils.rb
-- lib/types/character.rb
+- lib/types/cstring.rb
 - lib/types/string-utils.rb
+- lib/types/character.rb
 - lib/types/integer.rb
-- lib/types/cstring.rb
-- lib/types/basetype.rb
+- test/test-overload.rb
 - test/test-nesting.rb
 - test/test-dynarray.rb
-- test/test-condition.rb
-- test/test-simple-properties.rb
 - test/test-suite.rb
-- test/test-array.rb
 - test/test-primitives.rb
-- test/types/test-utils.rb
-- test/types/test-character.rb
-- test/types/test-cstring.rb
+- test/test-simple-properties.rb
+- test/test-condition.rb
+- test/test-lazy-string.rb
+- test/test-array.rb
 - test/types/test-string.rb
 - test/types/test-integer.rb
-- sample/gzip.rb
+- test/types/test-character.rb
+- test/types/test-cstring.rb
 - sample/flac.rb
+- sample/gzip.rb
 - sample/gzip-viewer.rb
-- sample/front.rb
+- sample/flac-front.rb
 - README.en
+has_rdoc: true
 homepage: https://github.com/natsuki14/bitstream
-licenses:
+licenses: 
 - Ruby's
 - 2-clause BSDL
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      - 1
       version: 1.9.1
-required_rubygems_version: !ruby/object:Gem::Requirement
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A bitstream parser supports dynamic-defined fields
-test_files:
+test_files: 
 - test/test-suite.rb

data/lib/types/basetype.rb

@@ -1,9 +0,0 @@
-module BitStream
-
-  module SingleType
-    def instance
-      
-    end
-  end
-
-end

data/lib/types/utils.rb

@@ -1,26 +0,0 @@
-module BitStream
-
-  module Utils
-
-    def self.align(s, offset, length)
-      index = offset
-      bitoffset = offset % 8
-      aligned = nil
-      if bitoffset != 0
-        aligned = ""
-        while index < offset + length
-          i = index / 8
-          c = s[i..(i + 1)].unpack('n')[0] >> (8 - bitoffset)
-          aligned << [c].pack('C')
-          index += 8
-        end
-      else
-        aligned = s[(offset / 8)...((offset + length) / 8)]
-      end
-      return aligned
-    end
-
-  end
-
-end
-

data/test/types/test-utils.rb

@@ -1,36 +0,0 @@
-require 'test/unit'
-require 'types/utils'
-
-class TestUtils < Test::Unit::TestCase
-
-  def test_align_aligned_bytelen
-    source = "abcde"
-    aligned = BitStream::Utils.align(source, 8, 8 * 3)
-    assert_equal("bcd", aligned)
-  end
-
-  def test_align_aligned_bytelen_lastbyte
-    source = "abcde"
-    aligned = BitStream::Utils.align(source, 8 * 2, 8 * 3)
-    assert_equal("cde", aligned)
-  end
-
-  def test_align_aligned
-    source = "defghi"
-    aligned = BitStream::Utils.align(source, 8 * 2, 8 * 2 + 6)
-    assert_equal(3, aligned.size)
-    aligned = aligned.unpack("a2C")
-    assert_equal("fg", aligned[0])
-    assert_equal("h".ord & 0b11111100, aligned[1] & 0b11111100)
-  end
-
-  def test_align_aligned_lastbyte
-    source = "defghi"
-    aligned = BitStream::Utils.align(source, 8 * 3, 8 * 2 + 6)
-    assert_equal(3, aligned.size)
-    aligned = aligned.unpack("a2C")
-    assert_equal("gh", aligned[0])
-    assert_equal("i".ord & 0b11111100, aligned[1] & 0b11111100)
-  end
-
-end