sstruct 1.0.1

data/doc/sstruct.txt

@@ -0,0 +1,204 @@
+
+SuperStruct
+Hal Fulton
+Version 1.0
+License: The Ruby License
+
+This is an easy way to create Struct-like classes; it converts easily
+between hashes and arrays, and it allows OpenStruct-like dynamic naming
+of members.
+
+Unlike Struct, it creates a "real" class, and it has real instance variables 
+with predictable names.
+
+A basic limitation is that the hash keys must be legal method names (unless
+used with send()).
+
+Basically, ss["alpha"], ss[:alpha], and ss.alpha all mean the same.
+
+
+NOTES:
+
+
+It's like a Struct...
+  - you can pass in a list of symbols for accessors
+  - it will create a class for you
+but...
+  - you don't have to pass in the class name
+  - it returns a "real" class
+    . instance variables have the expected names
+    . you can reopen and add methods
+  - it doesn't go into the Struct:: namespace
+  - it preserves the order of the fields
+  - you can use Strings instead of Symbols for the names
+
+It's like an Array...
+ - you can access the items by [number] and [number]=
+but...
+ - you can also access the items by ["name"] and ["name"]=
+ - you can access the items by accessors
+
+It's like an OpenStruct...
+ - (if you use .open instead of .new) you can add fields 
+   automatically with x.field or x.field=val
+but...
+ - you can initialize it like a Struct
+ - it preserves the order of the fields
+
+It's like a Hash...
+ - data can be accessed by ["name"]
+but...
+ - order (of entry or creation) is preserved
+ - arbitrary objects are not allowed (it does obj.to_str or obj.to_s)
+ - strings must be valid method names
+
+It's like Ara Howard's Named Array...
+ - we can access elements by ["name"] or ["name"]=
+but...
+ - you can access the items by accessors
+ - strings must be valid method names
+
+It's like Florian Gross's Keyed List...
+ (to be done)
+but...
+ - it preserves the order of the fields
+
+
+Some examples: (see test cases)
+--------------
+
+  # Need not assign to existing fields (default to nil)
+  myStruct = SuperStruct.new(:alpha)
+  x = myStruct.new
+  x.alpha  # nil
+
+  # A value assigned at construction may be retrieved
+  myStruct = SuperStruct.new(:alpha)
+  x = myStruct.new(234)
+  x.alpha  # 234
+
+  # Unassigned fields are nil
+  myStruct = SuperStruct.new(:alpha,:beta)
+  x = myStruct.new(234)
+  x.beta  # nil
+
+  # An open structure may not construct with nonexistent fields
+  myStruct = SuperStruct.open
+  x = myStruct.new(234)  # error
+
+  # An open structure may assign fields not previously existing
+  myStruct = SuperStruct.open
+  x = myStruct.new
+  x.foo = 123
+  x.bar = 456
+
+  # The act of retrieving a nonexistent field from an open struct will
+  # create that field
+  myStruct = SuperStruct.open
+  x = myStruct.new
+  x.foo   # nil
+
+  # A field (in an open struct) that is unassigned will be nil
+  myStruct = SuperStruct.open
+  x = myStruct.new
+  y = x.foobar
+
+  # A struct created with new rather than open cannot reference nonexistent
+  # fields
+  myStruct = SuperStruct.new
+  x = myStruct.new
+  x.foo  # error
+
+  # Adding a field to a struct will create a writer and reader for that field
+
+  # An open struct will also create a writer and a reader together
+
+  # A field has a real writer and reader corresponding to it
+
+  # A string will work as well as a symbol
+  myStruct = SuperStruct.new("alpha")
+
+  # to_a will return an array of values
+  myStruct = SuperStruct.new("alpha","beta","gamma")
+  x = myStruct.new(7,8,9)
+  assert(x.to_a == [7,8,9])
+
+  # Instance method 'members' will return a list of members (as strings)
+  myStruct = SuperStruct.new(:alpha,"beta")
+  x = myStruct.new
+  assert_equal(["alpha","beta"],x.members)
+
+  # Class method 'members' will return a list of members (as strings)
+  myStruct = SuperStruct.new(:alpha,"beta")
+  assert_equal(["alpha","beta"],myStruct.members)
+
+  # to_ary will allow a struct to be treated like an array in
+  # multiple assignment
+  myStruct = SuperStruct.new("alpha","beta","gamma")
+  x = myStruct.new(7,8,9)
+  a,b,c = x
+  assert(b == 8)
+
+  # to_ary will allow a struct to be treated like an array in
+  # passed parameters
+  myStruct = SuperStruct.new("alpha","beta","gamma")
+  x = myStruct.new(7,8,9)
+  b = meth(*x)
+
+  # to_hash will return a hash with fields as keys
+  myStruct = SuperStruct.new("alpha","beta","gamma")
+  x = myStruct.new(7,8,9)
+  h = x.to_hash
+  assert_equal({"alpha"=>7,"beta"=>8,"gamma"=>9},h)
+
+  # A field name (String) may be used in a hash-like notation
+  myStruct = SuperStruct.new("alpha","beta","gamma")
+  x = myStruct.new(7,8,9)
+  y = x["beta"]
+
+  # A field name (Symbol) may be used in a hash-like notation
+  myStruct = SuperStruct.new("alpha","beta","gamma")
+  x = myStruct.new(7,8,9)
+  y = x[:beta]
+
+  # [offset,length] may be used as for arrays
+  myStruct = SuperStruct.new("alpha","beta","gamma")
+  x = myStruct.new(7,8,9)
+  y = x[0,2]
+
+  # Ranges may be used as for arrays
+  myStruct = SuperStruct.new("alpha","beta","gamma")
+  x = myStruct.new(7,8,9)
+  y = x[1..2]
+
+  # Adding a field to an open struct adds it to the instance
+  myStruct = SuperStruct.open(:alpha)
+  x = myStruct.new
+  x.beta = 5
+
+  # Adding a field to an open struct adds it to the class also
+  myStruct = SuperStruct.open(:alpha)
+  x = myStruct.new
+  x.beta = 5
+
+  # An array passed to SuperStruct.new need not be starred
+  myStruct = SuperStruct.new(%w[alpha beta gamma])
+  x = myStruct.new
+
+  # A hash passed to #set will set multiple values at once
+  myStruct = SuperStruct.new(%w[alpha beta gamma])
+  x = myStruct.new
+  hash = {"alpha"=>234,"beta"=>345,"gamma"=>456}
+  x.set(hash)
+
+  # ||= works properly
+  x = SuperStruct.open.new
+  x.foo ||= 333
+  x.bar = x.bar || 444
+
+  # attr_tester will create a ?-method
+  myStruct = SuperStruct.new(:alive)
+  myStruct.attr_tester :alive
+  x = myStruct.new(true)
+  x.alive?  # true
+  

