structure 0.21.0 → 0.22.0

data/Gemfile

@@ -1,6 +1,11 @@
 source :rubygems
 gemspec
+
 gem 'activesupport', '~> 3.0'
-gem 'json', :platform => [:mri_18, :jruby, :rbx]
+if RUBY_VERSION.include? '1.8'
+  gem 'json'
+  gem 'minitest'
+end
+
 gem 'pry' unless ENV['CI']
 gem 'rake'

data/README.md

@@ -2,11 +2,11 @@
 
 [![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.
+Structure is a typed key/value container.
 
     class Person < Structure
-      key  :name
-      many :friends
+      key :name
+      key :friends, Array, []
     end
 
 Please see the [wiki] [1] for more detail.

data/Rakefile

@@ -4,6 +4,6 @@ require 'rake/testtask'
 task :default => :test
 
 Rake::TestTask.new do |test|
-  test.libs << 'test'
+  test.libs += %w{lib test}
   test.test_files = FileList['test/**/*_test.rb']
 end

data/lib/structure/json.rb

@@ -0,0 +1,58 @@
+begin
+  JSON::JSON_LOADED
+rescue NameError
+  require 'json'
+end
+
+class Structure
+  module JSON
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Converts structure to its JSON representation
+    #
+    # @param [Hash] args
+    # @return [JSON] a JSON representation of the structure
+    def to_json(*args)
+      { ::JSON.create_id => self.class.name }.
+        merge(@attributes).
+        to_json(*args)
+    end
+
+    if defined? ActiveSupport
+      # Converts structure to its JSON representation
+      #
+      # @param [Hash] options
+      # @return [JSON] a JSON representation of the structure
+      def as_json(options = nil)
+        subset = if options
+          if only = options[:only]
+            @attributes.slice(*Array.wrap(only))
+          elsif except = options[:except]
+            @attributes.except(*Array.wrap(except))
+          else
+            @attributes.dup
+          end
+        else
+          @attributes.dup
+        end
+
+        { ::JSON.create_id => self.class.name }.
+          merge(subset)
+      end
+    end
+
+    module ClassMethods
+      # Builds a structure out of its JSON representation
+      #
+      # @param [Hash] hsh a hashified JSON
+      # @return [Structure] a structure
+      def json_create(hsh)
+        hsh.delete('json_class')
+
+        new(hsh)
+      end
+    end
+  end
+end

data/lib/structure/version.rb

@@ -1,3 +1,3 @@
 class Structure
-  VERSION = '0.21.0'
+  VERSION = '0.22.0'
 end

data/lib/structure.rb

@@ -1,211 +1,190 @@
-begin
-  JSON::JSON_LOADED
-rescue NameError
-  require 'json'
-end
-
-# Structure is a nestable, typed key/value container.
+# Structure is a typed key/value container
 #
+# @example
 #    class Person < Structure
-#      key  :name
-#      many :friends
+#      key :name
+#      key :friends, Array, []
 #    end
 #
 class Structure
-  include Enumerable
-
-  # A namespaced basic object.
-  #
-  # If running a legacy Ruby version, we either quote Builder's or
-  # fabricate one 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)/
+  # Summon a Basic Object.
+  unless defined? BasicObject
+    if defined? BlankSlate
+      BasicObject = BlankSlate
+    else
+      class BasicObject
+        instance_methods.each do |mth|
+          undef_method(mth) unless mth =~ /__/
+        end
       end
     end
   end
 
-  # A double that stands in for a yet-to-be-defined class. Otherwise
-  # known as "lazy evaluation."
+  # A wrapper for lazy-evaluating undeclared classes
   #
-  # Idea lifted from:
-  # http://github.com/soveran/ohm/
-  class Double < BasicObject
+  # @note Borrowed from the same-named class in Ohm
+  class Wrapper < BasicObject
+    # Wraps specified class in a wrapper if it is not already wrapped
+    #
+    # @param [Class] klass
+    # @return [Wrapper]
+    def self.wrap(klass)
+      klass.class == self ? klass : new(klass.to_s)
+    end
+
+    # Creates a new wrapper for specified class name
+    #
+    # @param [#to_s] name
     def initialize(name)
-      @name = name
+      @name = name.to_s
+    end
+
+    # @return [Class] the class of the object
+    def class
+      Wrapper
     end
 
-    def to_s
-      @name.to_s
+    # Unwraps wrapped class
+    #
+    # @return [Class] the unwrapped class
+    def unwrap
+      @name.split('::').inject(::Kernel) do |parent, child|
+        parent.const_get(child)
+      end
     end
 
+    private
+
     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
   end
 
-  class << self
-    # Returns attribute keys and their default values.
-    def defaults
-      @defaults ||= {}
+  # A key definition
+  class Definition
+    # Creates a key definition
+    #
+    # @param [Class] type the key type
+    # @param [Object] default an optional default value
+    def initialize(type, default = nil)
+      @wrapper = Wrapper.wrap(type)
+      @default = default
+    end
+
+    # @return the default value for the key
+    attr :default
+
+    # @return [Class] the key type
+    def type
+      @type ||= @wrapper.unwrap
     end
 
-    # Recreates a structure out of its JSON representation.
-    def json_create(hsh)
-      hsh.delete('json_class')
-      new(hsh)
+    # Typecasts specified value
+    #
+    # @param [Object] val a value
+    # @raise [TypeError] value isn't a type
+    # @return [Object] a typecast value
+    def typecast(val)
+      if 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
+
+  class << self
+    # @return [Hash] a collection of keys and their definitions
+    def blueprint
+      @blueprint ||= {}
     end
 
-    # Defines an attribute.
+    # Defines a key
+    #
+    # @note Key type defaults to +String+ if not specified.
     #
-    # Takes a name and, optionally, a type and default value.
-    def key(name, type = nil, default = nil)
+    # @param [#to_sym] name the key name
+    # @param [Class] type an optional key type
+    # @param [Object] default an optional default value
+    # @raise [NameError] name is already taken
+    def key(name, type = String, default = nil)
       name = name.to_sym
 
       if method_defined?(name)
         raise NameError, "#{name} is taken"
       end
 
-      if !default || !type || default.is_a?(type)
-        defaults[name] = default
-      else
+       if default && !default.is_a?(type)
         raise TypeError, "#{default} isn't a #{type}"
       end
 
-      define_method(name) { attributes[name] }
+      # Add key to blueprint.
+      blueprint[name] = Definition.new(type, default)
 
-      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
+      # Define getter.
+      define_method(name) do
+        @attributes[name]
       end
-    end
-
-    # Defines an attribute that is an array and defaults to an empty
-    # one.
-    def many(name)
-      key name, Array, []
-    end
 
-    alias_method :new_original, :new
-
-    def new(hsh)
-      hsh = hsh.inject({}) do |a, (k, v)|
-        a[Inflector.underscore(k)] =
-          case v
-          when Hash
-            Structure.new(v)
-          when Array
-            v.map { |e| e.is_a?(Hash) ? Structure.new(e) : e }
-          else
-            v
-          end
-        a
-      end
-
-      klass = Class.new(Structure) do
-        hsh.keys.each { |k| key k }
+      # Define setter.
+      define_method("#{name}=") do |val|
+        @attributes[name] = self.class.blueprint[name].typecast(val)
       end
-
-      klass.new(hsh)
     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
+    private
 
-    def inherited(child)
-      if self.eql? Structure
-        class << child; alias_method :new, :new_original; end
-      end
-    end; private :inherited
+    def const_missing(name)
+      Wrapper.new(name)
+    end
   end
 
-  # Creates a new structure.
+  # Builds a new structure
   #
-  # A hash, if provided, seeds the attributes.
+  # @param [Hash] hsh a hash of key-value pairs
   def initialize(hsh = {})
-    @attributes = defaults.inject({}) do |a, (k, v)|
-      a[k] = v.dup rescue v
+    @attributes = blueprint.inject({}) do |a, (k, v)|
+      a[k] = v.default.dup rescue v.default
       a
     end
 
     hsh.each { |k, v| self.send("#{k}=", v) }
   end
 
-  # The attributes that make up the structure.
-  attr :attributes
-
-  # Calls block once for each attribute in the structure, passing that
-  # attribute as a parameter.
-  def each(&block)
-    attributes.each { |v| block.call(v) }
-  end
-
-  # Converts structure to a hash.
+  # @return [Hash] 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.map { |e| e.respond_to?(:to_hash) ? e.to_hash : e }
-        else
-          v
-        end
+    @attributes.inject({}) do |a, (k, v)|
+      a[k] = if v.respond_to?(:to_hash)
+               v.to_hash
+             elsif v.is_a?(Array)
+               v.map { |e| e.respond_to?(:to_hash) ? e.to_hash : e }
+             else
+               v
+             end
 
       a
     end
   end
 
-  # Converts structure to its JSON representation.
-  def to_json(*args)
-    { JSON.create_id => self.class.name }.
-      merge(attributes).
-      to_json(*args)
-  end
-
-  # Compares this object with another object for equality. A Structure
-  # is equal to the other object when both are of the same class and
-  # the their attributes are the same.
+  # Compares this object with another object for equality
+  #
+  # A structure is equal to another object when both are of the same
+  # class and their attributes are the same.
+  #
+  # @param [Object] other another object
+  # @return [true, false]
   def ==(other)
     other.is_a?(self.class) && attributes == other.attributes
   end
 
-  def defaults
-    self.class.defaults
-  end; private :defaults
+  private
 
-  module Inflector
-    # Makes an underscored, lowercase form from the expression in the
-    # string.
-    #
-    # You know where this is lifted from.
-    def self.underscore(camel_cased_word)
-      word = camel_cased_word.to_s.dup
-      word.gsub!(/::/, '/')
-      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      word.tr!("-", "_")
-      word.downcase!
-      word
-    end
+  def blueprint
+    self.class.blueprint
   end
 end
-
-require 'structure/ext/active_support' if defined?(Rails)

data/structure.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   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 = 'Structure is a typed, nestable key/value container.'
+  s.summary     = 'A typed key/value container'
+  s.description = 'Structure is a typed key/value container.'
 
   s.rubyforge_project = 'structure'
 

data/test/structure_test.rb

@@ -1,51 +1,33 @@
-require 'bundler/setup'
-require 'test/unit'
+require 'minitest/autorun'
+
 begin
   require 'pry'
 rescue LoadError
 end
-require File.expand_path('../../lib/structure', __FILE__)
+
+require 'structure'
+require 'structure/json'
 
 class Person < Structure
-  key  :name
-  key  :location, Location
-  many :friends
+  key :name
+  key :friends, Array, []
+  key :city, City
 end
 
-class Location < Structure
-  key :lon, Float
-  key :lat, Float
+class City < Structure
+  key :name
 end
 
-class TestStructure < Test::Unit::TestCase
-  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_anonymous
-    hsh = { 'FirstName' => 'John', 'LastName' => 'Doe' }
-    str = Structure.new(hsh)
-    assert_equal hsh['FirstName'], str.first_name
-    assert_equal hsh['LastName'], str.last_name
-    assert_raise(NoMethodError) { str.FirstName }
-  end
+class TestStructure < MiniTest::Unit::TestCase
+  def test_lazy_evaluation
+    wrapper = Structure::Wrapper.new(:Foo)
+    assert_raises(NameError) { wrapper.bar }
+    assert_raises(NameError) { wrapper.unwrap.bar }
 
-  def test_anonymous_recursion
-    hsh = { 'Name' => 'John',
-            'Address' => { 'City' => 'Oslo' },
-            'Friends' => [{ 'Name' => 'Jane' }]
-          }
-    str = Structure.new(hsh)
-    assert_equal hsh['Address']['City'], str.address.city
-    assert_equal hsh['Friends'].first['Name'], str.friends.first.name
-  end
-
-  def test_enumeration
-    assert_respond_to Person.new, :map
+    klass = Class.new { def self.bar; end }
+    ::Kernel.const_set(:Foo, klass)
+    assert_respond_to wrapper, :bar
+    assert_equal Foo, wrapper.unwrap
   end
 
   def test_accessors
@@ -54,24 +36,24 @@ class TestStructure < Test::Unit::TestCase
   end
 
   def test_key_errors
-    assert_raise(NameError) { Person.key :class }
-    assert_raise(TypeError) { Person.key :foo, String, 1 }
+    assert_raises(NameError) { Person.key :class }
+    assert_raises(TypeError) { Person.key :foo, Hash, 1 }
   end
 
   def test_key_defaults
     assert_equal [], Person.new.friends
   end
 
-  def test_typechecking
-    loc = Location.new
-    loc.lon = "1"
-    assert_kind_of Float, loc.lon
+  def test_typecasting
+    person = Person.new
+    person.name = 123
+    assert_kind_of String, person.name
 
-    loc.lon = nil
-    assert_nil loc.lon
+    person.name = nil
+    assert_nil person.name
   end
 
-  def test_array_type
+  def test_many_relationship
     person = Person.new
     assert_equal [], person.friends
 
@@ -80,26 +62,36 @@ class TestStructure < Test::Unit::TestCase
     assert_equal 0, person.friends.first.friends.size
   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
+  def test_new
+    person = Person.new(:name => 'John')
+    assert_equal 'John', person.name
+
+    other = Person.new(:name => 'Jane', :friends => [person])
+    assert_equal 'John', other.friends.first.name
+  end
+
+  def test_to_hash
+    person = Person.new(:name => 'John')
+    person.friends << Person.new(:name => 'Jane')
+    hash = person.to_hash
+
+    assert_equal 'John', hash[:name]
+    assert_equal 'Jane', hash[:friends].first[:name]
+  end
 
   def test_json
-    person = Person.new
-    person.friends << Person.new
+    Person.send :include, Structure::JSON
+
+    person = Person.new(:name => 'John')
+    person.friends << Person.new(:name => 'Jane')
     json = person.to_json
     assert_kind_of Person, JSON.parse(json)
     assert_kind_of Person, JSON.parse(json).friends.first
-
     assert_equal false, person.respond_to?(:as_json)
 
     require 'active_support/ordered_hash'
     require 'active_support/json'
-    require 'structure/ext/active_support'
-
+    load 'structure/json.rb'
     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.21.0
+  version: 0.22.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-10 00:00:00.000000000Z
+date: 2011-10-26 00:00:00.000000000 Z
 dependencies: []
-description: Structure is a typed, nestable key/value container.
+description: Structure is a typed key/value container.
 email:
 - code@papercavalier.com
 executables: []
@@ -25,7 +25,7 @@ files:
 - README.md
 - Rakefile
 - lib/structure.rb
-- lib/structure/ext/active_support.rb
+- lib/structure/json.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: -3352714224337607479
+      hash: 2031698207987898845
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -52,12 +52,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3352714224337607479
+      hash: 2031698207987898845
 requirements: []
 rubyforge_project: structure
-rubygems_version: 1.8.6
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: A typed, nestable key/value container
+summary: A typed key/value container
 test_files:
 - test/structure_test.rb

data/lib/structure/ext/active_support.rb

@@ -1,19 +0,0 @@
-class Structure
-  # Converts structure to a JSON representation.
-  def as_json(options = nil)
-    subset = if options
-      if only = options[:only]
-        attributes.slice(*Array.wrap(only))
-      elsif except = options[:except]
-        attributes.except(*Array.wrap(except))
-      else
-        attributes.dup
-      end
-    else
-      attributes.dup
-    end
-
-    { JSON.create_id => self.class.name }.
-      merge(subset)
-  end
-end