structure 0.12.2 → 0.13.1

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - jruby
+  - rbx

data/CHANGELOG.md

@@ -1,21 +1,26 @@
-# 0.8
+# 0.13
 
-* Make JSON patch compatible with Active Support.
-* Remove URI from list of types.
+* Remove static module.
+* Rename .key to .attribute.
 
-# 0.9
+# 0.12
 
-* Add presence method.
+* Add static module.
+
+# 0.11
+
+* .key now emulates DataMapper.property.
 
 # 0.10
 
-* Rename has_one and has_many to embeds_one and embeds_many to make room
+* Rename .has_one and .has_many to .embeds_one and .embeds_many to make room
   for associations.
 
-# 0.11
+# 0.9
 
-* .key now emulates the DataMapper.property method.
+* Add presence method.
 
-# 0.12
+# 0.8
 
-* Add basic support for static models.
+* Make JSON patch compatible with Active Support.
+* Remove URI from list of types.

data/Gemfile

@@ -1,4 +1,5 @@
-source "http://rubygems.org"
+source :rubygems
 
-# Specify your gem's dependencies in structure.gemspec
-gemspec
+gem 'activesupport', '>= 3.0'
+gem 'json',          :platform => [:mri_18, :jruby]
+gem 'rake',          '~> 0.9'

data/README.md

@@ -1,101 +1,69 @@
-Structure
-=========
-
-Structure is a key/value container for modeling ephemeral data in Ruby.
-
-Structure typecasts, nests other structures, and talks flawless JSON.
-
-    #_                                                                       d
-    ##_                                                                     d#
-    NN#p                                                                  j0NN
-    40NNh_                                                              _gN#B0
-    4JF@NNp_                                                          _g0WNNL@
-    JLE5@WRNp_                                                      _g@NNNF3_L
-    _F`@q4WBN@Np_                                                _gNN@ZL#p"Fj_
-    "0^#-LJ_9"NNNMp__                                         _gN#@#"R_#g@q^9"
-    a0,3_j_j_9FN@N@0NMp__                                __ggNZNrNM"P_f_f_E,0a
-    j  L 6 9""Q"#^q@NDNNNMpg____                ____gggNNW#W4p^p@jF"P"]"j  F
-    rNrr4r*pr4r@grNr@q@Ng@q@N0@N#@NNMpmggggmqgNN@NN@#@4p*@M@p4qp@w@m@Mq@r#rq@r
-     F Jp 9__b__M,Juw*w*^#^9#""EED*dP_@EZ@^E@*#EjP"5M"gM@p*Ww&,jL_J__f  F j
-    -r#^^0""E" 6  q  q__hg-@4""*,_Z*q_"^pwr""p*C__@""0N-qdL_p" p  J" 3""5^^0r-
-     t  J  __,Jb--N""",  *_s0M`""q_a@NW__JP^u_p"""p4a,p" _F""V--wL,_F_ F  #
-    _,Jp*^#""9   L  5_a*N"""q__INr" "q_e^"*,p^""qME_ y"""p6u,f  j'  f "N^--LL_
-      L  ]   k,w@#"""_  "_a*^E   ba-" ^qj-""^pe"  J^-u_f  _f "q@w,j   f  jL
-      #_,J@^""p  `_ _jp-""q  _Dw^" ^cj*""*,j^  "p#_  y""^wE_ _F   F"^qN,_j
-    w*^0   4   9__sAF" `L  _Dr"  m__m""q__a^"m__*  "qA_  j" ""Au__f   J   0^--
-      ]   J_,x-E   3_  jN^" `u _w^*_  _RR_  _J^w_ j"  "pL_  f   7^-L_F   #
-      jLs*^6   `_  _&*"  q  _,NF   "wp"  "*g"   _NL_  p  "-d_   F   ]"*u_F
-    ,x-"F   ]    Ax^" q    hp"  `u jM""u  a^ ^, j"  "*g_   p  ^mg_   D.H. 1992
-
-
-Usage
------
-
-Define a model:
+# Structure
 
