xbd 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in xbd.gemspec
+gemspec

data/LICENSE.TXT

@@ -0,0 +1,25 @@
+XBD Ruby-Gem Copyright (c) 2012, Imikimi LLC
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL IMIKIMI LLC BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README.md

@@ -0,0 +1,20 @@
+## XBD
+
+The XBD gem allows you to create, load and save XBD files. XBD files are arbitrary, self-describing, hierarchical,
+binary data structures consisting of "tags", "attributes", and "sub-tags".
+
+## XBD vs XML
+
+Feature differences:
+
+* Any XML file can be converted to XBD, but the referse is not true.
+* XBD allows you to store aribrary binary strings in attributes.
+* XBD does not allow any data between sub-tags
+* XBD Tag and Attribute names can be arbitrary binary string.
+
+Additional benefits of XBD:
+
+* XBD uses dictionaries (hashes) to store all Tag-Name, Attribute-Name and Attribute-Values. Consequently: XBD files can be as small as 1/10th the size an equivelent XML file
+* XBD files are simple and streamlined for encoding/decoding. Consequently they can be as much as 10x faster to read and write.
+
+(NOTE: The 10x performance improvement was tested on the original pure-C++ implementation vs a fast, pure-C++ XML parser. Tests have not been made in this Ruby version.)

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+
+# Load custom tasks
+Dir['tasks/*.rake'].sort.each { |f| load f }

data/lib/xbd.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__),"xbd/version.rb")
+require File.join(File.dirname(__FILE__),"xbd/xbd.rb")

data/lib/xbd/asi.rb

@@ -0,0 +1,180 @@
+# encoding: BINARY
+$ruby_inline=true
+require "inline" if $ruby_inline
+require "stringio"
+
+module Xbd
+  #*********************************
+  # Xbd::Asi module
+  #*********************************
+  #
+  # Read and Generate ASI strings
+  class Asi
+
+    # read an ASI from a string, returning an integer
+    # optionally starts and the specified offset index.
+    #
+    # returns the number read and the first index after the ASI data in the string.
+    def Asi.read_asi(source,index=0)
+      ret=0
+      shift=0
+      val=0
+      while index<source.length
+        val=source.byte(index)
+        ret+= (val & 0x7F) << shift;
+        shift+=7
+        index+=1
+        break if val<128
+      end
+      return ret,index
+    end
+
+    def Asi.read_asi_string(source,index=0)
+      n,index=read_asi(source,index)
+      return source[index,n],index+n
+    end
+
+    def Asi.read_asi_from_file(file)
+      ret=0
+      shift=0
+      val=0
+      while val=file.readbyte
+        ret+= (val & 0x7F) << shift;
+        shift+=7
+        break if val<128
+      end
+      return ret
+    end
+
+    def Asi.asi_to_i(source)
+      Asi.read_asi(source,0)[0]
+    end
+
+    # this C function supports all values up to the maximum value of 2^64-1
+    # RubyInline autodetects if the number is too big and throws an
+    if $ruby_inline
+    inline do |compiler|
+      compiler.c <<-ENDC
+        VALUE i_to_asi_c(unsigned long num) {
+          char str[11]; // I think 10 is enough, but just to be safe
+          int p=0;
+          while(p==0 || num > 0) {
+            int byte = (int)(num & 0x7F);
+            num = num >> 7;
+            if (num > 0) byte = byte | 0x80;
+            str[p++]=byte;
+          }
+          return rb_str_new(str,p);
+        }
+      ENDC
+    end
+    else
+      def i_to_asi_c(num)
+        Asi.i_to_asi_ruby(num)
+      end
+    end
+
+    ASI_INSTANCE=Asi.new
+    def Asi.i_to_asi2(num)
+      ASI_INSTANCE.i_to_asi_c(num)
+    end
+
+    def Asi.i_to_asi_ruby(num)
+      ret=""
+      while ret.length==0 || num>0
+        val=num & 0x7F;
+        num=num>>7
+        val|=0x80 if num>0
+        ret<<val
+      end
+      ret
+    end
+    class <<self
+      alias :i_to_asi :i_to_asi_ruby
+    end
+
+    def Asi.asi_length(num)
+      count=1
+      while num>=0x80
+        num>>=7
+        count+=1
+      end
+      count
+    end
+
+  #*********************************
+  # Enable ASI reading and writing
+  # in standard objects.
+  #*********************************
+    module IO
+      def read_asi(index=0)
+        Asi.read_asi_from_file(self)
+      end
+
+      # read an asi and then read the next N bytes, where N is the asi value
+      # index's value is ignored
+      def read_asi_string(index=0)
+        read(Asi.read_asi_from_file(self))
+      end
+    end
+
+    module Fixnum
+      ASI_INSTANCE = Asi.new
+      def to_asi
+        ASI_INSTANCE.i_to_asi_c(self)
+      end
+      def asi_length
+        Xbd::Asi.asi_length(self)
+      end
+    end
+
+    module Bignum
+      def to_asi
+        Asi.i_to_asi(self)
+      end
+      def asi_length
+        Xbd::Asi.asi_length(self)
+      end
+    end
+
+    module String
+      def from_asi
+        Asi.asi_to_i(self)
+      end
+
+      def to_asi_string
+        self.length.to_asi+self
+      end
+
+      def read_asi(index=0)
+        Asi.read_asi(self,index)
+      end
+
+      def read_asi_string(index=0)
+        Asi.read_asi_string(self,index)
+      end
+
+      # Ruby 1.8 patch to ignore force_encoding
+      if !"".respond_to?(:force_encoding)
+        def to_binary; self end
+        def force_encoding(a) self end
+        def byte(index)
+          self[index]
+        end
+      else
+      # Ruby 1.9
+        def to_binary; self.force_encoding("BINARY") end
+        def byte(index)
+          char=self[index]
+          char && char.bytes.next
+        end
+      end
+    end
+  end
+end
+
+class Fixnum  ; include Xbd::Asi::Fixnum   ; end
+class File    ; include Xbd::Asi::IO       ; end
+class StringIO; include Xbd::Asi::IO       ; end
+class Bignum  ; include Xbd::Asi::Bignum   ; end
+class String  ; include Xbd::Asi::String   ; end

