transmogrifier 0.0.1

data/spec/engine_spec.rb

@@ -0,0 +1,46 @@
+require "transmogrifier"
+
+describe Transmogrifier::Engine do
+  subject(:engine) { described_class.from_rules_array(rules) }
+
+  describe "#run" do
+    let(:rules) do
+      [
+        {
+          "type" => "append",
+          "selector" => "top",
+          "object" => {"some" => "attributes"}
+        },
+
+        {
+          "type" => "move",
+          "selector" => "top",
+          "from" => "key1",
+          "to" => "key2",
+        },
+
+        {
+          "type" => "delete",
+          "selector" => "top",
+          "name" => "key3"
+        }
+      ]
+    end
+
+    it "runs all the rules" do
+      input_hash = {
+        "top" => {
+          "key1" => "value1",
+          "key3" => "value2"
+        }
+      }
+  
+      expect(engine.run(input_hash)).to eq({
+        "top" => {
+          "some" => "attributes",
+          "key2" => "value1",
+        }
+      })
+    end
+  end
+end

data/spec/nodes/array_node_spec.rb

@@ -0,0 +1,84 @@
+require "transmogrifier"
+
+module Transmogrifier
+  describe ArrayNode do
+    describe "#raw" do
+      it "returns the underlying array" do
+        array = [{"name" => "object1"}, {"name" => "object2"}]
+        node = ArrayNode.new(array)
+        expect(node.raw).to eq(array)
+      end
+    end
+
+    describe "#find_all" do
+      it "returns wildcard matches" do
+        array = [
+          {"name" => "object1", "nested" => {"key1" => "value1"}},
+          {"name" => "object2",  "nested" => {"key2" => "value2"}}
+        ]
+        node = ArrayNode.new(array)
+
+        expect(node.find_all([[], "nested"]).map(&:raw)).to eq([
+          {"key1" => "value1"},
+          {"key2" => "value2"},
+        ])
+      end
+
+      it "filters by attributes" do
+        array = [
+          {"type" => "object", "key1" => "value1"},
+          {"type" => "object", "key2" => "value2"},
+        ]
+        node = ArrayNode.new(array)
+
+        expect(node.find_all([["type", "object"]]).map(&:raw)).to eq(array)
+      end
+    end
+
+    describe "#delete" do
+      context "when one node matches the criteria" do
+        it "deletes the node from the array" do
+          array = [
+            {"name" => "object1"},
+            {"name" => "object2"},
+          ]
+          node = ArrayNode.new(array)
+          expect(node.delete([["name", "object1"]])).to eq({"name" => "object1"})
+        end
+      end
+
+      context "when more than one node matches the criteria" do
+        it "raises an error" do
+          array = [
+            {"name" => "object1", "common_key" => "common_value"},
+            {"name" => "object2", "common_key" => "common_value"},
+          ]
+          node = ArrayNode.new(array)
+          expect {
+            node.delete([["common_key", "common_value"]])
+          }.to raise_error
+        end
+      end
+
+      context "when no nodes match the criteria" do
+        it "returns nil" do
+          array = [
+            {"name" => "object1"},
+            {"name" => "object2"},
+          ]
+          node = ArrayNode.new(array)
+          expect(node.delete([["name", "not_present"]])).to be_nil
+        end
+      end
+    end
+
+    describe "#append" do
+      it "appends the node to the array" do
+        array = [{"name" => "object1"}]
+        node = ArrayNode.new(array)
+        node.append("name" => "object2")
+        expect(node.raw).to eq([{"name" => "object1"}, {"name" => "object2"}])
+      end
+    end
+  end
+end

data/spec/nodes/hash_node_spec.rb

