ostruct2 0.1.0

data/.ruby

@@ -0,0 +1,63 @@
+---
+source:
+- meta
+authors:
+- name: Trans
+  email: transfire@gmail.com
+copyrights:
+- holder: Rubyworks
+  year: '2010'
+  license: BSD-2-Clause
+requirements:
+- name: detroit
+  groups:
+  - build
+  development: true
+- name: qed
+  groups:
+  - test
+  development: true
+- name: ae
+  groups:
+  - test
+  development: true
+dependencies: []
+alternatives: []
+conflicts: []
+repositories:
+- uri: git://github.com/rubyworks/ostruct2.git
+  scm: git
+  name: upstream
+resources:
+- uri: http://rubyworks.github.com/ostruct2
+  label: Website
+  type: home
+- uri: http://rubydoc.info/gems/ostruct2/frames
+  label: Documentation
+  type: docs
+- uri: http://github.com/rubyworks/ostruct2
+  label: Source Code
+  type: code
+- uri: http://groups.google.com/group/rubyworks-mailinglist
+  label: Mailing List
+  type: mail
+- uri: http://chat.us.freenode.net/rubyworks
+  label: IRC Channel
+  type: chat
+categories: []
+extra: {}
+load_path:
+- lib
+revision: 0
+created: '2010-04-21'
+summary: A Better OpenStruct
+title: OStruct2
+version: 0.1.0
+name: ostruct2
+description: ! 'OStruct2 is a reimplementation of Ruby''s standard ostruct.rb library.
+
+  This new OpenStruct class addresses issues the original has with conflicting
+
+  member names and cloning.'
+organization: Rubyworks
+date: '2012-05-20'

data/Config.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+#
+# QED test coverage report using SimpleCov.
+#
+# Use `$properties.coverage_folder` to set directory in which to store
+# coverage report this defaults to `log/coverage`.
+#
+# IMPORTANT! Unfortunately this will not give us a reliable report
+# b/c QED uses the RC gem, so SimpleCov can't differentiate the two.
+#
+config 'qed', profile: 'cov' do
+  #puts "QED w/coverage!"
+  dir = $properties.coverage_folder
+  require 'simplecov'
+  SimpleCov.command_name 'QED'
+  SimpleCov.start do
+    coverage_dir(dir || 'log/coverage')
+    #add_group "Label", "lib/qed/directory"
+  end
+end
+
+#
+# Pry
+#
+config 'pry' do
+  puts "RC on Pry!"
+  $LOAD_PATH.unshift('lib')
+end
+
+#
+# Rake tasks 
+#
+config 'rake' do
+  desc 'run unit tests'
+  task 'test' do
+    sh 'qed'
+  end
+end
+
+=begin
+#
+# Detroit assembly.
+#
+config 'detroit' do
+  service :email do |s|
+    s.mailto = ['ruby-talk@ruby-lang.org', 
+                'rubyworks-mailinglist@googlegroups.com']
+  end
+
+  service :gem do |s|
+    s.gemspec = 'pkg/ostruct2.gemspec'
+  end
+
+  service :github do |s|
+    s.folder = 'web'
+  end
+
+  service :dnote do |s|
+    s.title  = 'Source Notes'
+    s.output = 'log/notes.html'
+  end
+
+  service :locat do |s|
+    s.output = 'log/locat.html'
+  end
+
+  service :vclog do |s|
+    s.output = ['log/history.html',
+                'log/changes.html']
+  end
+end
+=end

data/DEMO.rdoc