-```ruby
-require 'structure'
+[![travis](https://secure.travis-ci.org/papercavalier/structure.png)](http://travis-ci.org/papercavalier/structure)
 
-class Person < Structure
-  key         :name, :default => "John Doe"
-  key         :age, Integer
-  embeds_many :friends
-  embeds_one  :partner
-end
-```
+Structure is Ruby module that turns a class into a key/value container.
+
+## Usage
 
-Create an object:
+Set up models.
 
 ```ruby
-p1 = Person.new :name => 'Gilles'
-```
+require 'structure'
 
-Typecast:
+class Book
+  include Structure
 
-```ruby
-p1.age = '28'
-p1.age
-=> 28
+  attribute   :title
+  attribute   :binding, :default => "Hardcover"
+  attribute   :year_published, Integer
+  embeds_many :authors
+end
+
+class Author
+  include Structure
+
+  attribute :name
+  attribute :role
+end
 ```
 
-Check for presence:
+Create some objects.
 
 ```ruby
-p1.age?
-=> true
+book = Book.new :title => "A Thousand Plateaus"
+author = Author.new :name => "Gilles Deleuze"
+book.authors << author
 ```
 
-
-Embed other structures:
+Attributes in structures are typecasted.
 
 ```ruby
-p2 = Person.new
-p1.friends << p2
+book.year_published = "1985"
+puts book.year_published
+=> 1985
 ```
 
-Talk JSON:
+Translate to JSON and back into Ruby.
 
 ```ruby
-require 'structure/json'
+json = book.to_json
+puts json
+=> {"json_class":"Book","title":"A Thousand Plateaus","binding":"Hardcover,"year_published":1985,"authors":[{"json_class":"Author","name":"Gilles Deleuze","role":null}]}
 
-json = p1.to_json
-=> {"json_class":"Person","name":"Gilles","age":28,"friends":[{"json_class":"Person","name":"John Doe","age":null,"friends":[]}],"partner":null}
-
-person = JSON.parse(json)
-person.friends.first
-=> #<Person:0x0000010107d030 @attributes={:name=>"John Doe", :age=>nil, :friends=>[], :partner=>nil}>
+book = JSON.parse(json)
+puts book.authors.first.name
+=> "Gilles Deleuze"
 ```
 
-Quack Active Model:
+Mix in Active Model modules.
 
 ```ruby
 require 'active_model'
 
-class Book < Structure
+class Book
   include ActiveModel::Validations
 
-  key :title
-
   validates_presence_of :title
 end
 
@@ -104,20 +72,4 @@ book.valid?
 => false
 book.errors
 => {:title=>["can't be blank"]}
-book.title = "Society of the Spectacle"
-book.valid?
-=> true
 ```
-
-Types
------
-
-Structure supports the following types:
-
-* Array
-* Boolean
-* Float
-* Hash
-* Integer
-* String
-* Structure

data/Rakefile

@@ -1,10 +1,9 @@
-require 'bundler'
-require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
-Bundler::GemHelper.install_tasks
+task :default => :test
 
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern = "spec/**/*_spec.rb"
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/**/*_test.rb']
 end
-
-task :default => [:spec]

data/lib/structure.rb

@@ -4,94 +4,95 @@ rescue NameError
   require 'json'
 end
 
-# Ruby doesn't have a Boolean class, so let's feign one.
-unless Object.const_defined?(:Boolean)
+# Fabricate a +Boolean+ class.
+unless defined? Boolean
   module Boolean; end
-  class TrueClass; include Boolean; end
-  class FalseClass; include Boolean; end
+  [TrueClass, FalseClass].each { |klass| klass.send :include, Boolean }
 end
 
-# A key/value container for modeling ephemeral data.
-class Structure
+# Structure is a Ruby module that turns a class into a key/value container.
+#
+#    class Person
+#      include Structure
+#
+#      attribute :name
+#      attribute :age, Integer
+#    end
+#
+#    person = Person.new(:name => "John")
+#    person.name
+#    => "John"
+#
+module Structure
   include Enumerable
 
+  # Structure supports the following types.
   TYPES = [Array, Boolean, Float, Hash, Integer, String, Structure]
 
