structure 0.16.0 → 0.17.1

data/Gemfile

@@ -2,13 +2,11 @@ source :rubygems
 
 gemspec
 
-gem 'json',          :platform => [:mri_18, :jruby, :rbx]
+gem 'activesupport', '~> 3.0'
+gem 'json', :platform => [:mri_18, :jruby, :rbx]
 gem 'rake'
 
-platforms :mri_18 do
-  gem 'ruby-debug', :require => 'ruby-debug' unless ENV['CI']
-end
-
-platforms :mri_19 do
-  gem 'ruby-debug19', :require => 'ruby-debug' unless ENV['CI']
+unless ENV['CI']
+  gem 'ruby-debug',   :platforms => :mri_18
+  gem 'ruby-debug19', :platforms => :mri_19
 end

data/README.md

@@ -4,25 +4,11 @@
 
 Structure is a typed, nestable key/value container.
 
-## Usage
-
-Install and require the gem.
-
-    require 'structure'
-
-Define a model.
-
-    Document = Structure::Document
-
-    class Person < Document
-      key  :name
-      many :friends, :class_name => 'Person'
+    class Person < Structure
+      key  :name, String
+      many :friends
     end
 
-    person = Person.create(:name => 'John')
-    person.friends << Person.create(:name => 'Jane')
-    person.friends.size # 1
-
 Please see [the project page] [1] for more detailed info.
 
 [1]: http://code.papercavalier.com/structure/

data/lib/structure/rails.rb

@@ -0,0 +1,19 @@
+class Structure
+  # Converts structure to a JSON representation.
+  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

data/lib/structure/static.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+
+# This module provides the class methods that render a structure
+# static, where records are sourced from a YAML file.
+class Structure
+  module Static
+    include Enumerable
+
+    def self.extended(base)
+      base.key(:_id, Integer)
+    end
+
+    # The data file path.
+    attr :data_path
+
+    # Returns all records.
+    def all
+      @all ||= YAML.load_file(data_path).map do |hsh|
+        hsh['_id'] ||= hsh.delete('id') || hsh.delete('ID') || incr_id
+        new(hsh)
+      end
+    end
+
+    # Yields each record to given block.
+    def each(&block)
+      all.each { |item| block.call(item) }
+    end
+
+    # Finds a record by its ID.
+    def find(id)
+      super() { |item| item._id == id }
+    end
+
+    private
+
+    def incr_id
+      @id_cnt = @id_cnt.to_i + 1
+    end
+  end
+end

data/lib/structure/version.rb

@@ -1,3 +1,3 @@
-module Structure
-  VERSION = '0.16.0'
+class Structure
+  VERSION = '0.17.1'
 end

data/lib/structure.rb

