mbleigh-mash 0.0.4

data/History.txt

@@ -0,0 +1,22 @@
+=== 0.0.4 / 2008-04-25
+
+* Setting up for GitHub gem hosting instead of Rubyforge.
+
+=== 0.0.3 / 2008-04-19
+
+* [] no longer defaults to a new Mash, will return nil if
+* Attribute-esque method names will yield the default value if not set
+* Hash extended with #to_mash and #stringify_keys
+* Added #dup and #deep_merge
+* Aliased the default Hash methods so they are still accessible
+* Cleaned up the recursive conversion process
+
+=== 0.0.2 / 2008-04-12
+
+* Added bang(!) method support
+* No longer automatically multi-level assigning
+* Hash conversion now calls methods instead of []= to allow for overrides
+
+=== 0.0.1 / 2008-04-12
+
+* Initial release

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/mash.rb
+spec/mash_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,68 @@
+= Mash (Mocking Hash)
+
+http://github.com/mbleigh/mash
+
+== DESCRIPTION:
+
+Mash is an extended Hash that gives simple pseudo-object functionality
+that can be built from hashes and easily extended. It is designed to
+be used in RESTful API libraries to provide easy object-like access 
+to JSON and XML parsed hashes.
+
+== SYNOPSIS:
+  
+  mash = Mash.new
+  mash.name? # => false
+  mash.name # => nil
+  mash.name = "My Mash"
+  mash.name # => "My Mash"
+  mash.name? # => true
+  mash.inspect # => <Mash name="My Mash">
+  
+  mash = Mash.new
+  # use bang methods for multi-level assignment
+  mash.author!.name = "Michael Bleigh"
+  mash.author # => <Mash name="Michael Bleigh">
+
+== INSTALL:
+
+Gem:
+
+Mash is hosted on the GitHub gem repository, so if you haven't already:
+
+  gem sources -a http://gems.github.com/  
+  sudo gem install mbleigh-mash
+  
+Git:
+
+  git clone git://github.com/mbleigh/mash.git
+  
+== RESOURCES
+
+If you encounter any problems or have ideas for new features 
+please report them at the Lighthouse project for Mash: 
+
+http://mbleigh.lighthouseapp.com/projects/10112-mash
+
+== LICENSE:
+
+Copyright (c) 2008 Michael Bleigh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rubygems'
+require './lib/mash.rb'
+require 'spec/rake/spectask'
+
+desc "Run specs."
+Spec::Rake::SpecTask.new("spec") do |t|
+  t.spec_files = "spec/*_spec.rb"
+end

data/lib/mash.rb