@@ -0,0 +1,110 @@
+# OpenStruct
+
+The constructor can take a priming hash.
+
+    o = OpenStruct.new(:a=>1,:b=>2)
+    o.a  #=> 1
+    o.b  #=> 2
+
+It can also take a default procedure, just like an Hash.
+
+    o = OpenStruct.new{ |h,k| h[k] = {} }
+    o.a  #=> {}
+
+Common usage of an OpenStruct is via the missing method dynamic calls.
+An entry can be made by making an assignment and read back via the
+same method call.
+
+    o = OpenStruct.new
+    o.a = 1
+    o.a  #=> 1
+
+Key existence can also be checked by adding a question mark.
+
+    o.a?  #=> true
+
+OpenStruct "circa 2" has a CRUDified design. There are only a few primary
+methods that handle access to the underlying table and all other methods
+route through these. Primarily they are `#read!`, `#store!`, `#delete!`
+as well as `#key?` and `#keys!`.
+
+    o = OpenStruct.new
+    o.store!(:a, 1)
+    o.read!(:a)  #=> 1
+    o.key?(:a)   #=> true
+    o.keys!      #=> [:a]
+    o.delete!(:a)
+    o.empty?     #=> true
+
+OpenStruct offers a number of methods to access the underlying table.
+Each of these ends in a exlimation mark, and include `#fetch!`, `#update!`, 
+and `merge!`.
+
+    o = OpenStruct.new
+    o.update!(:a=>1, :b=>2)
+    o.fetch!(:a)  #=> 1
+
+Note that `#merge!` is akin to `Hash#merge`, not `Hash#merge!` --it does not
+act in-place.
+
+    o = OpenStruct.new
+    x = o.merge!(:a=>1, :b=>2)
+    o.a  #=> nil
+    x.a  #=> 1
+
+OpenStruct also supports Hash-like read and write operators, #[] and #[]=.
+
+    o = OpenStruct.new
+    o[:a] = 1
+    o[:a]  #=> 1
+    o.a    #=> 1
+
+The OpenStruct object can be converted to a simple Hash, via `#to_h`.
+
+    o = OpenStruct.new(:a=>1,:b=>2)
+    o.to_h  #=> {:a=>1, :b=>2}
+
+Iteration can be achieved with `#each!`.
+
+    o = OpenStruct.new(:a=>1,:b=>2)
+    a = {}
+    o.each! do |k,v|
+      a[k] = v
+    end
+    a  #=> {:a=>1, :b=>2}
+
+Currently all Enumerable methods will work if suffixed with an exclemation mark. But they operate
+directly on the underlying Hash rather than at the level of the "CRUDified" OpenStruct itself.
+
+    o = OpenStruct.new(:a=>1,:b=>2)
+    a = o.map!{ |k,v| [k,v] }
+    a  #=> [[:a,1], [:b,2]]
+
+In most cases this will work fine. But it may cause some minor discrepencies in how Enumerable 
+methods work presently and how ultimatley they should work. A fix is a bit tricky so this is an
+endeavor left a future release. In the rare cases where it does matters, proper enumeratorion
+can be assured by calling `#to_enum` first.
+
+    o = OpenStruct.new(:a=>1,:b=>2)
+    a = {}
+    o.to_enum.each do |k,v|
+      a[k] = v
+    end
+    a  #=> {:a=>1, :b=>2}
+ 
+OpenStruct also has a unique method called `#key!` that is used to check for an key entry,
+and raise a KeyError if it not found.
+
+    o = OpenStruct.new
+    expect KeyError do
+      o.key!(:x)
+    end
+
+Lastly, OpenStruct has a convenient feature for creating cascading OpenStructs.
+
+    o = OpenStruct.cascade
+    o.x.a = 1
+    o.x.a  #=> 1
+    OpenStruct.assert === o.a
+
+

data/HISTORY.rdoc

@@ -0,0 +1,8 @@
+= RELEASE HISTORY
+
+0.1.0 | 2011-01-01
+
+Summary of release...
+
+* First release.
+

data/README.rdoc