-  class << self
-    # A shortcut to define an attribute that represents an array of other
-    # objects, possibly structures.
-    def embeds_many(name)
-      key name, Array, :default => []
+  module ClassMethods
+    # Defines an attribute that represents an array of objects, possibly
+    # structures.
+    def embeds_many(key)
+      attribute key, Array, :default => []
     end
 
-    # A shortcut to define an attribute that represents another structure.
-    def embeds_one(name)
-      key name, Structure
+    # Defines an attribute that represents another structure.
+    def embeds_one(key)
+      attribute key, Structure
     end
 
+    # Builds a structure out of its JSON representation.
     def json_create(object)
-      object.delete('json_class')
-      new(object)
+      object.delete 'json_class'
+      new object
     end
 
-    # Defines an attribute key.
+    # Defines an attribute.
     #
-    # Takes a name, an optional type, and an optional hash of options.
+    # Takes a key, an optional type, and an optional hash of options.
     #
-    # The type can be Array, Boolean, Float, Hash, Integer, String, or
-    # Structure. If none is specified, it defaults to String.
+    # The type can be +Array+, +Boolean+, +Float+, +Hash+, +Integer+, +String+,
+    # or +Structure+. If none is specified, this defaults to String.
     #
     # Available options are:
     #
-    # * :default, which sets the default value for the attribute.
-    #
-    #    class Book
-    #      key :title
-    #      key :authors, Array, :default => []
-    #    end
-    def key(name, *args)
-      name = name.to_sym
-      options = if args.last.is_a? Hash
-                  args.pop
-                else
-                  {}
-                end
-      type = args.shift || String
-
-      if method_defined?(name)
-        raise NameError, "#{name} is already defined"
-      end
+    # * +:default+, which sets the default value for the attribute.
+    def attribute(key, *args)
+      key     = key.to_sym
+      options = args.last.is_a?(Hash) ?  args.pop : {}
+      type    = args.shift || String
+      default = options[:default]
 
-      unless TYPES.include? type
-        raise TypeError, "#{type} is not a valid type"
+      if method_defined? key
+        raise NameError, "#{key} is already defined"
       end
 
-      default = options[:default]
-      unless default.nil? || default.is_a?(type)
-        raise TypeError, "#{default} is not #{%w{AEIOU}.include?(type.to_s[0]) ? 'an' : 'a'} #{type}"
+      if TYPES.include?(type) && (default.nil? || default.is_a?(type))
+        default_attributes[key] = default
+      else
+        msg = "#{default} is not a#{'n' if type.to_s.match(/^[AI]/)} #{type}"
+        raise TypeError, msg
       end
 
-      default_attributes[name] = default
-
       module_eval do
-
-        # Define a proc to typecast value.
+        # Define a closure that typecasts value.
         typecast =
           if type == Boolean
             lambda do |value|
               case value
+              when Boolean
+                value
               when String
-               value =~ /1|true/i
+                value !~ /0|false/i
               when Integer
                 value != 0
               else
-               !!value
+                !!value
               end
             end
           elsif [Hash, Structure].include? type
-
-            # Raise an exception rather than typecast if type is Hash or
-            # Structure.
+            # Don't bother with typecasting attributes of type +Hash+ or
+            # +Structure+.
             lambda do |value|
               unless value.is_a? type
                 raise TypeError, "#{value} is not a #{type}"
@@ -102,16 +103,17 @@ class Structure
             lambda { |value| Kernel.send(type.to_s, value) }
           end
 
-        # Define a getter.
-        define_method(name) { @attributes[name] }
+        # Define attribute accessors.
+        define_method(key) { @attributes[key] }
 
-        # Define a setter.
-        define_method("#{name}=") do |value|
-          @attributes[name] = value.nil? ? nil : typecast.call(value)
+        define_method("#{key}=") do |value|
+          @attributes[key] = value.nil? ? nil : typecast.call(value)
         end
 
-        # Define a "presence" (for lack of a better term) method
-        define_method("#{name}?") { !!@attributes[name] }
+        # Define a method to check for presence.
+        unless type == Array
+          define_method("#{key}?") { !!@attributes[key] }
+        end
       end
     end
 