@@ -1 +1,153 @@
-require 'structure/document'
+begin
+  JSON::JSON_LOADED
+rescue NameError
+  require 'json'
+end
+
+# A structure is a nestable key/value container.
+#
+#    class Person < Structure
+#      key  :name
+#      key  :age, Integer
+#      many :friends
+#    end
+#
+class Structure
+  include Enumerable
+
+  autoload :Static,'structure/static'
+
+  class << self
+    # Returns attribute keys and their default values.
+    def defaults
+      @defaults ||= {}
+    end
+
+    # Builds a structure out of the JSON representation of a
+    # structure.
+    def json_create(hsh)
+      hsh.delete 'json_class'
+      new hsh
+    end
+
+    # Defines an attribute.
+    #
+    # Takes a name and, optionally, a type and options hash.
+    #
+    # The type should be a Ruby class.
+    #
+    # Available options are:
+    #
+    # * +:default+, which specifies a default value for the attribute.
+    def key(name, *args)
+      name    = name.to_sym
+      options = args.last.is_a?(Hash) ?  args.pop : {}
+      type    = args.shift
+      default = options[:default]
+
+      if method_defined?(name)
+        raise NameError, "#{name} is taken"
+      end
+
+      unless type.nil? || type.is_a?(Class)
+        raise TypeError, "#{type} isn't a Class" 
+      end
+
+      if default.nil? || default.is_a?(type)
+        defaults[name] = default
+      else
+        raise TypeError, "#{default} isn't a #{type}"
+      end
+
+      define_method(name) { attributes[name] }
+
+      if type.nil?
+        define_method("#{name}=") { |val| attributes[name] = val }
+      elsif Kernel.respond_to? type.to_s
+        define_method("#{name}=") do |val|
+          attributes[name] =
+            if val.nil? || val.is_a?(type)
+              val
+            else
+              Kernel.send(type.to_s, val)
+            end
+        end
+      else
+        define_method("#{name}=") do |val|
+          attributes[name] =
+            if val.nil? || val.is_a?(type)
+              val
+            else
+              raise TypeError, "#{val} isn't a #{type}"
+            end
+        end
+      end
+    end
+
+    # A shorthand that defines an attribute that is an array.
+    def many(name)
+      key name, Array, :default => []
+    end
+
+    # Renders the structure static by setting the path for a YAML file
+    # that stores the records.
+    def set_data_file(path)
+      extend Static unless self.respond_to? :all
+
+      @data_path = path
+    end
+  end
+
+  # Creates a new structure.
+  #
+  # A hash, if provided, will seed the attributes.
+  def initialize(hsh = {})
+    @attributes = self.class.defaults.inject({}) do |a, (k, v)|
+      a[k] = v.is_a?(Array) ? v.dup : v
+      a
+    end
+
+    hsh.each { |k, v| self.send("#{k}=", v) }
+  end
+
+  # The attributes that make up the structure.
+  attr :attributes
+
+  # Calls block once for each attribute in the structure, passing that
+  # attribute as a parameter.
+  def each(&block)
+    attributes.each { |v| block.call(v) }
+  end
+
+  # Converts structure to a hash.
+  def to_hash
+    attributes.inject({}) do |a, (k, v)|
+      a[k] =
+        if v.respond_to? :to_hash
+          v.to_hash
+        elsif v.is_a? Array
+          v.map { |e| e.respond_to?(:to_hash) ? e.to_hash : e }
+        else
+          v
+        end
+
+      a
+    end
+  end
+
+  # Converts structure to a JSON representation.
+  def to_json(*args)
+    { JSON.create_id => self.class.name }.
+      merge(attributes).
+      to_json(*args)
+  end
+
+  # Compares this object with another object for equality. A Structure
+  # is equal to the other object when both are of the same class and
+  # the their attributes are the same.
+  def ==(other)
+    other.is_a?(self.class) && attributes == other.attributes
+  end
+end
+
+require 'structure/rails' if defined?(Rails)

data/structure.gemspec

@@ -10,14 +10,10 @@ Gem::Specification.new do |s|
   s.email       = ['code@papercavalier.com']
   s.homepage    = 'http://github.com/hakanensari/structure'
   s.summary     = 'A typed, nestable key/value container'
-  s.description = 'A typed, nestable key/value container'
+  s.description = 'Structure is a typed, nestable key/value container.'
 
   s.rubyforge_project = 'structure'
 
-  s.add_dependency 'certainty',     '~> 0.2.0'
-  s.add_dependency 'activesupport', '~> 3.0'
-  s.add_dependency 'i18n',          '~> 0.6.0'
-
   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) }

data/test/structure_test.rb