data/lib/sstruct.rb

@@ -0,0 +1,213 @@
+#
+# SuperStruct
+# Hal Fulton
+# Version 1.0.0
+# License: The Ruby License
+#
+# This is an easy way to create Struct-like classes; it converts easily
+# between hashes and arrays, and it allows OpenStruct-like dynamic naming
+# of members.
+#
+# Unlike Struct, it creates a "real" class, and it has real instance variables 
+# with predictable names.
+#
+# A basic limitation is that the hash keys must be legal method names (unless
+# used with send()).
+#
+# Basically, ss["alpha"], ss[:alpha], ss[0], and ss.alpha all mean the same.
+#
+
+
+class SuperStruct
+
+  def SuperStruct.new(*args)
+    @table = []
+    @setsyms = []        # Setter symbols
+    klass = Class.new
+    if (args.size == 1) && (args[0].is_a? Array)
+      args = args[0]
+    end
+    strs = args.map {|x| x.to_s }
+    args.each_with_index do |k,i|
+      case
+	when (! [String,Symbol].include? k.class)
+	  raise ArgumentError, "Need a String or Symbol"
+        when (strs[i] !~ /[_a-zA-Z][_a-zA-Z0-9]*/)
+          raise ArgumentError, "Illegal character"
+      end
+      k = k.intern if k.is_a? String
+      @table << k
+      @setsyms << (k.to_s + "=").intern
+      klass.instance_eval { attr_accessor k }
+    end
+
+    setsyms = @setsyms
+    table   = @table
+    vals    = @vals
+    klass.class_eval do
+      attr_reader :singleton
+      define_method(:initialize) do |*vals|
+        n = vals.size
+	m = table.size
+	case 
+	  when n < m
+	    # raise ArgumentError, "Too few arguments (#{n} for #{m})"
+	    # Never mind... extra variables will just be nil
+	  when n > m
+	    raise ArgumentError, "Too many arguments (#{n} for #{m})"
+	end
+        setsyms.each_with_index do |var,i|
+          self.send(var,vals[i])
+        end
+      end
+      define_method(:pretty_print) do |q|  # pp.rb support
+        q.object_group(self) do
+          q.seplist(self.members, proc { q.text "," }) do |member|
+#         self.members.each do |member|
+#           q.text ","  # unless q.first?
+            q.breakable
+            q.text member.to_s
+            q.text '='
+            q.group(1) do
+              q.breakable ''
+              q.pp self[member]
+            end
+          end
+        end
+      end
+      define_method(:inspect) do
+        str = "#<#{self.class}:"
+        table.each {|item| str << " #{item}=#{self.send(item)}" }
+        str + ">"
+      end
+      define_method(:[]) do |*index|
+        case index.map {|x| x.class }
+	  when [Fixnum]
+            self.send(table[*index])
+          when [Fixnum,Fixnum], [Range]
+	    table[*index].map {|x| self.send(x)}
+	  when [String]
+	    self.send(index[0].intern)
+	  when [Symbol]
+	    self.send(index[0])
+        else
+          raise ArgumentError,"Illegal index"
+	end
+      end
+      define_method(:[]=) do |*index|
+        value = index[-1]
+        index = index[0..-2]
+        case index.map {|x| x.class }
+	  when [Fixnum]
+            self.send(table[*index])
+          when [Fixnum,Fixnum], [Range]
+	    setsyms[*index].map {|x| self.send(x,value) }
+	  when [String]
+	    self.send(index[0].intern,value)
+	  when [Symbol]
+	    self.send(index[0],value)
+        else
+          raise ArgumentError,"Illegal index"
+	end
+      end
+      define_method(:to_a)    { table.map {|x| eval("@"+x.to_s) } }
+      define_method(:to_ary)  { to_a }
+      define_method(:members) { table.map {|x| x.to_s } }
+      define_method(:to_struct) do
+        mems = table
+        Struct.new("TEMP",*mems)
+        # Struct::TEMP.new(*vals) # Why doesn't this work??
+        data = mems.map {|x| self.send(x) }
+        Struct::TEMP.new(*data)
+      end
+      define_method(:to_hash) do
+        hash = {}
+	table.each do |mem|
+          mem = mem.to_s
+          hash.update(mem => self.send(mem))
+        end
+	hash
+      end
+      define_method(:set) {|h| h.each_pair {|k,v| send(k.to_s+"=",v) } }
+
+      # Class methods...
+
+      @singleton = class << self
+        self
+      end
+
+      @singleton.instance_eval do
+        define_method(:members) do 
+	  table.map {|x| x.to_s }
+	end
+        me = self
+        define_method(:attr_tester) do |*syms| 
+          syms.each {|sym| alias_method(sym.to_s+"?",sym) }
+        end
+      end
+
+    end
+    klass
+  end
+
+
+  def SuperStruct.open(*args)
+    klass = SuperStruct.new(*args)
+    table = @table
+    setsyms = @setsyms
+    table = @table
+    klass.class_eval do
+      define_method(:method_missing) do |meth, *args|
+        mname = meth.id2name
+        if mname =~ /=$/
+          getter = mname.chop
+          setter = mname
+        elsif mname =~ /\?$/
+          raise NoMethodError  # ?-methods are not created automatically
+        else
+          getter = mname
+          setter = mname + "="
+        end
+        gsym = getter.intern
+        ssym = setter.intern
+        ivar = "@" + getter
+        setsyms << setter
+        table << getter
+        len = args.length
+        if mname == getter
+          klass.class_eval do                 # getter
+            define_method(getter) do
+              instance_variable_get(ivar)
+            end
+          end
+        else
+          klass.class_eval do                 # setter
+            define_method(setter) do |*args|
+              if len != 1
+                raise ArgumentError, "Wrong # of arguments (#{len} for 1)", 
+                      caller(1)
+              end
+              instance_variable_set(ivar,args[0])
+              instance_variable_get(ivar)
+            end
+          end
+        end
+        if mname == setter
+          self.send(setter,*args)
+        else
+          if len == 0
+            self.send(getter)
+          else
+            raise NoMethodError, "Undefined method '#{mname}' for #{self}", 
+                  caller(1)
+          end
+        end
+      end
+    end
+    klass
+  end
+
+end
+
+
+require "test-sstruct" if $0 == __FILE__