@@ -121,23 +123,27 @@ class Structure
     end
   end
 
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
   # Creates a new structure.
   #
-  # Optionally, seeds the structure with a hash of attributes.
-  def initialize(seed = {})
+  # A hash, if provided, will seed its attributes.
+  def initialize(hash = {})
     @attributes = {}
     self.class.default_attributes.each do |key, value|
       @attributes[key] = value.is_a?(Array) ? value.dup : value
     end
 
-    seed.each { |key, value| self.send("#{key}=", value) }
+    hash.each { |key, value| self.send("#{key}=", value) }
   end
 
-  # A hash of attributes.
+  # A hash that stores the attributes of the structure.
   attr_reader :attributes
 
+  # Returns a Rails-friendly JSON representation of the structure.
   def as_json(options = nil)
-    # create a subset of the attributes by applying :only or :except
     subset = if options
       if attrs = options[:only]
         @attributes.slice(*Array.wrap(attrs))
@@ -155,6 +161,8 @@ class Structure
       merge(subset)
   end
 
+  # Calls block once for each attribute in the structure, passing that
+  # attribute as a parameter.
   def each(&block)
     @attributes.each { |value| block.call(value) }
   end
@@ -164,6 +172,7 @@ class Structure
     @attributes.keys
   end
 
+  # Returns a JSON representation of the structure.
   def to_json(*args)
     klass = self.class.name
     { JSON.create_id => klass }.

data/lib/structure/version.rb

@@ -1,3 +1,3 @@
-class Structure
-  VERSION = '0.12.2'
+module Structure
+  VERSION = '0.13.1'
 end

data/structure.gemspec

@@ -8,23 +8,12 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Paper Cavalier"]
   s.email       = ["code@papercavalier.com"]
-  s.homepage    = "http://rubygems.com/gems/structure"
-  s.summary     = "A key/value container for modeling ephemeral data"
-  s.description = <<-END_OF_DESCRIPTION.strip
-    Structure is a key/value container for modeling ephemeral data.
-    END_OF_DESCRIPTION
+  s.homepage    = "http://code.papercavalier.com/structure"
+  s.summary     = "Turns a class into a key/value container"
+  s.description = "Structure turns a class into a key/value container."
 
   s.rubyforge_project = "structure"
 
-  {
-    'activesupport'  => '>= 3.0',
-    'rake'           => '~> 0.9',
-    'rspec'          => '~> 2.6',
-    'ruby-debug19'   => '~> 0.11.6'
-  }.each do |lib, version|
-    s.add_development_dependency lib, version
-  end
-
   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/{spec/models/book.rb → test/models.rb}

@@ -1,4 +1,8 @@
-class Book < Structure
+class Book
+  include Structure
+
   key :title
   key :authors, Array, :value => []
 end
+
+

data/test/structure_test.rb