@@ -0,0 +1,94 @@
+require "transmogrifier"
+
+module Transmogrifier
+  describe HashNode do
+    describe "#raw" do
+      it "returns the passed in hash" do
+        node = HashNode.new({"key" => "value"})
+        expect(node.raw).to eq({"key" => "value"})
+      end
+    end
+
+    describe "#find_all" do
+      context "given an empty set of selector keys" do
+        it "returns itself in an array" do
+          hash = {
+            "key" => "value",
+            "extra_key" => "other_value",
+          }
+          node = HashNode.new(hash)
+
+          expect(node.find_all([]).map(&:raw)).to eq([{
+            "key" => "value",
+            "extra_key" => "other_value",
+          }])
+        end
+      end
+
+      context "given multiple selector keys" do
+        let(:keys) { ["key", [["k", "v"]]] }
+
+        context "when the first key is a key in the hash" do
+          let(:hash) {{
+            "key" => [
+              {"k" => "v", "a" => "b"},
+              {"k" => "not_v", "c" => "d"},
+              {"k" => "v", "e" => "f"},
+            ]
+          }}
+
+          it "finds all children of the first key's value satisfying the remaining selector keys" do
+            node = HashNode.new(hash)
+
+            expect(node.find_all(keys).map(&:raw)).to eq([
+              {"k" => "v", "a" => "b"},
+              {"k" => "v", "e" => "f"}
+            ])
+          end
+        end
+
+        context "when the first key is not a key in the hash" do
+          let(:hash) {{
+            "not_key" => [
+              {"k" => "v", "a" => "b"},
+              {"k" => "not_v", "c" => "d"},
+              {"k" => "v", "e" => "f"}
+            ]
+          }}
+
+          it "returns an empty array" do
+            node = HashNode.new(hash)
+
+            expect(node.find_all(keys).map(&:raw)).to eq([])
+          end
+        end
+      end
+    end
+
+    describe "#delete" do
+      it "deletes the given key" do
+        hash = {"key" => "value", "extra_key" => "other_value"}
+        node = HashNode.new(hash)
+        node.delete("extra_key")
+
+        expect(node.raw).to eq({"key" => "value"})
+      end
+
+      it "returns the node that was deleted" do
+        hash = {"key" => "value", "extra_key" => "other_value"}
+        node = HashNode.new(hash)
+
+        expect(node.delete("extra_key")).to eq("other_value")
+      end
+    end
+
+    describe "#append" do
+      it "appends the given node at the key" do
+        hash = {"key" => "value"}
+        node = HashNode.new(hash)
+        node.append({ "extra_key" => "extra_value"})
+        expect(node.raw).to eq({"key" => "value", "extra_key" => "extra_value"})
+      end
+    end
+  end
+end

data/spec/nodes/node_spec.rb

@@ -0,0 +1,19 @@
+require "transmogrifier"
+
+module Transmogrifier
+  describe Node do
+    describe ".for" do
+      it "returns a node value" do
+        Node.for("value").should be_a(ValueNode)
+      end
+
+      it "returns a hash value" do
+        Node.for("key" => "value").should be_a(HashNode)
+      end
+
+      it "returns an array value" do
+        Node.for(["value"]).should be_a(ArrayNode)
+      end
+    end
+  end
+end

data/spec/nodes/value_node_spec.rb

@@ -0,0 +1,46 @@
+require "transmogrifier"
+
+module Transmogrifier
+  describe ValueNode do
+    describe "#raw" do
+      it "returns the passed in value" do
+        node = ValueNode.new("hello")
+        expect(node.raw).to eq("hello")
+      end
+    end
+
+    describe "#find_all" do
+      context "when given empty keys" do
+        it "returns an array of itself" do
+          node = ValueNode.new("hello")
+          expect(node.find_all([])).to eq([node])
+        end
+      end
+
+      context "when given non-empty keys" do
+        it "raises an error" do
+          node = ValueNode.new("hello")
+          expect {
+            node.find_all(["foo.bar"])
+          }.to raise_error
+        end
+      end
+    end
+
+    describe "#delete" do
+      it "raises a NotImplementedError" do
+        expect {
+          ValueNode.new("hello").delete("key")
+        }.to raise_error(NotImplementedError)
+      end
+    end
+
+    describe "#append" do
+      it "raises a NotImplementedError" do
+        expect {
+          ValueNode.new("hello").append("value")
+        }.to raise_error(NotImplementedError)
+      end
+    end
+  end
+end

data/spec/rules/append_spec.rb

