structure 0.24.0 → 0.25.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9d097be9799d796318524e7594f98050b1d41be8
+  data.tar.gz: 710fa928be479806b678fc9c17ae3222d71f059b
+SHA512:
+  metadata.gz: 1c5f7f760400a8eb044df7efaa9a2d08ed8b0128db23659f64bbf4a98b9d2311f4772176a93c52c90745a0da4658aeba9cd85eaaf8719dfce2e3caa5b07973bf
+  data.tar.gz: 1d1a43d8aac01183286e82832f38540b03f5a5d7c2f2487fefc5cf2ad422b03e433de0c7f0394663a06b0948b91dbafa2b0993a7f77e3cbe25ed9c9a92d0dd4b

data/.gitignore

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

data/Gemfile

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

data/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2011 Hakan Ensari
+Copyright (c) 2013 Hakan Ensari
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,8 +1,30 @@
-![structure](http://f.cl.ly/items/2u2v0e3k2I3w1A0y2e25/ruby.png)
+# Structure
 
-> Machines only work when they break down and by continually breaking
-> down.
+Turn data (e.g. API responses) into immutable value objects in Ruby.
 
-[Read the API.](http://rubydoc.info/github/hakanensari/structure/master/Structure)
+## Usage
 
-[![travis](https://secure.travis-ci.org/hakanensari/structure.png?branch=master)](http://travis-ci.org/hakanensari/structure)
+Mix in Structure and define values with `.value`.
+
+```ruby
+class Location
+  include Structure
+
+  attr :res
+
+  def initialize(res)
+    @res = res
+  end
+
+  value :latitude do
+    res.fetch(:lat)
+  end
+
+  value :longitude do
+    res.fetch(:lng)
+  end
+end
+
+location = Location.new(lat: 10, lng: 100)
+location.to_h # {:latitude=>10, :longitude=>100}
+```

data/Rakefile

@@ -1,9 +1,9 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
-task :default => :test
-
-Rake::TestTask.new do |test|
-  test.libs += %w{lib test}
-  test.test_files = FileList['test/**/*_test.rb']
+Rake::TestTask.new do |t|
+  t.libs.push('lib')
+  t.test_files = FileList['test/**/*_test.rb']
 end
+
+task :default => [:test]

data/lib/structure.rb

@@ -1,278 +1,42 @@
-begin
-  JSON::JSON_LOADED
-rescue NameError
-  require 'json'
-end
-
-# Structure is a key/value container. On the most basic level, it mirrors the
-# functionality of OpenStruct:
-#
-#    require 'structure'
-#
-#    record = Structure.new
-#    record.name    = "John Smith"
-#    record.age     = 70
-#    record.pension = 300
-#
-#    puts record.name    # -> "John Smith"
-#    puts record.address # -> nil
-#
-# Build structures recursively:
-#
-#    hash = {
-#     "name"       => "Australia",
-#     "population" => "20000000",
-#     "cities"     => [
-#       {
-#         "name"       => "Sydney",
-#         "population" => "4100000"
-#       },
-#       {
-#         "name"       => "Melbourne",
-#         "population" => "4000000"
-#       } ]
-#     }
-#
-#     country = Structure.new(hash)
-#     puts country.name              # -> "Australia"
-#     puts country.cities.count      # -> 2
-#     puts country.cities.first.name # -> "Sydney"
-#
-# Define optionally-typed fields in a structure:
-#
-#     class Price < Structure
-#       field :cents, Integer
-#       field :currency, String, :default => "USD"
-#     end
-#
-#     hash = { "cents" => "100" }
-#
-#     price = Price.new(hash)
-#     puts price.cents    # -> 100
-#     puts price.currency # -> "USD"
-#
-# Alternatively, define a proc to cast or otherwise manipulate values and
-# assign defaults:
-#
-#     class Product < Structure
-#       field :sku, lambda(&:upcase)
-#       field :created_at, String, :default => lambda { Time.now.to_s }
-#     end
-#
-#     product = Product.new(:sku => 'foo-bar')
-#     puts product.sku # -> "FOO-BAR"
-#
-# Structures are fully conversant in JSON, which is quite handy in the
-# ephemeral landscape of APIs.
-class Structure
-  class << self
-    # @private
-    attr_accessor :blueprint
-
-    # Builds a structure out of a JSON representation.
-    # @param [Hash] hsh a JSON representation translated to a hash
-    # @return [Structure] a structure
-    def json_create(hsh)
-      hsh.delete('json_class')
-      new(hsh)
-    end
-
-    # Creates a field.
-    # @overload field(key, opts = {})
-    #   Creates a field.
-    #   @param [#to_sym] key the name of the field
-    #   @param [Hash] opts the options to create the field with
-    #   @option opts [Object] :default the default value
-    # @overload field(key, type, opts = {})
-    #   Creates a typed field.
-    #   @param [#to_sym] key the name of the field
-    #   @param [Class, Proc] type the type to cast assigned values
-    #   @param [Hash] opts the options to create the field with
-    #   @option opts [Object] :default the default value
-    def field(key, *args)
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      default = opts[:default]
-      type = args.shift
-      @blueprint[key] = { :type    => type,
-                          :default => default }
-    end
-
-    alias key field
-
-    # Syntactic sugar to create a typed field that defaults to an empty array.
-    # @param key the name of the field
-    def many(key)
-      field(key, Array, :default => [])
-    end
-
-    # Syntactic sugar to create a field that stands in for another structure.
-    # @param key the name of the field
-    def one(key)
-      field(key, lambda { |v| v.is_a?(Structure) ? v : Structure.new(v) })
-    end
-
-    private
-
-    def inherited(child)
-      child.blueprint = blueprint.dup
-    end
-  end
-
-  @blueprint = {}
-
-  # Creates a new structure.
-  # @param [Hash] hsh an optional hash to populate fields
-  def initialize(hsh = {})
-    @table = blueprint.inject({}) do |a, (k, v)|
-      default = if v[:default].is_a? Proc
-                  v[:default].call
-                else
-                  v[:default].dup rescue v[:default]
-                end
-
-      a.merge new_field(k, v[:type]) => default
-    end
-
-    marshal_load(hsh)
+module Structure
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.instance_variable_set(:@value_names, [])
   end
 
-  # Deletes a field.
-  # @param [#to_sym] key
-  # @return [Object] the value of the deleted field
-  def delete_field(key)
-    key = key.to_sym
-    class << self; self; end.class_eval do
-      [key, "#{key}="].each { |m| remove_method m }
-    end
-
-    @table.delete key
-  end
+  def values
+    vals = {}
+    self.class.value_names.each { |name| vals[name] = self.send(name) }
 
-  # Provides marshalling support for use by the Marshal library.
-  # @return [Hash] a hash of the keys and values of the structure
-  def marshal_dump
-    @table.inject({}) do |a, (k, v)|
-      a.merge k => recursively_dump(v)
-    end
+    vals
   end
+  alias :to_h :values
 
-  # Provides marshalling support for use by the Marshal library.
-  # @param [Hash] hsh a hash of keys and values to populate the structure
-  def marshal_load(hsh)
-    hsh.each do |k, v|
-      self.send("#{new_field(k)}=", v)
-    end
-  end
-
-  # @return [String] a JSON representation of the structure
-  def to_json(*args)
-    { JSON.create_id => self.class.name }.
-      merge(marshal_dump).
-      to_json(*args)
-  end
-
-  # @return [Boolean] whether the object and +other+ are equal
   def ==(other)
-    other.is_a?(Structure) && @table == other.table
-  end
-
-  protected
-
-  attr :table
-
-  private
-
-  def blueprint
-    self.class.blueprint
+    values == other.values
   end
+  alias :eql? :==
 
-  def initialize_copy(orig)
-    super
-    @table = @table.dup
-  end
+  def inspect
+    str = "#<#{self.class}"
 
-  def method_missing(mth, *args)
-    name = mth.to_s
-    len = args.length
-    if name.chomp!('=') && mth != :[]=
-      modifiable[new_field(name)] = recursively_load(args.first)
-    elsif len == 0
-      @table[new_field(mth)]
-    else
-      super
+    first = true
+    values.each do |k, v|
+      str << ',' unless first
+      first = false
+      str << " #{k}=#{v.inspect}"
     end
-  end
 
-  def modifiable
-    if frozen?
-      raise RuntimeError, "can't modify frozen #{self.class}", caller(3)
-    end
-
-    @table
+    str << '>'
   end
+  alias :to_s :inspect
 
-  def new_field(key, type = nil)
-    key = key.to_sym
-    unless self.respond_to?(key)
-      class << self; self; end.class_eval do
-        define_method(key) { @table[key] }
-
-        assignment =
-          case type
-          when nil
-            lambda { |v| modifiable[key] = recursively_load(v) }
-          when Proc
-            lambda { |v| modifiable[key] = type.call(v) }
-          when Class
-            mth = type.to_s.to_sym
-            if Kernel.respond_to?(mth)
-              lambda { |v|
-                modifiable[key] = v.nil? ? nil : Kernel.send(mth, v)
-              }
-            else
-              lambda { |v|
-                modifiable[key] =
-                  if v.nil? || v.is_a?(type)
-                    v
-                  else
-                    raise TypeError, "#{v} isn't a #{type}"
-                  end
-              }
-            end
-          else
-            raise TypeError, "#{type} isn't a valid type"
-          end
+  module ClassMethods
+    attr :value_names
 
-        define_method("#{key}=", assignment)
-      end
+    def value(name, &blk)
+      define_method(name, &blk)
+      @value_names << name
     end
-
-    key
-  end
-
-  def recursively_dump(val)
-    if val.respond_to? :marshal_dump
-       val.marshal_dump
-     elsif val.is_a? Array
-       val.map { |v| recursively_dump(v) }
-     else
-       val
-     end
-  end
-
-  def recursively_load(val)
-    case val
-    when Hash
-      self.class.new(val)
-    when Array
-      val.map { |v| recursively_load(v) }
-    else
-      val
-    end
-  end
-
-  if defined? ActiveSupport
-    require 'structure/ext/active_support'
-    include Ext::ActiveSupport
   end
 end

data/lib/structure/version.rb

@@ -1,3 +1,3 @@
-class Structure
-  VERSION = '0.24.0'
+module Structure
+  VERSION = '0.25.0'
 end

data/structure.gemspec

@@ -1,21 +1,23 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'structure/version'
 
-Gem::Specification.new do |s|
-  s.name        = 'structure'
-  s.version     = Structure::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Hakan Ensari']
-  s.email       = ['code@papercavalier.com']
-  s.homepage    = 'http://github.com/hakanensari/structure'
-  s.summary     = 'A key/value container'
-  s.description = 'Structure is a key/value container.'
+Gem::Specification.new do |spec|
+  spec.name          = 'structure'
+  spec.version       = Structure::VERSION
+  spec.authors       = ['Hakan Ensari']
+  spec.email         = ['hakan.ensari@papercavalier.com']
+  spec.description   = 'Value objects in Ruby'
+  spec.summary       = 'Value objects in Ruby'
+  spec.homepage      = 'http://github.com/hakanensari/structure'
+  spec.license       = 'MIT'
 
-  s.rubyforge_project = 'structure'
+  spec.files         = `git ls-files`.split("\n")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
 
-  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']
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'rake'
 end

data/test/structure_test.rb

@@ -1,161 +1,51 @@
-require File.expand_path('../helper.rb', __FILE__)
+require 'minitest/autorun'
+require 'structure'
 
-# Most tests below are borrowed from RubySpec.
-class TestStructure < MiniTest::Unit::TestCase
-  def setup
-    @person = Structure.new(:name => 'John')
-  end
-
-  def test_delete_field
-    @person.delete_field(:name)
-    assert_nil @person.send(:table)[:name]
-    refute_respond_to(@person, :name)
-    refute_respond_to(@person, :name=)
-  end
-
-  def test_element_reference
-    assert_raises(NoMethodError) { @person[1] }
-  end
-
-  def test_element_set
-    assert_raises(NoMethodError) { @person[1] = 2 }
-  end
-
-  def test_equal_value
-    refute @person == 'foo'
-    assert @person == @person
-    assert @person == Structure.new(:name => 'John')
-    assert @person == Class.new(Structure).new(:name => 'John')
-    refute @person == Structure.new(:name => 'Johnny')
-    refute @person == Structure.new(:name => 'John', :age => 20)
-  end
-
-  def test_frozen
-    @person.freeze
-
-    assert_equal 'John', @person.name
-    assert_raises(RuntimeError) { @person.age = 42 }
-    assert_raises(RuntimeError) { @person.state = :new }
-
-    c = @person.clone
-    assert_equal 'John', c.name
-    assert_raises(RuntimeError) { c.age = 42 }
-    assert_raises(RuntimeError) { c.state = :new }
+class Location
+  include Structure
 
-    d = @person.dup
-    assert_equal 'John', d.name
-    d.age = 42
-    assert_equal 42, d.age
-  end
-
-  def test_initialize_copy
-    d = @person.dup
-    d.name = 'Jane'
-    assert_equal 'Jane', d.name
-    assert_equal 'John', @person.name
+  attr :res
 
-    @person.friends = ['Joe']
-    d = @person.dup
-    d.friends = ['Jim']
-    assert_equal ['Jim'], d.friends
-    assert_equal ['Joe'], @person.friends
+  def initialize(res)
+    @res = res
   end
 
-  def test_json
-    friend = Structure.new(:name => 'Jane')
-    @person.friend = friend
-    @person.cities = ['Zurich']
-    json = '{"json_class":"Structure",
-             "name":"John",
-             "friend":{"name":"Jane"},
-             "cities":["Zurich"]}'.gsub(/\s+/, '')
-    assert_equal @person, JSON.parse(json)
-    assert_equal friend, JSON.parse(json).friend
-    assert_equal 'Zurich', JSON.parse(json).cities.first
-
-    refute_respond_to @person, :as_json
-    require 'active_support/ordered_hash'
-    require 'active_support/json'
-    load 'structure.rb'
-    assert @person.as_json(:only => :name).has_key?(:name)
-    refute @person.as_json(:except => :name).has_key?(:name)
+  value :latitude do
+    res.fetch(:lat)
   end
 
-  def test_marshaling
-    assert_equal({ :name => 'John' }, @person.marshal_dump)
-    @person.marshal_load(:age => 20, :name => 'Jane')
-    assert_equal 20, @person.age
-    assert_equal 'Jane', @person.name
+  value :longitude do
+    res.fetch(:lng)
   end
+end
 
-  def test_method_missing
-    @person.test = 'test'
-    assert_respond_to @person, :test
-    assert_respond_to @person, :test=
-    assert_equal 'test', @person.test
-    assert_equal 'test', @person.send(:table)[:test]
-    @person.test = 'changed'
-    assert_equal 'changed', @person.test
-
-
-    @person.send(:table)[:age] = 20
-    assert_equal 20, @person.age
-
-    assert_raises(NoMethodError) { @person.gender(1) }
-    assert_nil @person.gender
-
-    @person.freeze
-    assert_raises(RuntimeError) { @person.gender = 'male' }
+class StructureTest < MiniTest::Test
+  def setup
+    @location = Location.new(lat: 10, lng: 100)
   end
 
-  def test_new
-    person = Structure.new(:name => 'John', :age => 70)
-    assert_equal 'John', person.name
-    assert_equal 70, person.age
-    assert_equal({}, Structure.new.send(:table))
+  def test_has_value
+    assert_equal 10, @location.latitude
+    assert_equal 100, @location.longitude
   end
 
-  def test_new_field
-    @person.send(:table)[:age] = 20
-    @person.send(:new_field, :age)
-
-    assert_equal 20, @person.age
-
-    @person.age = 30
-    assert_equal 30, @person.age
-
-    @person.instance_eval { def gender; 'male'; end }
-    @person.send(:new_field, :gender)
-    assert_equal 'male', @person.gender
-    refute_respond_to @person, :gender=
+  def test_class_returns_value_names
+    assert_equal [:latitude, :longitude], Location.value_names
   end
 
-  def test_recursive_assignment
-    friend = { :name => 'Jane' }
-    @person.friend = friend
-    @person.friends = [friend]
-    assert_equal 'Jane', @person.friend.name
-    assert_equal 'Jane', @person.friends.first.name
+  def test_returns_values
+    assert_equal({ latitude: 10, longitude: 100 }, @location.values)
+    assert_equal @location.to_h, @location.values
   end
 
-  def test_recursive_marshaling
-    hsh = {
-      :name => 'John',
-      :friend => { :name => 'Jane' },
-      :friends => [{ :name => 'Jane' }]
-    }
-    friend = Structure.new(:name => 'Jane')
-    @person.friend = friend
-    @person.friends = [friend]
-    assert_equal hsh, @person.marshal_dump
-
-    person = Structure.new
-    person.marshal_load(hsh)
-    assert_equal friend, person.friend
-    assert_equal friend, person.friends.first
+  def test_compares
+    @other = Location.new(lng: 100, lat: 10)
+    assert @location == @other
+    assert @location.eql?(@other)
   end
 
-  def test_table
-    assert_equal({ :name => 'John' }, @person.send(:table))
+  def test_pretty_inspects
+    assert_equal '#<Location latitude=10, longitude=100>', @location.inspect
+    assert_equal @location.to_s, @location.inspect
   end
 end

metadata

@@ -1,63 +1,82 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 0.24.0
-  prerelease: 
+  version: 0.25.0
 platform: ruby
 authors:
 - Hakan Ensari
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-16 00:00:00.000000000 Z
-dependencies: []
-description: Structure is a key/value container.
+date: 2013-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Value objects in Ruby
 email:
-- code@papercavalier.com
+- hakan.ensari@papercavalier.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
-- .travis.yml
-- .yardopts
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/structure.rb
-- lib/structure/ext/active_support.rb
 - lib/structure/version.rb
 - structure.gemspec
-- test/helper.rb
 - test/structure_test.rb
-- test/structure_with_fields_test.rb
 homepage: http://github.com/hakanensari/structure
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: structure
-rubygems_version: 1.8.11
+rubyforge_project: 
+rubygems_version: 2.0.5
 signing_key: 
-specification_version: 3
-summary: A key/value container
+specification_version: 4
+summary: Value objects in Ruby
 test_files:
-- test/helper.rb
 - test/structure_test.rb
-- test/structure_with_fields_test.rb
-has_rdoc: 

data/.travis.yml

@@ -1,8 +0,0 @@
-rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - jruby
-  - rbx
-  - rbx-2.0
-  - ree

data/.yardopts

@@ -1,2 +0,0 @@
---no-private
-lib/**/*.rb

data/lib/structure/ext/active_support.rb

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

data/test/helper.rb

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

data/test/structure_with_fields_test.rb

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