@@ -0,0 +1,134 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+
+require File.expand_path("../../lib/structure", __FILE__)
+
+class Person
+  include Structure
+
+  attribute   :name
+  attribute   :age, Integer
+  attribute   :married, Boolean, :default => false
+  embeds_one  :spouse 
+  embeds_many :children
+end
+
+class TestStructure < Test::Unit::TestCase
+  def test_enumeration
+    person = Person.new
+    assert_respond_to(person, :map)
+  end
+
+  def test_method_generation
+    person = Person.new
+    assert_respond_to(person, :name)
+    assert_respond_to(person, :name=)
+    assert_respond_to(person, :name?)
+  end
+
+  def test_attribute_errors
+    assert_raise(NameError) { Person.attribute :class }
+    assert_raise(TypeError) { Person.attribute :foo, Object }
+    assert_raise(TypeError) { Person.attribute :foo, :default => 1 }
+  end
+
+  def test_default_attributes
+    assert_equal({ :name => nil, :age => nil, :married => false, :spouse => nil, :children => [] }, Person.default_attributes)
+  end
+
+  def test_initialization
+    person = Person.new(:name => 'John', :age => 28)
+    assert_equal('John', person.name)
+    assert_equal(28, person.age)
+  end
+
+  def test_typecasting
+    person = Person.new
+
+    person.age = "28"
+    assert_equal(28, person.age)
+
+    person.age = nil
+    assert_nil(person.age)
+  end
+
+  def test_presence
+    person = Person.new
+
+    person.married = nil
+    assert(!person.married?)
+
+    person.married = false
+    assert(!person.married?)
+
+    person.married = true
+    assert(person.married?)
+  end
+
+  def test_default_type
+    person = Person.new
+    person.name = 1
+    assert(person.name.is_a? String)
+  end
+
+  def test_boolean_typecasting
+    person = Person.new
+
+    person.married = 'false'
+    assert(person.married == false)
+
+    person.married = 'FALSE'
+    assert(person.married == false)
+
+    person.married = '0'
+    assert(person.married == false)
+
+    person.married = 'foo'
+    assert(person.married == true)
+
+    person.married = 0
+    assert(person.married == false)
+
+    person.married = 10
+    assert(person.married == true)
+  end
+
+  def test_defaults
+    person = Person.new
+    assert_equal(false, person.married)
+    assert_equal(nil, person.name)
+    assert_equal(nil, person.spouse)
+    assert_equal([], person.children)
+  end
+
+  def test_array
+    person = Person.new
+    child = Person.new
+    person.children << child
+    assert_equal(1, person.children.count)
+    assert_equal(0, child.children.count)
+  end
+
+  def test_json
+    person = Person.new(:name => 'Joe')
+    json = person.to_json
+    assert_equal(person, JSON.parse(json))
+  end
+
+  def test_json_with_nested_structures
+    person = Person.new
+    person.children << Person.new
+    json = person.to_json
+    assert(JSON.parse(json).children.first.is_a? Person)
+  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

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 12
-  - 2
-  version: 0.12.2
+  - 13
+  - 1
+  version: 0.13.1
 platform: ruby
 authors: 
 - Paper Cavalier
@@ -14,67 +14,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-25 00:00:00 +01:00
+date: 2011-07-26 00:00:00 +01:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        version: "3.0"
-  type: :development
-  prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 9
-        version: "0.9"
-  type: :development
-  prerelease: false
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 6
-        version: "2.6"
-  type: :development
-  prerelease: false
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: ruby-debug19
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 11
-        - 6
-        version: 0.11.6
-  type: :development
-  prerelease: false
-  version_requirements: *id004
-description: Structure is a key/value container for modeling ephemeral data.
+dependencies: []
+
+description: Structure turns a class into a key/value container.
 email: 
 - code@papercavalier.com
 executables: []
@@ -86,28 +30,19 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - .rvmrc
+- .travis.yml
 - CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- benchmark.rb
 - lib/structure.rb
-- lib/structure/static.rb
 - lib/structure/version.rb
-- spec/fixtures/cities.yml
-- spec/fixtures/cities_with_neighborhoods.yml
-- spec/fixtures/cities_without_id.yml
-- spec/models/book.rb
-- spec/models/city.rb
-- spec/models/person.rb
-- spec/spec_helper.rb
-- spec/structure/json_spec.rb
-- spec/structure/static_spec.rb
-- spec/structure_spec.rb
 - structure.gemspec
+- test/models.rb
+- test/structure_test.rb
 has_rdoc: true
-homepage: http://rubygems.com/gems/structure
+homepage: http://code.papercavalier.com/structure
 licenses: []
 
 post_install_message: 
@@ -120,7 +55,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2262708410600119149
+      hash: -2785152293474576694
       segments: 
       - 0
       version: "0"
@@ -129,7 +64,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2262708410600119149
       segments: 
       - 0
       version: "0"
@@ -139,15 +73,7 @@ rubyforge_project: structure
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: A key/value container for modeling ephemeral data
+summary: Turns a class into a key/value container
 test_files: 
-- spec/fixtures/cities.yml
-- spec/fixtures/cities_with_neighborhoods.yml
-- spec/fixtures/cities_without_id.yml
-- spec/models/book.rb
-- spec/models/city.rb
-- spec/models/person.rb
-- spec/spec_helper.rb
-- spec/structure/json_spec.rb
-- spec/structure/static_spec.rb
-- spec/structure_spec.rb
+- test/models.rb
+- test/structure_test.rb