data/sstruct.gemspec

@@ -0,0 +1,40 @@
+ require 'rubygems'
+
+  spec = Gem::Specification.new do |s|
+
+    #### Basic information.
+
+    s.name = 'sstruct'
+    s.version = "1.0.1"
+    s.summary = <<-EOF
+      SuperStruct class: Best of Struct, OpenStruct, Array, Hash, etc.
+    EOF
+    s.description = <<-EOF
+      The SuperStruct class allows the easy and quick creation of classes that
+      consist mainly of data. It borrows from Struct, OpenStruct, Array, Hash,
+      ArrayFields, and others.
+    EOF
+
+    #### Dependencies and requirements.
+
+    #### Which files are to be included in this gem?  Everything!  (Except CVS)
+
+    s.files = Dir.glob("**/*").delete_if { |item| item.include?("CVS") }
+
+    #### Load-time details: library and application (you will need one or both).
+
+    s.require_path = 'lib'                         # Use these for libraries.
+    s.autorequire = 'sstruct'
+
+    #### Documentation and testing.
+
+    s.has_rdoc = false
+    s.test_file = "test/test-sstruct.rb"
+
+    #### Author and project details.
+
+    s.author = "Hal E. Fulton"
+    s.email = "hal9000@hypermetrics.com"
+    s.homepage = "http://sstruct.rubyforge.org"
+    s.rubyforge_project = "sstruct"
+  end

