symbolmatrix 0.0.1 → 1.0.0

data/Gemfile

@@ -7,3 +7,12 @@ gemspec
 group :test do
   gem "rake"
 end
+
+group :development do 
+  gem "guard-rspec"
+  gem "guard-cucumber"
+  gem "libnotify"
+  gem "cucumber"
+  gem "pry"
+  gem "rb-inotify"
+end

data/Guardfile

@@ -0,0 +1,39 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :cli => "--color --format doc" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+#  watch('spec/complete_features_helper.rb')  { "spec" }
+#  watch('spec/plain_symbolmatrix_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+
+
+#guard 'cucumber', :cli => "-ci" do
+#  watch(%r{^features/.+\.feature$})
+#  watch(%r{^features/support/.+$})          { 'features' }
+#  watch(%r{^features/stepdefs/(.+)\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
+#end
+
+guard 'cucumber' do
+  watch(%r{^features/.+\.feature$})
+  watch(%r{^features/support/.+$})          { 'features' }
+  watch(%r{^features/stepdefs/(.+)\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
+end

data/README.md

@@ -5,6 +5,8 @@ SymbolMatrix
 
 > Strongly inspired in [SymbolTable][symboltable] gem by [Michael Jackson][michael-jackson-home] (thanks a lot!)
 
+> **New!**: SymbolMatrix now features a serialization syntax from which it can be parsed and to which it can be serialized. I'm calling it SMAS (SymbolMAtris Serialization) and it's loosely inspired in both [rake][rake-link] and [thor][thor-link]'s argument syntax styles. Read more about it in the *SMAS* section downstairs.
+
 **SymbolMatrix** is a simple Ruby Gem that extends `Hash` so that only `Symbol`s can be used as keys. Why? Because it also allows you to query the SymbolMatrix object using the dot syntax and a string key equivalent to the symbol one, making it more Principle of Least Surprise.
 
 The showdown:
@@ -25,56 +27,135 @@ m['a']      # => 1
 m.a         # => 1
 ```
 
-If you are familiar with SymbolTable you may have noticed that, so far, the same functionality is provided in the original gem. SymbolMatrix adds two key features:
+If you are familiar with SymbolTable you may have noticed that, so far, the same functionality is provided in the original gem. SymbolMatrix adds three key features:
 
 1.  **Recursive convertion to SymbolMatrix**
 
     ```ruby
     require "symbolmatrix"
     
-    m = SymbolMatrix.new :quantum => { :nano => "data" }
+    m = SymbolMatrix :quantum => { :nano => "data" }
 
     m.quatum.nano # => "data"
     ```
 
-2.  **YAML autoloading**
+2.  **JSON/YAML autoloading**
     
     ```ruby
     require "symbolmatrix"
     
-    m = SymbolMatrix.new "quantum: of solace"
+    m = SymbolMatrix "quantum: of solace"
     m.quantum   # => "of solace"
     
     # Or alternatively
-    m.from_yaml "quantum: of solace"
+    m.from.yaml "quantum: of solace"
     
     # Provided a file exists "configuration.yaml" with "database_uri: mysql://root@localhost/database"
-    m.from_file "configuration.yaml"
+    m.from.file "configuration.yaml"
     m.database_uri  # => "mysql://root@localhost/database"
     
     # Or simply
-    m = SymbolMatrix.new "configuration.yaml"
+    m = SymbolMatrix "configuration.yaml"
+    ```
+    
+    Since all JSON is valid YAML... yey, it works with JSON too!
+	```ruby
+    require 'symbolmatrix'
+    
+    data = SymbolMatrix '{"message":"Awesome"}'
+    data.message # => 'Awesome'
     ```
 
+3.  **Own serialization format for command line**
+    
+    Look the next section
+
 [symboltable]: https://github.com/mjijackson/symboltable
 [michael-jackson-home]: http://mjijackson.com/
+[rake-link]: https://github.com/jimweirich/rake
+[thor-link]: https://github.com/wycats/thor
+
+SMAS: SymbolMatrix Serialization
+--------------------------------
+
+The serialization format is designed to serve as an alternative for the command line environment, when multiline (YAML) and special characters (JSON) are not well suited. It's very intuitive and designed to closely resemble the way SymbolMatrix is used within Ruby code. For example:
+    
+```ruby
+require 'symbolmatrix'
+
+s = SymbolMatrix 'this.serialization:format i.think:rocks!'
+
+s.this.serialization    # => "format"
+s.i.think               # => "rocks!"
+
+s.from.serialization 'works.with.numbers:793'
+
+s.works.with.numbers    # => 793
+```
+
+You can get the serialization from any SymbolMatrix:
+
+```ruby
+require 'symbolmatrix'
+
+SymbolMatrix(:where => { 
+  :is => { 
+    :paris  => "france", 
+    :roma   => "italia"
+  }
+).to.serialization # => 'where.is.paris:france where.is.roma:italia'
+```
+
+> This serialization format is better exploited in the [Empezar Ruby Gem][empezar-link]
+
+[empezar-link]: https://github.com/Fetcher/empezar
 
 Further details
 ---------------
 
-### Recursive `#to_hash` convertion
+### Recursive `#to.hash` convertion
 
-SymbolMatrix provides the `#to_hash` method that recursively transforms the matrix into a n-dimentional Hash.
+SymbolMatrix provides the `#to.hash` method that recursively transforms the matrix into a n-dimentional Hash.
 
-### Disabling the YAML discovery
+### Disabling the extras
 
-If for some reason you don't want this class to use YAML, you can just require `symbolmatrix/symbolmatrix` and the YAML functionality will not be loaded.
+If for some reason you don't want this class to use YAML nor the serialization format SMAS, you can just require `symbolmatrix/symbolmatrix` and those functionalities will not be loaded.
 
 ### Exceptions
 
 Whenever a key is not found in the SymbolMatrix, a custom `SymbolMatrix::KeyNotDefinedException` will be raised. 
 Similarly, if you attempt to use an inconvertible key (inconvertible to `Symbol`) a `SymbolMatrix::InvalidKeyException` will be raised.
 
+Changelog for 1.0.0
+-------------------
+
+Serialization format aside, there had been some minor changes to the API worth noting:
+
+### Deprecations
+
+As of version 1.0.0, Writers and Readers has been added, so now the regular methods `from_yaml`, `from_file` and `to_hash` are deprecated in favor of `from.yaml`, `from.file` and `to.hash`. Please change to the new API is you're working with SymbolMatrix right now.
+
+### `.new` no longer needed
+
+`SymbolMatrix :a => 'b'` is now equivalent to `SymbolMatrix.new(:a => 'b')`.
+
+SymbolMatrix is mostly about the developers having an easier time with code so I place strong priority in these small changes for comfort.
+
+### `#recursive_merge` available
+
+> Note: this is not yet working with any Hash, just SymbolMatrices.
+
+Yey! This one was missing quite a while from Ruby Hashes (if you are like me and spend a lot of time dealing with multidimensional hashes).
+
+The API is straightforward:
+```ruby
+sm = SymbolMatrix(:a => { :b => "c" })
+sm.recursive_merge SymbolMatrix(:a => { :c => "d"})
+
+sm.a.b # => "c"
+sm.a.c # => "d"
+```
+
 Installation
 ------------
 
@@ -89,6 +170,15 @@ And then execute:
 
     bundle install
 
+## Known issues
+
+- When loading a YAML/JSON document that has an sequence –array– as the root item, SymbolMatrix will crash. This is because SymbolMatrix wasn't intended for arrays, just Hashes, and the recursive conversion from Hash to SymbolMatrix is not working with Arrays.
+- Some keys overlap with method names, so can't be used with the dot syntax. For example, `key`. Just use them with the hash syntax instead :)
+
+## Future
+
+- Make SymbolMatrix raise a more relevant error when the file does not exist (something along the lines of "There was an error parsing the YAML string, may be it was a file path and the file does not exist?"). It is possible to increase the chances of detecting properly with a really simple regular expression...
+
 ## Testing
 
 RSpec specs are provided to check functionality.

data/features/parse_serialization.feature

@@ -0,0 +1,26 @@
+Feature: Parsing a SymbolMatrix serialization
+  In order to be able to build multidimensional hashes from 
+    single line contexts, such as terminals
+  As a developer
+  I want to have a simple way to parse a serialization
+
+Scenario: Quite basic structure
+  Given "data:datum"
+  When I parse it
+  Then I should see (serialized in yaml)
+  """
+  data: datum
+  """
+
+Scenario: Needlessly complicated
+  Given "remote.client.host:fetcher remote.client.path:/ remote.client.port:bridge.fetcher remote.server:8080"
+  When I parse it
+  Then I should see (serialized in yaml)
+  """
+  remote: 
+    client:
+      host: fetcher
+      path: /
+      port: bridge.fetcher
+    server: 8080
+  """

data/features/serialize.feature

@@ -0,0 +1,43 @@
+Feature: Serializing a SymbolMatrix
+  In order to be able to send SymbolMatrices
+    in command line environments
+  As a developer
+  I want to be able to serialize SymbolMatrices
+
+Scenario: Nice SymbolMatrix serialized
+  Given the SymbolMatrix:
+  """
+  roses:
+    are: red
+  violets:
+    are: blue
+  I:
+    get: joke
+    like: poetry
+    say: 
+      to: you
+      some: stuff
+  """
+  When I serialize it
+  Then I should get "roses.are:red violets.are:blue I.get:joke I.like:poetry I.say.to:you I.say.some:stuff"
+
+Scenario: Serializing and parsing back
+  Given the SymbolMatrix:
+  """
+  greetings:
+    aloha: hawaii
+  cities:
+    roma: italy
+    paris: france
+  """
+  When I serialize it
+  Then I should get "greetings.aloha:hawaii cities.roma:italy cities.paris:france"
+  When I parse it
+  Then I should see (serialized in yaml)
+  """
+  greetings:
+    aloha: hawaii
+  cities:
+    roma: italy
+    paris: france
+  """

data/features/stepdefs/parse_serialization.rb

@@ -0,0 +1,11 @@
+Given /^"(.+?)"$/ do |serialization|
+  @serialization = serialization
+end
+
+When /^I parse it$/ do 
+  @parsed = SymbolMatrix.new @serialization
+end
+
+Then /^I should see \(serialized in yaml\)$/ do |data|
+  @parsed.to_hash.should include SymbolMatrix.new(data).to_hash
+end

data/features/stepdefs/serialize.rb

@@ -0,0 +1,11 @@
+Given /^the SymbolMatrix:$/ do |yaml| 
+  @symbolmatrix = SymbolMatrix yaml
+end
+
+When /^I serialize it$/ do 
+  @serialization = @symbolmatrix.to.serialization
+end
+
+Then /^I should get "(.+?)"$/ do |serialization|
+  @serialization.should == serialization
+end

data/features/support/env.rb

@@ -0,0 +1,3 @@
+$:.push File.expand_path "../../../lib", __FILE__
+
+require 'symbolmatrix'

data/lib/reader/symbolmatrix.rb

@@ -0,0 +1,37 @@
+module Reader
+  class SymbolMatrix
+    attr_accessor :source
+
+    def initialize source
+      @source = source
+    end
+
+    def file path
+      @source.merge! YAML.load_file path
+    end
+
+    def yaml data
+      @source.merge! YAML.load data
+    end
+
+    def serialization data
+      @source.merge! ::SymbolMatrix::Serialization.parse data
+    end
+
+    alias :smas :serialization
+  end
+end
+
+class SymbolMatrix < Hash
+  include Discoverer::Reader
+
+  # @deprecated Use #from.yaml
+  def from_yaml *args
+    Kernel.warn "[DEPRECATION]: #from_yaml is deprecated, please use #from.yaml instead"
+  end
+
+  # @deprecated Use #from.file
+  def from_file *args
+    Kernel.warn "[DEPRECATION]: #from_file is deprecated, please use #from.file instead"
+  end
+end

data/lib/symbolmatrix.rb

@@ -1,2 +1,7 @@
-require "symbolmatrix/symbolmatrix"
-require "yaml/symbolmatrix"
+require 'yaml'
+require 'discoverer'
+
+require 'symbolmatrix/symbolmatrix'
+require 'symbolmatrix/serialization'
+require 'reader/symbolmatrix'
+require 'writer/symbolmatrix'

data/lib/symbolmatrix/serialization.rb

@@ -0,0 +1,41 @@
+class SymbolMatrix < Hash
+  class Serialization
+    def self.parse serialization
+      result = SymbolMatrix.new
+      if serialization.include? " "
+        serialization.split(" ").each do |command|
+          result = result.recursive_merge parse command
+        end
+      else
+        parts = serialization.split ":"
+        unless parts.first.include? "."          
+          begin
+            parts[1] = Integer parts.last
+          rescue ArgumentError => e
+          end
+          result.merge! parts.first => parts.last
+        else
+          the_key = serialization[0..serialization.index(".") -1]
+          result[the_key] = parse serialization[serialization.index(".")+1..-1]
+        end
+      end
+      result
+    end
+  end
+
+  def initialize argument = nil
+    if argument.is_a? String
+      if File.exist? argument
+        from.file argument
+      else
+        begin
+          from.yaml argument
+        rescue NoMethodError => e
+          from.serialization argument
+        end
+      end
+    else
+      merge! argument unless argument.nil?
+    end
+  end
+end

data/lib/symbolmatrix/symbolmatrix.rb

@@ -36,18 +36,9 @@ class SymbolMatrix < Hash
 
   alias []= store  
   
-  # Returns a hashed version of this SymbolMatrix, with all SymbolMatrix objects within recursively 
-  # converted into hashes
-  def to_hash recursive = true
-    the_hash = {}
-    self.each do |key, value|
-      if value.is_a? SymbolMatrix and recursive
-        the_hash[key] = value.to_hash
-      else
-        the_hash[key] = value
-      end
-    end
-    return the_hash
+  # @deprecated Use #to.hash instead
+  def to_hash 
+    Kernel.warn "[DEPRECATION]: #to_hash is deprecated, please use #to.hash instead"
   end
   
   # Merges the passed hash within self
@@ -77,6 +68,27 @@ class SymbolMatrix < Hash
     end
   end
   
+  # Merges this SymbolMatrix with another SymbolMatrix recursively
+  def recursive_merge hash
+    result = SymbolMatrix.new
+    self.keys.each do |key|
+      result[key] = self[key]
+    end
+
+    hash.keys.each do |key|
+      if result.has_key? key
+        result[key] = result[key].recursive_merge hash[key]
+      else
+        result[key] = hash[key]
+      end
+    end
+    return result
+  end
+
   class KeyNotDefinedException < RuntimeError; end
   class InvalidKeyException < RuntimeError; end 
 end
+
+def SymbolMatrix *args
+  SymbolMatrix.new *args
+end

data/lib/symbolmatrix/version.rb

@@ -1,3 +1,3 @@
 module Symbolmatrix
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/lib/writer/symbolmatrix.rb

@@ -0,0 +1,39 @@
+module Writer
+  class SymbolMatrix
+    attr_accessor :source
+
+    def initialize source
+      @source = source
+    end
+
+    def serialization prefix = nil
+      result = ""
+      @source.each do |key, value|
+        unless value.is_a? Hash
+          result += " #{prefix}#{key}:#{value}"
+        else
+          result += " " + Writer::SymbolMatrix.new(value).serialization("#{prefix}#{key}.")
+        end
+      end
+      result[1..-1]
+    end
+
+    alias :smas :serialization
+
+    def hash
+      the_hash = {}
+      @source.each do |key, value|
+        if value.respond_to? :to
+          the_hash[key] = value.to.hash
+        else
+          the_hash[key] = value
+        end
+      end
+      the_hash
+    end
+  end
+end
+
+class SymbolMatrix < Hash
+  include Discoverer::Writer
+end

data/spec/complete_features_helper.rb

@@ -0,0 +1,3 @@
+require "symbolmatrix"
+
+require "fast/fast" # For testing easyness

data/spec/plain_symbolmatrix_helper.rb

@@ -0,0 +1 @@
+require 'symbolmatrix/symbolmatrix'

data/spec/reader/symbolmatrix_spec.rb

@@ -0,0 +1,78 @@
+require 'complete_features_helper'
+
+describe Reader::SymbolMatrix do 
+  describe '#initialize' do 
+    it 'should receive a source and add it as source' do 
+      source = stub 'source'
+      reader = Reader::SymbolMatrix.new source
+      reader.source.should == source
+    end
+  end
+
+  describe "#yaml" do
+    it "should call #merge! the source using the parsed YAML data as argument" do
+      sample_yaml = "a: { nested: { data: with, very: much }, content: to find }"
+      the_stub = stub "a theoretical SymbolMatrix"
+      reader = Reader::SymbolMatrix.new the_stub
+      the_stub.should_receive(:merge!).with "a" => { "nested" => { "data" => "with", "very" => "much" }, "content" => "to find" }
+      reader.yaml sample_yaml
+    end
+  end
+  
+  describe "#file" do
+    context "there is a YAML file in the given path" do
+      before do
+        Fast.file.write "temp/data.yaml", "a: { nested: { data: with, very: much }, content: to find }"
+      end
+      
+      it "should call #merge! on the source using the parsed YAML data found in the file" do
+        the_stub = stub "a theoretical SymbolMatrix"
+        reader = Reader::SymbolMatrix.new the_stub
+        the_stub.should_receive(:merge!).with "a" => { "nested" => { "data" => "with", "very" => "much" }, "content" => "to find" }
+        reader.file "temp/data.yaml"
+      end
+      
+      after do
+        Fast.dir.remove! :temp
+      end
+    end
+  end
+
+  shared_examples_for "any serialization" do 
+    it 'should call merge! to source with the parsed data' do 
+      the_sm = stub 'sm'
+      data_stub = stub 'data'
+      ready_to_merge = stub 'ready to merge'
+      reader = Reader::SymbolMatrix.new the_sm
+      SymbolMatrix::Serialization.should_receive(:parse).with(data_stub).and_return ready_to_merge
+      the_sm.should_receive(:merge!).with ready_to_merge
+      reader.send @method, data_stub
+    end
+  end
+
+  describe "#serialization" do 
+    before { @method = :serialization }
+    it_behaves_like 'any serialization'
+  end
+
+  describe '#smas' do 
+    before { @method = :smas }
+    it_behaves_like 'any serialization'
+  end
+end
+
+describe SymbolMatrix do
+  it 'should include the Discoverer for Reader' do 
+    SymbolMatrix.ancestors.should include Discoverer::Reader
+  end
+
+  it 'should feature a deprecation notice in #from_yaml' do
+    Kernel.should_receive(:warn).with "[DEPRECATION]: #from_yaml is deprecated, please use #from.yaml instead" 
+    SymbolMatrix.new.from_yaml stub 'argument'
+  end
+
+  it 'should feature a deprecation notice in #from_file' do 
+    Kernel.should_receive(:warn).with "[DEPRECATION]: #from_file is deprecated, please use #from.file instead" 
+    SymbolMatrix.new.from_file stub 'argument'
+  end
+end

data/spec/symbolmatrix/serialization_spec.rb

@@ -0,0 +1,109 @@
+require 'complete_features_helper'
+
+describe SymbolMatrix::Serialization do
+  describe '.parse' do 
+    it 'should parse a simple string aja:hola' do
+      sm = SymbolMatrix::Serialization.parse 'aja:hola'
+      sm.aja.should == 'hola'
+    end
+
+    it 'should parse another simple string esto:distinto' do 
+      SymbolMatrix::Serialization
+        .parse('esto:distinto')
+        .esto.should == "distinto"
+    end
+
+    it 'should parse to a number when is a number' do
+      SymbolMatrix::Serialization
+        .parse("esto:3442")
+        .esto.should == 3442
+    end
+
+    it 'should parse a more complex string' do 
+      sm = SymbolMatrix::Serialization.parse 'hola:eso que:pensas'
+      sm.hola.should == 'eso'
+      sm.que.should == 'pensas'
+    end
+
+    it 'should parse another complex string' do 
+      sm = SymbolMatrix::Serialization
+        .parse("esto:es bastante:original gracias:bdd")
+      sm.esto.should == "es"
+      sm.bastante.should == "original"
+      sm.gracias.should == "bdd"
+    end
+
+    it 'should parse a string with a single dot' do 
+      SymbolMatrix::Serialization
+        .parse("just.one:dot")
+        .just.one.should == "dot"
+    end
+
+    it 'should parse another string with single dot' do 
+      SymbolMatrix::Serialization
+        .parse("just.one:point")
+        .just.one.should == "point"
+    end
+
+    it 'should parse another one, other var name' do 
+      SymbolMatrix::Serialization
+        .parse("just.another:data")
+        .just.another.should == "data"
+    end
+
+    it 'should parse a string with dots' do
+      SymbolMatrix::Serialization
+        .parse("the.one.with:dots")
+        .the.one.with.should == "dots"
+    end
+
+    it 'should parse a string with dots and spaces' do
+      sm = SymbolMatrix::Serialization
+        .parse("in.one.with:dots the.other.with:dots")
+      sm.the.other.with.should == "dots"
+      sm.in.one.with.should == "dots"
+    end    
+
+    it 'should merge recursively when needed' do 
+      sm = SymbolMatrix::Serialization
+        .parse("client.host:localhost client.path:hola")
+
+      sm.client.host.should == "localhost"
+      sm.client.path.should == "hola"
+    end
+  end
+end
+
+describe SymbolMatrix do
+  describe "#initialize" do
+    context "a valid path to a file is provided" do
+      before do 
+        Fast.file.write "temp/data.yaml", "a: { nested: { data: with, very: much }, content: to find }"
+      end
+      
+      it "should load the data into self" do
+        f = SymbolMatrix.new "temp/data.yaml"
+        f.a.nested.data.should == "with"
+      end
+
+      after do
+        Fast.dir.remove! :temp
+      end
+    end
+    
+    context "a YAML string is provided" do
+      it "should load the data into self" do
+        e = SymbolMatrix.new "beta: { nano: { data: with, very: much }, content: to find }"
+        e.beta.nano[:very].should == "much"
+      end
+    end
+
+    context "a SymbolMatrix serialization is provided" do 
+      it 'should load the data into self' do 
+        a = SymbolMatrix.new "those.pesky:attempts of.making.it:work"
+        a.those.pesky.should == "attempts"
+        a.of.making.it.should == "work"
+      end
+    end
+  end
+end

data/spec/{symbolmatrix_spec.rb → symbolmatrix/symbolmatrix_spec.rb}

@@ -1,7 +1,6 @@
-require "symbolmatrix/symbolmatrix"
+require "plain_symbolmatrix_helper"
 
 describe SymbolMatrix do
-
   describe "#validate_key" do
     context "an not convertible to Symbol key is passed" do
       it "should raise a SymbolMatrix::InvalidKeyException" do
@@ -76,34 +75,9 @@ describe SymbolMatrix do
   end
 
   describe "#to_hash" do
-    it "should return an instance of Hash" do
-      m = SymbolMatrix[:b, 1]
-      m.to_hash.should be_instance_of Hash
-    end
-    
-    it "should have the same keys" do
-      m = SymbolMatrix[:a, 1]
-      m.to_hash[:a].should == 1
-    end
-    
-    context "there is some SymbolMatrix within this SymbolMatrix" do
-      it "should recursively call #to_hash in it" do
-        inside = SymbolMatrix.new
-        inside.should_receive :to_hash
-        
-        m = SymbolMatrix[:a, inside]
-        m.to_hash
-      end
-      
-      context "and recursive is set to false" do
-        it "should not call #to_hash on values" do
-          inside = SymbolMatrix.new
-          inside.should_not_receive :to_hash
-          
-          m = SymbolMatrix[:a, inside]
-          m.to_hash false
-        end
-      end
+    it "should show a deprecation notice" do
+      Kernel.should_receive(:warn).with "[DEPRECATION]: #to_hash is deprecated, please use #to.hash instead" 
+      SymbolMatrix.new.to_hash
     end
   end
 
@@ -144,4 +118,61 @@ describe SymbolMatrix do
       a.a.should be_instance_of B
     end
   end
+
+  describe "#recursive_merge" do 
+    it 'should merge two symbolmatrices' do 
+      sm = SymbolMatrix.new a: "hola"
+      result = sm.recursive_merge SymbolMatrix.new b: "chau"
+      result.a.should == "hola"
+      result.b.should == "chau"
+    end
+
+    it 'should merge two symbolmatrices (new values)' do 
+      sm = SymbolMatrix.new a: "hey"
+      result = sm.recursive_merge SymbolMatrix.new b: "bye"
+      result.a.should == "hey"
+      result.b.should == "bye"
+    end
+
+    it 'should merge two symbolmatrices (new keys)' do 
+      sm = SymbolMatrix.new y: "allo"
+      result = sm.recursive_merge SymbolMatrix.new z: "ciao"
+      result.y.should == "allo"
+      result.z.should == "ciao"
+    end
+
+    it 'should recursively merge this with that (simple)' do 
+      sm = SymbolMatrix.new another: { b: "aa" }
+      result = sm.recursive_merge SymbolMatrix.new another: { c: "ee" }
+      result.another.b.should == "aa"
+      result.another.c.should == "ee"
+    end
+
+    it 'should recursively merge this with that (simple)' do 
+      sm = SymbolMatrix.new distinct: { b: "rr" }
+      result = sm.recursive_merge SymbolMatrix.new distinct: { c: "gg" }
+      result.distinct.b.should == "rr"
+      result.distinct.c.should == "gg"
+    end
+
+    it 'should recursively merge this with that v2 (simple)' do
+      sm = SymbolMatrix.new a: { z: "ee" }
+      result = sm.recursive_merge SymbolMatrix.new a: { g: "oo" }
+      result.a.z.should == "ee"
+      result.a.g.should == "oo"
+    end
+
+    it 'should recursively merge this with the argument hash' do 
+      sm = SymbolMatrix.new a: { b: { c: "hola" } }
+      result = sm.recursive_merge a: { b: { d: "aaa" } }
+      result.a.b.c.should == "hola"
+      result.a.b.d.should == "aaa"
+    end
+  end
+
+  it 'should be a method that calls SymbolMatrix.new with its arguments' do 
+    argument = stub 'argument'
+    SymbolMatrix.should_receive(:new).with argument
+    SymbolMatrix argument
+  end
 end

data/spec/writer/symbolmatrix_spec.rb

@@ -0,0 +1,155 @@
+require 'complete_features_helper'
+
+describe Writer::SymbolMatrix do 
+  describe '#initialize' do 
+    it 'should set the argument as the source' do 
+      source = stub 'source'
+      writer = Writer::SymbolMatrix.new source
+      writer.source.should == source
+    end
+  end
+
+  describe '#hash' do 
+    it "should return an instance of Hash" do
+      m = SymbolMatrix[:b, 1]
+      writer = Writer::SymbolMatrix.new m
+      writer.hash.should be_instance_of Hash
+    end
+    
+    it "should have the same keys" do
+      m = SymbolMatrix[:a, 1]
+      writer = Writer::SymbolMatrix.new m
+      writer.hash[:a].should == 1
+    end
+
+    it "should have the same keys (more keys)" do
+      m = SymbolMatrix[:a, 2]
+      writer = Writer::SymbolMatrix.new m
+      writer.hash[:a].should == 2
+    end
+    
+    context "there is some SymbolMatrix within this SymbolMatrix" do
+      it "should recursively call #to.hash in it" do
+        in_writer = stub 'inside writer'
+
+        inside = SymbolMatrix.new
+        inside.should_receive(:to).and_return in_writer
+        in_writer.should_receive(:hash)
+        
+        m = SymbolMatrix[:a, inside]
+        writer = Writer::SymbolMatrix.new m
+        writer.hash
+      end
+    end
+  end
+
+  shared_examples_for 'any serialization' do 
+    it 'should serialize "try: this" into "try:this"' do 
+      s = SymbolMatrix try: "this"
+      writer = Writer::SymbolMatrix.new s
+      writer.send(@method).should == "try:this"
+    end
+
+    it 'should serialize "try: that" into "try:that"' do 
+      s = SymbolMatrix try: "that"
+      Writer::SymbolMatrix
+        .new(s).send(@method).should == "try:that"
+    end
+
+    it 'should serialize "attempt: this" into "attempt:this"' do
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(attempt: "this"))
+        .send(@method).should == "attempt:this"
+    end
+
+    it 'should serialize "attempt: that" into "attempt:that"' do
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(attempt: "that"))
+        .send(@method).should == "attempt:that"
+    end
+
+    it 'should serialize a more complex hash' do 
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(a: "b", c: "d"))
+        .send(@method).should == "a:b c:d"
+    end
+
+    it 'should serialize a more complex hash with different values' do 
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(g: "e", r: "t"))
+        .send(@method).should == "g:e r:t"
+    end
+
+    it 'should serialize a multidimentional hash' do 
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(g: {e: "s"}))
+        .send(@method).should == "g.e:s"
+    end
+
+    it 'should serialize a different multidimentional hash' do 
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(r: {e: "s"}))
+        .send(@method).should == "r.e:s"
+    end
+
+    it 'should serialize a yet different multidimentional hash' do 
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(r: {a: "s"}))
+        .send(@method).should == "r.a:s"
+    end
+
+    it 'should serialize a more complex multidimentional hash' do 
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(r: {a: "s", f: "o"}))
+        .send(@method).should == "r.a:s r.f:o"
+    end
+
+    it 'should serialize a different more complex multidimentional hash' do 
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(r: {ar: "s", fe: "o"}))
+        .send(@method).should == "r.ar:s r.fe:o"
+    end
+
+    it 'should serialize a yet different more complex multidimentional hash' do 
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(r: {ar: "s", fe: "o", wh: "at"}))
+        .send(@method).should == "r.ar:s r.fe:o r.wh:at"
+    end
+
+    it 'should serialize a more complex multidimentional hash' do 
+      Writer::SymbolMatrix
+        .new(SymbolMatrix(r: {a: { f: "o", s: "h", y: "u"}}))
+        .send(@method).should == "r.a.f:o r.a.s:h r.a.y:u"
+    end
+
+    it 'should transform the multidimentional hash into a simple dot and colons serialization' do 
+      multidimentional = SymbolMatrix.new hola: {
+          the: "start",
+          asdfdf: 8989,
+          of: {
+            some: "multidimentional"
+          }
+        },
+        stuff: "oops"
+      
+      writer = Writer::SymbolMatrix.new multidimentional
+      writer.send(@method).should == "hola.the:start hola.asdfdf:8989 hola.of.some:multidimentional stuff:oops"
+    end
+  end
+
+  describe '#serialization' do 
+    before { @method = :serialization }
+    it_behaves_like 'any serialization'
+  end
+
+  describe '#smas' do 
+    before { @method = :smas }
+    it_behaves_like 'any serialization'
+  end
+end
+
+describe SymbolMatrix do
+  it 'should include the Discoverer for Writer' do 
+    SymbolMatrix.ancestors.should include Discoverer::Writer
+  end
+end