data/benchmark.rb

@@ -1,24 +0,0 @@
-require 'benchmark'
-require 'ostruct'
-require_relative 'lib/structure'
-
-class Person1 < Structure
-  key :name
-end
-
-class Person2 < Struct.new(:name)
-end
-
-class Person3
- attr_accessor :name
-end
-
-n = 100000
-Benchmark.bm do |x|
-  x.report('Structure')  { n.times { Person1.new(:name => 'John') } }
-  x.report('Structure')  { n.times { Person1.new.name = 'John' } }
-  x.report('OpenStruct') { n.times { OpenStruct.new(:name => 'John') } }
-  x.report('Struct')     { n.times { Person2.new('John') } }
-  x.report('Class')      { n.times { Person3.new.name = 'John' } }
-  x.report('Hash')       { n.times { { name: 'John' } } }
-end

data/lib/structure/static.rb

@@ -1,52 +0,0 @@
-require 'yaml'
-
-class Structure
-
-  # An enumerable static structure, sourced from a yaml file.
-  module Static
-    def self.included(base)
-      base.key(:id, Integer)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      include Enumerable
-
-      attr_accessor :data_path
-
-      def all
-        @all ||= data.map do |record|
-          record["id"] ||= increment_id
-          new(record)
-        end
-      end
-
-      def each(&block)
-        all.each { |record| block.call(record) }
-      end
-
-      def find(id)
-        detect { |record| record.id == id }
-      end
-
-      def set_data_path(data_path)
-        @data_path = data_path
-      end
-
-      private
-
-      def data
-        YAML.load_file(data_path)
-      end
-
-      # Overwrite this method with an opiniated location to dry if necessary.
-      def data_path
-        @data_path
-      end
-
-      def increment_id
-        @increment_id = @increment_id.to_i + 1
-      end
-    end
-  end
-end

data/spec/fixtures/cities.yml

@@ -1,5 +0,0 @@
----
-- id: 1
-  name: New York
-- id: 2
-  name: Tokyo

data/spec/fixtures/cities_with_neighborhoods.yml

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

data/spec/fixtures/cities_without_id.yml

@@ -1,4 +0,0 @@
----
-- name: New York
-- name: Tokyo
-- name: Paris

data/spec/models/city.rb

@@ -1,14 +0,0 @@
-require 'structure/static'
-
-class City < Structure
-  include Static
-
-  set_data_path File.expand_path("../../fixtures/cities.yml", __FILE__)
-
-  key         :name
-  embeds_many :neighborhoods
-end
-
-class Neighborhood < Structure
-  key :name
-end

data/spec/models/person.rb

@@ -1,5 +0,0 @@
-class Person < Structure
-  key :name
-  key :age, Integer
-  embeds_many :friends
-end

data/spec/spec_helper.rb

@@ -1,7 +0,0 @@
-require "rubygems"
-require "bundler/setup"
-require "rspec"
-
-require_relative "../lib/structure"
-
-Dir["#{File.dirname(__FILE__)}/models/**/*.rb"].each { |f| require f }

data/spec/structure/json_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for "a JSON interface" do
-  it "dumps to JSON" do
-    person.to_json.should eql json
-  end
-
-  it "loads from JSON" do
-    JSON.parse(json).should == person
-  end
-
-  context "when nesting other structures" do
-    before do
-      person.friends = [Person.new(:name => 'Jane')]
-    end
-
-    it "loads them into their corresponding structures" do
-      json = person.to_json
-      JSON.parse(json).friends.first.should be_a Person
-    end
-  end
-end
-
-describe Structure do
-  let(:person) { Person.new(:name => 'Joe') }
-  let(:json) { '{"json_class":"Person","name":"Joe","age":null,"friends":[]}' }
-
-  context "without Active Support" do
-    it_behaves_like "a JSON interface"
-  end
-
-  context "with Active Support" do
-    before(:all) do
-      require 'active_support/ordered_hash'
-      require 'active_support/json'
-    end
-
-    after(:all) do
-      Object.send(:remove_const, :ActiveSupport)
-    end
-
-    it_behaves_like "a JSON interface"
-
-    describe "#as_json" do
-      it "returns a hash" do
-        person.as_json.should be_a Hash
-      end
-
-      it "selects a subset of attributes" do
-        as_json = person.as_json(:only => :name)
-        as_json.should have_key :name
-        as_json.should_not have_key :age
-      end
-
-      it "rejects a subset of attributes" do
-        as_json = person.as_json(:except => :name)
-        as_json.should_not have_key :name
-        as_json.should have_key :age
-      end
-    end
-  end
-end