@@ -0,0 +1,29 @@
+require "transmogrifier"
+
+describe Transmogrifier::Rules::Append do
+  let(:input_hash) do
+    { "key" => "value", "array" => [] }
+  end
+
+  context "when the selector finds a HashNode" do
+    subject(:append) { described_class.new("", {"new_key" => "new_value"}) }
+    it "appends to the hash" do
+      expect(append.apply!(input_hash)).to eq({
+        "key" => "value",
+        "array" => [],
+        "new_key" => "new_value",
+      })
+    end
+  end
+
+  context "when the selector finds an ArrayNode" do
+    subject(:append) { described_class.new("array", {"new_key" => "new_value"}) }
+
+    it "appends to the array" do
+      expect(append.apply!(input_hash)).to eq({
+        "key" => "value",
+        "array" => [{"new_key" => "new_value"}],
+      })
+    end
+  end
+end

data/spec/rules/delete_spec.rb

@@ -0,0 +1,38 @@
+require "transmogrifier"
+
+describe Transmogrifier::Rules::Delete do
+  let(:input_hash) do
+    {
+      "key" => "value",
+      "array" => [{"inside" => "value"}],
+      "nested" => {
+        "key" => "value"
+      },
+    }
+  end 
+
+  context "when the selector finds a HashNode" do
+    subject(:delete) { described_class.new("", "nested") }
+
+    it "deletes the hash from the parent" do
+      expect(delete.apply!(input_hash)).to eq({
+        "key" => "value",
+        "array" => [{"inside" => "value"}],
+      })
+    end
+  end
+
+  context "when the selector finds an ArrayNode" do
+    subject(:delete) { described_class.new("array", "[inside=value]") }
+    
+    it "deletes the array from the parent" do
+      expect(delete.apply!(input_hash)).to eq({
+        "key" => "value",
+        "array" => [],
+        "nested" => {
+          "key" => "value"
+        },
+      })
+    end
+  end
+end

data/spec/rules/move_spec.rb

@@ -0,0 +1,110 @@
+require "transmogrifier"
+
+describe Transmogrifier::Rules::Move do
+  let(:input_hash) do
+    {
+      "key" => "value",
+      "array" => [{"inside" => "value"}],
+      "nested" => {
+        "key" => "value",
+      },
+    }
+  end
+
+  context "when the selector finds a HashNode" do
+    context "when the target key exists" do
+      subject(:move) { described_class.new("", "array.[inside=value]", "nested") }
+      
+      it "moves the hash to the to selector" do
+        expect(move.apply!(input_hash)).to eq({
+          "key" => "value",
+          "array" => [],
+          "nested" => {
+            "key" => "value",
+            "inside" => "value",
+          },
+        })
+      end
+    end
+
+    context "when the target key doesn't exist" do
+      subject(:move) { described_class.new("", "array.[inside=value]", "nested.nested_again") }
+
+      it "moves the hash to a new child" do
+        expect(move.apply!(input_hash)).to eq({
+          "key" => "value",
+          "array" => [],
+          "nested" => {
+            "key" => "value",
+            "nested_again" => {
+              "inside" => "value",
+            }
+          },
+        })
+      end
+    end
+
+    context "when the from selector has a wildcard" do
+      let(:input_hash) do
+        {
+          "list_of_things" => [
+            {
+              "name" => "object1",
+              "property" => "property1",
+              "nested" => {}
+            },
+            {
+              "name" => "object2",
+              "property" => "property2",
+              "nested" => {}
+            },
+          ]
+        }
+      end
+      subject(:move) { described_class.new("list_of_things.[]", "property", "nested.property") }
+
+      it "moves the matched hash to the correct place" do
+        expect(move.apply!(input_hash)).to eq({
+          "list_of_things" => [
+            {
+              "name" => "object1",
+              "nested" => { "property" => "property1" }
+            },
+            {
+              "name" => "object2",
+              "nested" => { "property" => "property2" }
+            },
+          ]
+        })
+      end
+    end
+  end
+
+  context "when the selector finds an ArrayNode" do
+    subject(:move) { described_class.new("", "array", "nested.array") }
+
+    it "moves the array to the to selector" do
+      expect(move.apply!(input_hash)).to eq({
+        "key" => "value",
+        "nested" => {
+          "key" => "value",
+          "array" => [{"inside" => "value"}],
+        },
+      })
+    end
+  end
+
+  context "using move as a rename" do
+    subject(:rename) { described_class.new("", "array", "new_array") }
+
+    it "renames the node" do
+      expect(rename.apply!(input_hash)).to eq({
+        "key" => "value",
+        "new_array" => [{"inside" => "value"}],
+        "nested" => {
+          "key" => "value",
+        },
+      })
+    end
+  end
+end