data/symbolmatrix.gemspec

@@ -8,8 +8,9 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{Very useful for configuration files, SymbolMatrix is a hash-like multidimentional Symbol-only class with ability to discover and load YAML data}
   gem.homepage      = "http://github.com/fetcher/symbolmatrix"
 
+  gem.add_dependency "discoverer"
+
   gem.add_development_dependency "rspec"
-  gem.add_development_dependency "pry"
   gem.add_development_dependency "fast"
 
   gem.files         = `git ls-files`.split($\)

metadata

@@ -1,120 +1,132 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: symbolmatrix
-version: !ruby/object:Gem::Version 
-  hash: 29
+version: !ruby/object:Gem::Version
+  version: 1.0.0
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
 platform: ruby
-authors: 
+authors:
 - Xavier Via
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-07-31 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  type: :development
-  requirement: &id001 !ruby/object:Gem::Requirement 
+date: 2012-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: discoverer
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  version_requirements: *id001
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: rspec
-- !ruby/object:Gem::Dependency 
-  type: :development
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  version_requirements: *id002
-  prerelease: false
-  name: pry
-- !ruby/object:Gem::Dependency 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  version_requirements: *id003
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: fast
-description: Very useful for configuration files, SymbolMatrix is a hash-like multidimentional Symbol-only class with ability to discover and load YAML data
-email: 
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Very useful for configuration files, SymbolMatrix is a hash-like multidimentional
+  Symbol-only class with ability to discover and load YAML data
+email:
 - xavier.via.canel@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .travis.yml
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
+- features/parse_serialization.feature
+- features/serialize.feature
+- features/stepdefs/parse_serialization.rb
+- features/stepdefs/serialize.rb
+- features/support/env.rb
+- lib/reader/symbolmatrix.rb
 - lib/symbolmatrix.rb
