dagwood 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8b26b85e1455bc22180f34ad7947adbd052c3e67f7275cbda7c64cb5267c5fa4
+  data.tar.gz: fdd26a9a58377513a33f7702ce66a03550e8507e88d28b6b1227e4cc0ff83008
+SHA512:
+  metadata.gz: 6fc45a8a4600bf12007d753f25603446dfe51f921ddb10a8ba8731bae5f0cf69140bb7555b5d4b385df2c724fc568114a03d2a56b940f67e1c138e0e783a7d03
+  data.tar.gz: 2059b6ceb2a6f4c6b05f315590392b2482e0e85b2c2b13122bf901e23398c84b6102f3375279f69a66df3c27bd7f5086d65d52c129c2577f21611be607f71304

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,2 @@
+inherit_gem:
+  rewind-ruby-style: rubocop.yml

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.2
+before_install: gem install bundler -v 2.0.2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.9.0]
+
+Pre-release

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dagwood.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: .
+  specs:
+    dagwood (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    ast (2.4.1)
+    diff-lcs (1.4.4)
+    docile (1.3.2)
+    parallel (1.19.2)
+    parser (2.7.1.4)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (13.0.1)
+    regexp_parser (1.7.1)
+    rewind-ruby-style (1.0.10)
+      rubocop (>= 0.85, < 0.89)
+    rexml (3.2.4)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    rubocop (0.87.1)
+      parallel (~> 1.10)
+      parser (>= 2.7.1.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.7)
+      rexml
+      rubocop-ast (>= 0.1.0, < 1.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (0.3.0)
+      parser (>= 2.7.1.4)
+    ruby-progressbar (1.10.1)
+    simplecov (0.19.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-console (0.7.2)
+      ansi
+      simplecov
+      terminal-table
+    simplecov-html (0.12.2)
+    terminal-table (1.8.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
+    unicode-display_width (1.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (= 2.0.1)
+  dagwood!
+  rake (~> 13.0)
+  rewind-ruby-style
+  rspec (~> 3.9.0)
+  rubocop (~> 0.87.0)
+  simplecov (~> 0.19)
+  simplecov-console (~> 0.4)
+
+BUNDLED WITH
+   2.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Rewind
+
+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,97 @@
+# 🥪 Dagwood
+
+Dagwood allows you to determine the resolution order of dependencies, using a [topologically sorted directed acyclic graph](https://en.wikipedia.org/wiki/Topological_sorting) (DAG - get it?).
+
+What does this mean? Let's use an example. When making a sandwich, it is important to follow a specific order of operations. We know that the bread needs to be sliced before we can put the mustard on it, just like we know there is no point closing the sandwich before putting the smoked meat in it. By stating all these dependencies (e.g. `add_mustard` depends on `slice_bread`), we can determine the full, correct order in which we should make our sandwich. We call this a `DependencyGraph`.
+
+See the features listed below for ways in which we can use this information.
+
+Dagwood might be useful for scheduling Sidekiq jobs to run in a specific order, determining the order in which software packages must be installed on a server, figuring out how long a project might take based on which steps need to be completed first, and many more use cases.
+
+#### Features:
+**Serial ordering of dependencies**
+
+The basic case. Determine the order of dependencies, one item at a time. The `order` method returns an array of dependencies, in the order they need to be resolved.
+```ruby
+graph = Dagwood::DependencyGraph.new(add_mustard: [:slice_bread], add_smoked_meat: [:slice_bread], close_sandwich: [:add_smoked_meat])
+graph.order
+=> [:slice_bread, :add_mustard, :add_smoked_meat, :close_sandwich]
+```
+ 
+**Parallel ordering of dependencies**
+
+Sometimes certain dependencies can be resolved at the same time. For example, a friend is helping you make your sandwich and you can both complete certain steps at the same time. The `parallel_order` method functions very similarly to `order`, except the items in the array are "groups" of dependencies which can be resolved in parallel (in this example, `add_smoked_meat` and `add_mustard` can be done at the same time).
+
+```ruby
+graph = Dagwood::DependencyGraph.new(add_mustard: [:slice_bread], add_smoked_meat: [:slice_bread], close_sandwich: [:add_smoked_meat])
+graph.parallel_order
+=> [[:slice_bread], [:add_smoked_meat, :add_mustard], [:close_sandwich]]
+```
+
+**Reverse ordering of dependencies**
+
+The `reverse_order` method can be useful in cases where you'd like to apply the opposite order of operations.
+
+```ruby
+graph = Dagwood::DependencyGraph.new(add_mustard: [:slice_bread], add_smoked_meat: [:slice_bread], close_sandwich: [:add_smoked_meat])
+graph.reverse_order
+=> [:close_sandwich, :add_smoked_meat, :add_mustard, :slice_bread]
+```
+
+**Subgraphs**
+
+Perhaps you only care about what is needed to perform the `add_mustard` operation. The `subgraph` method allows you to grab a slice of the DependencyGraph, based on the given node.
+
+
+```ruby
+graph = Dagwood::DependencyGraph.new(add_mustard: [:slice_bread], add_smoked_meat: [:slice_bread], close_sandwich: [:add_smoked_meat])
+subgraph = graph.subgraph :add_mustard
+subgraph.order
+=> [:slice_bread, :add_mustard]
+```
+
+**Graph merging**
+
+The `merge` method allows you to take two DependencyGraphs and merge them. If your two most beloved restaurants have really good sandwich recipes, perhaps you'd like to attempt creating the Ultimate Sandwich by combining the steps for making both?
+
+```ruby
+recipe1 = Dagwood::DependencyGraph.new(add_mustard: [:slice_bread], add_smoked_meat: [:slice_bread], close_sandwich: [:add_smoked_meat])
+recipe2 = Dagwood::DependencyGraph.new(add_mayo: [:slice_bread], add_turkey: [:slice_bread], close_sandwich: [:add_turkey, :add_pickles])
+
+ultimate_recipe = recipe1.merge(recipe2)
+ultimate_recipe.order
+=> [:slice_bread, :add_mustard, :add_smoked_meat, :add_pickles, :add_mayo, :add_turkey, :close_sandwich]
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dagwood'
+```
+
+or this line to your gem's gemspec:
+
+```ruby
+spec.add_dependency 'dagwood'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dagwood
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the spec. 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
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/rewindio/dagwood](https://github.com/rewindio/dagwood).

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError # rubocop:disable Lint/SuppressedException
+end
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'dagwood'
+
+# 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(__FILE__)

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/dagwood.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dagwood/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dagwood'
+  spec.version       = Dagwood::VERSION
+  spec.authors       = ['Rewind.io']
+  spec.email         = ['team@rewind.io']
+
+  spec.summary       = 'For all your dependency graph needs'
+  spec.description   = 'Dagwood allows you to create dependency graphs for doing work in series or in parallel, always in the right order.'
+  spec.homepage      = 'https://github.com/rewindio/dagwood'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|.github|examples)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '2.0.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rewind-ruby-style'
+  spec.add_development_dependency 'rspec', '~> 3.9.0'
+  spec.add_development_dependency 'rubocop', '~> 0.87.0'
+  spec.add_development_dependency 'simplecov', '~> 0.19'
+  spec.add_development_dependency 'simplecov-console', '~> 0.4'
+end

data/lib/dagwood.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'dagwood/version'
+require 'dagwood/dependency_graph'
+
+module Dagwood
+  class Error < StandardError; end
+end

data/lib/dagwood/dependency_graph.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'tsort'
+
+module Dagwood
+  class DependencyGraph
+    include TSort
+
+    attr_reader :dependencies
+
+    # @param dependencies [Hash]
+    #   A hash of the form { item1: ['item2', 'item3'], item2: ['item3'], item3: []}
+    #   would mean that "item1" depends on item2 and item3, item2 depends on item3
+    #   and item3 has no dependencies. Nil and missing values will be converted to [].
+    def initialize(dependencies)
+      @dependencies = Hash.new([]).merge(dependencies.transform_values { |v| v.nil? ? [] : v.sort })
+    end
+
+    def order
+      @order ||= tsort
+    end
+
+    def reverse_order
+      @reverse_order ||= order.reverse
+    end
+
+    # Similar to #order, except this will group items that
+    # have the same "priority", thus indicating they can be done
+    # in parallel.
+    #
+    # Same priority means:
+    #  1) They have the same exact same sub-dependencies OR
+    #  2) B comes after A and all of B's dependencies have been resolved before A
+    def parallel_order
+      groups = []
+      ungrouped_dependencies = order.dup
+
+      until ungrouped_dependencies.empty?
+        # Start this group with the first dependency we haven't grouped yet
+        group_starter = ungrouped_dependencies.delete_at(0)
+        group = [group_starter]
+
+        ungrouped_dependencies.each do |ungrouped_dependency|
+          same_priority = @dependencies[ungrouped_dependency].all? do |sub_dependency|
+            groups.reduce(false) { |found, g| found || g.include?(sub_dependency) }
+          end
+
+          group << ungrouped_dependency if same_priority
+        end
+
+        # Remove depedencies we managed to group
+        ungrouped_dependencies -= group
+
+        groups << group.sort
+      end
+
+      groups
+    end
+
+    # Generate a subgraph starting at the given node
+    def subgraph(node)
+      return self.class.new({}) unless @dependencies.key? node
+
+      # Add the given node and its dependencies to our hash
+      hash = {}
+      hash[node] = @dependencies[node]
+
+      # For every dependency of the given node, recursively create a subgraph and merge it into our result
+      @dependencies[node].each { |dep| hash.merge! subgraph(dep).dependencies }
+
+      self.class.new hash
+    end
+
+    # Returns a new graph containing all dependencies from this graph and the given graph.
+    # If both graphs depend on the same item, but that item's sub-dependencies differ, the
+    # resulting graph will depend on the union of both.
+    def merge(other)
+      all_dependencies = {}
+
+      (dependencies.keys | other.dependencies.keys).each do |key|
+        all_dependencies[key] = dependencies[key] | other.dependencies[key]
+      end
+
+      self.class.new all_dependencies
+    end
+
+    private
+
+    def tsort_each_child(node, &block)
+      @dependencies.fetch(node, []).each(&block)
+    end
+
+    def tsort_each_node(&block)
+      @dependencies.each_key(&block)
+    end
+  end
+end

data/lib/dagwood/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Dagwood
+  VERSION = '0.9.0'
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: dagwood
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Rewind.io
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-08-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rewind-ruby-style
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.87.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.87.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: Dagwood allows you to create dependency graphs for doing work in series
+  or in parallel, always in the right order.
+email:
+- team@rewind.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dagwood.gemspec
+- lib/dagwood.rb
+- lib/dagwood/dependency_graph.rb
+- lib/dagwood/version.rb
+homepage: https://github.com/rewindio/dagwood
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: For all your dependency graph needs
+test_files: []