@@ -0,0 +1,140 @@
+$:.push File.expand_path('../../lib', __FILE__)
+
+require 'bundler/setup'
+
+begin
+  require 'ruby-debug'
+rescue LoadError
+end
+
+require 'structure'
+require 'test/unit'
+
+class Test::Unit::TestCase
+  def self.test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+    if method_defined? test_name
+      raise "#{test_name} is already defined in #{self}"
+    end
+    define_method test_name, &block
+  end
+end
+
+class Person < Structure
+  key  :name
+  key  :age, Integer
+  many :friends
+end
+
+class TestStructure < Test::Unit::TestCase
+  test "should enumerate" do
+    assert_respond_to Person.new, :map
+  end
+
+  test "should define accessors" do
+    assert_respond_to Person.new, :name
+    assert_respond_to Person.new, :name=
+  end
+
+  test "should raise errors" do
+    assert_raise(NameError) { Person.key :class }
+    assert_raise(TypeError) { Person.key :foo, Module.new }
+    assert_raise(TypeError) { Person.key :foo, String, :default => 1 }
+  end
+
+  test "should store defaults" do
+    assert_equal [], Person.new.friends
+  end
+
+  test "should typecheck" do
+    person = Person.new
+    person.age = '18'
+    assert_equal 18, person.age
+
+    person.age = nil
+    assert_nil person.age
+  end
+
+  test "should handle arrays" do
+    person = Person.new
+    assert_equal [], person.friends
+
+    person.friends << Person.new
+    assert_equal 1, person.friends.size
+    assert_equal 0, person.friends.first.friends.size
+  end
+
+  test "should translate to hash" do
+    person = Person.new(:name => 'John')
+    person.friends << Person.new(:name => 'Jane')
+    assert_equal 'John', person.to_hash[:name]
+    assert_equal 'Jane', person.to_hash[:friends].first[:name]
+  end
+
+  test "should translate to JSON" do
+    person = Person.new
+    person.friends << Person.new
+    json = person.to_json
+    assert_kind_of Person, JSON.parse(json)
+    assert_kind_of Person, JSON.parse(json).friends.first
+  end
+
+  test "should translate to JSON in a Rails app" do
+    person = Person.new
+    assert_equal false, person.respond_to?(:as_json)
+
+    require 'active_support/ordered_hash'
+    require 'active_support/json'
+    require 'structure/rails'
+    assert_equal true,  person.as_json(:only => :name).has_key?(:name)
+    assert_equal false, person.as_json(:except => :name).has_key?(:name)
+  end
+end
+
+class City < Structure
+  key :name
+end
+
+class Stadt < Structure
+  key :name
+end
+
+class TestStatic < Test::Unit::TestCase
+  def fix(klass, path)
+    klass.instance_variable_set(:@all, nil)
+    klass.instance_variable_set(:@id_cnt, nil)
+    fixture = File.expand_path("../fixtures/#{path}.yml", __FILE__)
+    klass.set_data_file(fixture)
+  end
+
+  test "should enumerate at the class level" do
+    fix City, 'cities'
+    assert_respond_to City, :map
+  end
+
+  test "should return all records" do
+    fix City, 'cities'
+    cities = City.all
+    assert_kind_of City, cities.first
+    assert_equal 2, cities.size
+  end
+
+  test "should find a record" do
+    fix City, 'cities'
+    assert 'New York', City.find(1).name
+    assert_nil City.find(4)
+  end
+
+  test "should work if records contain no id field" do
+    fix City, 'cities_without_ids'
+    assert_equal 'New York', City.find(1).name
+    assert_equal 'Paris', City.find(3).name
+  end
+
+  test "should auto increment independently in each structure" do
+    fix City, 'cities_without_ids'
+    fix Stadt, 'cities_without_ids'
+    assert_equal 'New York', City.find(1).name
+    assert_equal 'New York', Stadt.find(1).name
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,42 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-24 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: certainty
-  requirement: &70198704238520 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.2.0
-  type: :runtime
-  prerelease: false
-  version_requirements: *70198704238520
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: &70198704237620 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: *70198704237620
-- !ruby/object:Gem::Dependency
-  name: i18n
-  requirement: &70198704236860 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-  type: :runtime
-  prerelease: false
-  version_requirements: *70198704236860
-description: A typed, nestable key/value container
+date: 2011-08-26 00:00:00.000000000Z
+dependencies: []
+description: Structure is a typed, nestable key/value container.
 email:
 - code@papercavalier.com
 executables: []
@@ -58,18 +25,13 @@ files:
 - README.md
 - Rakefile
 - lib/structure.rb