data/test/test-sstruct.rb

@@ -0,0 +1,318 @@
+#
+# SuperStruct test code
+# Hal Fulton
+# Version 1.0.0 (in sync with library code)
+# License: The Ruby License
+#
+
+require "test/unit"
+require "sstruct"
+
+class Tester < Test::Unit::TestCase
+
+  def test001
+    # Must pass in String or Symbol
+    assert_raises(ArgumentError) { SuperStruct.new(0) }
+  end
+  
+  def test002
+    # Must pass in valid name(s)
+    assert_raises(ArgumentError) { SuperStruct.new("###") }
+  end
+  
+  def test003
+    # Can't assign to nonexistent fields
+    myStruct = SuperStruct.new
+    assert_raises(ArgumentError) { myStruct.new(345) }
+  end
+  
+  def test004
+    # Need not assign to existing fields (default to nil)
+    myStruct = SuperStruct.new(:alpha)
+    assert_nothing_raised(ArgumentError) { myStruct.new }
+  end
+  
+  def test005
+    # A value assigned at construction may be retrieved
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new(234)
+    assert(x.alpha == 234)
+  end
+  
+  def test006
+    # Unassigned fields are nil
+    myStruct = SuperStruct.new(:alpha,:beta)
+    x = myStruct.new(234)
+    assert(x.beta == nil)
+  end
+  
+  def test007
+    # An open structure still may not construct with nonexistent fields
+    myStruct = SuperStruct.open
+    assert_raises(ArgumentError) { x = myStruct.new(234) }
+  end
+  
+  def test008
+    # An open structure may assign fields not previously existing
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    assert_nothing_raised { x.foobar = 123 }
+  end
+  
+  def test009
+    # A field assigned to an open struct after its construction may be retrieved
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    x.foobar = 123
+    assert(x.foobar == 123)
+  end
+  
+  def test010
+    # The act of retrieving a nonexistent field from an open struct will
+    # create that field
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    assert_nothing_raised { y = x.foobar }
+  end
+  
+  def test011
+    # A field (in an open struct) that is unassigned will be nil
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    y = x.foobar
+    assert(y == nil)
+  end
+  
+  def test012
+    # A struct created with new rather than open cannot reference nonexistent
+    # fields
+    myStruct = SuperStruct.new
+    x = myStruct.new
+    assert_raises(NoMethodError) { y = x.foobar }
+  end
+  
+  def test013
+    # Adding a field to a struct will create a writer and reader for that field
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new
+    x.send(:alpha=,1)
+    assert(x.alpha == 1)
+  end
+  
+  def test014
+    # Only a single value may be passed to a writer (for code coverage)
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new
+    assert_raises(ArgumentError) { x.send(:alpha=,1,2) }
+  end
+  
+  def test015
+    # An open struct will also create a writer and a reader together
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    x.send(:alpha=,1)
+    assert(x.alpha == 1)
+  end
+  
+  def test016
+    # Only a single value may be passed to a writer (for code coverage)
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    assert_raises(ArgumentError) { x.send(:alpha=,1,2) }
+  end
+  
+  def test017
+    # A field has a real writer and reader corresponding to it
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new
+    assert(myStruct.instance_methods.include?("alpha"))
+    assert(myStruct.instance_methods.include?("alpha="))
+  end
+  
+  def test018
+    # Creating a field by retrieval in an open struct will NOT create a writer 
+    # (This behavior has changed!)
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    y = x.alpha
+    assert(myStruct.instance_methods.include?("alpha"))
+    assert(!myStruct.instance_methods.include?("alpha="))
+  end
+  
+  def test019
+    # Creating a field by writing in an open struct will NOT create a reader
+    # (This behavior has changed!)
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    x.alpha = 5
+    assert(myStruct.instance_methods.include?("alpha="))
+    assert(!myStruct.instance_methods.include?("alpha"))
+  end
+  
+  def test020
+    # A string will work as well as a symbol
+    myStruct = SuperStruct.new("alpha")
+    x = myStruct.new
+    assert(myStruct.instance_methods.include?("alpha"))
+    assert(myStruct.instance_methods.include?("alpha="))
+  end
+  
+  def test021
+    # to_a will return an array of values
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    assert(x.to_a == [7,8,9])
+  end
+  
+  def test022
+    # Instance method 'members' will return a list of members (as strings)
+    myStruct = SuperStruct.new(:alpha,"beta")
+    x = myStruct.new
+    assert_equal(["alpha","beta"],x.members)
+  end
+  
+  def test023
+    # Class method 'members' will return a list of members (as strings)
+    myStruct = SuperStruct.new(:alpha,"beta")
+    assert_equal(["alpha","beta"],myStruct.members)
+  end
+  
+  def test024
+    # to_ary will allow a struct to be treated like an array in
+    # multiple assignment
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    a,b,c = x
+    assert(b == 8)
+  end
+  
+     def aux025(*arr)  # Just used in test 25
+       arr[1]
+     end
+  
+  def test025
+    # to_ary will allow a struct to be treated like an array in
+    # passed parameters
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    b = aux025(*x)
+    assert(b == 8)
+  end
+  
+  def test026
+    # to_hash will return a hash with fields as keys
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    h = x.to_hash
+    assert_equal({"alpha"=>7,"beta"=>8,"gamma"=>9},h)
+  end
+  
+  def test027
+    # A field name (String) may be used in a hash-like notation
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x["beta"]
+    assert(8,y)
+  end
+  
+  def test028
+    # A field name (Symbol) may be used in a hash-like notation
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x[:beta]
+    assert(8,y)
+  end
+  
+  def test029
+    # [offset,length] may be used as for arrays
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x[0,2]
+    assert([7,8],y)
+  end
+  
+  def test030
+    # Ranges may be used as for arrays
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x[1..2]
+    assert([8,9],y)
+  end
+  
+  def test031
+    # Adding a field to an open struct adds it to the instance
+    myStruct = SuperStruct.open(:alpha)
+    x = myStruct.new
+    x.beta = 5
+    assert_equal(["alpha","beta"],x.members)
+  end
+  
+  def test032
+    # Adding a field to an open struct adds it to the class also
+    myStruct = SuperStruct.open(:alpha)
+    x = myStruct.new
+    x.beta = 5
+    assert_equal(["alpha","beta"],myStruct.members)
+  end
+  
+  def test033
+    # An array passed to SuperStruct.new need not be starred
+    myStruct = SuperStruct.new(%w[alpha beta gamma])
+    x = myStruct.new
+    assert_equal(%w[alpha beta gamma],x.members)
+  end
+  
+  def xtest034
+    # A hash passed to SuperStruct.new will initialize the values
+    # (but order will not be predictable!)
+    assert false, "Not implemented yet."
+  end
+  
+  def test035
+    # A hash passed to #set will set multiple values at once
+    myStruct = SuperStruct.new(%w[alpha beta gamma])
+    x = myStruct.new
+    hash = {"alpha"=>234,"beta"=>345,"gamma"=>456}
+    x.set(hash)
+    assert_equal([234,345,456], x.to_a)
+  end
+  
+  def test036
+    # Make sure ||= works properly
+    x = SuperStruct.open.new
+    x.foo ||= 333
+    x.bar = x.bar || 444
+    assert_equal(333,x.foo)
+    assert_equal(444,x.bar)
+  end
+
+  def test037
+    # A simple array index works ok
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    assert_equal(7,x[0])
+    assert_equal(8,x[1])
+    assert_equal(9,x[2])
+  end
+
+  def test038
+    # attr_tester will create a ?-method
+    klass = SuperStruct.new(:alpha,:beta,:gamma)
+    klass.attr_tester :alpha, :gamma
+    x = klass.new(22,33,nil)
+    assert(x.alpha?)
+    assert_raises(NoMethodError) { x.beta? }
+    assert(! x.gamma?)
+  end
+
+  def test039
+    # attr_tester works with open() (?-methods not created)
+    klass = SuperStruct.open(:alpha,:beta,:gamma)
+    klass.attr_tester :alpha, :gamma
+    x = klass.new(22,33,nil)
+    assert(x.alpha?)
+    assert_raises(NoMethodError) { x.beta? }  # ?-methods are not automatic
+    assert(! x.gamma?)
+  end
+  
+end

metadata

@@ -0,0 +1,43 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: sstruct
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+date: 2004-11-17
+summary: "SuperStruct class: Best of Struct, OpenStruct, Array, Hash, etc."
+require_paths: 
+  - lib
+author: Hal E. Fulton
+email: hal9000@hypermetrics.com
+homepage: http://sstruct.rubyforge.org
+rubyforge_project: sstruct
+description: "The SuperStruct class allows the easy and quick creation of classes that consist mainly of data. It borrows from Struct, OpenStruct, Array, Hash, ArrayFields, and others."
+autorequire: sstruct
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - doc
+  - sstruct.gemspec
+  - test
+  - lib
+  - doc/sstruct.txt
+  - test/test-sstruct.rb
+  - lib/sstruct.rb
+test_files: 
+  - test/test-sstruct.rb
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []