transmogrifier 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NGEzMmI4YjQ5ODEyZGE3NDJiYWE4OGU5MTg1MDY4NDk5YmI2MDFmNA==
+  data.tar.gz: !binary |-
+    NjA2ZGNlOGQzMWQ2MmYyMWZmMjVlNzg3MjZjYWMwYjY1YTQ4ZTliOQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZDg5MWEwOGE4YTkwMmUzNzA0ZjliMjJiZDJjYzhlOGEwNzI0OGRkMTMyYTM4
+    NjI0YjE1N2NhZmZkYTE1MWEwYmEwYjBiZGVmNzUyNDlmODQyZDQ0YmI2ZWVm
+    NTNmZTFlOGRjMzZkOWU1NWRlZjQwZGZlNzVlMWZhOTFhZWVhYjA=
+  data.tar.gz: !binary |-
+    Y2JiMTQ5ZDhjNjU1Y2YwYzk4ZWYwYzlmMmQxMTkzNTU3MGFlY2M5ZGQ0NTU3
+    NjE4NDYyNDRmZDRlMmMwMDU3ZGEwMDEwZTZlN2Q2Mjk3MzMyYjljMDJhNDMy
+    MDY4OTEyZWZlZWUyNGFkYWEwMjgwM2ZhMmE0ZDU5NmU2MjNkMTE=

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in transmogrifier.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 John Foley
+
+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/README.md

@@ -0,0 +1,112 @@
+# Transmogrifier
+
+Transmogrifier is a tool that allows you to decalaritively migrate a hash from one schema to another. It works by specifying a set of rules to apply to the hash and then running them in order.
+
+## Usage
+### Available Rules
+#### Appending a key
+```ruby
+engine = Transmogrifier::Engine.new
+append = Transmogrifier::Rules::Append.new("", "new_key", "new_value")
+
+engine.add_rule(append)
+
+input_hash = {"key" => "value"}
+output_hash = engine.run(input_hash)
+
+# output_hash => {"key" => "value", "new_key" => "new_value"}
+```
+
+#### Deleting  a key
+```ruby
+engine = Transmogrifier::Engine.new
+delete = Transmogrifier::Rules::Delete("", "extra_key")
+
+engine.add_rule(delete)
+
+input_hash = {"key" => "value", "extra_key" => "some_value"}
+output_hash = engine.run(input_hash)
+
+# output_hash => {"key" => "value"}
+```
+
+#### Moving a key
+```ruby
+engine = Transmogrifier::Engine.new
+move = Transmogrifier::Rules::Move.new("", "key", "nested")
+
+engine.add_rule(:move, "", "key", "nested")
+
+input_hash = {"key" => "value", "nested" => {"nested_key" => "nested_value"}}
+output_hash = transmogrifier.run(input_hash)
+
+# output_hash => {"nested" => {"nested_key" => "nested_value", "key" => "value"}}
+```
+
+### Programmatically loading rules
+Rules can be specified in ruby code, but they can also be loaded with an array.
+```ruby
+rules = [
+  {
+    "type" => "append",
+    "selector" => "top",
+    "object" => {"some" => "attributes"},
+  },
+
+  {
+    "type" => "move",
+    "selector" => "top",
+    "from" => "key1",
+    "to" => "key2",
+  },
+
+  {
+    "type" => "delete",
+    "selector" => "top",
+    "name" => "key3",
+  },
+]
+
+engine = Transmogrifier::Engine.from_rules_array(rules)
+
+
+input_hash = {
+  "top" => {
+    "key1" => "value1",
+    "key3" => "value2",
+  },
+}
+output_hash = engine.run(input_hash)
+
+# output_hash => 
+# { 
+#   "top" => {
+#     "some" => "attributes",
+#     "key2" => "value1",
+#   },
+# }
+```
+
+### Selectors
+Selectors are a string of hash keys seperated by dots that tell the Engine where to apply a given rule. For example, given the following structure:
+```ruby
+{ 
+  "key" => "value", 
+  "nested" => {
+    "second_level" => {
+      "deep" => "buried_value",
+    },
+  },
+}
+```
+the selector `nested.second_level.deep` will apply to `buried_value`. Rules can also be applied to hashes inside of an array. Given the structure:
+```ruby
+{ 
+  "key" => "value", 
+  "array" => [
+    {"name" => "not me"},
+    {"name" => "this one!"},
+  ],
+}
+```
+the hash with the name `this one!` can be operated on with `array.[name=this one!]`. Arrays can also wildcard match all children. For example to match both hashes in the array above, use the selector `array.[]`. 

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/transmogrifier.rb

@@ -0,0 +1,5 @@
+require "transmogrifier/version"
+require "transmogrifier/rules"
+require "transmogrifier/selector"
+require "transmogrifier/nodes"
+require "transmogrifier/engine"

data/lib/transmogrifier/engine.rb

@@ -0,0 +1,28 @@
+module Transmogrifier
+  class Engine
+    def self.from_rules_array(rules_array)
+      new(
+        rules_array.map do |rule|
+          type = rule["type"].capitalize
+          selector = rule["selector"]
+          options = [rule["object"], rule["from"], rule["to"], rule["name"]].compact
+          Transmogrifier::Rules.const_get(type).new(selector, *options)
+        end
+      )
+    end
+
+    def initialize(rules=[])
+      @rules = rules
+    end
+
+    def add_rule(rule)
+      @rules << rule
+    end
+
+    def run(input_hash)
+      output_hash = input_hash.dup
+      @rules.each { |rule| output_hash = rule.apply!(output_hash) }
+      output_hash
+    end
+  end
+end

data/lib/transmogrifier/nodes.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + '/nodes/*.rb'].each { |file| require file }