-- lib/structure/collection.rb
-- lib/structure/document.rb
-- lib/structure/document/static.rb
+- lib/structure/rails.rb
+- lib/structure/static.rb
 - lib/structure/version.rb
 - structure.gemspec
-- test/collection_test.rb
-- test/document_test.rb
 - test/fixtures/cities.yml
-- test/fixtures/cities_with_neighborhoods.yml
 - test/fixtures/cities_without_ids.yml
-- test/helper.rb
-- test/static_test.rb
+- test/structure_test.rb
 homepage: http://github.com/hakanensari/structure
 licenses: []
 post_install_message: 
@@ -84,7 +46,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2067006556322233036
+      hash: -4025252562895677644
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -93,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2067006556322233036
+      hash: -4025252562895677644
 requirements: []
 rubyforge_project: structure
 rubygems_version: 1.8.6
@@ -101,10 +63,6 @@ signing_key:
 specification_version: 3
 summary: A typed, nestable key/value container
 test_files:
-- test/collection_test.rb
-- test/document_test.rb
 - test/fixtures/cities.yml
-- test/fixtures/cities_with_neighborhoods.yml
 - test/fixtures/cities_without_ids.yml
-- test/helper.rb
-- test/static_test.rb
+- test/structure_test.rb

data/lib/structure/collection.rb

@@ -1,67 +0,0 @@
-require 'forwardable'
-
-module Structure
-  class Collection < Array
-    class << self
-      attr :type
-
-      alias overridden_new new
-
-      def new(type)
-        unless type < Document
-          raise TypeError, "#{type} isn't a Document"
-        end
-        class_name = "#{type}Collection"
-
-        begin
-          class_name.constantize
-        rescue NameError
-          Object.class_eval <<-ruby
-            class #{class_name} < Structure::Collection
-              @type = #{type}
-            end
-          ruby
-          retry
-        end
-      end
-
-      private
-
-      def inherited(child)
-        Kernel.send(:define_method, child.name) do |arg|
-          case arg
-          when child
-            arg
-          else
-            [arg].flatten.inject(child.new) { |a, e| a << e }
-          end
-        end
-        child.instance_eval { alias new overridden_new }
-      end
-    end
-
-    attr :members
-
-    %w{concat eql? push replace unshift}.each do |method|
-      define_method method do |ary|
-        super ary.map { |item| Kernel.send(type.to_s, item) }
-      end
-    end
-
-    def <<(item)
-      super Kernel.send(type.to_s, item)
-    end
-
-    def create(*args)
-      self.<< type.new(*args)
-
-      true
-    end
-
-    private
-
-    def type
-      self.class.type
-    end
-  end
-end

data/lib/structure/document/static.rb

@@ -1,66 +0,0 @@
-require 'yaml'
-
-# When included in a document, this module will turn it into a static
-# model which sources its records from a yaml file.
-module Structure
-  class Document
-    module Static
-      class << self
-        private
-
-        def included(base)
-          base.key(:_id, Integer)
-          base.extend(ClassMethods)
-        end
-      end
-
-      module ClassMethods
-        include Enumerable
-
-        # The path for the data file.
-        #
-        # This file should contain a YAML representation of the records.
-        #
-        # Overwrite this reader with an opiniated location to dry.
-        attr :data_path
-
-        # Returns all records.
-        def all
-          @records ||= data.map do |record|
-            record['_id'] ||= record.delete('id') || increment_id
-            new(record)
-          end
-        end
-
-        # Yields each record to given block.
-        #
-        # Other enumerators will be made available by the Enumerable
-        # module.
-        def each(&block)
-          all.each { |record| block.call(record) }
-        end
-
-        # Finds a record by its ID.
-        def find(id)
-          detect { |record| record._id == id }
-        end
-
-        # Sets the path for the data file.
-        def set_data_path(data_path)
-          @data_path = data_path
-        end
-
-        private
-
-        def data
-          YAML.load_file(@data_path)
-        end
-
-
-        def increment_id
-          @increment_id = @increment_id.to_i + 1
-        end
-      end
-    end
-  end
-end