@@ -0,0 +1,226 @@
+# Mash allows you to create pseudo-objects that have method-like
+# accessors for hash keys. This is useful for such implementations
+# as an API-accessing library that wants to fake robust objects
+# without the overhead of actually doing so. Think of it as OpenStruct
+# with some additional goodies.
+#
+# A Mash will look at the methods you pass it and perform operations
+# based on the following rules:
+# 
+# * No punctuation: Returns the value of the hash for that key, or nil if none exists.
+# * Assignment (<tt>=</tt>): Sets the attribute of the given method name.
+# * Existence (<tt>?</tt>): Returns true or false depending on whether that key has been set.
+# * Bang (<tt>!</tt>): Forces the existence of this key, used for deep Mashes. Think of it as "touch" for mashes.
+#
+# == Basic Example
+#    
+#   mash = Mash.new
+#   mash.name? # => false
+#   mash.name = "Bob"
+#   mash.name # => "Bob"
+#   mash.name? # => true
+#
+# == Hash Conversion  Example
+#   
+#   hash = {:a => {:b => 23, :d => {:e => "abc"}}, :f => [{:g => 44, :h => 29}, 12]}
+#   mash = Mash.new(hash)
+#   mash.a.b # => 23
+#   mash.a.d.e # => "abc"
+#   mash.f.first.g # => 44
+#   mash.f.last # => 12
+#
+# == Bang Example
+#
+#   mash = Mash.new
+#   mash.author # => nil
+#   mash.author! # => <Mash>
+#   
+#   mash = Mash.new
+#   mash.author!.name = "Michael Bleigh"
+#   mash.author # => <Mash name="Michael Bleigh">
+#
+class Mash < Hash
+  VERSION = '0.0.3'
+  
+  # If you pass in an existing hash, it will
+  # convert it to a Mash including recursively
+  # descending into arrays and hashes, converting
+  # them as well.
+  def initialize(source_hash = nil)
+    deep_update(source_hash) if source_hash
+    super(nil)
+  end
+  
+  def id #:nodoc:
+    self["id"] ? self["id"] : super
+  end
+  
+  # Borrowed from Merb's Mash object.
+  #
+  # ==== Parameters
+  # key<Object>:: The default value for the mash. Defaults to nil.
+  #
+  # ==== Alternatives
+  # If key is a Symbol and it is a key in the mash, then the default value will
+  # be set to the value matching the key.
+  def default(key = nil) 
+    if key.is_a?(Symbol) && key?(key) 
+      self[key] 
+    else 
+      super 
+    end 
+  end
+  
+  alias_method :regular_reader, :[]
+  alias_method :regular_writer, :[]=
+  
+  # Retrieves an attribute set in the Mash. Will convert
+  # any key passed in to a string before retrieving.
+  def [](key)
+    key = convert_key(key)
+    regular_reader(key)
+  end
+  
+  # Sets an attribute in the Mash. Key will be converted to
+  # a string before it is set.
+  def []=(key,value) #:nodoc:
+    key = convert_key(key)
+    regular_writer(key,convert_value(value))
+  end
+  
+  # This is the bang method reader, it will return a new Mash
+  # if there isn't a value already assigned to the key requested.
+  def initializing_reader(key)
+    return self[key] if key?(key)
+    self[key] = Mash.new
+  end
+  
+  # Duplicates the current mash as a new mash.
+  def dup
+    Mash.new(self)
+  end
+  
+  alias_method :regular_inspect, :inspect
+  
+  alias_method :picky_key?, :key?
+  def key?(key)
+    picky_key?(convert_key(key))
+  end
+  
+  # Prints out a pretty object-like string of the
+  # defined attributes.
+  def inspect
+    ret = "<#{self.class.to_s}"
+    keys.sort.each do |key|
+      ret << " #{key}=#{self[key].inspect}"
+    end
+    ret << ">"
+    ret
+  end
+  alias_method :to_s, :inspect
+  
+  # Performs a deep_update on a duplicate of the
+  # current mash.
+  def deep_merge(other_hash)
+    dup.deep_merge!(other_hash)
+  end
+  
+  # Recursively merges this mash with the passed
+  # in hash, merging each hash in the hierarchy.
+  def deep_update(other_hash)
+    stringified_hash = other_hash.stringify_keys
+    stringified_hash.each_pair do |k,v|
+      k = convert_key(k)
+      self[k] = self[k].to_mash if self[k].is_a?(Hash) unless self[k].is_a?(Mash)
+      if self[k].is_a?(Hash) && stringified_hash[k].is_a?(Hash)
+        self[k].deep_merge!(stringified_hash[k])
+      else
+        self.send(k + "=", convert_value(stringified_hash[k]))
+      end
+    end
+  end
+  alias_method :deep_merge!, :deep_update
+  
+  # ==== Parameters
+  # other_hash<Hash>::
+  # A hash to update values in the mash with. Keys will be
+  # stringified and Hashes will be converted to Mashes.
+  #
+  # ==== Returns
+  # Mash:: The updated mash.
+  def update(other_hash)
+    other_hash.each_pair do |key, value|
+      if respond_to?(convert_key(key) + "=")
+        self.send(convert_key(key) + "=", convert_value(value))
+      else
+        regular_writer(convert_key(key), convert_value(value))
+      end
+    end
+    self
+  end
+  alias_method :merge!, :update
+  
+  # Converts a mash back to a hash (with stringified keys)
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+  
+  def method_missing(method_name, *args) #:nodoc:
+    if (match = method_name.to_s.match(/(.*)=$/)) && args.size == 1
+      self[match[1]] = args.first
+    elsif (match = method_name.to_s.match(/(.*)\?$/)) && args.size == 0
+      key?(match[1])
+    elsif (match = method_name.to_s.match(/(.*)!$/)) && args.size == 0
+      initializing_reader(match[1])
+    elsif key?(method_name)
+      self[method_name]
+    elsif match = method_name.to_s.match(/^([a-z][a-z0-9A-Z_]+)$/)
+      default
+    else
+      super
+    end
+  end
+  
+  protected
+  
+  def convert_key(key) #:nodoc:
+    key.to_s
+  end
+  
+  def convert_value(value) #:nodoc:
+    case value
+      when Hash
+        value.is_a?(Mash) ? value : value.to_mash
+      when Array
+        value.collect{ |e| convert_value(e) }
+      else
+        value
+    end
+  end
+end
+
+class Hash
+  # Returns a new Mash initialized from this Hash.
+  def to_mash
+    mash = Mash.new(self)
+    mash.default = default
+    mash
+  end
+  
+  # Returns a duplicate of the current hash with
+  # all of the keys converted to strings.
+  def stringify_keys
+    dup.stringify_keys!
+  end
+  
+  # Converts all of the keys to strings
+  def stringify_keys!
+    keys.each{|k| 
+      v = delete(k)
+      self[k.to_s] = v
+      v.stringify_keys! if v.is_a?(Hash)
+      v.each{|p| p.stringify_keys! if p.is_a?(Hash)} if v.is_a?(Array)
+    }
+    self
+  end
+end

