dlt-mosh 0.2.1

data/README

@@ -0,0 +1,66 @@
+= Mosh (My Own Hash With Methods)
+ 
+http://github.com/dlt/Mosh
+ 
+== DESCRIPTION:
+ 
+Mosh is my own version of mash (http://github.com/mbleigh/mash/).
+I prefered to avoid method_missing and instead used instance_eval
+for creating methods.
+This library can be useful when you need to have hashes that look like
+objects.
+ 
+== SYNOPSIS:
+  
+  mosh = Mosh.new
+  mosh['name'] = "Hello"
+  mosh.name # => "Hello"
+  
+  #it recursively creates moshes from arrays and nested hashes/moshes
+  nested = Mosh.new :a => [1, 2, 3], :b => {:c => 2}
+  nested.a # => [1, 2, 3]
+  nested.b.c # => 2
+  
+  #See more info at the specs diretory. 
+== INSTALL:
+ 
+Gem:
+ 
+Mosh is hosted on the GitHub gem repository, so if you haven't already:
+ 
+  gem sources -a http://gems.github.com/
+  sudo gem install dlt-Mosh
+  
+Git:
+ 
+  git clone git://github.com/dlt/Mosh.git
+  
+== RESOURCES
+ 
+If you encounter any problems or have ideas for new features
+please send and e-mail to daltojr [] gmail [] com
+ 
+ 
+== LICENSE:
+ 
+Copyright (c) 2009 Dalto Curvelano Jr (http://daltojr.wordpress.com/),
+released under the MIT license
+ 
+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/mosh.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = "mosh"
+  s.summary = "A hash extended with methods for easy access to values. Inspired by Mash."
+  s.description = "A hash extended with methods for easy access to values. Inspired by Mash."
+  s.version = "0.2.1"
+  s.date = "2009-03-07"
+  s.email = "daltojr@gmail.com"
+  s.homepage = "http://github.com/dlt/Mosh"
+  s.has_rdoc = false
+  s.authors = ["Dalto Curvelano Jr"]
+  s.files = ["README", "mosh.gemspec", "mosh.rb", "specs/mosh_spec.rb"]
+end

data/mosh.rb

@@ -0,0 +1,94 @@
+class Mosh < Hash
+
+  def initialize(arg = {})
+    copy_values arg
+    add_hash_methods(arg, '', true)
+  end
+
+  def []=(key, value)
+    key   = convert_key key
+    value = convert_value value
+    add_method(key, self)
+    super
+  end
+  
+  def [](key)
+    key = convert_key key
+    super
+  end
+
+  private
+  def convert_key(key); key.to_s; end
+  
+  def convert_value(value)
+    case value
+      when Hash
+        Mosh.new(value)
+      when Array
+        value.each_with_index {|item, idx| value[idx] = Mosh.new item if item.is_a? Hash}
+      else
+        value
+    end
+  end
+
+  def extract_method_names(hash, prefix = '')
+     hash.each_pair.inject([]) do |arr, (key, value)|
+
+      method_name = prefix + key.to_s
+      arr << method_name
+
+      case value
+        when Hash
+          arr << add_hash_methods(value, method_name + '_')
+        when Array 
+          arr << extract_array_method_names(value, method_name + '_') if all_items_are_hashes?(value)
+      end
+      arr
+    end.flatten
+  end
+
+  def add_hash_methods(hash, prefix = '', add_to_self = false)
+    meths = extract_method_names(hash, prefix)
+    meths.each do |method_name|
+      if add_to_self
+        add_method(method_name, self)
+      else
+        add_method(method_name, hash)
+      end
+    end
+  end
+
+  def extract_array_method_names(array, prefix = '')
+    array.collect {|item| add_hash_methods(item, '')}.flatten 
+  end
+
+  def add_method(method_name, obj)
+    keys    = method_name.split '_'
+    method = method_string(method_name.gsub(':','_'), keys)
+    obj.instance_eval method
+  end
+   
+  def all_items_are_hashes?(array)
+    array.each do |item|
+      return false unless item.is_a? Hash
+    end
+    true
+  end
+
+  def method_string(method_name, keys)
+    hash_accessor = hash_keys_as_string(keys)
+    %Q{
+      def #{method_name}
+        self#{hash_accessor}
+      end
+    }
+  end
+
+  def hash_keys_as_string(keys)
+    keys.map {|k| "['#{k}']"}.join
+  end
+
+  def copy_values(other)
+    other.each_pair{|key, value| self[key] = value}
+  end
+end

data/specs/mosh_spec.rb

@@ -0,0 +1,65 @@
+require '../mosh.rb'
+
+describe Mosh do
+  before do
+    @mosh = Mosh.new({
+      'rss' => 'items',
+      'links' => ['www.google.com', 'www.google.com.br', 'a string'],
+      'category' => {'a' => 1},
+      'array' => [{'arr:item' => 2}]
+    })
+  end
+
+  it "should inherit from hash" do
+    @mosh.is_a?(Hash).should be_true
+  end
+  
+  it "should have metaprogrammed methods to get hash values" do
+    @mosh.rss.should == 'items'
+
+    @mosh.links.should include('a string')
+    @mosh.category.keys.should include('a')
+    @mosh.category.keys.should_not include('b')
+
+    @mosh.category_a.should == 1
+    @mosh.category_a.should == @mosh.category['a']
+    @mosh.array.first.arr_item.should == 2
+  end
+
+  it "should be able to retrieve hash values through method= calls" do
+    @mosh["test"]= "abc"
+    @mosh.test.should  == "abc"
+    @mosh[:taste] = "mint"
+    @mosh[:taste].should == "mint"
+    @mosh.taste.should  == "mint"
+  end
+
+  it "should convert hash assignments into moshes" do
+    @mosh['details'] = {:email => 'dalto@asf.com', :address => {:state => 'TX'} }
+    @mosh.details.email.should == 'dalto@asf.com'
+    @mosh.details.address.state.should == 'TX'
+  end
+
+  it "should convert hashes recursively into moshes" do
+  	converted = Mosh.new({:a => {:b => 1, :c => {:d => 23}}})
+    converted.a.is_a?(Mosh).should be_true
+    converted.a.b.should == 1
+    converted.a.c.d.should == 23
+  end
+
+  it "should convert hashes in arrays into moshes" do
+  	converted = Mosh.new({:a => [{:b => 12}, 23]})
+    converted.a.first.b.should == 12
+    converted.a.last.should == 23
+  end
+
+	it "should convert an existing Mosh into a Mosh" do
+  	initial = Mosh.new(:name => 'randy', :address => {:state => 'TX'})
+    copy = Mosh.new(initial)
+    initial.name.should == copy.name
+    initial.object_id.should_not == copy.object_id
+    copy.address.state.should == 'TX'
+    initial.address.state.should == 'TX'
+    copy.address.object_id.should_not == initial.address.object_id
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: dlt-mosh
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Dalto Curvelano Jr
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-07 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A hash extended with methods for easy access to values. Inspired by Mash.
+email: daltojr@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- mosh.gemspec
+- mosh.rb
+- specs/mosh_spec.rb
+has_rdoc: false
+homepage: http://github.com/dlt/Mosh
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+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.3.5
+signing_key: 
+specification_version: 2
+summary: A hash extended with methods for easy access to values. Inspired by Mash.
+test_files: []
+