gamera-symbolmatrix 1.2.1

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.smas
+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
+      yaml(File.read(path))
+    end
+
+    def yaml data
+      @source.merge! YAML.load(ERB.new(data).result)
+    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

@@ -0,0 +1,9 @@
+require 'yaml'
+require 'json'
+require 'erb'
+require 'discoverer'
+
+require 'symbolmatrix/symbolmatrix'
+require 'symbolmatrix/serialization'
+require 'reader/symbolmatrix'
+require 'writer/symbolmatrix'

data/lib/symbolmatrix/serialization.rb

@@ -0,0 +1,43 @@
+class SymbolMatrix < Hash
+  class Serialization
+    def self.parse serialization
+      result = SymbolMatrix.new
+      return result if serialization.length == 0
+      
+      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

@@ -0,0 +1,122 @@
+require "symbolmatrix/version"
+
+class SymbolMatrix < Hash
+
+  # Initializes the SymbolMatrix with the passed Hash if a hash is passed
+  def initialize hash = nil
+    super
+    merge! hash unless hash.nil?
+  end
+
+  # Validates whether the given key is usable in a SymbolMatrix
+  def validate_key key
+    unless key.respond_to? :to_sym
+      raise InvalidKeyException, "The key '#{key}' does not respond to #to_sym, so is not a valid key for SymbolMatrix"
+    end
+      
+    return true
+  end
+
+  # Sets the value of the given +key+ to +val+ if the key is valid.
+  def store key, val
+    validate_key key
+    if val.instance_of? Hash
+      super(key.to_sym, SymbolMatrix.new(val))
+    else
+      super(key.to_sym, val)
+    end
+  end
+
+  # Retrieves the value of the given +key+.
+  def [] key
+    validate_key key
+    raise KeyNotDefinedException, "The key :#{key} is not defined" unless self.has_key? key.to_sym
+    super key.to_sym
+  end
+
+  alias []= store  
+  
+  # @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
+  def merge! hash
+    hash.each do |key, value|
+      store key, value
+    end
+  end
+  
+  alias update merge!
+  
+  # Checks the keys for compatibility with SymbolMatrix and calls the merge in Hash
+  def merge hash
+    # Before merging, let's check the keys
+    hash.each_key do |key|
+      validate_key key
+    end
+    super hash
+  end
+
+  # Allows values to be retrieved and set using Ruby's dot method syntax.
+  def method_missing sym, *args
+    if sym.to_s.index "="
+      store sym.to_s[0..-2].to_sym, args.shift
+    else
+      self[sym]
+    end
+  end
+  
+  # Merges this SymbolMatrix with another SymbolMatrix recursively
+  def recursive_merge hash, override = false
+    result = SymbolMatrix.new
+    self.keys.each do |key|
+      result[key] = self[key]
+    end
+
+    hash.keys.each do |key|
+      if result.has_key? key
+        if result[key].respond_to? :recursive_merge
+          result[key] = result[key].recursive_merge hash[key], override
+        else
+          if override
+            result[key] = hash[key]
+          else
+            raise MergeError, "The value of the :#{key} key is already defined. Run recursive merge with flag true if you want it to override"
+          end
+        end
+      else
+        result[key] = hash[key]
+      end
+    end
+    return result
+  end
+
+  # Merges recursively the passed SymbolMatrix into self
+  def recursive_merge! symbolmatrix, override = false
+    symbolmatrix.each do |key, value|
+      if self.has_key? key
+        if self[key].respond_to? :recursive_merge!
+          self[key].recursive_merge! value, override
+        else
+          if override
+            self[key] = value
+          else
+            raise MergeError, "The value of the :#{key} key is already defined. Run recursive merge with flag true if you want it to override"
+          end
+        end
+      else 
+        self[key] = value
+      end
+    end
+  end
+
+  class KeyNotDefinedException < NoMethodError; end
+  class InvalidKeyException < RuntimeError; end 
+  class MergeError < RuntimeError; end 
+end
+
+def SymbolMatrix *args
+  SymbolMatrix.new *args
+end

data/lib/symbolmatrix/version.rb

@@ -0,0 +1,3 @@
+module Symbolmatrix
+  VERSION = "1.2.1"
+end

data/lib/writer/symbolmatrix.rb