data/lib/xbd/version.rb

@@ -0,0 +1,3 @@
+module Xbd
+  VERSION = "0.1.0"
+end

data/lib/xbd/xbd.rb

@@ -0,0 +1,122 @@
+# encoding: BINARY
+#*****************************************************
+# Ruby XBD Library
+# (C) 2010-10-03 Shane Brinkman-Davis
+#
+# SRC home:
+#   URL: https://svn.imikimi.com/auto_branch/2008-10-30_15-54-25_iphone_edge/xbd/xbd.rb
+#   Repository Root: https://svn.imikimi.com
+#   Repository UUID: d1359c2d-ec2c-0410-b0bc-eca7d5e44040
+#   Revision: 11647
+#*****************************************************
+=begin
+
+This code read and writes XBD files.
+
+To get started:
+
+Take any XBD file
+  example Kimi from Imikimi.com (all Kimis are XBD containers)
+    http://imikimi.com/plugin/get_kimi/o-10i
+
+And run:
+  require "xbd.rb"
+  puts Xbd.load_from_file("your_xbd_filename.xbd")
+
+Master verison of this file lives in: imikimi_plugin_source/xbd/xbd.rb
+
+=end
+require File.join(File.dirname(__FILE__),"asi")
+require File.join(File.dirname(__FILE__),"xbd_dictionary")
+require File.join(File.dirname(__FILE__),"xbd_tag")
+
+#*********************************
+# Xbd Module
+#*********************************
+module Xbd
+
+  SBDXML_HEADER="SBDXML\1\0"
+
+  #**********************************************************
+  # XML escaping
+  #**********************************************************
+  # Used when converting TO xml (Xbd::Tag.to_s)
+  # Note, some of these codes are actually invalid strict XML because XML has no escape codes for some values.
+  #   SBD: WTF! (I'm still surprised by this, but it appears to be true.)
+  XML_ESCAPE_CODES={
+    "�"=>0,
+    ""=>1,
+    ""=>2,
+    ""=>3,
+    ""=>4,
+    ""=>5,
+    ""=>6,
+    ""=>7,
+    ""=>8,
+    "	"=>9,
+    "
"=>10,
+    ""=>11,
+    ""=>12,
+    "
"=>13,
+    ""=>14,
+    ""=>15,
+    ""=>16,
+    ""=>17,
+    ""=>18,
+    ""=>19,
+    ""=>20,
+    ""=>21,
+    ""=>22,
+    ""=>23,
+    ""=>24,
+    ""=>25,
+    ""=>26,
+    ""=>27,
+    ""=>28,
+    ""=>29,
+    ""=>30,
+    ""=>31,
+    """=>34,   #"
+    "&"=>38,    #&
+    "'"=>39,   #'
+    "&lt;"=>60,     #<
+    "&gt;"=>62      #>
+  }
+
+  @@escape_for_xml=[]
+  (0..255).each {|i| @@escape_for_xml<<i.chr}
+  XML_ESCAPE_CODES.each {|k,v| @@escape_for_xml[v]=k}
+
+  def self.xml_escape(s)
+    out=""
+    s.each_byte {|b| out<< @@escape_for_xml[b]}
+    out
+  end
+
+  # XBD.parse accepts:
+  #   a string or
+  #   any object that returns a string in response to the method "read"
+  #     (for example, an open file handle)
+  def Xbd.parse(source)
+    #treat source as a stream(file) if it isn't a string
+    source=source.read.force_encoding("BINARY") if source.class!=String
+
+    # read the header
+    raise "Not a valid XBD file" unless source[0..SBDXML_HEADER.length-1]==SBDXML_HEADER
+    index=SBDXML_HEADER.length
+
+    # read each of the 3 dictionaries in order
+    tagsd,index=Dictionary.parse(source,index)
+    attrsd,index=Dictionary.parse(source,index)
+    valuesd,index=Dictionary.parse(source,index)
+
+    # read all tags, return the root-tag
+    Tag.parse(source,index,tagsd,attrsd,valuesd)[0]
+  end
+
+  # Load XBD from filename
+  def Xbd.load_from_file(filename)
+    Xbd.parse(File.open(filename,"rb"))
+  end
+
+end

data/lib/xbd/xbd_dictionary.rb

@@ -0,0 +1,52 @@
+module Xbd
+  #*********************************
+  # Xbd::Dictionary
+  #*********************************
+  # Consists of:
+  #   @hash:  a map from values to IDs and IDs to values
+  #   @array: a list of values; their indexes == their IDs
+  #
+  class Dictionary
+    attr_reader :hash,:array
+
+    def initialize(initial_values=[])
+      @hash={}
+      @array=[]
+      initial_values.each {|v| self<<(v)}
+    end
+
+    # return String given an ID, or ID given a String
+    def [](i) @hash[i] end
+
+    def Dictionary.sanitize_string(str)
+      case str
+      when String then  "#{str}".force_encoding("BINARY")
+      else              str.to_s.force_encoding("BINARY")
+      end
+    end
+
+    # add a String to the dictionary
+    def <<(str)
+      str = Dictionary.sanitize_string str
+      @hash[str] ||= begin
+        new_id = @array.length
+        @array << @hash[new_id] = str
+        new_id
+      end
+    end
+
+    # convert to binary string
+    def to_binary
+      [@array.length.to_asi, @array.collect{|v| v.length.to_asi}, @array].join.to_asi_string
+    end
+
+    def Dictionary.parse(source,index=0)
+      encoded_dictionary, index = source.read_asi_string index
+      encoded_dictionary = StringIO.new(encoded_dictionary)
+      num_entries = encoded_dictionary.read_asi
+      lengths = num_entries.times.collect {encoded_dictionary.read_asi}
+      strings = lengths.collect {|len| encoded_dictionary.read len}
+      [Dictionary.new(strings), index]
+    end
+  end
+end

data/lib/xbd/xbd_tag.rb

@@ -0,0 +1,187 @@
+module Xbd
+  #*********************************
+  # Xbd::Tag object
+  #*********************************
+  #
+  # Consists of:
+  #   name:     a string
+  #   attrs:    a Hash of Attributes, String -> String
+  #   tags:     an ordered Array of Tag objects
+  class Tag
+
+    def initialize(name,attrs=nil,tags=nil,&block)
+      @name=name.to_s
+      @attrs={}
+      attrs.each {|k,v|@attrs[k.to_s]=v.to_s} if attrs
+      @tags=[]
+      self<<tags if tags
+      yield self if block
+    end
+    #************************************************************
+    # Access Name
+    #************************************************************
+    def name() @name end
+    def name=(n) @name=n end
+
+    #************************************************************
+    # Access Attrs
+    #************************************************************
+    attr_reader :attrs
+    def [](attr) @attrs[attr.to_s] end
+    def []=(attr,val) val==nil ? @attrs.delete(attr.to_s) : @attrs[attr.to_s]=val.to_s end
+
+    #************************************************************
+    # Access Tags
+    #************************************************************
+    # return tags array
+    attr_reader :tags
+    def tagnames() @tags.collect {|t| t.name} end
+
+    # returns first tag that matches name
+    # names can be a "/" delimited path string
+    # OR an array of exact string values to match (in case you want to match "/" in a tag name)
+    def tag(names)
+      return self if !names || (names.kind_of?(Array) && names.length==0)
+      names=names.split("/") unless names.kind_of?(Array)
+      name=names[0]
+      tags.each do |tag|
+        return tag.tag(names[1..-1]) if tag.name==name
+      end
+      return nil
+    end
+
+    def each_attribute
+      @attrs.each {|k,v| yield k,v}
+    end
+
+    # iterate over all tags or only with matching names
+    def each_tag(name=nil)
+      tags.each do |tag|
+        yield tag if !name || tag.name==name
+      end
+    end
+
+    # Add sub-tag or array of sub-tags
+    def <<(tag)
+      return unless tag # ignore nil
+      tags= tag.kind_of?(Array) ? tag : [tag]
+      tags.each {|t| raise "All sub-tags in must be #{self.class} objects. Attempted to add #{t.class} object." unless t.kind_of?(self.class)}
+      @tags+=tags
+      tag
+    end
+
+    def ==(tag)
+      name==tag.name &&
+      attrs==tag.attrs &&
+      tags==tag.tags
+    end
+
+    #************************************************************
+    # to XML (to_s)
+    #************************************************************
+    def to_s(indent="",max_attr_value_length=nil)
+      a=[name]
+      attrs.keys.sort.each do |k|
+        v=attrs[k]
+        v=v[0..max_attr_value_length-1] if max_attr_value_length
+        a<<"#{k}=\"#{Xbd.xml_escape(v)}\""
+      end
+      ret="#{indent}<#{a.join(' ')}"
+      if tags.length>0
+        ret+=">\n"
+        tags.each {|st| ret+=st.to_s(indent+"    ",max_attr_value_length)}
+        ret+="#{indent}</#{name}>\n"
+      else
+        ret+="/>\n"
+      end
+    end
+    alias :to_xml :to_s
+
+    def inspect
+      to_s("",32)
+    end
+
+    # convert to basic ruby data structure
+    def to_ruby
+      {:name=>name, :attrs=>@attrs.clone, :tags=>tags.collect {|tag|tag.to_ruby}}
+    end
+
+    #************************************************************
+    # to binary XBD support methods
+    #************************************************************
+    def populate_dictionaries(tagsd,attrsd,valuesd)
+      tagsd<<name                                                       # add this tag's name
+      attrs.each {|k,v| attrsd<<k; valuesd<<v}                           # add all attribute names and values
+      tags.each {|tag| tag.populate_dictionaries(tagsd,attrsd,valuesd)} # recurse on sub-tags
+    end
+
+    # encode just this tag in binary
+    # Note this returned value alone is not parsable
+    def to_binary_partial(tagsd,attrsd,valuesd)
+      # build attrs_data string: all attr name-value pairs as ASIs concatinated
+      attrs_data=attrs.keys.sort.collect {|key| attrsd[key].to_asi + valuesd[attrs[key]].to_asi}.join
+
+      data=tagsd[name].to_asi +                                         # name asi
+        attrs_data.length.to_asi + attrs_data +                         # attrs length asi and attrs
+        tags.collect {|tag| tag.to_binary_partial(tagsd,attrsd,valuesd)}.join   # sub-tags
+      data.to_asi_string                                                # tag data pre-pended with tag-data length asi
+    end
+
+    #************************************************************
+    # to binary XBD (to_xbd)
+    #************************************************************
+    # use this to convert an xbd tag structure into a saveable xbd file-string
+    def to_binary
+      populate_dictionaries(tagsd=Dictionary.new, attrsd=Dictionary.new, valuesd=Dictionary.new)
+      Xbd::SBDXML_HEADER + tagsd.to_binary + attrsd.to_binary + valuesd.to_binary + to_binary_partial(tagsd,attrsd,valuesd)
+    end
+
+    #**********************************************************
+    # Load XBD Tag Data from String
+    #**********************************************************
+    # parse a Tag, all its Attributes and all its Sub-tags recursively.
+    #
+    # inputs:
+    #   source - source binary string
+    #   index - offset to start reading at
+    #   tagsd - tag-names dictionary
+    #   attrsd - attribute-names dictionary
+    #   valuesd - attribute-values dictionary
+    # returns the Tag object generated AND the first "index" in the string after read tag-data
+    def Tag.parse(source,index,tagsd,attrsd,valuesd)
+      tag_length,index=Asi.read_asi(source,index)
+      tag_start_index=index
+
+      # read tag name
+      tag_name_id,index=Asi.read_asi(source,index)
+      tag_name=tagsd[tag_name_id]
+      raise "tag name id(#{tag_name_id}) not in tag-names dictionary" if !tag_name
+
+      # read attributes
+      attr_byte_size,index=Asi.read_asi(source,index)
+      attrs_hash={}
+      while attr_byte_size>0
+        i=index
+        name_id,index=Asi.read_asi(source,index)
+        value_id,index=Asi.read_asi(source,index)
+        attr_byte_size-=(index-i)
+        n=attrsd[name_id]
+        v=valuesd[value_id]
+        raise "attribute name id(#{name_id}) not in attribute-names dictionary" if !n
+        raise "attribute value id(#{value_id}) not in attribue-values dictionary" if !v
+        attrs_hash[n]=v
+      end
+      tag_length-=(index-tag_start_index)
+
+      # read sub-tags
+      tags=[]
+      while tag_length>0
+        i=index
+        node,index=Tag.parse(source,index,tagsd,attrsd,valuesd)
+        tags<<node
+        tag_length-=(index-i)
+      end
+      return Tag.new(tag_name,attrs_hash,tags),index
+    end
+  end
+end

data/spec/xbd_asi_spec.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__),"xbd_test_helper")
+
+module Xbd
+describe Asi do
+
+  def test_asi(n)
+    asi1=n.to_asi
+    asi2=Asi::ASI_INSTANCE.i_to_asi_c(n)
+    raise "(asi1=n.to_asi)!=asi2 (#{asi1.inspect}!=#{asi2.inspect}) n=#{n} asi1.encoding=#{asi1.encoding} asi2.encoding=#{asi2.encoding}" unless asi1==asi2
+    asi1.read_asi[0].should == n
+  end
+
+  it "should be possible to convert all powers of two up to 2^64-1" do
+    v=0
+    65.times do
+      n=2**v-1
+      test_asi(n)
+      v+=1
+    end
+  end
+
+  if $ruby_inline
+  it "should fail to convert 2^64 to an asi" do
+    lambda {test_asi(2**64)}.should raise_error(RangeError)
+  end
+  end
+
+  it "Fixnum > String > Fixnum" do
+    test_edges do |num|
+      num.to_asi.from_asi.should==num
+    end
+  end
+
+  it "to_asi_string and StringIO" do
+    test_string="foo"
+    asi_foo=test_string.to_asi_string
+    StringIO.new(asi_foo).read_asi_string.should==test_string
+  end
+
+  it "to_asi and StringIO" do
+    test_edges do |num|
+      asi=num.to_asi
+      StringIO.new(asi).read_asi.should==num
+    end
+  end
+
+  it "to_asi_string and String" do
+    test_string="foo"
+    asi_foo=test_string.to_asi_string
+    asi_foo.read_asi_string.should== [test_string,asi_foo.length]
+  end
+
+  it "asi_length" do
+    test_edges do |n,c|
+      n.asi_length.should==c
+    end
+  end
+
+  def test_edges
+    yield 0,1
+
+    (1..10).each do |c|
+      n=(1<<(7*c))
+      n_1=n-1
+      yield n_1,c
+      yield n,c+1
+    end
+  end
+end
+end

data/spec/xbd_dictionary_spec.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__),"xbd_test_helper")
+
+module Xbd
+describe Dictionary do
+  it "should be possible to create a dictionary" do
+    Dictionary.new.should_not == nil
+  end
+
+  it "should return nils for non-existant entries" do
+    dict=Dictionary.new
+    dict["not_there"].should==nil
+  end
+
+  it "should be enumerate words added to it" do
+    dict=Dictionary.new
+    dict<<"word"
+    dict<<"with"
+    dict<<"you"
+
+    dict["word"].should==0
+    dict["with"].should==1
+    dict["you"].should==2
+
+    dict[0].should=="word"
+    dict[1].should=="with"
+    dict[2].should=="you"
+  end
+
+  it "should accept non-string values and convert them to strings" do
+    dict=Dictionary.new
+    dict<<:word
+    dict["word"].should==0
+  end
+
+  it "should work to_bin and parse" do
+    dict=Dictionary.new
+    dict<<"foo"
+    dict<<"bar"
+    dict["foo"].should==0
+    dict["bar"].should==1
+    dict[0].should=="foo"
+    dict[1].should=="bar"
+
+    bin=dict.to_binary
+    dict2,next_index=Dictionary.parse(bin)
+    next_index.should==bin.length
+    dict2["foo"].should==0
+    dict2["bar"].should==1
+  end
+end
+end

data/spec/xbd_tag_spec.rb

@@ -0,0 +1,132 @@
+require File.join(File.dirname(__FILE__),"xbd_test_helper")
+require "fileutils"
+
+module Xbd
+describe Tag do
+  it "test the various creation methods" do
+    Tag.new("my_tag").attrs.should=={}
+    Tag.new("my_tag",{:foo=>:bar}).attrs.should=={"foo"=>"bar"}
+    Tag.new("my_tag",{:foo=>:bar},[Tag.new("my_other_tag")]).attrs.should=={"foo"=>"bar"}
+    Tag.new("my_tag") do |tag|
+      tag[:foo]=:bar
+    end.attrs.should=={"foo"=>"bar"}
+  end
+
+  it "test attrs" do
+    tag=Tag.new("my_tag")
+    tag.attrs.should=={}
+    tag[:foo]=:bar
+    tag["foo"].should=="bar"
+    tag.attrs.should=={"foo"=>"bar"}
+    tag[:foo]=:bar2
+    tag["foo"].should=="bar2"
+    tag.attrs.should=={"foo"=>"bar2"}
+    tag[:foo2]=:bar3
+    tag["foo2"].should=="bar3"
+    tag.attrs.should=={"foo"=>"bar2","foo2"=>"bar3"}
+  end
+
+  it "test tags" do
+    tag=full_test_tag
+    tag.tagnames.should==["sub1","sub2"]
+    tag.tag("sub1")["sub1k"].should==nil
+    tag.tag("sub2")["sub2k"].should=="sub2v"
+    tag.each_tag("sub1") do |t|
+      t.name.should=="sub1"
+    end
+  end
+
+  it "should convert to XML" do
+    tag=full_test_tag
+    tag.tag("sub1").to_s.strip.should=='<sub1/>'
+    tag.tag("sub2").to_s.strip.should=='<sub2 sub2k="sub2v"/>'
+    tag.to_s.gsub(/\s+/," ").strip.should=='<my_tag a1="v1"> <sub1/> <sub2 sub2k="sub2v"/> </my_tag>'
+    tag.inspect
+  end
+
+  it "should convert to Ruby Hashes" do
+    tag=full_test_tag
+
+    tag.to_ruby.should=={
+      :name=>"my_tag",
+      :attrs=>{"a1"=>"v1"},
+      :tags=>[
+        {:name=>"sub1", :attrs=>{}, :tags=>[]},
+        {:name=>"sub2", :attrs=>{"sub2k"=>"sub2v"}, :tags=>[]}
+      ]
+    }
+  end
+
+  it "should work to convert to xbd" do
+    tag=full_test_tag
+    xbd=tag.to_binary
+    tag2=Xbd.parse(xbd)
+    tag.to_s.should==tag2.to_s
+  end
+
+  it "should work to store binaries" do
+    tag1=full_test_tag
+    tag1["nested_xbd"]=full_test_tag.to_binary
+    tag2=Xbd.parse(tag1.to_binary)
+    tag2["nested_xbd"].should==tag1["nested_xbd"]
+    Xbd.parse(tag2["nested_xbd"]).should==full_test_tag
+  end
+
+  it "should work to == and !=" do
+    tag1=full_test_tag
+    tag2=full_test_tag
+    (tag1!=tag2).should==false
+    (tag1==tag2).should==true
+
+    # test diff tags
+    tag2.tags.reverse!
+    (tag1!=tag2).should==true
+    (tag1==tag2).should==false
+
+    # test diff names
+    tag2=full_test_tag
+    tag2.name="nameeroo"
+    (tag1!=tag2).should==true
+    (tag1==tag2).should==false
+
+    # test diff attrs
+    tag2=full_test_tag
+    tag2["foomagoo"]="goofoo"
+    (tag1!=tag2).should==true
+    (tag1==tag2).should==false
+  end
+
+  it "should work to load from file" do
+    begin
+      filename=File.join(File.dirname(__FILE__),"xbd_test_file.xbd")
+      tag=full_test_tag
+      File.open(filename,"wb") {|file| file.write(tag.to_binary)}
+      File.exists?(filename).should==true
+      tag2=Xbd.load_from_file(filename)
+      tag2.should==tag
+    ensure
+      FileUtils.rm filename
+    end
+  end
+
+  it "should work to convert to/from binary" do
+    tagsd=Dictionary.new
+    attrsd=Dictionary.new
+    valuesd=Dictionary.new
+    tag=full_test_tag
+    tag.populate_dictionaries(tagsd,attrsd,valuesd)
+    bin=tag.to_binary_partial(tagsd,attrsd,valuesd)
+    tag2,index=Tag.parse(bin,0,tagsd,attrsd,valuesd)
+    index.should==bin.length
+    tag.to_s.should==tag2.to_s
+  end
+
+  def full_test_tag
+    Tag.new("my_tag") do |tag|
+      tag["a1"]="v1"
+      tag<<Tag.new("sub1")
+      tag<<Tag.new("sub2",{:sub2k=>:sub2v})
+    end
+  end
+end
+end

data/spec/xbd_test_helper.rb

@@ -0,0 +1,3 @@
+#require 'simplecov'
+#SimpleCov.start
+require File.join(File.dirname(__FILE__),"../lib/xbd.rb")

data/tasks/spec.rake

@@ -0,0 +1,17 @@
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+  
+  desc "Run all examples with RCov"
+  RSpec::Core::RakeTask.new('spec:rcov') do |t|
+    t.rcov = true
+  end
+  
+  RSpec::Core::RakeTask.new('spec') do |t|
+    t.verbose = true    
+  end
+  
+  task :default => :spec
+rescue LoadError
+  puts "rspec, or one of its dependencies, is not available. Install it with: sudo gem install rspec"
+end

data/xbd.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "xbd/version"
+
+Gem::Specification.new do |s|
+  s.name        = "xbd"
+  s.version     = Xbd::VERSION
+  s.authors     = ["Shane Brinkman-Davis"]
+  s.email       = ["shanebdavis@imikimi.com"]
+  s.homepage    = "https://github.com/Imikimi-LLC/xbd"
+  s.summary     = %q{A fast, simplified, XML-inspired binary file format.}
+  s.description = %q{The XBD gem allows you to create, load and save XBD files. XBD files are arbitrary, self-describing, hierarchical, binary data structures consisting of "tags", "attributes", and "sub-tags".}
+
+  s.rubyforge_project = "xbd"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'RubyInline', '~> 3.11.0'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '~> 2.6.0'
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification 
+name: xbd
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Shane Brinkman-Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: RubyInline
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 3
+        - 11
+        - 0
+        version: 3.11.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id003
+description: The XBD gem allows you to create, load and save XBD files. XBD files are arbitrary, self-describing, hierarchical, binary data structures consisting of "tags", "attributes", and "sub-tags".
+email: 
+- shanebdavis@imikimi.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.TXT
+- README.md
+- Rakefile
+- lib/xbd.rb
+- lib/xbd/asi.rb
+- lib/xbd/version.rb
+- lib/xbd/xbd.rb
+- lib/xbd/xbd_dictionary.rb
+- lib/xbd/xbd_tag.rb
+- spec/xbd_asi_spec.rb
+- spec/xbd_dictionary_spec.rb
+- spec/xbd_tag_spec.rb
+- spec/xbd_test_helper.rb
+- tasks/spec.rake
+- xbd.gemspec
+homepage: https://github.com/Imikimi-LLC/xbd
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: xbd
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A fast, simplified, XML-inspired binary file format.
+test_files: 
+- spec/xbd_asi_spec.rb
+- spec/xbd_dictionary_spec.rb
+- spec/xbd_tag_spec.rb
+- spec/xbd_test_helper.rb