structure 0.15.1 → 0.16.0

data/.travis.yml

@@ -6,3 +6,6 @@ rvm:
   - rbx
   - rbx-2.0
   - ree
+branches:
+  only:
+    - master

data/Gemfile

@@ -1,5 +1,14 @@
 source :rubygems
 
-gem 'activesupport', '>= 3.0'
+gemspec
+
 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']
+end

data/README.md

@@ -2,17 +2,27 @@
 
 [![travis](https://secure.travis-ci.org/hakanensari/structure.png)](http://travis-ci.org/hakanensari/structure)
 
-Structure is a Struct-like key/value container .
+Structure is a typed, nestable key/value container.
 
-It will shine in the ephemeral landscape of API-backed data.
+## Usage
+
+Install and require the gem.
 
     require 'structure'
 
-    class Person < Structure
+Define a model.
+
+    Document = Structure::Document
+
+    class Person < Document
       key  :name
-      many :friends
+      many :friends, :class_name => 'Person'
     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/collection.rb

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,212 @@
+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/lib/structure/version.rb

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

data/lib/structure.rb

@@ -1,189 +1 @@
-begin
-  JSON::JSON_LOADED
-rescue NameError
-  require 'json'
-end
-
-# Fabricate a +Boolean+ class.
-unless defined? Boolean
-  module Boolean; end
-  [TrueClass, FalseClass].each { |klass| klass.send :include, Boolean }
-end
-
-# = Structure
-#
-# Structure is a Struct-like key/value container.
-#
-#    class Person < Structure
-#      key  :name
-#      many :friends
-#    end
-#
-class Structure
-  include Enumerable
-
-  autoload :Static, 'structure/static'
-
-  # Available data type.
-  TYPES = [Array, Boolean, Float, Hash, Integer, String, Structure]
-
-  class << self
-    # Defines an attribute that represents an array of objects.
-    def many(name, options = {})
-      key name, Array, { :default => [] }.merge(options)
-    end
-
-    # Defines an attribute that represents another structure.
-    def one(name)
-      key name, Structure
-    end
-
-    # Builds a structure out of its JSON representation.
-    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.
-    #
-    # The type can be +Array+, +Boolean+, +Float+, +Hash+, +Integer+,
-    # +String+, a +Structure+, or a subclass thereof. If none is
-    # specified, this defaults to +String+.
-    #
-    # Available options are:
-    #
-    # * +:default+, which sets the default value for the attribute.
-    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} is not a valid type"
-      end
-
-      if default.nil? || default.is_a?(type)
-        default_attributes[name] = default
-      else
-        msg = "#{default} isn't a#{'n' if type.name.match(/^[AI]/)} #{type}"
-        raise TypeError, msg
-      end
-
-      module_eval do
-        # A proc that typecasts value based on type.
-        typecaster =
-          case type.name
-          when 'Boolean'
-            lambda { |value|
-              # This should take care of the different representations
-              # of truth we might be feeding into the model.
-              #
-              # Any string other than "0" or "false" will evaluate to
-              # true.
-              #
-              # Any integer other than 0 will evaluate to true.
-              #
-              # Otherwise, we do the double-bang trick to non-boolean
-              # values.
-              case value
-              when Boolean
-                value
-              when String
-                value !~ /0|false/i
-              when Integer
-                value != 0
-              else
-                !!value
-              end
-            }
-          when /Hash|Structure/
-            # We could possibly check if the value responds to #to_hash
-            # and cast to hash if it does, but I don't see any use case
-            # for this right now.
-            lambda { |value|
-              unless value.is_a? type
-                raise TypeError, "#{value} is not a #{type}"
-              end
-              value
-            }
-          else
-            lambda { |value| Kernel.send(type.to_s, value) }
-          end
-
-        # Define attribute accessors.
-        define_method(name) { @attributes[name] }
-
-        define_method("#{name}=") do |value|
-          @attributes[name] = value.nil? ? nil : typecaster.call(value)
-        end
-      end
-    end
-
-    # Returns a hash of all attributes with default values.
-    def default_attributes
-      @default_attributes ||= {}
-    end
-  end
-
-  # Creates a new structure.
-  #
-  # 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
-
-    hash.each { |key, value| self.send("#{key}=", value) }
-  end
-
-  # A hash that stores the attributes of 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 { |value| block.call(value) }
-  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
+require 'structure/document'

data/structure.gemspec

@@ -3,19 +3,23 @@ $:.push File.expand_path('../lib', __FILE__)
 require 'structure/version'
 
 Gem::Specification.new do |s|
-  s.name        = "structure"
+  s.name        = 'structure'
   s.version     = Structure::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Hakan Ensari"]
-  s.email       = ["code@papercavalier.com"]
-  s.homepage    = "http://code.papercavalier.com/structure"
-  s.summary     = "A Struct-like key/value container"
-  s.description = "Structure is a Struct-like key/value container."
+  s.authors     = ['Hakan Ensari']
+  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.rubyforge_project = "structure"
+  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) }
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 end

data/test/collection_test.rb

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,113 @@
+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/helper.rb

@@ -1,6 +1,5 @@
 $:.push File.expand_path('../../lib', __FILE__)
 
-require 'rubygems'
 require 'bundler/setup'
 
 begin
@@ -10,3 +9,5 @@ end
 
 require 'structure'
 require 'test/unit'
+
+Document = Structure::Document

data/test/static_test.rb

@@ -1,17 +1,17 @@
 require File.expand_path('../helper.rb', __FILE__)
 
-class City < Structure
+class City < Document
   include Static
 
   key  :name
   many :neighborhoods
 end
 
-class Neighborhood < Structure
+class Neighborhood < Document
   key :name
 end
 
-class Dummy < Structure
+class Dummy < Document
   include Static
 
   key :name
@@ -57,6 +57,6 @@ class TestStatic < Test::Unit::TestCase
 
   def test_nesting
     fixture City, 'cities_with_neighborhoods'
-    # assert_kind_of Neighborhood, City.first.neighborhoods.first
+    assert_kind_of Neighborhood, City.first.neighborhoods.first
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.16.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,42 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-12 00:00:00.000000000Z
-dependencies: []
-description: Structure is a Struct-like key/value container.
+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
 email:
 - code@papercavalier.com
 executables: []
@@ -20,22 +53,24 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
-- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/structure.rb
-- lib/structure/static.rb
+- lib/structure/collection.rb
+- lib/structure/document.rb
+- lib/structure/document/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://code.papercavalier.com/structure
+homepage: http://github.com/hakanensari/structure
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -49,23 +84,27 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2919723217978587663
+      hash: -2067006556322233036
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2067006556322233036
 requirements: []
 rubyforge_project: structure
 rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: A Struct-like key/value container
+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/CHANGELOG.md

@@ -1,39 +0,0 @@
-# CHANGELOG
-
-## 0.15.0
-* bring back static module
-
-## 0.14.0
-* rename .attribute back to .key
-* shorten .embeds_many and .embeds_one to .many and .one
-* remove presence methods
-* add options to .many
-
-## 0.13.0
-
-* remove static module
-* rename .key to .attribute
-
-# 0.12.0
-
-* add static module
-
-# 0.11.0
-
-* .key now emulates DataMapper.property
-
-# 0.10.0
-
-* rename .has_one and .has_many to .embeds_one and .embeds_many to make room
-  for associations
-
-# 0.9.0
-
-* add presence method
-
-# 0.8.0
-
-* make JSON patch compatible with Active Support
-* remove URI from list of types
-
-The rest is history.

data/lib/structure/static.rb

@@ -1,61 +0,0 @@
-# When included in a structure, this module turns it into a static
-# model, the data of which is sourced from a yaml file.
-#
-# This is a basic implementation and does not handle nested structures.
-# See test.
-class Structure
-  module Static
-    def self.included(base)
-      base.key(:_id, Integer)
-      base.extend(ClassMethods)
-    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

data/test/structure_test.rb

@@ -1,124 +0,0 @@
-require File.expand_path('../helper.rb', __FILE__)
-
-class Book < Structure
-  key  :title
-  key  :published, Boolean, :default => true
-  key  :pages,     Integer
-end
-
-class Person < Structure
-  key  :name
-  one  :partner
-  many :friends
-  many :parents, :default => 2.times.map { Person.new }
-end
-
-class TestStructure < Test::Unit::TestCase
-  def test_enumeration
-    assert_respond_to Book.new, :map
-  end
-
-  def test_accessors
-    book = Book.new
-    assert_respond_to book, :title
-    assert_respond_to book, :title=
-  end
-
-  def test_key_errors
-    assert_raise(NameError) { Book.key :class }
-    assert_raise(TypeError) { Book.key :foo, Object }
-    assert_raise(TypeError) { Book.key :foo, :default => 1 }
-  end
-
-  def test_default_attributes
-    exp = { :title     => nil,
-            :published => true,
-            :pages => nil }
-    assert_equal exp, Book.default_attributes
-  end
-
-  def test_initialization
-    book = Book.new(:title => 'Foo', :pages => 100)
-    assert_equal 'Foo', book.title
-    assert_equal 100, book.pages
-  end
-
-  def test_typecasting
-    book = Book.new
-
-    book.pages = "100"
-    assert_equal 100, book.pages
-
-    book.pages = nil
-    assert_nil book.pages
-
-    book.title = 1
-    book.title = '1'
-  end
-
-  def test_boolean_typecasting
-    book = Book.new
-
-    book.published = 'false'
-    assert book.published == false
-
-    book.published = 'FALSE'
-    assert book.published == false
-
-    book.published = '0'
-    assert book.published == false
-
-    book.published = 'foo'
-    assert book.published == true
-
-    book.published = 0
-    assert book.published == false
-
-    book.published = 10
-    assert book.published == true
-  end
-
-  def test_defaults
-    assert_equal nil, Book.new.title
-    assert_equal true, Book.new.published
-    assert_equal nil, Person.new.partner
-    assert_equal [], Person.new.friends
-  end
-
-  def test_array
-    person = Person.new
-    friend = Person.new
-    person.friends << person
-    assert_equal 1, person.friends.count
-    assert_equal 0, friend.friends.count
-  end
-
-  def test_many
-    person = Person.new
-    assert_equal 2, person.parents.size
-  end
-
-  def test_json
-    book = Book.new(:title => 'Foo')
-    json = book.to_json
-    assert_equal book, JSON.parse(json)
-  end
-
-  def test_json_with_nested_structures
-    person = Person.new
-    person.friends << Person.new
-    person.partner = Person.new
-    json = person.to_json
-    assert JSON.parse(json).friends.first.is_a? Person
-    assert JSON.parse(json).partner.is_a? Person
-  end
-
-  def test_json_with_active_support
-    require 'active_support/ordered_hash'
-    require 'active_support/json'
-
-    book = Book.new
-    assert book.as_json(:only => :title).has_key?(:title)
-    assert !book.as_json(:except => :title).has_key?(:title)
-  end
-end