data/mash.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = "mash"
+  s.version = "0.0.4"
+  s.date = "2008-04-26"
+  s.summary = "An extended Hash that gives simple pseudo-object functionality that can be built from hashes and easily extended"  
+  s.email = "michael@intridea.com"
+  s.homepage = "http://github.com/mbleigh/mash"
+  s.summary = "Mash is an extended Hash that gives simple pseudo-object functionality that can be built from hashes and easily extended"  
+  s.has_rdoc = true
+  s.authors = ["Michael Bleigh"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "mash.gemspec", "lib/mash.rb", "spec/mash_spec.rb","spec/spec_helper.rb"]
+  s.rdoc_options = ["--main", "README.txt"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+end

data/spec/mash_spec.rb

@@ -0,0 +1,114 @@
+require File.join(File.dirname(__FILE__),"..","lib","mash")
+require File.join(File.dirname(__FILE__),"spec_helper")
+
+describe Mash do
+  before(:each) do
+    @mash = Mash.new
+  end
+  
+  it "should inherit from hash" do
+    @mash.is_a?(Hash).should be_true
+  end
+  
+  it "should be able to set hash values through method= calls" do
+    @mash.test = "abc"
+    @mash["test"].should == "abc"
+  end
+  
+  it "should be able to retrieve set values through method calls" do
+    @mash["test"] = "abc"
+    @mash.test.should == "abc"
+  end
+  
+  it "should test for already set values when passed a ? method" do
+    @mash.test?.should be_false
+    @mash.test = "abc"
+    @mash.test?.should be_true
+  end
+  
+  it "should make all [] and []= into strings for consistency" do
+    @mash["abc"] = 123
+    @mash.key?('abc').should be_true
+    @mash["abc"].should == 123
+  end
+  
+  it "should have a to_s that is identical to its inspect" do
+    @mash.abc = 123
+    @mash.to_s.should == @mash.inspect
+  end
+  
+  it "should return nil instead of raising an error for attribute-esque method calls" do
+    @mash.abc.should be_nil
+  end
+  
+  it "should return a Mash when passed a bang method to a non-existenct key" do
+    @mash.abc!.is_a?(Mash).should be_true
+  end
+  
+  it "should return the existing value when passed a bang method for an existing key" do
+    @mash.name = "Bob"
+    @mash.name!.should == "Bob"
+  end
+  
+  it "#initializing_reader should return a Mash when passed a non-existent key" do
+    @mash.initializing_reader(:abc).is_a?(Mash).should be_true
+  end
+  
+  it "should allow for multi-level assignment through bang methods" do
+    @mash.author!.name = "Michael Bleigh"
+    @mash.author.should == Mash.new(:name => "Michael Bleigh")
+    @mash.author!.website!.url = "http://www.mbleigh.com/"
+    @mash.author.website.should == Mash.new(:url => "http://www.mbleigh.com/")
+  end
+  
+  it "#deep_update should recursively mash mashes and hashes together" do
+    @mash.first_name = "Michael"
+    @mash.last_name = "Bleigh"
+    @mash.details = {:email => "michael@asf.com"}.to_mash
+    @mash.deep_update({:details => {:email => "michael@intridea.com"}})
+    @mash.details.email.should == "michael@intridea.com"
+  end
+  
+  context "#initialize" do
+    it "should convert an existing hash to a Mash" do
+      converted = Mash.new({:abc => 123, :name => "Bob"})
+      converted.abc.should == 123
+      converted.name.should == "Bob"
+    end
+  
+    it "should convert hashes recursively into mashes" do
+      converted = Mash.new({:a => {:b => 1, :c => {:d => 23}}})
+      converted.a.is_a?(Mash).should be_true
+      converted.a.b.should == 1
+      converted.a.c.d.should == 23
+    end
+  
+    it "should convert hashes in arrays into mashes" do
+      converted = Mash.new({:a => [{:b => 12}, 23]})
+      converted.a.first.b.should == 12
+      converted.a.last.should == 23
+    end
+  end
+end
+
+describe Hash do
+  it "should be convertible to a Mash" do
+    mash = {:some => "hash"}.to_mash
+    mash.is_a?(Mash).should be_true
+    mash.some.should == "hash"
+  end
+  
+  it "#stringify_keys! should turn all keys into strings" do
+    hash = {:a => "hey", 123 => "bob"}
+    hash.stringify_keys!
+    hash.should == {"a" => "hey", "123" => "bob"}
+  end
+  
+  it "#stringify_keys should return a hash with stringified keys" do
+    hash = {:a => "hey", 123 => "bob"}
+    stringified_hash = hash.stringify_keys
+    hash.should == {:a => "hey", 123 => "bob"}
+    stringified_hash.should == {"a" => "hey", "123" => "bob"}
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__),"..","lib","mash")

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: mbleigh-mash
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Michael Bleigh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-26 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: michael@intridea.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- mash.gemspec
+- lib/mash.rb
+- spec/mash_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mbleigh/mash
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Mash is an extended Hash that gives simple pseudo-object functionality that can be built from hashes and easily extended
+test_files: []
+