data/lib/structure/document.rb

@@ -1,212 +0,0 @@
-begin
-  JSON::JSON_LOADED
-rescue NameError
-  require 'json'
-end
-
-require 'active_support/inflector'
-require 'certainty'
-
-require 'structure/collection'
-
-module Structure
-  # A document is a typed, nestable key/value container.
-  #
-  #    class Person < Document
-  #      key  :name
-  #      key  :age, Integer
-  #      one  :location
-  #      many :friends, :class_name => 'Person'
-  #    end
-  #
-  class Document
-    include Enumerable
-
-    autoload :Static,'structure/document/static'
-
-    # An attribute may be of the following data types.
-    TYPES = [Array, Boolean, Collection, Document, Float, Hash, Integer, String]
-
-    class << self
-      # Returns the default values for the attributes.
-      def defaults
-        @defaults ||= {}
-      end
-
-      # Builds a Ruby object out of the JSON representation of a
-      # structure.
-      def json_create(object)
-        object.delete 'json_class'
-        new object
-      end
-
-      # Defines an attribute.
-      #
-      # Takes a name, an optional type, and an optional hash of options.
-      #
-      # If nothing is specified, type defaults to +String+.
-      #
-      # Available options are:
-      #
-      # * +:default+, which sets the default value for the attribute. If
-      #   no default value is specified, it defaults to +nil+.
-      def key(name, *args)
-        name    = name.to_sym
-        options = args.last.is_a?(Hash) ?  args.pop : {}
-        type    = args.shift || String
-        default = options[:default]
-
-        if method_defined? name
-          raise NameError, "#{name} is already defined"
-        end
-
-        if (type.ancestors & TYPES).empty?
-          raise TypeError, "#{type} isn't a valid type"
-        end
-
-        if default.nil? || default.is_a?(type)
-          defaults[name] = default
-        else
-          raise TypeError, "#{default} isn't a #{type}"
-        end
-
-        module_eval do
-          define_method(name) { @attributes[name] }
-
-          define_method("#{name}=") do |value|
-            @attributes[name] = if value.is_a?(type) || value.nil?
-                                  value
-                                else
-                                  Kernel.send(type.to_s, value)
-                                end
-          end
-
-          alias_method "#{name}?", name if type == Boolean
-        end
-      end
-
-      # Defines an attribute that represents a collection.
-      def many(name, options = {})
-        class_name = options.delete(:class_name) || name.to_s.classify
-        klass      = constantize class_name
-        collection = Collection.new(klass)
-
-        key name, collection, options.merge(:default => collection.new)
-      end
-
-      # Defines an attribute that represents another structure. Takes
-      # a name and optional hash of options.
-      def one(name, options = {})
-        class_name = options.delete(:class_name) || name.to_s.classify
-        klass      = constantize class_name
-
-        unless klass < Document
-          raise TypeError, "#{klass} isn't a Document"
-        end
-
-        define_method("create_#{name}") do |*args|
-          self.send("#{name}=", klass.new(*args))
-        end
-
-        key name, klass, options
-      end
-
-      alias create new
-
-      private
-
-      def constantize(name)
-        name.constantize
-      rescue
-        Object.class_eval <<-ruby
-          class #{name} < Structure::Document; end
-        ruby
-        retry
-      end
-
-      def inherited(child)
-        Kernel.send(:define_method, child.name) do |arg|
-          case arg
-          when child
-            arg
-          when Hash
-            child.new arg
-          else
-            raise TypeError, "can't convert #{arg.class} into #{child}"
-          end
-        end
-      end
-    end
-
-    # Creates a new structure.
-    #
-    # A hash, if provided, will seed its attributes.
-    def initialize(hash = {})
-      @attributes = self.class.defaults.inject({}) do |a, (k, v)|
-        a[k] = v.is_a?(Array) || v.is_a?(Collection) ? v.dup : v
-        a
-      end
-
-      hash.each { |k, v| self.send("#{k}=", v) }
-    end
-
-    # The attributes that make up the structure.
-    attr :attributes
-
-    # Returns a Rails-friendly JSON representation of the structure.
-    def as_json(options = nil)
-      subset = if options
-        if attrs = options[:only]
-          @attributes.slice(*Array.wrap(attrs))
-        elsif attrs = options[:except]
-          @attributes.except(*Array.wrap(attrs))
-        else
-          @attributes.dup
-        end
-      else
-        @attributes.dup
-      end
-
-      klass = self.class.name
-      { JSON.create_id => klass }.
-        merge(subset)
-    end
-
-    # Calls block once for each attribute in the structure, passing that
-    # attribute as a parameter.
-    def each(&block)
-      @attributes.each { |v| block.call(v) }
-    end
-
-    # Returns a hash representation of the structure.
-    def to_hash
-      @attributes.inject({}) do |a, (k, v)|
-        a[k] =
-          if v.respond_to?(:to_hash)
-            v.to_hash
-          elsif v.is_a?(Array) || v.is_a?(Collection)
-            v.map { |e| e.respond_to?(:to_hash) ? e.to_hash : e }
-          else
-            v
-          end
-
-        a
-      end
-    end
-
-    # Returns a JSON representation of the structure.
-    def to_json(*args)
-      klass = self.class.name
-      { JSON.create_id => klass }.
-        merge(@attributes).
-        to_json(*args)
-    end
-
-    # Compares this object with another object for equality. A Structure
-    # is equal to the other object when latter is of the same class and
-    # the two objects' attributes are the same.
-    def ==(other)
-      other.is_a?(self.class) && @attributes == other.attributes
-    end
-  end
-end

