gamera-symbolmatrix 1.2.1

data/spec/symbolmatrix/serialization_spec.rb

@@ -0,0 +1,133 @@
+require 'complete_features_helper'
+
+describe SymbolMatrix::Serialization do
+  describe '.parse' do
+    it 'parses an empty string' do
+      sm = SymbolMatrix::Serialization.parse ""
+      expect(sm.keys).to be_empty
+    end
+
+    it 'parses a simple string aja:hola' do
+      sm = SymbolMatrix::Serialization.parse 'aja:hola'
+      expect(sm.aja).to eq 'hola'
+    end
+
+    it 'parses another simple string esto:distinto' do
+      expect(
+        SymbolMatrix::Serialization
+          .parse('esto:distinto')
+          .esto
+      ).to eq "distinto"
+    end
+
+    it 'parses to a number when is a number' do
+      expect(
+        SymbolMatrix::Serialization
+          .parse("esto:3442")
+          .esto
+      ).to eq 3442
+    end
+
+    it 'parses a more complex string' do
+      sm = SymbolMatrix::Serialization.parse 'hola:eso que:pensas'
+      expect(sm.hola).to eq 'eso'
+      expect(sm.que).to eq 'pensas'
+    end
+
+    it 'parses another complex string' do
+      sm = SymbolMatrix::Serialization
+        .parse("esto:es bastante:original gracias:bdd")
+      expect(sm.esto).to eq "es"
+      expect(sm.bastante).to eq "original"
+      expect(sm.gracias).to eq "bdd"
+    end
+
+    it 'parses a string with a single dot' do
+      expect(
+        SymbolMatrix::Serialization
+          .parse("just.one:dot")
+          .just.one
+      ).to eq "dot"
+    end
+
+    it 'parses another string with single dot' do
+      expect(
+        SymbolMatrix::Serialization
+          .parse("just.one:point")
+          .just.one
+      ).to eq "point"
+    end
+
+    it 'parses another one, other var name' do
+      expect(
+        SymbolMatrix::Serialization
+          .parse("just.another:data")
+          .just.another
+      ).to eq "data"
+    end
+
+    it 'parses a string with dots' do
+      expect(
+        SymbolMatrix::Serialization
+          .parse("the.one.with:dots")
+          .the.one.with
+      ).to eq "dots"
+    end
+
+    it 'parses a string with dots and spaces' do
+      sm = SymbolMatrix::Serialization
+        .parse("in.one.with:dots the.other.with:dots")
+      expect(sm.the.other.with).to eq "dots"
+      expect(sm.in.one.with).to eq "dots"
+    end
+
+    it 'merges recursively when needed' do
+      sm = SymbolMatrix::Serialization
+        .parse("client.host:localhost client.path:hola")
+
+      expect(sm.client.host).to eq "localhost"
+      expect(sm.client.path).to eq "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 "loads the data into self" do
+        f = SymbolMatrix.new "temp/data.yaml"
+        expect(f.a.nested.data).to eq "with"
+      end
+
+      after do
+        Fast.dir.remove! :temp
+      end
+    end
+
+    context "a YAML string is provided" do
+      it "loads the data into self" do
+        e = SymbolMatrix.new "beta: { nano: { data: with, very: much }, content: to find }"
+        expect(e.beta.nano[:very]).to eq "much"
+      end
+    end
+
+    context "a SymbolMatrix serialization is provided" do
+      it 'loads the data into self' do
+        a = SymbolMatrix.new "those.pesky:attempts of.making.it:work"
+        expect(a.those.pesky).to eq "attempts"
+        expect(a.of.making.it).to eq "work"
+      end
+    end
+
+    context "an empty string is provided" do
+      it 'loads nothing into the SymbolMatrix' do
+        a = SymbolMatrix ""
+        expect(a.keys).to be_empty
+      end
+    end
+  end
+end

data/spec/symbolmatrix/symbolmatrix_spec.rb