+- lib/symbolmatrix/serialization.rb
 - lib/symbolmatrix/symbolmatrix.rb
 - lib/symbolmatrix/version.rb
-- lib/yaml/symbolmatrix.rb
-- spec/symbolmatrix_spec.rb
-- spec/yaml-symbolmatrix_spec.rb
+- lib/writer/symbolmatrix.rb
+- spec/complete_features_helper.rb
+- spec/plain_symbolmatrix_helper.rb
+- spec/reader/symbolmatrix_spec.rb
+- spec/symbolmatrix/serialization_spec.rb
+- spec/symbolmatrix/symbolmatrix_spec.rb
+- spec/writer/symbolmatrix_spec.rb
 - symbolmatrix.gemspec
 homepage: http://github.com/fetcher/symbolmatrix
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
-summary: Very useful for configuration files, SymbolMatrix is a hash-like multidimentional Symbol-only class with ability to discover and load YAML data
-test_files: 
-- spec/symbolmatrix_spec.rb
-- spec/yaml-symbolmatrix_spec.rb
+summary: Very useful for configuration files, SymbolMatrix is a hash-like multidimentional
+  Symbol-only class with ability to discover and load YAML data
+test_files:
+- features/parse_serialization.feature
+- features/serialize.feature
+- features/stepdefs/parse_serialization.rb
+- features/stepdefs/serialize.rb
+- features/support/env.rb
+- spec/complete_features_helper.rb
+- spec/plain_symbolmatrix_helper.rb
+- spec/reader/symbolmatrix_spec.rb
+- spec/symbolmatrix/serialization_spec.rb
+- spec/symbolmatrix/symbolmatrix_spec.rb
+- spec/writer/symbolmatrix_spec.rb
+has_rdoc: 