data/test/collection_test.rb

@@ -1,33 +0,0 @@
-require File.expand_path('../helper.rb', __FILE__)
-
-class Foo < Document
-  key :bar
-end
-
-class TestCollection < Test::Unit::TestCase
-  def setup
-    Structure::Collection.new(Foo)
-  end
-
-  def test_subclassing
-    assert       FooCollection < Structure::Collection
-    assert_equal Foo, FooCollection.type
-  end
-
-  def test_conversion
-    item = Foo.new
-
-    assert_equal   item, FooCollection([item]).first
-    assert_kind_of FooCollection, FooCollection([item])
-
-    assert_equal   item, FooCollection(item).first
-    assert_kind_of FooCollection, FooCollection(item)
-
-    assert_raise(TypeError) { FooCollection('foo') }
-  end
-
-  def test_enumeration
-    assert_respond_to FooCollection.new, :map
-    assert_kind_of    FooCollection, FooCollection.new.map! { |e| e }
-  end
-end

data/test/document_test.rb

@@ -1,113 +0,0 @@
-require File.expand_path('../helper.rb', __FILE__)
-
-class Person < Document
-  key  :name
-  key  :single, Boolean, :default => true
-  one  :location
-  many :friends,  :class_name => 'Person'
-end
-
-class Location < Document
-  key :lon, Float
-  key :lat, Float
-end
-
-class TestDocument < Test::Unit::TestCase
-  def test_enumeration
-    assert_respond_to Person.new, :map
-  end
-
-  def test_accessors
-    assert_respond_to Person.new, :name
-    assert_respond_to Person.new, :name=
-  end
-
-  def test_converter
-    assert_kind_of Person, Person(Person.new)
-    assert_kind_of Person, Person(:name => 'John')
-    assert_raise(TypeError) { Person('John') }
-  end
-
-  def test_errors
-    assert_raise(NameError) { Person.key :class }
-    assert_raise(TypeError) { Person.key :foo, Object }
-    assert_raise(TypeError) { Person.key :foo, :default => 1 }
-  end
-
-  def test_defaults
-    assert_equal true, Person.create.single?
-  end
-
-  def test_typecheck
-    location = Location.new
-
-    location.lon = '100'
-    assert_equal 100.0, location.lon
-
-    location.lon = nil
-    assert_nil location.lon
-  end
-
-  def test_one
-    person = Person.new
-
-    person.location = Location.new(:lon => 2.0)
-    assert_equal 2.0, person.location.lon
-
-    person.create_location :lon => 1.0
-    assert_equal 1.0, person.location.lon
-  end
-
-  def test_many
-    person = Person.new
-
-    person.friends.create
-    person.friends.create :name => 'John'
-    assert_equal 2, person.friends.size
-    assert_equal 0, person.friends.last.friends.size
-
-    friend = Person.new
-
-    person.friends = [friend]
-    assert_equal 1, person.friends.size
-    assert_equal 0, friend.friends.size
-
-    person.friends << friend
-    assert_equal 2, person.friends.size
-    assert_equal 0, friend.friends.size
-    assert_equal 0, person.friends.last.friends.size
-
-    person.friends.clear
-    assert_equal 0, person.friends.size
-    assert       person.friends.empty?
-  end
-
-  def test_to_hash
-    person = Person.new
-    person.friends.create :name => 'John'
-    assert_equal 'John', person.to_hash[:friends].first[:name]
-  end
-
-  def test_json
-    person = Person.new
-    json = person.to_json
-    assert_equal person, JSON.parse(json)
-  end
-
-  def test_json_with_nested_structures
-    person = Person.new
-    person.friends << Person.new
-    person.location = Location.new
-    json = person.to_json
-    assert JSON.parse(json).friends.first.is_a? Person
-    assert JSON.parse(json).location.is_a? Location
-  end
-
-  def test_json_with_active_support
-    require 'active_support/ordered_hash'
-    require 'active_support/json'
-    person = Person.new
-    assert person.as_json(:only => :name).has_key?(:name)
-    assert !person.as_json(:except => :name).has_key?(:name)
-  end
-end

