structure 0.22.1 → 0.23.0

data/Gemfile

@@ -1,11 +1,11 @@
 source :rubygems
 gemspec
 
-gem 'activesupport', '~> 3.0'
+gem 'activesupport' # Required for testing Rails compatibility
+gem 'pry' unless ENV['CI']
+gem 'rake'
+
 if RUBY_VERSION.include? '1.8'
   gem 'json'
   gem 'minitest'
 end
-
-gem 'pry' unless ENV['CI']
-gem 'rake'

data/LICENSE

@@ -1,13 +1,22 @@
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-                    Version 2, December 2004
+(The MIT License)
 
- Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+Copyright (c) 2011 Hakan Ensari
 
- Everyone is permitted to copy and distribute verbatim or modified
- copies of this license document, and changing it is allowed as long
- as the name is changed.
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
 
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-  0. You just DO WHAT THE FUCK YOU WANT TO.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,14 +1,8 @@
-# Structure
+![structure](http://f.cl.ly/items/2u2v0e3k2I3w1A0y2e25/ruby.png)
 
-[![travis](https://secure.travis-ci.org/hakanensari/structure.png?branch=master)](http://travis-ci.org/hakanensari/structure)
-
-Structure is a typed key/value container.
+> Machines only work when they break down and by continually breaking
+> down.
 
-    class Person < Structure
-      key :name
-      key :friends, Array, []
-    end
+[Delve into the API.](http://rubydoc.info/github/hakanensari/structure/master/frames)
 
-Please see the [wiki] [1] for more detail.
-
-[1]: https://github.com/hakanensari/structure/wiki/
+[![travis](https://secure.travis-ci.org/hakanensari/structure.png?branch=master)](http://travis-ci.org/hakanensari/structure)

data/lib/structure.rb

@@ -1,189 +1,267 @@
-# Structure is a typed key/value container
+begin
+  JSON::JSON_LOADED
+rescue NameError
+  require 'json'
+end
+
+# Structure is a key/value container. On the most basic level, it
+# mirrors the functionality of OpenStruct:
+#
+#    require 'structure'
+#
+#    record = Structure.new
+#    record.name    = "John Smith"
+#    record.age     = 70
+#    record.pension = 300
+#
+#    puts record.name    # -> "John Smith"
+#    puts record.address # -> nil
+#
+# Build structures recursively:
+#
+#    hash = {
+#     "name"       => "Australia",
+#     "population" => "20000000",
+#     "cities"     => [
+#       {
+#         "name"       => "Sydney",
+#         "population" => "4100000"
+#       },
+#       {
+#         "name"       => "Melbourne",
+#         "population" => "4000000"
+#       } ]
+#     }
+#
+#     country = Structure.new(hash)
+#     puts country.name              # -> "Australia"
+#     puts country.cities.count      # -> 2
+#     puts country.cities.first.name # -> "Sydney"
 #
-# @example
-#    class Person < Structure
-#      key :name
-#      key :friends, Array, []
-#    end
+# Define optionally-typed fields in a structure:
 #
+#     class Price < Structure
+#       field :cents, Integer
+#       field :currency, :default => "USD"
+#     end
+#
+#     hash = { "cents" => "100" }
+#
+#     price = Price.new(hash)
+#     puts price.cents    # -> 100
+#     puts price.currency # -> "USD"
+#
+# Alternatively, define a proc to cast or otherwise manipulate assigned
+# values:
+#
+#     class Product < Structure
+#       field :sku, lambda(&:upcase)
+#     end
+#
+#     product = Product.new(:sku => 'foo-bar')
+#     puts product.sku # -> "FOO-BAR"
+#
+# Structures are fully conversant in JSON, which is quite handy in the
+# ephemeral landscape of APIs.
 class Structure
-  unless defined? BasicObject
-    if defined? BlankSlate
-      BasicObject = BlankSlate
-    else
-      class BasicObject
-        instance_methods.each do |mth|
-          undef_method(mth) unless mth =~ /__/
-        end
-      end
-    end
-  end
+  class << self
+    attr_accessor :blueprint
 
-  # A wrapper for lazy-evaluating undeclared classes
-  #
-  # @note Somewhat borrowed from the same-named class in Ohm
-  class Wrapper < BasicObject
-    # Wraps specified class in a wrapper if it is not already wrapped
-    #
-    # @param [Class] klass a class, which may already be wrapped
-    # @return [Wrapper] the wrapped class
-    def self.wrap(klass)
-      klass.class == self ? klass : new(klass.to_s)
+    # Builds a structure out of a JSON representation.
+    # @param [Hash] hsh a JSON representation translated to a hash
+    # @return [Structure] a structure
+    def json_create(hsh)
+      hsh.delete('json_class')
+      new(hsh)
     end
 
-    # Creates a new wrapper for specified class name
-    #
-    # @param [#to_s] name
-    def initialize(name)
-      @name = name.to_s
+    # Creates a field.
+    # @overload field(key, opts = {})
+    #   Creates a field.
+    #   @param [#to_sym] key the name of the field
+    #   @param [Hash] opts the options to create the field with
+    #   @option opts [Object] :default the default value
+    # @overload field(key, type, opts = {})
+    #   Creates a typed field.
+    #   @param [#to_sym] key the name of the field
+    #   @param [Class, Proc] type the type to cast assigned values
+    #   @param [Hash] opts the options to create the field with
+    #   @option opts [Object] :default the default value
+    def field(key, *args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      default = opts[:default]
+      type = args.shift
+      @blueprint[key] = { :type    => type,
+                          :default => default }
     end
 
-    # @return [Class] the class of the object
-    def class
-      Wrapper
+    # Syntactic sugar to create a typed field that defaults to an empty
+    # array.
+    # @param key the name of the field
+    def many(key)
+      field(key, Array, :default => [])
     end
 
-    # Unwraps wrapped class
-    #
-    # @return [Class] the unwrapped class
-    def unwrap
-      @name.split('::').inject(::Kernel) do |parent, child|
-        parent.const_get(child)
-      end
-    end
+    private
 
-    def method_missing(mth, *args, &block)
-      @unwrapped ? super : @unwrapped = true
-      ::Kernel.const_get(@name).send(mth, *args, &block)
-    ensure
-      @unwrapped = false
+    def inherited(child)
+      child.blueprint = blueprint.dup
     end
   end
 
-  # A key definition
-  class Definition
-    # Creates a key definition
-    #
-    # @param [Class] type the key type
-    # @param [Object] default an optional default value
-    def initialize(type, default = nil)
-      @wrapper = Wrapper.wrap(type)
-      @default = typecast(default)
-    end
-
-    # @return the default value for the key
-    attr :default
+  @blueprint = {}
 
-    # @return [Class] the key type
-    def type
-      @type ||= @wrapper.unwrap
+  # Creates a new structure.
+  # @param [Hash] hsh an optional hash to populate fields
+  def initialize(hsh = {})
+    # It may have improved performance if I had defined these methods
+    # on the class level, but I decided to privilege consistency here.
+    # Who wouldn't?
+    @table = blueprint.inject({}) do |a, (k, v)|
+      a.merge new_field(k, v[:type]) => v[:default]
     end
 
-    # Typecasts specified value
-    #
-    # @param [Object] val a value
-    # @raise [TypeError] value isn't a type
-    # @return [Object] a typecast value
-    def typecast(val)
-      if val.nil?
-        nil
-      elsif val.is_a?(type)
-        val.dup rescue val
-      elsif Kernel.respond_to?(type.to_s)
-        Kernel.send(type.to_s, val)
-      else
-        raise TypeError, "#{val} isn't a #{type}"
-      end
-    end
+    marshal_load(hsh)
   end
 
-  class << self
-    # @return [Hash] a collection of keys and their definitions
-    def blueprint
-      @blueprint ||= {}
+  # Deletes a field.
+  # @param [#to_sym] key
+  # @return [Object] the value of the deleted field
+  def delete_field(key)
+    key = key.to_sym
+    class << self; self; end.class_eval do
+      [key, "#{key}="].each { |m| remove_method m }
     end
 
-    # Defines a key
-    #
-    # @note Key type defaults to +String+ if not specified.
-    #
-    # @param [#to_sym] name the key name
-    # @param [Class] type an optional key type
-    # @param [Object] default an optional default value
-    # @raise [NameError] name is already taken
-    def key(name, type = String, default = nil)
-      if method_defined?(name = name.to_sym)
-        raise NameError, "#{name} is taken"
-      end
+    @table.delete key
+  end
 
-      blueprint[name] = Definition.new(type, default)
-      define_method(name) { @attributes[name] }
-      define_method("#{name}=") do |val|
-        modifiable[name] = blueprint[name].typecast(val)
-      end
+  # Provides marshalling support for use by the Marshal library.
+  # @return [Hash] a hash of the keys and values of the structure
+  def marshal_dump
+    @table.inject({}) do |a, (k, v)|
+      a.merge k => recursively_dump(v)
     end
+  end
 
-    def const_missing(name)
-      Wrapper.new(name)
+  # Provides marshalling support for use by the Marshal library.
+  # @param [Hash] hsh a hash of keys and values to populate the
+  # structure
+  def marshal_load(hsh)
+    hsh.each do |k, v|
+      self.send("#{new_field(k)}=", v)
     end
   end
 
-  # Builds a new structure
-  #
-  # @param [Hash] hsh a hash of key-value pairs
-  def initialize(hsh = {})
-    @attributes = blueprint.inject({}) do |a, (k, v)|
-      a[k] = v.default.dup rescue v.default
-      a
-    end
+  # @return [String] a JSON representation of the structure
+  def to_json(*args)
+    { JSON.create_id => self.class.name }.
+      merge(marshal_dump).
+      to_json(*args)
+  end
 
-    hsh.each { |k, v| self.send("#{k}=", v) }
+  # @return [Boolean] whether the object and +other+ are equal
+  def ==(other)
+    other.is_a?(Structure) && @table == other.table
   end
 
-  # @return [Hash] a hash representation of the structure
-  def to_hash
-    @attributes.inject({}) { |a, (k, v)| a.merge k => hashify(v) }
+  protected
+
+  attr :table
+
+  private
+
+  def blueprint
+    self.class.blueprint
+  end
+
+  def initialize_copy(orig)
+    super
+    @table = @table.dup
   end
 
-  def hashify(obj)
-    if obj.respond_to? :to_hash
-      obj.to_hash
-    elsif obj.is_a? Array
-      obj.map { |e| hashify(e) }
+  def method_missing(mth, *args)
+    name = mth.to_s
+    len = args.length
+    if name.chomp!('=') && mth != :[]=
+      modifiable[new_field(name)] = recursively_load(args.first)
+    elsif len == 0
+      @table[new_field(mth)]
     else
-      obj
+      super
     end
   end
-  private :hashify
-
-  # Compares this object with another object for equality
-  #
-  # A structure is equal to another object when both are of the same
-  # class and their attributes are the same.
-  #
-  # @param [Object] other another object
-  # @return [true, false]
-  def ==(other)
-    other.is_a?(self.class) && attributes == other.attributes
+
+  def modifiable
+    if frozen?
+      raise RuntimeError, "can't modify frozen #{self.class}", caller(3)
+    end
+
+    @table
   end
 
-  def blueprint
-    self.class.blueprint
+  def new_field(key, type = nil)
+    key = key.to_sym
+    unless self.respond_to?(key)
+      class << self; self; end.class_eval do
+        define_method(key) { @table[key] }
+
+        assignment =
+          case type
+          when nil
+            lambda { |v| modifiable[key] = recursively_load(v) }
+          when Proc
+            lambda { |v| modifiable[key] = type.call(v) }
+          when Class
+            mth = type.to_s.to_sym
+            if Kernel.respond_to?(mth)
+              lambda { |v|
+                modifiable[key] = v.nil? ? nil : Kernel.send(mth, v)
+              }
+            else
+              lambda { |v|
+                modifiable[key] =
+                  if v.nil? || v.is_a?(type)
+                    v
+                  else
+                    raise TypeError, "#{v} isn't a #{type}"
+                  end
+              }
+            end
+          else
+            raise TypeError, "#{type} isn't a valid type"
+          end
+
+        define_method("#{key}=", assignment)
+      end
+    end
+
+    key
   end
-  private :blueprint
 
-  # Used internally to check if the structure is frozen or not before
-  # updating a value
-  #
-  # @note Borrowed from OpenStruct
-  def modifiable
-    begin
-      @modifiable = true
-    rescue
-      raise TypeError, "can't modify frozen #{self.class}", caller(3)
+  def recursively_dump(val)
+    if val.respond_to? :marshal_dump
+       val.marshal_dump
+     elsif val.is_a? Array
+       val.map { |v| recursively_dump(v) }
+     else
+       val
+     end
+  end
+
+  def recursively_load(val)
+    case val
+    when Hash
+      self.class.new(val)
+    when Array
+      val.map { |v| recursively_load(v) }
+    else
+      val
     end
+  end
 
-    @attributes
+  if defined? ActiveSupport
+    require 'structure/ext/active_support'
+    include Ext::ActiveSupport
   end
-  private :modifiable
 end

data/lib/structure/ext/active_support.rb

@@ -0,0 +1,22 @@
+class Structure
+  module Ext
+    module ActiveSupport
+      def as_json(options = nil)
+        subset = if options
+          if only = options[:only]
+            marshal_dump.slice(*Array.wrap(only))
+          elsif except = options[:except]
+            marshal_dump.except(*Array.wrap(except))
+          else
+            marshal_dump
+          end
+        else
+          marshal_dump
+        end
+
+        { JSON.create_id => self.class.name }.
+          merge(subset)
+      end
+    end
+  end
+end

data/lib/structure/version.rb

@@ -1,3 +1,3 @@
 class Structure
-  VERSION = '0.22.1'
+  VERSION = '0.23.0'
 end

data/structure.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   s.authors     = ['Hakan Ensari']
   s.email       = ['code@papercavalier.com']
   s.homepage    = 'http://github.com/hakanensari/structure'
-  s.summary     = 'A typed key/value container'
-  s.description = 'Structure is a typed key/value container.'
+  s.summary     = 'A key/value container'
+  s.description = 'Structure is a key/value container.'
 
   s.rubyforge_project = 'structure'
 

data/test/defined_structure_test.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../helper.rb', __FILE__)
+
+class Product < Structure
+  field :title
+  field :sku, lambda(&:upcase)
+  field :cents, Integer
+  field :currency, String, :default => 'USD'
+  field :in_stock, :default => true
+  many :related
+end
+
+class Foo < Structure
+  field :bar, Hash
+end
+
+class TestDefinedStructure < MiniTest::Unit::TestCase
+  def setup
+    @product = Product.new(:title => 'Widget')
+  end
+
+  def test_inheritance
+    assert_equal 'USD', Class.new(Product).new.currency
+  end
+
+  def test_equal_value
+    assert @product == Class.new(Product).new(:title => 'Widget')
+    refute @product == Product.new(:title => 'Widget', :sku => '123')
+  end
+
+  def test_casting
+    @product.title = 1
+    assert_kind_of Integer, @product.title
+
+    @product.sku = 'sku-123'
+    assert_equal 'SKU-123', @product.sku
+
+    @product.cents = '1'
+    assert_kind_of Integer, @product.cents
+
+    @product.related = '1'
+    assert_kind_of Array, @product.related
+  end
+
+  def test_default_values
+    assert_equal nil, @product.cents
+    assert_equal 'USD', @product.currency
+    assert_equal true, @product.in_stock
+    assert_equal [], @product.related
+  end
+
+  def test_hashes_with_recursion
+    foo = Foo.new('bar' => { 'baz' => 1 })
+    hsh = foo.marshal_dump
+    foo.marshal_load(hsh)
+    assert_equal({ 'baz' => 1 }, foo.bar)
+
+    json = foo.to_json
+    assert foo, JSON.parse(json)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,8 @@
+require 'minitest/autorun'
+
+begin
+  require 'pry'
+rescue LoadError
+end
+
+require 'structure'

data/test/structure_test.rb

@@ -1,109 +1,161 @@
-require 'minitest/autorun'
+require File.expand_path('../helper.rb', __FILE__)
 
-begin
-  require 'pry'
-rescue LoadError
-end
-
-require 'structure'
-require 'structure/json'
+# Most tests below are borrowed from RubySpec.
+class TestStructure < MiniTest::Unit::TestCase
+  def setup
+    @person = Structure.new(:name => 'John')
+  end
 
-class Person < Structure
-  key :name
-  key :friends, Array, []
-  key :city, City
-end
+  def test_delete_field
+    @person.delete_field(:name)
+    assert_nil @person.send(:table)[:name]
+    refute_respond_to(@person, :name)
+    refute_respond_to(@person, :name=)
+  end
 
-class City < Structure
-  key :name
-end
+  def test_element_reference
+    assert_raises(NoMethodError) { @person[1] }
+  end
 
-class TestStructure < MiniTest::Unit::TestCase
-  def test_lazy_evaluation
-    wrapper = Structure::Wrapper.new(:Foo)
-    assert_raises(NameError) { wrapper.bar }
-    assert_raises(NameError) { wrapper.unwrap.bar }
-
-    klass = Class.new { def self.bar; end }
-    ::Kernel.const_set(:Foo, klass)
-    assert_respond_to wrapper, :bar
-    assert_equal Foo, wrapper.unwrap
+  def test_element_set
+    assert_raises(NoMethodError) { @person[1] = 2 }
   end
 
-  def test_accessors
-    assert_respond_to Person.new, :name
-    assert_respond_to Person.new, :name=
+  def test_equal_value
+    refute @person == 'foo'
+    assert @person == @person
+    assert @person == Structure.new(:name => 'John')
+    assert @person == Class.new(Structure).new(:name => 'John')
+    refute @person == Structure.new(:name => 'Johnny')
+    refute @person == Structure.new(:name => 'John', :age => 20)
   end
 
-  def test_key_errors
-    assert_raises(NameError) { Person.key :class }
-    assert_raises(TypeError) { Person.key :foo, Hash, 1 }
+  def test_frozen
+    @person.freeze
+
+    assert_equal 'John', @person.name
+    assert_raises(RuntimeError) { @person.age = 42 }
+    assert_raises(RuntimeError) { @person.state = :new }
+
+    c = @person.clone
+    assert_equal 'John', c.name
+    assert_raises(RuntimeError) { c.age = 42 }
+    assert_raises(RuntimeError) { c.state = :new }
+
+    d = @person.dup
+    assert_equal 'John', d.name
+    d.age = 42
+    assert_equal 42, d.age
   end
 
-  def test_key_defaults
-    assert_equal [], Person.new.friends
+  def test_initialize_copy
+    d = @person.dup
+    d.name = 'Jane'
+    assert_equal 'Jane', d.name
+    assert_equal 'John', @person.name
+
+    @person.friends = ['Joe']
+    d = @person.dup
+    d.friends = ['Jim']
+    assert_equal ['Jim'], d.friends
+    assert_equal ['Joe'], @person.friends
   end
 
-  def test_typecasting
-    person = Person.new
-    person.name = 123
-    assert_kind_of String, person.name
+  def test_json
+    friend = Structure.new(:name => 'Jane')
+    @person.friend = friend
+    @person.cities = ['Zurich']
+    json = '{"json_class":"Structure",
+             "name":"John",
+             "friend":{"name":"Jane"},
+             "cities":["Zurich"]}'.gsub(/\s+/, '')
+    assert_equal @person, JSON.parse(json)
+    assert_equal friend, JSON.parse(json).friend
+    assert_equal 'Zurich', JSON.parse(json).cities.first
+
+    refute_respond_to @person, :as_json
+    require 'active_support/ordered_hash'
+    require 'active_support/json'
+    load 'structure.rb'
+    assert @person.as_json(:only => :name).has_key?(:name)
+    refute @person.as_json(:except => :name).has_key?(:name)
+  end
 
-    person.name = nil
-    assert_nil person.name
+  def test_marshaling
+    assert_equal({ :name => 'John' }, @person.marshal_dump)
+    @person.marshal_load(:age => 20, :name => 'Jane')
+    assert_equal 20, @person.age
+    assert_equal 'Jane', @person.name
   end
 
-  def test_many_relationship
-    person = Person.new
-    assert_equal [], person.friends
+  def test_method_missing
+    @person.test = 'test'
+    assert_respond_to @person, :test
+    assert_respond_to @person, :test=
+    assert_equal 'test', @person.test
+    assert_equal 'test', @person.send(:table)[:test]
+    @person.test = 'changed'
+    assert_equal 'changed', @person.test
+
 
-    person.friends << Person.new
-    assert_equal 1, person.friends.size
-    assert_equal 0, person.friends.first.friends.size
+    @person.send(:table)[:age] = 20
+    assert_equal 20, @person.age
+
+    assert_raises(NoMethodError) { @person.gender(1) }
+    assert_nil @person.gender
+
+    @person.freeze
+    assert_raises(RuntimeError) { @person.gender = 'male' }
   end
 
   def test_new
-    person = Person.new(:name => 'John')
+    person = Structure.new(:name => 'John', :age => 70)
     assert_equal 'John', person.name
-
-    other = Person.new(:name => 'Jane', :friends => [person])
-    assert_equal 'John', other.friends.first.name
+    assert_equal 70, person.age
+    assert_equal({}, Structure.new.send(:table))
   end
 
-  def test_cant_change_sex_when_frozen
-    person = Person.new(:name => 'John')
-    person.freeze
-    assert_raises(TypeError) { person.name = 'Jane' }
-  end
+  def test_new_field
+    @person.send(:table)[:age] = 20
+    @person.send(:new_field, :age)
 
-  def test_to_hash
-    person = Person.new(:name => 'John')
-    friend = Person.new(:name => 'Jane')
-    person.friends << friend
-    hsh = person.to_hash
+    assert_equal 20, @person.age
 
-    assert_equal person.name, hsh[:name]
-    assert_equal friend.name, hsh[:friends].first[:name]
+    @person.age = 30
+    assert_equal 30, @person.age
 
-    person.friends = [[friend]]
-    hsh = person.to_hash
-    assert_equal friend.name, hsh[:friends].first.first[:name]
+    @person.instance_eval { def gender; 'male'; end }
+    @person.send(:new_field, :gender)
+    assert_equal 'male', @person.gender
+    refute_respond_to @person, :gender=
   end
 
-  def test_json
-    Person.send :include, Structure::JSON
+  def test_recursive_assignment
+    friend = { :name => 'Jane' }
+    @person.friend = friend
+    @person.friends = [friend]
+    assert_equal 'Jane', @person.friend.name
+    assert_equal 'Jane', @person.friends.first.name
+  end
 
-    person = Person.new(:name => 'John')
-    person.friends << Person.new(:name => 'Jane')
-    json = person.to_json
-    assert_kind_of Person, JSON.parse(json)
-    assert_kind_of Person, JSON.parse(json).friends.first
-    assert_equal false, person.respond_to?(:as_json)
+  def test_recursive_marshaling
+    hsh = {
+      :name => 'John',
+      :friend => { :name => 'Jane' },
+      :friends => [{ :name => 'Jane' }]
+    }
+    friend = Structure.new(:name => 'Jane')
+    @person.friend = friend
+    @person.friends = [friend]
+    assert_equal hsh, @person.marshal_dump
+
+    person = Structure.new
+    person.marshal_load(hsh)
+    assert_equal friend, person.friend
+    assert_equal friend, person.friends.first
+  end
 
-    require 'active_support/ordered_hash'
-    require 'active_support/json'
-    load 'structure/json.rb'
-    assert_equal true,  person.as_json(:only => :name).has_key?(:name)
-    assert_equal false, person.as_json(:except => :name).has_key?(:name)
+  def test_table
+    assert_equal({ :name => 'John' }, @person.send(:table))
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 0.22.1
+  version: 0.23.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-27 00:00:00.000000000 Z
+date: 2011-12-07 00:00:00.000000000 Z
 dependencies: []
-description: Structure is a typed key/value container.
+description: Structure is a key/value container.
 email:
 - code@papercavalier.com
 executables: []
@@ -25,9 +25,11 @@ files:
 - README.md
 - Rakefile
 - lib/structure.rb
-- lib/structure/json.rb
+- lib/structure/ext/active_support.rb
 - lib/structure/version.rb
 - structure.gemspec
+- test/defined_structure_test.rb
+- test/helper.rb
 - test/structure_test.rb
 homepage: http://github.com/hakanensari/structure
 licenses: []
@@ -49,9 +51,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: structure
-rubygems_version: 1.8.10
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: A typed key/value container
+summary: A key/value container
 test_files:
+- test/defined_structure_test.rb
+- test/helper.rb
 - test/structure_test.rb

data/lib/structure/json.rb

@@ -1,79 +0,0 @@
-begin
-  JSON::JSON_LOADED
-rescue NameError
-  require 'json'
-end
-
-class Structure
-  # JSON methods for a structure
-  #
-  # Include this in your structure if you need to cast it to JSON and
-  # vice versa.
-  #
-  # @example
-  #   class Point < Structure
-  #     include JSON
-  #
-  #     key :x, Integer
-  #     key :y, Integer
-  #   end
-  #
-  # Alternatively, include it in the parent class if you have more than
-  # one structure.
-  #
-  # @example
-  #   class Structure
-  #     include JSON
-  #   end
-  #
-  module JSON
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    # Converts structure to its JSON representation
-    #
-    # @param [Hash] args
-    # @return [JSON] a JSON representation of the structure
-    def to_json(*args)
-      { ::JSON.create_id => self.class.name }.
-        merge(@attributes).
-        to_json(*args)
-    end
-
-    if defined? ActiveSupport
-      # Converts structure to its JSON representation
-      #
-      # @param [Hash] options
-      # @return [JSON] a JSON representation of the structure
-      def as_json(options = nil)
-        subset = if options
-          if only = options[:only]
-            @attributes.slice(*Array.wrap(only))
-          elsif except = options[:except]
-            @attributes.except(*Array.wrap(except))
-          else
-            @attributes.dup
-          end
-        else
-          @attributes.dup
-        end
-
-        { ::JSON.create_id => self.class.name }.
-          merge(subset)
-      end
-    end
-
-    module ClassMethods
-      # Builds a structure out of its JSON representation
-      #
-      # @param [Hash] hsh a hash representation of a JSON
-      # @return [Structure] a structure
-      def json_create(hsh)
-        hsh.delete('json_class')
-
-        new(hsh)
-      end
-    end
-  end
-end