@@ -0,0 +1,275 @@
+require "plain_symbolmatrix_helper"
+
+describe SymbolMatrix do
+  describe "#validate_key" do
+    context "an not convertible to Symbol key is passed" do
+      it "raises a SymbolMatrix::InvalidKeyException" do
+        m = SymbolMatrix.new
+        o = Object.new
+        expect { m.validate_key o
+        }.to raise_error SymbolMatrix::InvalidKeyException, "The key '#{o}' does not respond to #to_sym, so is not a valid key for SymbolMatrix"
+      end
+    end
+  end
+
+  describe "#store" do
+    context "a key is stored using a symbol" do
+      it "is foundable with #[<symbol]" do
+        a = SymbolMatrix.new
+        a.store :a, 2
+        expect(a[:a]).to eq 2
+      end
+    end
+
+    context "the passed value is a Hash" do
+      it "is converted into a SymbolTable" do
+        a = SymbolMatrix.new
+        a.store :b, { :c => 3 }
+        expect(a[:b]).to be_a SymbolMatrix
+      end
+    end
+  end
+
+  shared_examples_for "any merging operation" do
+    it "calls :store for every item in the passed Hash" do
+      m = SymbolMatrix.new
+      expect(m).to receive(:store).exactly(3).times
+      m.send @method, { :a => 1, :b => 3, :c => 4 }
+    end
+  end
+
+  describe "#merge!" do
+    before { @method = :merge! }
+    it_behaves_like "any merging operation"
+  end
+
+  describe "#update" do
+    before { @method = :update }
+    it_behaves_like "any merging operation"
+  end
+
+  describe "#merge" do
+    it "calls #validate_key for each passed item" do
+      m = SymbolMatrix.new
+      expect(m).to receive(:validate_key).exactly(3).times.and_return(true)
+      m.merge :a => 2, :b => 3, :c => 4
+    end
+  end
+
+  describe "#[]" do
+    context "the matrix is empty" do
+      it "raises a SymbolMatrix::KeyNotDefinedException" do
+        m = SymbolMatrix.new
+        expect { m['t']
+        }.to raise_error SymbolMatrix::KeyNotDefinedException, "The key :t is not defined"
+      end
+    end
+
+    context "the matrix has a key defined using a symbol" do
+      it "returns the same value when called with a string" do
+        m = SymbolMatrix.new
+        m[:s] = 3
+        expect(m["s"]).to eq 3
+      end
+    end
+  end
+
+  describe "#to_hash" do
+    it "shows a deprecation notice" do
+      expect(Kernel).to receive(:warn).with "[DEPRECATION]: #to_hash is deprecated, please use #to.hash instead"
+      SymbolMatrix.new.to_hash
+    end
+  end
+
+  describe ".new" do
+    context "a Hash is passed as argument" do
+      it "accepts it" do
+        m = SymbolMatrix.new :a => 1
+        expect(m["a"]).to eq 1
+        expect(m[:a]).to eq 1
+      end
+    end
+  end
+
+  describe "method_missing" do
+    it "stores in a key named after the method without the '=' sign" do
+      m = SymbolMatrix.new
+      m.a = 4
+      expect(m[:a]).to eq 4
+    end
+
+    it "returns the same as the symbol representation of the method" do
+      m = SymbolMatrix.new
+      m.a = 3
+      expect(m[:a]).to eq 3
+      expect(m["a"]).to eq 3
+      expect(m.a).to eq 3
+    end
+
+    it "preserves the class of the argument" do
+      class A < SymbolMatrix; end
+      class B < SymbolMatrix; end
+
+      a = A.new
+      b = B.new
+
+      a.a = b
+
+      expect(a.a).to be_instance_of B
+    end
+  end
+
+  describe "#recursive_merge" do
+    it 'raises a relevant error when the two matrices collide' do
+      sm = SymbolMatrix a: "hola"
+      expect { sm.recursive_merge SymbolMatrix a: "hey"
+      }.to raise_error SymbolMatrix::MergeError,
+        "The value of the :a key is already defined. Run recursive merge with flag true if you want it to override"
+    end
+
+    it 'overrides on collide if the override flag is on' do
+      sm = SymbolMatrix a: "hola"
+      result = sm.recursive_merge SymbolMatrix(a: "hey"), true
+      expect(result.a).to eq "hey"
+    end
+
+    it 'sends the override directive into the recursion' do
+      sm = SymbolMatrix a: { b: "hola" }
+      result = sm.recursive_merge SymbolMatrix( a: { b: "hey" } ), true
+      expect(result.a.b).to eq "hey"
+    end
+
+    it 'merges two symbolmatrices' do
+      sm = SymbolMatrix.new a: "hola"
+      result = sm.recursive_merge SymbolMatrix.new b: "chau"
+      expect(result.a).to eq "hola"
+      expect(result.b).to eq "chau"
+    end
+
+    it 'merges two symbolmatrices (new values)' do
+      sm = SymbolMatrix.new a: "hey"
+      result = sm.recursive_merge SymbolMatrix.new b: "bye"
+      expect(result.a).to eq "hey"
+      expect(result.b).to eq "bye"
+    end
+
+    it 'merges two symbolmatrices (new keys)' do
+      sm = SymbolMatrix.new y: "allo"
+      result = sm.recursive_merge SymbolMatrix.new z: "ciao"
+      expect(result.y).to eq "allo"
+      expect(result.z).to eq "ciao"
+    end
+
+    it 'recursively merges this with that (simple)' do
+      sm = SymbolMatrix.new another: { b: "aa" }
+      result = sm.recursive_merge SymbolMatrix.new another: { c: "ee" }
+      expect(result.another.b).to eq "aa"
+      expect(result.another.c).to eq "ee"
+    end
+
+    it 'recursively merges this with that (simple)' do
+      sm = SymbolMatrix.new distinct: { b: "rr" }
+      result = sm.recursive_merge SymbolMatrix.new distinct: { c: "gg" }
+      expect(result.distinct.b).to eq "rr"
+      expect(result.distinct.c).to eq "gg"
+    end
+
+    it 'recursively merges this with that v2 (simple)' do
+      sm = SymbolMatrix.new a: { z: "ee" }
+      result = sm.recursive_merge SymbolMatrix.new a: { g: "oo" }
+      expect(result.a.z).to eq "ee"
+      expect(result.a.g).to eq "oo"
+    end
+
+    it 'recursively merges this with the argument hash' do
+      sm = SymbolMatrix.new a: { b: { c: "hola" } }
+      result = sm.recursive_merge a: { b: { d: "aaa" } }
+      expect(result.a.b.c).to eq "hola"
+      expect(result.a.b.d).to eq "aaa"
+    end
+  end
+
+  describe '#recursive_merge!' do
+    it 'raises a relevant error when the two matrices collide' do
+      sm = SymbolMatrix a: "hola"
+      expect { sm.recursive_merge! SymbolMatrix a: "hey"
+      }.to raise_error SymbolMatrix::MergeError,
+        "The value of the :a key is already defined. Run recursive merge with flag true if you want it to override"
+    end
+
+    it 'overrides on collide if the override flag is on' do
+      sm = SymbolMatrix a: "hola"
+      sm.recursive_merge! SymbolMatrix(a: "hey"), true
+      expect(sm.a).to eq "hey"
+    end
+
+    it 'sends the override directive into the recursion' do
+      sm = SymbolMatrix a: { b: "hola" }
+      sm.recursive_merge! SymbolMatrix( a: { b: "hey" } ), true
+      expect(sm.a.b).to eq "hey"
+    end
+
+    it 'merges a symbolmatrix into this' do
+      sm = SymbolMatrix.new a: "hola"
+      sm.recursive_merge! SymbolMatrix.new b: "chau"
+      expect(sm.a).to eq "hola"
+      expect(sm.b).to eq "chau"
+    end
+
+    it 'merges two symbolmatrices (new values)' do
+      sm = SymbolMatrix.new a: "hey"
+      sm.recursive_merge! SymbolMatrix.new b: "bye"
+      expect(sm.a).to eq "hey"
+      expect(sm.b).to eq "bye"
+    end
+
+    it 'merges two symbolmatrices (new keys)' do
+      sm = SymbolMatrix.new y: "allo"
+      sm.recursive_merge! SymbolMatrix.new z: "ciao"
+      expect(sm.y).to eq "allo"
+      expect(sm.z).to eq "ciao"
+    end
+
+    it 'recursively merges this with that (simple)' do
+      sm = SymbolMatrix.new another: { b: "aa" }
+      sm.recursive_merge! SymbolMatrix.new another: { c: "ee" }
+      expect(sm.another.b).to eq "aa"
+      expect(sm.another.c).to eq "ee"
+    end
+
+    it 'recursively merges this with that (simple)' do
+      sm = SymbolMatrix.new distinct: { b: "rr" }
+      sm.recursive_merge! SymbolMatrix.new distinct: { c: "gg" }
+      expect(sm.distinct.b).to eq "rr"
+      expect(sm.distinct.c).to eq "gg"
+    end
+
+    it 'recursively merges this with that v2 (simple)' do
+      sm = SymbolMatrix.new a: { z: "ee" }
+      sm.recursive_merge! SymbolMatrix.new a: { g: "oo" }
+      expect(sm.a.z).to eq "ee"
+      expect(sm.a.g).to eq "oo"
+    end
+
+    it 'recursively merges this with the argument hash' do
+      sm = SymbolMatrix.new a: { b: { c: "hola" } }
+      sm.recursive_merge! a: { b: { d: "aaa" } }
+      expect(sm.a.b.c).to eq "hola"
+      expect(sm.a.b.d).to eq "aaa"
+    end
+  end
+
+  it 'is a method that calls SymbolMatrix.new with its arguments' do
+    argument = double 'argument'
+    expect(SymbolMatrix).to receive(:new).with argument
+    SymbolMatrix argument
+  end
+end
+
+describe SymbolMatrix::KeyNotDefinedException do
+  it 'is a subclass of NoMethodError' do
+    expect(
+      SymbolMatrix::KeyNotDefinedException.superclass
+    ).to eq NoMethodError
+  end
+end