data/lib/yaml/symbolmatrix.rb

@@ -1,35 +0,0 @@
-require "yaml"
-
-module YAML
-  module SymbolMatrix
-    # Calls #merge! using the parsed YAML data as argument
-    def from_yaml yaml
-      merge! YAML.load yaml
-    end
-    
-    # Calls #merge! using the parsed YAML data from the file
-    def from_file path
-      merge! YAML.load_file path
-    end
-    
-    # Can I override initialize and call super anyways??
-    def initialize argument = nil
-    end
-  end
-end
-
-class SymbolMatrix
-  include YAML::SymbolMatrix
-  
-  def initialize argument = nil
-    if argument.is_a? String
-      if File.exist? argument
-        from_file argument
-      else
-        from_yaml argument
-      end
-    else
-      merge! argument unless argument.nil?
-    end
-  end
-end

data/spec/yaml-symbolmatrix_spec.rb

@@ -1,60 +0,0 @@
-require "symbolmatrix"
-
-require "fast" # For testing easyness
-
-describe YAML::SymbolMatrix do
-  describe "#from_yaml" do
-    it "should call #merge! on self using the parsed YAML data as argument" do
-      sample_yaml = "a: { nested: { data: with, very: much }, content: to find }"
-      the_stub = stub "a theoretical SymbolMatrix"
-      the_stub.extend YAML::SymbolMatrix
-      the_stub.should_receive(:merge!).with "a" => { "nested" => { "data" => "with", "very" => "much" }, "content" => "to find" }
-      the_stub.from_yaml sample_yaml
-    end
-  end
-  
-  describe "#from_file" do
-    context "there is a YAML file in the given path" do
-      before do
-        Fast.file.write "temp/data.yaml", "a: { nested: { data: with, very: much }, content: to find }"
-      end
-      
-      it "should call #merge! on self using the parsed YAML data found in the file" do
-        the_stub = stub "a theoretical SymbolMatrix"
-        the_stub.extend YAML::SymbolMatrix
-        the_stub.should_receive(:merge!).with "a" => { "nested" => { "data" => "with", "very" => "much" }, "content" => "to find" }
-        the_stub.from_file "temp/data.yaml"
-      end
-      
-      after do
-        Fast.dir.remove! :temp
-      end
-    end
-  end
-end
-
-describe SymbolMatrix do
-  describe "#initialize" do # Soooooo meta... tell me its true!
-    context "a valid path to a file is provided" do
-      before do 
-        Fast.file.write "temp/data.yaml", "a: { nested: { data: with, very: much }, content: to find }"
-      end
-      
-      it "should load the data into self" do
-        f = SymbolMatrix.new "temp/data.yaml"
-        f.a.nested.data.should == "with"
-      end
-
-      after do
-        Fast.dir.remove! :temp
-      end
-    end
-    
-    context "a YAML string is provided" do
-      it "should load the data into self" do
-        e = SymbolMatrix.new "beta: { nano: { data: with, very: much }, content: to find }"
-        e.beta.nano[:very].should == "much"
-      end
-    end
-  end
-end