@@ -0,0 +1,59 @@
+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
+
+    def json
+      @source.to_json
+    end
+
+    def yaml
+      string_key_hash.to_yaml
+    end
+
+    def string_key_hash 
+      the_hash = {}
+      @source.each do |key, value|
+        if value.respond_to? :to
+          the_hash[key.to_s] = value.to.string_key_hash
+        else
+          the_hash[key.to_s] = 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,149 @@
+require 'complete_features_helper'
+
+describe Reader::SymbolMatrix do
+  describe '#initialize' do
+    it 'receives a source and add it as source' do
+      source = double 'source'
+      reader = Reader::SymbolMatrix.new source
+      expect(reader.source).to eq source
+    end
+  end
+
+  describe "#yaml" do
+    shared_examples_for "parsed YAML" do
+      it "calls #merge! the source using the parsed YAML data as argument" do
+        the_stub = double "a theoretical SymbolMatrix"
+        reader = Reader::SymbolMatrix.new the_stub
+        expect(the_stub).to receive(:merge!).with parsed_hash
+        reader.yaml sample_yaml
+      end
+    end
+
+    context "with YAML" do
+      let(:sample_yaml) { "a: { nested: { data: with, very: much }, content: to find }" }
+      let(:parsed_hash) {
+        {
+          "a" => {
+            "nested" => {
+              "data" => "with",
+              "very" => "much"
+            },
+            "content" => "to find"
+          }
+        }
+      }
+
+      it_behaves_like "parsed YAML"
+    end
+
+    context "with YAML containing ERB" do
+      let(:sample_yaml) { "a: { nested: { data: with, very: much }, content: <%= 'to find' %> }" }
+      let(:parsed_hash) {
+        {
+          "a" => {
+            "nested" => {
+              "data" => "with",
+              "very" => "much"
+            },
+            "content" => "to find"
+          }
+        }
+      }
+
+      it_behaves_like "parsed YAML"
+    end
+  end
+
+  describe "#file" do
+    shared_examples_for "parsed file" do
+      let(:path) { File.join('temp', file) }
+
+      around do |example|
+        Fast.file.write path, yaml
+        example.run
+        Fast.dir.remove! :temp
+      end
+
+      it "calls #merge! on the source using the parsed YAML data found in the file" do
+        the_stub = double "a theoretical SymbolMatrix"
+        reader = Reader::SymbolMatrix.new the_stub
+        expect(the_stub).to receive(:merge!).with parsed_hash
+        reader.file path
+      end
+    end
+
+    context "there is a YAML file in the given path" do
+      let(:file) { 'data.yaml' }
+      let(:yaml) { "a: { nested: { data: with, very: much }, content: to find }" }
+      let(:parsed_hash) {
+        {
+          "a" => {
+            "nested" => {
+              "data" => "with",
+              "very" => "much"
+            },
+            "content" => "to find"
+          }
+        }
+      }
+
+      it_behaves_like "parsed file"
+    end
+
+    context "there is a YAML file with ERB in the given path" do
+      let(:file) { 'data.yaml' }
+      let(:yaml) { "a: { nested: { data: with, very: much }, content: <%= 'to find' %> }" }
+      let(:parsed_hash) {
+        {
+          "a" => {
+            "nested" => {
+              "data" => "with",
+              "very" => "much"
+            },
+            "content" => "to find"
+          }
+        }
+      }
+
+      it_behaves_like "parsed file"
+    end
+  end
+
+  shared_examples_for "any reader serialization" do
+    it 'calls merge! to source with the parsed data' do
+      the_sm = double 'sm'
+      data_stub = double 'data'
+      ready_to_merge = double 'ready to merge'
+      reader = Reader::SymbolMatrix.new the_sm
+      expect(SymbolMatrix::Serialization).to receive(:parse).with(data_stub).and_return ready_to_merge
+      expect(the_sm).to receive(:merge!).with ready_to_merge
+      reader.send @method, data_stub
+    end
+  end
+
+  describe "#serialization" do
+    before { @method = :serialization }
+    it_behaves_like 'any reader serialization'
+  end
+
+  describe '#smas' do
+    before { @method = :smas }
+    it_behaves_like 'any reader serialization'
+  end
+end
+
+describe SymbolMatrix do
+  it 'includes the Discoverer for Reader' do
+    expect(SymbolMatrix.ancestors).to include Discoverer::Reader
+  end
+
+  it 'features a deprecation notice in #from_yaml' do
+    expect(Kernel).to receive(:warn).with "[DEPRECATION]: #from_yaml is deprecated, please use #from.yaml instead"
+    SymbolMatrix.new.from_yaml double 'argument'
+  end
+
+  it 'features a deprecation notice in #from_file' do
+    expect(Kernel).to receive(:warn).with "[DEPRECATION]: #from_file is deprecated, please use #from.file instead"
+    SymbolMatrix.new.from_file double 'argument'
+  end
+end