@@ -0,0 +1,24 @@
+= OpenStruct 2
+
+{Website}[http://rubyworks.github.com/ostruct2] /
+{Report Issue}[http://github.com/rubyworks/ostruct2/issues] /
+{Source Code}[http://github.com/rubyworks/ostruct2]
+
+{<img src="https://secure.travis-ci.org/rubyworks/ostruct2.png" />}[http://travis-ci.org/rubyworks/ostruct2]
+
+
+== Description
+
+OStruct2 is a reimplementation of Ruby's standard ostruct.rb library.
+This new OpenStruct class addresses issues the original has with conflicting
+member names and cloning.
+
+
+== Copyrights
+
+Copyright (c) 2010 Rubyworks
+
+OStruct2 is distributed under the *BSD-2-Clause* license.
+
+See LICENSE.txt for detatils.
+

data/lib/ostruct2.rb

@@ -0,0 +1,150 @@
+# A better OpenStruct class.
+#
+class OpenStruct < BasicObject
+
+  class << self
+    #
+    # Create cascading OpenStruct.
+    #
+    def cascade(data=nil)
+      leet = lambda{ |h,k| OpenStruct.new(&leet) }
+      new(&leet)
+    end
+
+    # Is there a better name for #auto?
+    #alias :autorenew :cascade
+
+    # Original name for #cascade method.
+    alias :auto :cascade
+  end
+
+  #
+  def initialize(data=nil, &block)
+    @table = ::Hash.new(&block)
+    update!(data || {})
+  end
+
+  #
+  def method_missing(sym, *args, &blk)
+    str  = sym.to_s
+    type = str[-1,1]
+    name = str.chomp('=').chomp('!').chomp('?')
+
+    case type
+    when '='
+      store!(name, args.first)
+    when '!'
+      @table.public_send(name, *args, &blk)
+    when '?'
+      key?(name)
+    else
+      read!(name)
+    end
+  end
+
+  # CRUD method for listing all keys.
+  def keys!
+    @table.keys
+  end
+
+  # Also a CRUD method like #read!, but for checking for the existence of a key.
+  def key?(key)
+    @table.key?(key.to_sym)
+  end
+
+  # The CRUD method for read.
+  def read!(key)
+    @table[key.to_sym]
+  end
+
+  # The CRUD method for create and update.
+  def store!(key, value)
+    @table[key.to_sym] = value
+  end
+
+  # The CRUD method for destroy.
+  def delete!(key)
+    @table.delete(key.to_sym)
+  end
+
+  #
+  # Like #read but will raise a KeyError if key is not found.
+  #
+  def fetch!(key)
+    key!(key)
+    read!(key)
+  end
+
+  #
+  def [](key)
+    read!(key)
+  end
+
+  #
+  def []=(key, value)
+    store!(key, value)
+  end
+
+  # CRUDified each.
+  def each!
+    @table.each_key do |key|
+      yield(key, read!(key))
+    end
+  end
+
+  # CRUDified update method.
+  def update!(other)
+    other.each do |k,v|
+      store!(k,v)
+    end
+  end
+
+  #
+  # IMPORTANT! This method does not act in-place like `Hash#merge!`,
+  # rather it works like `Hash#merge`.
+  #
+  def merge!(other)
+    # TODO: is there anyway to #dup a BasicObject subclass instance?
+    o = ::OpenStruct.new(@table, &@table.default_proc)
+    other.each do |k,v|
+      o.store!(k,v)
+    end
+    o
+  end
+
+  #
+  # Is the OpenStruct void of entries?
+  #
+  def empty?
+    @table.empty?
+  end
+
+  #
+  # Get a duplicate of the underlying table.
+  #
+  def to_h
+    @table.dup
+  end
+
+  #
+  def to_enum
+    ::Enumerator.new(self, :each!)
+  end
+
+  #
+  # If key is not present raise a KeyError.
+  #
+  def key!(key)
+    return key if key?(key)
+    ::Kernel.raise ::KeyError, ("key not found: %s" % [key.inspect])
+  end
+
+  #
+  #
+  #
+  def inspect
+    "#<OpenStruct: #{@table.inspect}>"
+  end
+
+end
+

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: ostruct2
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Trans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &26950880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *26950880
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: &26950340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *26950340
+- !ruby/object:Gem::Dependency
+  name: ae
+  requirement: &26949840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *26949840
+description: ! 'OStruct2 is a reimplementation of Ruby''s standard ostruct.rb library.
+
+  This new OpenStruct class addresses issues the original has with conflicting
+
+  member names and cloning.'
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- HISTORY.rdoc
+- DEMO.rdoc
+- README.rdoc
+files:
+- .ruby
+- lib/ostruct2.rb
+- HISTORY.rdoc
+- DEMO.rdoc
+- README.rdoc
+- Config.rb
+homepage: 
+licenses:
+- BSD-2-Clause
+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: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A Better OpenStruct
+test_files: []