data/test/fixtures/cities_with_neighborhoods.yml

@@ -1,7 +0,0 @@
----
-- id: 1
-  name: New York
-  neighborhoods:
-  - name: Manhattan
-  - name: Brooklyn
-  - name: Queens

data/test/helper.rb

@@ -1,13 +0,0 @@
-$:.push File.expand_path('../../lib', __FILE__)
-
-require 'bundler/setup'
-
-begin
-  require 'ruby-debug'
-rescue LoadError
-end
-
-require 'structure'
-require 'test/unit'
-
-Document = Structure::Document

data/test/static_test.rb

@@ -1,62 +0,0 @@
-require File.expand_path('../helper.rb', __FILE__)
-
-class City < Document
-  include Static
-
-  key  :name
-  many :neighborhoods
-end
-
-class Neighborhood < Document
-  key :name
-end
-
-class Dummy < Document
-  include Static
-
-  key :name
-end
-
-class TestStatic < Test::Unit::TestCase
-  def fixture(klass, path)
-    klass.instance_variable_set(:@records, nil)
-    klass.instance_variable_set(:@increment_id, nil)
-    fixture = File.expand_path("../fixtures/#{path}.yml", __FILE__)
-    klass.set_data_path(fixture)
-  end
-
-  def test_class_enumeration
-    assert_respond_to City, :map
-  end
-
-  def test_all
-    fixture City, 'cities'
-    cities = City.all
-    assert_kind_of City, cities.first
-    assert_equal 2, cities.size
-  end
-
-  def test_find
-    fixture City, 'cities'
-    assert 'New York', City.find(1).name
-    assert_nil City.find(4)
-  end
-
-  def test_data_without_ids
-    fixture City, 'cities_without_ids'
-    assert_equal 'New York', City.find(1).name
-    assert_equal 'Paris', City.find(3).name
-  end
-
-  def test_auto_increment
-    fixture City, 'cities_without_ids'
-    fixture Dummy, 'cities_without_ids'
-    assert_equal 'New York', City.find(1).name
-    assert_equal 'New York', Dummy.find(1).name
-  end
-
-  def test_nesting
-    fixture City, 'cities_with_neighborhoods'
-    assert_kind_of Neighborhood, City.first.neighborhoods.first
-  end
-end