kvdag 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9dc47fb88bc0c77952ce8e6f30522c7e7bc584a4
+  data.tar.gz: 917cb05694be1c5122cf593627d43c709b76edc1
+SHA512:
+  metadata.gz: 5ca02a82d6c95cf6284198d2a47a77544f824054f95e828f2ffc6eb7b0ca5b359d59564ffad8f19653e96e3007321bd958815aefd3692829bdaeb5b8bb70f70a
+  data.tar.gz: 3f75cd8ee7498d565fb53e0465b908c0ba056eb577ba8ceebf9a63a2ed44138004445456db92424936ba2f4adb6dcfa1fc9c803415bb9becb478e2c1ba4b9124

data.tar.gz.sig

@@ -0,0 +1,2 @@
+r C���0�(�'���=,@���J
+�[�C�ve��R��Y�"���.!�S���9�)�F

data/.gitignore

@@ -0,0 +1,53 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+*~
+# Ignore personal preferences for rspec output
+.rspec

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 saab-simc-admin
+
+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,77 @@
+# KVDAG
+
+Implements a Directed Acyclic Graph for Key-Value searches.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kvdag'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kvdag
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install
+dependencies. Then, run `rake spec` to run the tests. You can also run
+`bin/console` for an interactive prompt that will allow you to
+experiment.
+
+To install this gem onto your local machine, run `bundle exec rake
+install`.
+
+## Contributing
+
+We are happy to accept contributions in the form of issues and pull
+requests on
+[GitHub](https://github.com/saab-simc-admin/keyvaluedag). Please
+follow these guidelines to make the experience as smooth as possible:
+
+- All development takes place in feature branches, with master only
+  accepting non-fast-forward merges.
+
+- Others shall be able to use the KeyValue DAG library to build their
+  own tools. If you introduce API changes, please increment version
+  numbers according to [semantic versioning](http://semver.org/).
+
+- All code will be reviewed before it is merged. To help the reviewer,
+  send your work as a series of logically separate changes, not as one
+  gigantic squash commit. Make sure bisection will work by ensuring
+  the code actually works after each change.
+
+- GnuPG sign all your commits and tags, with a key that is [validated
+  by
+  GitHub](https://help.github.com/articles/about-gpg-commit-and-tag-signatures/).
+
+  - GitHub's web UI cannot generate signed merges when accepting pull
+    requests. Instead, we use [a custom
+    tool](https://github.com/saab-simc-admin/workflow-tools/tree/master/git-ghpr)
+    to accept them. You can still send them through the web as usual.
+
+  - Your code shall be signed by you. Therefore, the maintainer cannot
+    fix any merge conflicts arising from your pull request. If there
+    are any conflicts, please rebase onto current master before
+    sending your pull request.
+
+- Document your work.
+
+  - At an absolute minimum, Ruby code shall have
+    [RDoc](https://rdoc.github.io/rdoc/) blocks documenting each
+    function.
+
+  - Write your commit messages in the usual Git style: a short summary
+    in the first line, then paragraphs of explanatory text, line
+    wrapped.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "kvdag"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/kvdag.gemspec

@@ -0,0 +1,35 @@
+#-*- ruby -*-
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kvdag/version'
+
+Gem::Specification.new do |spec|
+  spec.name	= 'kvdag'
+  spec.version  = KVDAG::VERSION
+  spec.summary	= 'Directed Acyclic Graph for Key-Value searches'
+  spec.description	= spec.summary
+  spec.homepage    = 'https://github.com/saab-simc-admin/keyvaluedag'
+  spec.authors	= ['Calle Englund']
+  spec.email	= ['calle.englund@saabgroup.com']
+  spec.license	= 'MIT'
+
+  spec.has_rdoc	= true
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.platform	= Gem::Platform::RUBY
+  spec.required_ruby_version = '~>2'
+  spec.add_runtime_dependency 'activesupport', '~>4'
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-collection_matchers", "~> 1.1.2"
+
+end

data/lib/kvdag.rb

@@ -0,0 +1,68 @@
+require 'active_support'
+require "kvdag/version"
+require 'kvdag/error'
+require 'kvdag/attrnode'
+require 'kvdag/vertex'
+require 'kvdag/edge'
+require 'kvdag/keypathhash'
+
+# Directed Acyclic Graph for multiple inheritance key-value lookup
+
+class KVDAG
+  include Enumerable
+
+  attr_reader :hash_proxy_class
+
+  # Create a new KVDAG, optionally using a specialized
+  # hash class for storing key-values. The default is to use
+  # a dot-separated keypath proxy for storing key-values like
+  #
+  #     hsh["a.b.c"] = value
+  #
+  # in a tree of hashes
+  #
+  #     {"a" => {"b" => {"c" => value}}}
+  #
+  # The default hash proxy will also stringify all keys, and
+  # makes all merge operations deep merges.
+
+  private :initialize
+  def initialize(hash_proxy_class = KVDAG::KeyPathHashProxy)
+    @vertices = Set.new
+    @hash_proxy_class = hash_proxy_class
+  end
+
+  def inspect
+    "#<%s:%x(%d vertices, %d edges)>" % [self.class, self.object_id,
+                                         vertices.length, edges.length]
+  end
+
+  # Create a new vertex in this DAG, optionally loaded with
+  # key-values.
+
+  def vertex(attrs = {})
+    KVDAG::Vertex.new(self, attrs)
+  end
+
+  # Return the set of all vertices, possibly filtered by
+  # Vertex#match? expressions.
+
+  def vertices(filter = {})
+    return @vertices if filter.empty?
+
+    Set.new(@vertices.select{|vertex| vertex.match?(filter) })
+  end
+
+  # Return the set of all edges
+
+  def edges
+    @vertices.reduce(Set.new) {|edges,vertex| edges + vertex.edges}
+  end
+
+  # Enumerate all vertices in the DAG, possibly filtered
+  # by Vertex#match? expressions.
+
+  def each(filter = {}, &block)
+    vertices(filter).each(&block)
+  end
+end

data/lib/kvdag/attrnode.rb

@@ -0,0 +1,116 @@
+class KVDAG
+
+  # Mixin with common methods for managing the +attrs+ of
+  # vertices and edges in a KVDAG.
+
+  module AttributeNode
+    attr_reader :attrs
+
+    # Returns the value for an +attr+. If the +attr+ can't be found,
+    # it will raise a KeyError exception.
+    #
+    # +options+:
+    # [+shallow+] If true, lookup is limited to attrs defined in
+    #             this attrnode. The default is lookup in the tree
+    #             returned by +to_hash_proxy+.
+
+    def fetch(attr, options = {})
+      case
+      when (options[:shallow])
+        @attrs.fetch(attr)
+      when self.respond_to?(:to_hash_proxy)
+        to_hash_proxy.fetch(attr)
+      else
+        to_hash.fetch(attr)
+      end
+    end
+
+    # Return the value for an +attr+, or +nil+ if the +attr+ can't be found.
+    #
+    # +options+:
+    # [+shallow+] If true, lookup is limited to attrs defined in
+    #             this attrnode. The default is lookup in the tree
+    #             returned by +to_hash_proxy+.
+
+    def [](attr, options = {})
+      fetch(attr, options)
+    rescue
+      nil
+    end
+
+    # Set the +value+ for an +attr+ in this attrnode.
+
+    def []=(attr, value)
+      @attrs[attr] = value
+    end
+
+    def to_hash
+      if self.respond_to?(:to_hash_proxy) then
+        to_hash_proxy.to_hash
+      else
+        @attrs
+      end
+    end
+
+    def merge!(other)
+      @attrs.merge!(other.to_hash)
+      self
+    end
+
+    # Filter the key-value view of a vertex by a list of key prefixes,
+    # and return a hash_proxy containing only those trees.
+    #
+    # :call-seq:
+    #   filter("key.path1", ..., "key.pathN") -> hash_proxy
+
+    def filter(*keys)
+      if self.respond_to?(:to_hash_proxy) then
+        to_hash_proxy.filter(*keys)
+      else
+        raise NotImplementedError.new("not implemented for plain hash")
+      end
+    end
+
+    # :call-seq:
+    #   match?()                           -> true
+    #   match?(method: match, ...)         -> true or false
+    #   match?(one?:{ matches }, ...)      -> true or false
+    #   match?(any?:{ matches }, ...)      -> true or false
+    #   match?(all?:{ matches }, ...)      -> true of false
+    #   match?(none?:{ matches }, ...)     -> true or false
+    #
+    # Checks if the key-value view visible from a node matches all of
+    # set of filters. An empty filter set is considered a match.
+    #
+    # Any +method+ given will be matched against its result:
+    #   match === self.send(method)
+    #
+    # +matches+ should be a hash with 'key.path' strings at keys,
+    # and +match+ values to check for equality:
+    #   match === self[key]
+    #
+    # Examples:
+    #
+    #   node.match?(class:KVDAG::Vertex)
+    #   node.match?(none?:{'key' => Integer})
+    #   node.match?(all?:{'key' => /this|that/})
+    #   node.match?(any?:{'key1' => 'this', 'key2' => 'that'})
+    #   node.match?(one?:{'key1' => 'this', 'key2' => 'that'})
+
+    def match?(filter={})
+      valid_enumerators = [:none?, :one?, :any?, :all?]
+
+      filter.all? do |item|
+        method, match = item
+        if valid_enumerators.include?(method)
+          match.send(method) do |match_item|
+            key, value = match_item
+            value === self[key]
+          end
+        else
+          match === self.send(method)
+        end
+      end
+    end
+  end
+end

data/lib/kvdag/edge.rb

@@ -0,0 +1,47 @@
+class KVDAG
+
+  # An edge to a vertex in a KVDAG
+
+  class Edge
+    include AttributeNode
+
+    # Return the target vertex of this edge
+
+    attr_reader :to_vertex
+
+    # Create a new edge towards a vertex in a KVDAG,
+    # optionally loaded with key-values
+    #
+    # N.B: KVDAG::Edge.new should never be called directly,
+    # always use KVDAG::Vertex#edge to create edges.
+
+    private :initialize
+    def initialize(dag, target, attrs = {})
+      @to_vertex = target
+      @attrs = dag.hash_proxy_class.new(attrs)
+    end
+
+    def inspect
+      "#<%s @attr=%s @to_vertex=%s>" % [self.class, @attrs.to_hash, @to_vertex]
+    end
+
+    alias to_s inspect
+
+    # Return the proxied key-value hash tree visible from this edge
+    # via its target vertex and all its ancestors
+    #
+    # Calling to_hash instead will return a regular hash tree, without
+    # any special properties, e.g. for serializing as YAML or JSON.
+
+    def to_hash_proxy
+      result = @to_vertex.to_hash_proxy
+      result.merge!(@attrs)
+    end
+
+    # Is the +target+ vertex reachable via this edge?
+
+    def reachable?(target)
+      @to_vertex.equal?(target) || @to_vertex.reachable?(target)
+    end
+  end
+end

data/lib/kvdag/error.rb

@@ -0,0 +1,12 @@
+class KVDAG
+
+  # Vertices belong to different DAG:s
+
+  class VertexError < StandardError
+  end
+
+  # Inserted edge would cause a cycle.
+
+  class CyclicError < StandardError
+  end
+end

data/lib/kvdag/keypathhash.rb

@@ -0,0 +1,97 @@
+require 'delegate'
+require 'active_support/core_ext/hash'
+
+class KVDAG
+  class KeyPathHashProxy < DelegateClass(Hash)
+    class KeyPath < Array
+      private :initialize
+      def initialize(keypath)
+        keypath = keypath.split(".") if keypath.is_a?(String)
+        super
+      end
+    end
+
+    private :initialize
+    def initialize(hash = {})
+      raise TypeError.new("Must be initialized with a `hash`") unless hash.is_a?(Hash)
+      @hash = hash.deep_stringify_keys
+      super(@hash)
+    end
+
+    def merge(other, &block)
+      self.class.new(@hash.deep_merge(other.deep_stringify_keys, &block))
+    end
+
+    def merge!(other, &block)
+      @hash.deep_merge!(other.deep_stringify_keys, &block)
+      self
+    end
+
+    # :call-seq:
+    #   fetch("key.path")      -> value or KeyError
+    #   fetch(["key", "path"]) -> value or KeyError
+    #
+    # Return the value at a specified keypath. If the keypath
+    # does not specify a terminal value, return the remaining
+    # subtree instead.
+    #
+    # Raises a KeyError exception if the keypath is not found.
+
+    def fetch(keypath)
+      *keysubpath, key = KeyPath.new(keypath)
+      hash = @hash
+
+      keysubpath.each {|key| hash = hash.fetch(key)}
+      hash.fetch(key)
+    rescue KeyError
+      raise KeyError.new("keypath not found: #{keypath.inspect}")
+    end
+
+    # :call-seq:
+    #   []("key.path")      -> value or nil
+    #   [](["key", "path"]) -> value or nil
+    #
+    # Return the value at a specified keypath. If the keypath
+    # does not specify a terminal value, return the remaining
+    # subtree instead.
+    #
+    # Returns nil if the keypath is not found.
+
+    def [](keypath)
+      fetch(keypath)
+    rescue
+      nil
+    end
+
+    def []=(keypath, value)
+      *keypath, key = KeyPath.new(keypath)
+
+      if keypath.empty? then
+        hash = @hash
+      else
+        if not hash = self[keypath] then
+          self[keypath] = hash = Hash.new
+        end
+      end
+
+      hash[key] = value
+    end
+
+    # :call-seq:
+    #   filter("key.path1", ..., "key.pathN") -> KeyPathHashProxy
+    #
+    # Filter a keypathhash tree by a list of keypath prefixes, and
+    # return a new keypathhash containing only those trees.
+    #
+    # Raises a KeyError exception if any of the specified keypaths
+    # cannot be found.
+
+    def filter(*keypaths)
+      result = self.class.new
+      keypaths.each do |keypath|
+        result[keypath] = self.fetch(keypath)
+      end
+      result
+    end
+  end
+end

data/lib/kvdag/version.rb

@@ -0,0 +1,3 @@
+class KVDAG
+  VERSION = '0.1.3'
+end

data/lib/kvdag/vertex.rb

@@ -0,0 +1,176 @@
+class KVDAG
+
+  # A vertex in a KVDAG
+
+  class Vertex
+    include AttributeNode
+    include Comparable
+    attr_reader :dag
+    attr_reader :edges
+
+    # Create a new vertex in a KVDAG, optionally loaded
+    # with key-values.
+    #
+    # N.B: KVDAG::Vertex.new should never be called directly,
+    # always use KVDAG#vertex to create vertices.
+
+    private :initialize
+    def initialize(dag, attrs = {})
+      @edges = Set.new
+      @dag = dag
+      @attrs = dag.hash_proxy_class.new(attrs)
+      @child_cache = Set.new
+
+      @dag.vertices << self
+    end
+
+    def inspect
+      "#<%s @attr=%s @edges=%s>" % [self.class, @attrs.to_hash, @edges.to_a]
+    end
+
+    alias to_s inspect
+
+    # :call-seq:
+    #   vtx.parents                 -> all parents
+    #   vtx.parents(filter)         -> parents matching +filter+
+    #   vtx.parents {|cld| ... }    -> call block with each parent
+    #
+    # Returns the set of all direct parents, possibly filtered by #match?
+    # expressions. If a block is given, call it with each parent.
+
+    def parents(filter={}, &block)
+      result = Set.new(edges.map {|edge|
+                         edge.to_vertex
+                       }.select {|parent|
+                         parent.match?(filter)
+                       })
+
+      if block_given?
+        result.each(&block)
+      else
+        result
+      end
+    end
+
+    # :call-seq:
+    #   vtx.children                 -> all children
+    #   vtx.children(filter)         -> children matching +filter+
+    #   vtx.children {|cld| ... }    -> call block with each child
+    #
+    # Returns the set of all direct children, possibly filtered by #match?
+    # expressions. If a block is given, call it with each child.
+
+    def children(filter={}, &block)
+      result = @child_cache.select {|child|
+                 child.match?(filter)
+               }
+
+      if block_given?
+        result.each(&block)
+      else
+        result
+      end
+    end
+
+    # Is +other+ vertex reachable via any of my #edges?
+    #
+    # A KVDAG::VertexError is raised if vertices belong
+    # to different KVDAG.
+
+    def reachable?(other)
+      raise VertexError.new("Not in the same DAG") unless @dag.equal?(other.dag)
+
+      equal?(other) || parents.any? {|parent| parent.reachable?(other)}
+    end
+
+    # Am I reachable from +other+ via any of its #edges?
+    #
+    # A KVDAG::VertexError is raised if vertices belong
+    # to different KVDAG.
+
+    def reachable_from?(other)
+      other.reachable?(self)
+    end
+
+    # Return the set of this object and all its parents, and their
+    # parents, recursively
+    #
+    # This is the same as all #reachable? vertices.
+
+
+    def ancestors
+      result = Set.new([self])
+      parents.each {|p| result += p.ancestors }
+      result
+    end
+
+    # Return the set of this object and all its children, and their
+    # children, recursively
+    #
+    # This is the same as all #reachable_from? vertices.
+
+    def descendants
+      result = Set.new([self])
+      children.each {|c| result += c.descendants }
+      result
+    end
+
+    # Comparable ordering for a DAG:
+    #
+    # Reachable vertices are lesser.
+    # Unreachable vertices are equal.
+
+    def <=>(other)
+      return -1 if reachable?(other)
+      return 1 if reachable_from?(other)
+      return 0
+    end
+
+    # Create an edge towards an +other+ vertex, optionally
+    # loaded with key-values.
+    #
+    # A KVDAG::VertexError is raised if vertices belong
+    # to different KVDAG.
+    #
+    # A KVDAG::CyclicError is raised if the edge would
+    # cause a cycle in the KVDAG.
+
+    def edge(other, attrs = {})
+      other = other.to_vertex unless other.is_a?(Vertex)
+      raise VertexError.new("Not in the same DAG") if @dag != other.dag
+      raise CyclicError.new("Would become cyclic") if other.reachable?(self)
+
+      edge = Edge.new(@dag, other, attrs)
+      @edges << edge
+      other.add_child(self)
+      edge
+    end
+
+    # Return the proxied key-value hash tree visible from this vertex
+    # via its edges and all its ancestors.
+    #
+    # Calling #to_hash instead will return a regular hash tree, without
+    # any special properties, e.g. for serializing as YAML or JSON.
+
+    def to_hash_proxy
+      result = @dag.hash_proxy_class.new
+      edges.each do |edge|
+        result.merge!(edge.to_hash_proxy)
+      end
+      result.merge!(@attrs)
+    end
+
+  protected
+
+    # Cache the fact that the +other+ vertex has created an edge to
+    # us.
+    #
+    # Do not call this except from #edge, which performs all required
+    # sanity checks.
+
+    def add_child(other)
+      @child_cache << other
+    end
+
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: kvdag
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Calle Englund
+autorequire: 
+bindir: exe
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDljCCAn6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBIMRYwFAYDVQQDDA1jYWxs
+  ZS5lbmdsdW5kMRkwFwYKCZImiZPyLGQBGRYJc2FhYmdyb3VwMRMwEQYKCZImiZPy
+  LGQBGRYDY29tMB4XDTE2MTEwMjA5MjYyN1oXDTE3MTEwMjA5MjYyN1owSDEWMBQG
+  A1UEAwwNY2FsbGUuZW5nbHVuZDEZMBcGCgmSJomT8ixkARkWCXNhYWJncm91cDET
+  MBEGCgmSJomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+  ggEBAM7OxaztzD0LyOwK1mPcg3BhioX1EDVbD/qAFOAzBSGGlAhtmHMqAkyvJMvs
+  iiG7xvBidWUapxiEiBwamXiOTSrp2eW+XSXW9omdWHXjBZcwHqwb1VmAlYRDkSHf
+  dzcM/z4xlV+DJw/pFyMRWzqNdVBtWTbVXAFGjJSqQ6q21ACYJldV9U71AIpXo+oF
+  VEMf6PZS2uhB1G+FgAtnX/xmy7OM1Cy3qc/CaJbWSddpegxWJMUn2HNQxFwIe40g
+  WoEoiFA7qQg9DnR/5i3lW6QyfIaA5k9cv2su1VyjqKLbkFTTTjYw0P1BJmvfXjtc
+  rMl+3HCWYj6UunZwfZi2wDGsBkkCAwEAAaOBijCBhzAJBgNVHRMEAjAAMAsGA1Ud
+  DwQEAwIEsDAdBgNVHQ4EFgQUwHCMEKgrIMaiTkTVLKZn6yOD1SIwJgYDVR0RBB8w
+  HYEbY2FsbGUuZW5nbHVuZEBzYWFiZ3JvdXAuY29tMCYGA1UdEgQfMB2BG2NhbGxl
+  LmVuZ2x1bmRAc2FhYmdyb3VwLmNvbTANBgkqhkiG9w0BAQUFAAOCAQEAP9OnE0jP
+  2vRHI/vnOkgCvLFNoOqK/YB4yDVVW69Pza+xIXcmUBvl7DQ+bBdF5AK0B1A7U0rp
+  Pbdj0bpQtWxmUmMIbnE1w6iuVCXAabsyUfHY4mlztToWXMVOXc1SPlJ/S2XXaRd5
+  fiNj/nBTb0YTQA0E4pZ0Aud80qZ2WLdc6FfzHUEMW91BL3bhLeDL40noHK5Lvk52
+  phzVHIrDjCowUMTnGiPZCXEo4KZW76KwYYV6oQ6LzcrYBw5mJ4XpdgQKZgnTnRBP
+  f8wtQllq82VF0AXUYeLtTh1f+DW3WW5BO1e2OCu5eOV7dbyaVPaNK/+rHjCN8kM/
+  DGZSwUoNADmVkQ==
+  -----END CERTIFICATE-----
+date: 2016-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+description: Directed Acyclic Graph for Key-Value searches
+email:
+- calle.englund@saabgroup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- kvdag.gemspec
+- lib/kvdag.rb
+- lib/kvdag/attrnode.rb
+- lib/kvdag/edge.rb
+- lib/kvdag/error.rb
+- lib/kvdag/keypathhash.rb
+- lib/kvdag/version.rb
+- lib/kvdag/vertex.rb
+homepage: https://github.com/saab-simc-admin/keyvaluedag
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Directed Acyclic Graph for Key-Value searches
+test_files: []