data/lib/transmogrifier/nodes/array_node.rb

@@ -0,0 +1,36 @@
+require_relative "node"
+
+module Transmogrifier
+  class ArrayNode < Node
+    extend Forwardable
+
+    def initialize(array)
+      @array = array
+    end
+
+    def find_all(keys)
+      first_key, *remaining_keys = keys
+
+      if first_key.nil?
+        [self]
+      else
+        find_nodes(first_key).flat_map { |x| Node.for(x).find_all(remaining_keys) }
+      end
+    end
+
+    def delete(key)
+      matching_nodes = find_nodes(key)
+      raise "Multiple nodes match #{key}, deletion criteria ambiguous" if matching_nodes.length > 1
+      @array.delete(matching_nodes.first)
+    end
+
+    def_delegator :@array, :<<, :append
+    def_delegator :@array, :to_a, :raw
+
+    private
+
+    def find_nodes(attributes)
+      @array.select { |node| node.merge(Hash[attributes]) == node }
+    end
+  end
+end

data/lib/transmogrifier/nodes/hash_node.rb

@@ -0,0 +1,27 @@
+require_relative "node"
+
+module Transmogrifier
+  class HashNode < Node
+    extend Forwardable
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def find_all(keys)
+      first_key, *remaining_keys = keys
+
+      if first_key.nil?
+        [self]
+      elsif child = @hash[first_key]
+        Node.for(child).find_all(remaining_keys)
+      else
+        []
+      end
+    end
+
+    def_delegator :@hash, :delete
+    def_delegator :@hash, :merge!, :append
+    def_delegator :@hash, :to_hash, :raw
+  end
+end

data/lib/transmogrifier/nodes/node.rb

@@ -0,0 +1,30 @@
+module Transmogrifier
+  class Node
+    def self.for(obj)
+      case obj
+        when Hash
+          HashNode.new(obj)
+        when Array
+          ArrayNode.new(obj)
+        else
+          ValueNode.new(obj)
+      end
+    end
+
+    def initialize(obj)
+      raise NotImplementedError
+    end
+
+    def raw
+      raise NotImplementedError
+    end
+
+    def delete(key_or_name)
+      raise NotImplementedError
+    end
+
+    def append(node)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/transmogrifier/nodes/value_node.rb

@@ -0,0 +1,18 @@
+require_relative "node"
+
+module Transmogrifier
+  class ValueNode < Node
+    def initialize(value)
+      @value = value
+    end
+
+    def find_all(keys)
+      return [self] if keys.empty?
+      raise "cannot find children of ValueNode satisfying non-empty selector #{keys}"
+    end
+
+    def raw
+      @value
+    end
+  end
+end

data/lib/transmogrifier/rules.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + '/rules/*.rb'].each { |file| require file }

data/lib/transmogrifier/rules/append.rb

@@ -0,0 +1,19 @@
+module Transmogrifier
+  module Rules
+    class Append
+      def initialize(parent_selector, hash)
+        @parent_selector, @hash = parent_selector, hash
+      end
+
+      def apply!(input_hash)
+        top = Node.for(input_hash)
+        parent_keys = Selector.from_string(@parent_selector).keys
+
+        parents = top.find_all(parent_keys)
+        parents.each { |parent| parent.append(@hash) }
+
+        top.raw
+      end
+    end
+  end
+end

data/lib/transmogrifier/rules/delete.rb

@@ -0,0 +1,20 @@
+module Transmogrifier
+  module Rules
+    class Delete
+      def initialize(parent_selector, selector_to_delete)
+        @parent_selector, @selector_to_delete = parent_selector, selector_to_delete
+      end
+
+      def apply!(input_hash)
+        top = Node.for(input_hash)
+        parent_keys = Selector.from_string(@parent_selector).keys
+        child_key = Selector.from_string(@selector_to_delete).keys.first
+
+        parents = top.find_all(parent_keys)
+        parents.each { |parent| parent.delete(child_key) }
+
+        top.raw
+      end
+    end
+  end
+end

data/lib/transmogrifier/rules/move.rb

@@ -0,0 +1,29 @@
+module Transmogrifier
+  module Rules
+    class Move
+      def initialize(parent_selector, from, to)
+        @parent_selector, @from, @to = parent_selector, from, to
+      end
+
+      def apply!(input_hash)
+        top = Node.for(input_hash)
+        *from_keys, from_key = Selector.from_string(@from).keys
+        *to_keys, to_key = Selector.from_string(@to).keys
+
+        parents = top.find_all(Selector.from_string(@parent_selector).keys)
+        parents.each do |parent|
+          to_parent = parent.find_all(to_keys).first
+          deleted_object = parent.find_all(from_keys).first.delete(from_key)
+
+          if to_child = to_parent.find_all([to_key]).first
+            to_child.append(deleted_object)
+          else
+            to_parent.append({to_key => deleted_object})
+          end
+        end
+
+        top.raw
+      end
+    end
+  end
+end

data/lib/transmogrifier/selector.rb

@@ -0,0 +1,20 @@
+module Transmogrifier
+  class Selector
+    FILTER_REGEX = /\[(.*)\]/
+
+    def self.from_string(string)
+      new(
+        string.split(".").map do |str|
+          match = str.scan(FILTER_REGEX).flatten.first
+          match ? match.split(",").map { |s| s.split("=") } : str
+        end
+      )
+    end
+
+    attr_reader :keys
+
+    def initialize(keys)
+      @keys = keys
+    end
+  end
+end

data/lib/transmogrifier/version.rb

@@ -0,0 +1,3 @@
+module Transmogrifier
+  VERSION = "0.0.1"
+end