data/spec/structure/static_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-class Structure
-  describe "A static structure" do
-    def replace_fixture(new_path)
-      City.instance_variable_set(:@all, nil)
-      fixture = File.expand_path("../../fixtures/#{new_path}", __FILE__)
-      City.set_data_path(fixture)
-    end
-
-    it "is enumerable" do
-      City.should be_an Enumerable
-    end
-
-    describe ".all" do
-      it "returns all records" do
-        City.all.should have(2).cities
-      end
-    end
-
-    describe ".find" do
-      it "finds a record by its id" do
-        City.find(1).should be_a City
-      end
-
-      it "returns nil if the record does not exist" do
-        City.find(4).should be_nil
-      end
-    end
-
-    describe ".set_data_path" do
-      it "sets the data path" do
-        City.set_data_path("foo")
-        City.send(:data_path).should eql "foo"
-      end
-    end
-
-    context "when sourcing data without ids" do
-      before(:all) do
-        @old_path = City.instance_variable_get(:@data_path)
-        replace_fixture("cities_without_id.yml")
-      end
-
-      after(:all) do
-        replace_fixture(@old_path)
-      end
-
-      it "should auto-increment the ids of loaded records" do
-        City.map(&:id).should =~ [1, 2, 3]
-      end
-
-      describe ".increment_id" do
-        before do
-          City.instance_variable_set(:@increment_id, nil)
-        end
-
-        it "starts from 1" do
-          City.send(:increment_id).should eql 1
-        end
-
-        it "auto-increments" do
-          City.send(:increment_id)
-          City.send(:increment_id).should eql 2
-        end
-      end
-    end
-
-    context "when sourcing nested models" do
-      before(:all) do
-        @old_path = City.instance_variable_get(:@data_path)
-        replace_fixture("cities_with_neighborhoods.yml")
-      end
-
-      after(:all) do
-        replace_fixture(@old_path)
-      end
-
-      it "loads nested models" do
-        pending
-        neighborhoods = City.first.neighborhoods
-        neighborhoods.first.should be_a Neighborhood
-      end
-    end
-  end
-end

data/spec/structure_spec.rb

