deepstruct 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in deepstruct.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,62 @@
+Deepstruct
+==========
+
+An adapter that wraps common ruby data-structures and makes them look like proper Objects.
+
+    struct = DeepStruct.wrap({"a" => { "b" => "bingo!"}})
+    struct.a.b
+      => "bingo!"
+
+
+Installation
+============
+
+Not yet published as a gem, so you'll have to
+
+    git clone git@github.com:simen/deepstruct.git
+    cd deepstruct
+    rake install
+
+Or if you use the awesomeness that is bundler, you stick this in your Gemfile:
+
+    gem "deepstruct", :git => git@github.com:simen/deepstruct.git
+
+Usage
+=====
+
+    struct = DeepStruct.wrap({:awesome => [1,2,3, {"a" => "hello from the abyss"}]})
+    struct.awesome[3].a
+      => "hello from the abyss"
+
+You can also write back through the wrapper with indifferent access
+
+    struct = DeepStruct.wrap({:a => 1, "b" => 2})
+    struct.a = 10
+    struct.b = 20
+    struct
+      => #<DeepStruct::HashWrapper {:a=>10, "b"=>20}> 
+
+When you want to you can still use hash-style syntax when accessing your DeepStructs. These accessors implement indifferent access too.
+
+    struct = DeepStruct.wrap({:a => {1 => 'One', 2 => 'Two'}})
+    struct.a[1]
+      => "One"
+    struct["a"][1]
+      => "One"
+    struct["b"] = "Hello"
+    struct[:b]
+      => "Hello"
+    struct.b
+      => "Hello"
+
+If DeepStruct is getting in your way, you can always get access to the raw content by unwrapping it:
+
+    struct = Deepstruct.wrap({"hello => "world"})
+    struct.unwrap
+      => {"hello" => "world"}
+  
+DeepStruct is a perfect companion to your json-oriented application!
+
+    struct = DeepStruct.wrap(JSON.parse('{"full_name": "Don Corleone"}'))
+    puts struct.to_json
+    {"full_name":"Don Corleone"}

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/deepstruct.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "deepstruct/version"
+
+Gem::Specification.new do |s|
+  s.name        = "deepstruct"
+  s.version     = Deepstruct::VERSION
+  s.authors     = ["Simen Svale Skogsrud"]
+  s.email       = ["simen@bengler.no"]
+  s.homepage    = ""
+  s.summary     = %q{A sibling of ostruct that handles deeply nested structures and basic data type detection}
+  s.description = %q{A sibling of ostruct that handles deeply nested structures and basic data type detection}
+
+  s.rubyforge_project = "deepstruct"
+
+  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.add_development_dependency "rspec"
+end

data/lib/deepstruct/version.rb

@@ -0,0 +1,3 @@
+module Deepstruct
+  VERSION = "0.0.1"
+end

data/lib/deepstruct.rb

@@ -0,0 +1,94 @@
+module DeepStruct
+  class DeepWrapper
+    def initialize(value)
+      @value = value
+    end
+    
+    def unwrap
+      @value
+    end
+    
+    def [](index)
+      return DeepStruct.wrap(@value[index])
+    end
+    
+    def []=(index, value)
+      @value[index] = value
+    end
+    
+    def inspect
+      "#<#{self.class} #{@value.inspect}>"
+    end
+
+    def to_json
+      @value.to_json 
+    end
+  end
+  
+  class HashWrapper < DeepWrapper
+    def respond_to?(method)
+      @value.respond_to?(method) || self.has_key?(method.to_s.chomp('=')) 
+    end
+
+    # Given a symbol or a string this yields the variant of the key that 
+    # exists in the wrapped hash if any. If none exists (or the key is not
+    # a symbol or string) the input value is passed through unscathed.
+    def indiffrently(key, &block)
+      return yield(key) if @value.has_key?(key)
+      return yield(key.to_s) if key.is_a?(Symbol) && @value.has_key?(key.to_s)
+      return yield(key.to_sym) if key.is_a?(String) && @value.has_key?(key.to_sym)
+      return yield(key)
+    end
+
+    def []=(key, value)
+      indiffrently(key) { |key| @value[key] = value }      
+    end
+
+    def [](key)
+      indiffrently(key) { |key| DeepStruct.wrap(@value[key]) }
+    end
+
+    def has_key?(key)
+      indiffrently(key) { |key| @value.has_key?(key) }
+    end
+
+    def method_missing(method, *args, &block)
+      return @value.send(method, *args, &block) if @value.respond_to?(method)
+      method = method.to_s
+      if method.chomp!('=')        
+        raise ArgumentError, "wrong number of arguments (#{arg_count} for 1)", caller(1) if args.length != 1
+        self[method] = args[0]
+      elsif args.length == 0 && self.has_key?(method)
+        self[method]
+      else
+        raise NoMethodError, "undefined method `#{method}' for #{self}", caller(1)
+      end
+    end
+  end
+  
+  class ArrayWrapper < DeepWrapper
+    include Enumerable
+
+    def each
+      block_given? or return enum_for(__method__)
+      @value.each { |o| yield(DeepStruct.wrap(o)) }
+      self
+    end
+
+    def size
+      @value.size
+    end
+    alias :length :size
+  end
+  
+  def self.wrap(value)
+    case value
+    when Hash
+      return HashWrapper.new(value)
+    when Enumerable
+      return ArrayWrapper.new(value)
+    else
+      return value
+    end
+  end
+end

data/spec/deepstruct_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'json'
+
+describe DeepStruct do
+  it "wraps a simple hash" do
+    struct = DeepStruct.wrap({:a => 1, :b => 2})
+    struct.a.should eq(1)
+    struct.b.should eq(2)
+  end
+
+  it "can unwrap a wrapped value" do 
+    DeepStruct.wrap([1]).unwrap.should eq [1]
+  end
+
+  it "avoids wrapping common datatypes" do
+    DeepStruct.wrap("hello").should eq ("hello")
+    DeepStruct.wrap(1).should eq(1)
+    DeepStruct.wrap(1.0).should eq(1.0)
+  end
+
+  it "implements indifferenct access" do
+    struct = DeepStruct.wrap({:a => 1, "b" => 2})
+    struct.a.should eq(1)
+    struct.b.should eq(2)
+  end
+
+  it "writes back to the hash with the same key-type as the original hash" do
+    struct = DeepStruct.wrap({:a => 1, "b" => 2})
+    struct.a = 3
+    struct.b = 4
+    struct.a.should eq(3)
+    struct.b.should eq(4)
+    struct.keys.should_not include("a")
+    struct.keys.should_not include(:b)
+  end
+
+  it "wraps nested hashes" do
+    struct = DeepStruct.wrap({:a => {:b => {:c => "hello from deep space"}}})
+    struct.a.b.c.should eq("hello from deep space")
+  end
+
+  it "wraps arrays and support all common operations" do
+    struct = DeepStruct.wrap([1,2,3,4,5])
+    struct[3].should eq(4)
+    struct.sort{|a,b| b <=> a}.should eq([5,4,3,2,1])
+    struct.map(&:to_s).should eq(['1', '2', '3', '4', '5'])
+  end
+
+  it "wraps hashes nested within arrays" do
+    struct = DeepStruct.wrap([1, {:a => "hello"}])
+    struct[1].a.should eq('hello')
+    struct[1].class.should eq(DeepStruct::HashWrapper)
+  end
+
+  it "wraps arrays nested within hashes" do
+    struct = DeepStruct.wrap({:a => [1,2,3]})
+    struct.a[1].should eq(2)
+    struct.a.class.should eq(DeepStruct::ArrayWrapper)
+  end
+
+  it "supports being converted to json" do
+    struct = DeepStruct.wrap({:a => [1,2,3]})
+    struct.to_json.should eq('{"a":[1,2,3]}')
+  end
+
+  it "raises NoMethodError when reading missing keys" do
+    ->{DeepStruct.wrap({}).not_there}.should raise_error(NoMethodError)
+  end
+
+  context "HashWrapper, hash-like methods" do
+    it "can be used as a common ruby hash with indifferent access" do
+      struct = DeepStruct.wrap({:a => "hello", 'b' => "world"})
+      struct[:a].should eq "hello"
+      struct['a'].should eq "hello"
+      struct[:b].should eq "world"
+      struct['b'].should eq "world"
+      struct['a'] = "Mmkay"
+      struct[:a].should eq "Mmkay"
+      struct.has_key?("a").should be_true
+    end
+
+    it "can access non string/symbol elements via hashistic syntax" do
+      struct = DeepStruct.wrap({1 => "One"})
+      struct[1].should eq 'One'
+      struct[2] = "Two"
+      struct[2].should eq 'Two'
+      struct['2'].should eq nil
+    end
+  end
+
+  context "HashWrapper, #respond_to?" do
+    it "responds to hash methods" do
+      struct = DeepStruct.wrap({:a => true})
+      struct.size.should eq(1)
+      struct.respond_to?(:size).should be_true
+    end
+
+    it "responds to keys that are present as symbols" do
+      struct = DeepStruct.wrap({:a => nil})
+      struct.respond_to?(:a).should be_true
+    end
+
+    it "responds to keys that are present as strings" do
+      struct = DeepStruct.wrap({'a' => nil})
+      struct.respond_to?(:a).should be_true
+    end
+
+    it "doesn't respond to missing keys" do
+      struct = DeepStruct.wrap({:a => true})
+      struct.respond_to?(:b).should be_false
+    end
+
+    it "responds to keys that can be assigned to" do
+      struct = DeepStruct.wrap({:a => true})
+      struct.respond_to?(:a=).should be_true
+    end
+
+  end
+end

data/spec/delegation_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'delegate'
+
+class PassingTheBuck < SimpleDelegator
+end
+
+describe DeepStruct do
+
+  specify "HashWrapper can be delegated to" do
+    buck = DeepStruct.wrap(:for_sure => 'hell, yeah!')
+
+    thing = PassingTheBuck.new(buck)
+    thing.for_sure.should eq('hell, yeah!')
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__)+'/../lib/deepstruct.rb'

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: deepstruct
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Simen Svale Skogsrud
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-29 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70116432443300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70116432443300
+description: A sibling of ostruct that handles deeply nested structures and basic
+  data type detection
+email:
+- simen@bengler.no
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- deepstruct.gemspec
+- lib/deepstruct.rb
+- lib/deepstruct/version.rb
+- spec/deepstruct_spec.rb
+- spec/delegation_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+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: deepstruct
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A sibling of ostruct that handles deeply nested structures and basic data
+  type detection
+test_files:
+- spec/deepstruct_spec.rb
+- spec/delegation_spec.rb
+- spec/spec_helper.rb