data/spec/writer/symbolmatrix_spec.rb

@@ -0,0 +1,204 @@
+require 'complete_features_helper'
+
+describe Writer::SymbolMatrix do
+  describe '#initialize' do
+    it 'sets the argument as the source' do
+      source = double 'source'
+      writer = Writer::SymbolMatrix.new source
+      expect(writer.source).to eq source
+    end
+  end
+
+  describe '#hash' do
+    it "returns an instance of Hash" do
+      m = SymbolMatrix[:b, 1]
+      writer = Writer::SymbolMatrix.new m
+      expect(writer.hash).to be_instance_of Hash
+    end
+
+    it "has the same keys" do
+      m = SymbolMatrix[:a, 1]
+      writer = Writer::SymbolMatrix.new m
+      expect(writer.hash[:a]).to eq 1
+    end
+
+    it "has the same keys (more keys)" do
+      m = SymbolMatrix[:a, 2]
+      writer = Writer::SymbolMatrix.new m
+      expect(writer.hash[:a]).to eq 2
+    end
+
+    context "there is some SymbolMatrix within this SymbolMatrix" do
+      it "recursively calls #to.hash in it" do
+        in_writer = double 'inside writer'
+
+        inside = SymbolMatrix.new
+        expect(inside).to receive(:to).and_return in_writer
+        expect(in_writer).to receive(:hash)
+
+        m = SymbolMatrix[:a, inside]
+        writer = Writer::SymbolMatrix.new m
+        writer.hash
+      end
+    end
+  end
+
+  shared_examples_for 'any writer serialization' do
+    it 'serializes "try: this" into "try:this"' do
+      s = SymbolMatrix try: "this"
+      writer = Writer::SymbolMatrix.new s
+      expect(writer.send(@method)).to eq "try:this"
+    end
+
+    it 'serializes "try: that" into "try:that"' do
+      s = SymbolMatrix try: "that"
+      expect(
+        Writer::SymbolMatrix
+          .new(s).send(@method)
+      ).to eq "try:that"
+    end
+
+    it 'serializes "attempt: this" into "attempt:this"' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(attempt: "this"))
+          .send(@method)
+      ).to eq "attempt:this"
+    end
+
+    it 'serializes "attempt: that" into "attempt:that"' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(attempt: "that"))
+          .send(@method)
+      ).to eq "attempt:that"
+    end
+
+    it 'serializes a more complex hash' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(a: "b", c: "d"))
+          .send(@method)
+      ).to eq "a:b c:d"
+    end
+
+    it 'serializes a more complex hash with different values' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(g: "e", r: "t"))
+          .send(@method)
+      ).to eq "g:e r:t"
+    end
+
+    it 'serializes a multidimentional hash' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(g: {e: "s"}))
+          .send(@method)
+      ).to eq "g.e:s"
+    end
+
+    it 'serializes a different multidimentional hash' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(r: {e: "s"}))
+          .send(@method)
+      ).to eq "r.e:s"
+    end
+
+    it 'serializes a yet different multidimentional hash' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(r: {a: "s"}))
+          .send(@method)
+      ).to eq "r.a:s"
+    end
+
+    it 'serializes a more complex multidimentional hash' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(r: {a: "s", f: "o"}))
+          .send(@method)
+      ).to eq "r.a:s r.f:o"
+    end
+
+    it 'serializes a different more complex multidimentional hash' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(r: {ar: "s", fe: "o"}))
+          .send(@method)
+      ).to eq "r.ar:s r.fe:o"
+    end
+
+    it 'serializes a yet different more complex multidimentional hash' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(r: {ar: "s", fe: "o", wh: "at"}))
+          .send(@method)
+      ).to eq "r.ar:s r.fe:o r.wh:at"
+    end
+
+    it 'serializes a more complex multidimentional hash' do
+      expect(
+        Writer::SymbolMatrix
+          .new(SymbolMatrix(r: {a: { f: "o", s: "h", y: "u"}}))
+          .send(@method)
+      ).to eq "r.a.f:o r.a.s:h r.a.y:u"
+    end
+
+    it 'transforms 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
+      expect(writer.send(@method)).to eq "hola.the:start hola.asdfdf:8989 hola.of.some:multidimentional stuff:oops"
+    end
+  end
+
+  describe '#serialization' do
+    before { @method = :serialization }
+    it_behaves_like 'any writer serialization'
+  end
+
+  describe '#smas' do
+    before { @method = :smas }
+    it_behaves_like 'any writer serialization'
+  end
+
+  describe '#json' do
+    it 'returns a json serialization' do
+      sm = SymbolMatrix alpha: { beta: "gamma" }
+      writer = Writer::SymbolMatrix.new sm
+      expect(writer.json).to eq '{"alpha":{"beta":"gamma"}}'
+    end
+  end
+
+  describe '#yaml' do
+    it 'returns a yaml serialization' do
+      sm = SymbolMatrix alpha: { beta: "gamma" }
+      writer = Writer::SymbolMatrix.new sm
+      expect(writer.yaml).to include "alpha:\n  beta: gamma"
+    end
+  end
+
+  describe '#string_key_hash' do
+    it 'converts a SymbolMatrix to a multidimentional hash with all string keys' do
+      sm = SymbolMatrix alpha: { beta: "gamma" }
+      writer = Writer::SymbolMatrix.new sm
+      expect(writer.string_key_hash)
+        .to eq({ "alpha" => { "beta" => "gamma"} })
+    end
+  end
+end
+
+describe SymbolMatrix do
+  it 'includes the Discoverer for Writer' do
+    expect(SymbolMatrix.ancestors).to include Discoverer::Writer
+  end
+end