@@ -1,221 +0,0 @@
-require 'spec_helper'
-
-describe Structure do
-  let(:person) { Person.new }
-
-  it "is enumerable" do
-    person.should respond_to :map
-  end
-
-  describe ".key" do
-    it "defines accessors" do
-      %w{name name=}.each { |method| person.should respond_to method }
-    end
-
-    context "when a key name clashes with a method name" do
-      it "raises an error" do
-        expect do
-          Person.key :class
-        end.to raise_error NameError
-      end
-    end
-
-    context "when an invalid type is specified" do
-      it "raises an error" do
-        expect do
-          Person.key :location, Object
-        end.to raise_error TypeError
-      end
-    end
-
-    context "when default value is not of the specified type" do
-      it "raises an error" do
-        expect do
-          Person.key :location, String, :default => 0
-        end.to raise_error TypeError
-      end
-    end
-  end
-
-  describe ".default_attributes" do
-    it "returns the default attributes for the structure" do
-      Person.send(:default_attributes).should == { :name    => nil,
-                                                   :age     => nil,
-                                                   :friends => [] }
-      Book.send(:default_attributes).should == { :title   => nil,
-                                                 :authors => nil }
-    end
-  end
-
-  describe "attribute getter" do
-    it "returns the value of the attribute" do
-      person.instance_variable_get(:@attributes)[:name] = 'Joe'
-      person.name.should eql 'Joe'
-    end
-
-    context "when type is Array and default value is []" do
-      let(:friend) { Person.new }
-
-      it "supports the `<<' idiom" do
-        person.friends << friend
-        person.friends.count.should eql 1
-        friend.friends.count.should eql 0
-      end
-    end
-  end
-
-  describe "attribute setter" do
-    it "sets the value of the attribute" do
-      person.name = "Joe"
-      person.instance_variable_get(:@attributes)[:name].should eql 'Joe'
-    end
-
-    context "when a type is specified" do
-      it "casts the value" do
-        person.age = "28"
-        person.age.should be_an Integer
-      end
-    end
-
-    context "when a type is not specified" do
-      it "casts to String" do
-        person.name = 123
-        person.name.should be_a String
-      end
-    end
-
-    context "when type is Boolean" do
-      context "when default value is true" do
-        it "does not raise an invalid type error" do
-          expect do
-            Person.key :single, Boolean, :default => true
-          end.not_to raise_error
-        end
-      end
-
-      context "when default value is false" do
-        it "does not raise an invalid type error" do
-          expect do
-            Person.key :married, Boolean, :default => false
-          end.not_to raise_error
-        end
-      end
-
-      context "when typecasting a set value" do
-        before(:all) do
-          Person.key :vegetarian, Boolean
-        end
-
-        it "typecasts 'true' to true" do
-          person.vegetarian = 'true'
-          person.vegetarian.should be_true
-        end
-
-        it "typecasts 'TRUE' to true" do
-          person.vegetarian = 'TRUE'
-          person.vegetarian.should be_true
-        end
-
-        it "typecasts '1' to true" do
-          person.vegetarian = '1'
-          person.vegetarian.should be_true
-        end
-
-        it "typecasts all other strings to false" do
-          person.vegetarian = 'foo'
-          person.vegetarian.should be_false
-        end
-
-        it "typecasts 0 to false" do
-          person.vegetarian = 0
-          person.vegetarian.should be_false
-        end
-
-        it "typecasts all other integers to true" do
-          person.vegetarian = 1
-          person.vegetarian.should be_true
-        end
-      end
-    end
-
-    context "when type is Hash" do
-      before(:all) do
-        Person.key :education, Hash
-      end
-
-      context "when setting to a value that is not a Hash" do
-        it "raises an error" do
-          expect do
-            person.education = 'foo'
-          end.to raise_error TypeError
-        end
-      end
-    end
-
-    context "when type is Structure" do
-      before(:all) do
-        Person.embeds_one :father
-      end
-
-      context "when setting to a value that is not a Structure" do
-        it "raises an error" do
-          expect do
-            person.father = 'foo'
-          end.to raise_error TypeError
-        end
-      end
-    end
-
-    context "when a default is specified" do
-      it "defaults to that value" do
-        Person.key :location, :default => 'New York'
-        person.location.should eql 'New York'
-      end
-    end
-
-    context "when a default is not specified" do
-      it "defaults to nil" do
-        person.age.should be_nil
-      end
-    end
-
-    context "when setting the value of an attribute to nil" do
-      it "does not typecast the value" do
-        person.age = nil
-        person.age.should be_a NilClass
-      end
-    end
-  end
-
-  describe "attribute presence" do
-    context "when the value of an attribute is nil" do
-      it "returns false" do
-        person.name?.should be_false
-      end
-    end
-
-    context "when the value of an attribute is false" do
-      it "returns false" do
-        person.instance_variable_get(:@attributes)[:name] = false
-        person.name?.should be_false
-      end
-    end
-
-    context "when the value of an attribute is set to a value other than false or nil" do
-      it "returns true" do
-        person.instance_variable_get(:@attributes)[:name] = "John"
-        person.name?.should be_true
-      end
-    end
-  end
-
-  describe ".new" do
-    context "when attributes are specified" do
-      it "initializes the object with those attributes" do
-        jane = Person.new(:name => 'Jane', :age => "29")
-        jane.name.should eql 'Jane'
-        jane.age.should eql 29
-      end
-    end
-  end
-end