structure 0.19.0 → 0.20.0

data/Gemfile

@@ -1,12 +1,6 @@
 source :rubygems
-
 gemspec
-
 gem 'activesupport', '~> 3.0'
 gem 'json', :platform => [:mri_18, :jruby, :rbx]
+gem 'pry' unless ENV['CI']
 gem 'rake'
-
-unless ENV['CI']
-  gem 'ruby-debug',   :platforms => :mri_18
-  gem 'ruby-debug19', :platforms => :mri_19
-end

data/README.md

@@ -1,14 +1,14 @@
 # Structure
 
-[![travis](https://secure.travis-ci.org/hakanensari/structure.png)](http://travis-ci.org/hakanensari/structure)
+[![travis](https://secure.travis-ci.org/hakanensari/structure.png?branch=master)](http://travis-ci.org/hakanensari/structure)
 
 Structure is a typed, nestable key/value container.
 
     class Person < Structure
-      key  :name, String
+      key  :name
       many :friends
     end
 
-Please see [the project page] [1] for more detailed info.
+Please see the [wiki] [1] for more detail.
 
-[1]: http://code.papercavalier.com/structure/
+[1]: https://github.com/hakanensari/structure/wiki/

data/lib/structure.rb

@@ -1,94 +1,124 @@
+require 'forwardable'
 begin
   JSON::JSON_LOADED
 rescue NameError
   require 'json'
 end
 
-# A structure is a nestable key/value container.
+# Structure is a nestable, typed key/value container.
 #
 #    class Person < Structure
 #      key  :name
-#      key  :age, Integer
 #      many :friends
 #    end
 #
 class Structure
+  extend Forwardable
   include Enumerable
 
+  # A namespaced basic object.
+  #
+  # If running a legacy Ruby version, we either quote Builder's or
+  # fabricate ourselves.
+  if defined?(BasicObject)
+    BasicObject = ::BasicObject
+  elsif defined?(BlankSlate)
+    BasicObject = ::BlankSlate
+  else
+    class BasicObject
+      instance_methods.each do |mth|
+        undef_method(mth) unless mth =~ /\A(__|instance_eval)/
+      end
+    end
+  end
+
+  # A double that stands in for a yet-to-be-defined class. Otherwise
+  # known as "lazy evaluation."
+  #
+  # Idea lifted from:
+  # http://github.com/soveran/ohm/
+  class Double < BasicObject
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      @name.to_s
+    end
+
+    def method_missing(mth, *args, &block)
+      @unwrapped ? super : @unwrapped = true
+      ::Kernel.const_get(@name).send(mth, *args, &block)
+    ensure
+      @unwrapped = false
+    end; private :method_missing
+  end
+
   class << self
     # Returns attribute keys and their default values.
     def defaults
       @defaults ||= {}
     end
 
-    # Builds a structure out of the JSON representation of a
-    # structure.
+    # Recreates a structure out of its JSON representation.
     def json_create(hsh)
-      hsh.delete 'json_class'
-      new 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]
+    # Takes a name and, optionally, a type and default value.
+    def key(name, type = nil, default = nil)
+      name = name.to_sym
 
       if method_defined?(name)
         raise NameError, "#{name} is taken"
       end
 
-      if default.nil? || type.nil? || default.is_a?(type)
+      if !default || !type || default.is_a?(type)
         defaults[name] = default
       else
+        binding.pry
         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
+      define_method("#{name}=") do |val|
+        attributes[name] =
+          if type.nil? || val.nil? || val.is_a?(type)
+            val.dup rescue val
+          elsif Kernel.respond_to?(type.to_s)
+            Kernel.send(type.to_s, val)
+          else
+            raise TypeError, "#{val} isn't a #{type}"
+          end
       end
     end
 
-    # A shorthand that defines an attribute that is an array.
+    # Defines an attribute that is an array and defaults to an empty
+    # one.
     def many(name)
-      key name, Array, :default => []
+      key name, Array, []
     end
+
+    # Lazy-eval undefined constants, typically other structures,
+    # assuming they will be defined later in the text.
+    def const_missing(name)
+      Double.new(name)
+    end; private :const_missing
+
+    def inherited(child)
+      child.def_delegator child, :defaults
+    end; private :inherited
   end
 
   # Creates a new structure.
   #
-  # A hash, if provided, will seed the attributes.
+  # A hash, if provided, seeds the attributes.
   def initialize(hsh = {})
-    @attributes = self.class.defaults.inject({}) do |a, (k, v)|
+    @attributes = defaults.inject({}) do |a, (k, v)|
       a[k] = v.is_a?(Array) ? v.dup : v
       a
     end
@@ -109,9 +139,9 @@ class Structure
   def to_hash
     attributes.inject({}) do |a, (k, v)|
       a[k] =
-        if v.respond_to? :to_hash
+        if v.respond_to?(:to_hash)
           v.to_hash
-        elsif v.is_a? Array
+        elsif v.is_a?(Array)
           v.map { |e| e.respond_to?(:to_hash) ? e.to_hash : e }
         else
           v
@@ -121,7 +151,7 @@ class Structure
     end
   end
 
-  # Converts structure to a JSON representation.
+  # Converts structure to its JSON representation.
   def to_json(*args)
     { JSON.create_id => self.class.name }.
       merge(attributes).
@@ -136,4 +166,4 @@ class Structure
   end
 end
 
-require 'structure/rails' if defined?(Rails)
+require 'structure/active_support' if defined?(Rails)

data/lib/structure/version.rb

@@ -1,3 +1,3 @@
 class Structure
-  VERSION = '0.19.0'
+  VERSION = '0.20.0'
 end

data/test/structure_test.rb

@@ -1,60 +1,58 @@
-$:.push File.expand_path('../../lib', __FILE__)
-
 require 'bundler/setup'
-
+require 'test/unit'
 begin
-  require 'ruby-debug'
+  require 'pry'
 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
+require File.expand_path('../../lib/structure', __FILE__)
 
 class Person < Structure
   key  :name
-  key  :age, Integer
+  key  :location, Location
   many :friends
 end
 
+class Location < Structure
+  key :lon, Float
+  key :lat, Float
+end
+
 class TestStructure < Test::Unit::TestCase
-  test "should enumerate" do
+  def test_double
+    double = Structure::Double.new(:Foo)
+    assert_equal 'Foo', "#{double}"
+    assert_raise(NameError) { double.class }
+    ::Kernel.const_set(:Foo, 1)
+    assert_kind_of Fixnum, double
+  end
+
+  def test_enumeration
     assert_respond_to Person.new, :map
   end
 
-  test "should define accessors" do
+  def test_accessors
     assert_respond_to Person.new, :name
     assert_respond_to Person.new, :name=
   end
 
-  test "should raise errors" do
+  def test_key_errors
     assert_raise(NameError) { Person.key :class }
-    assert_raise(TypeError) { Person.key :foo, String, :default => 1 }
   end
 
-  test "should store defaults" do
+  def test_key_defaults
     assert_equal [], Person.new.friends
   end
 
-  test "should typecheck" do
-    person = Person.new
-    person.age = '18'
-    assert_equal 18, person.age
+  def test_typechecking
+    loc = Location.new
+    loc.lon = "1"
+    assert_kind_of Float, loc.lon
 
-    person.age = nil
-    assert_nil person.age
+    loc.lon = nil
+    assert_nil loc.lon
   end
 
-  test "should handle arrays" do
+  def test_array_type
     person = Person.new
     assert_equal [], person.friends
 
@@ -63,28 +61,26 @@ class TestStructure < Test::Unit::TestCase
     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
+  # def test_to_hash
+  #   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
+  def test_json
     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'
+    require 'structure/active_support'
+
     assert_equal true,  person.as_json(:only => :name).has_key?(:name)
     assert_equal false, person.as_json(:except => :name).has_key?(:name)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-27 00:00:00.000000000Z
+date: 2011-09-06 00:00:00.000000000Z
 dependencies: []
 description: Structure is a typed, nestable key/value container.
 email:
@@ -25,7 +25,7 @@ files:
 - README.md
 - Rakefile
 - lib/structure.rb
-- lib/structure/rails.rb
+- lib/structure/active_support.rb
 - lib/structure/version.rb
 - structure.gemspec
 - test/structure_test.rb
@@ -43,7 +43,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4009138194620496744
+      hash: -506799676672156126
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -52,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4009138194620496744
+      hash: -506799676672156126
 requirements: []
 rubyforge_project: structure
 rubygems_version: 1.8.6