dsort 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e29b9d36c3e4bb2c6122b967ffdfa3e3609a01fe5dfe37cf6c1d4d319a8495b3
+  data.tar.gz: 81fffd543f6dd5518583cca18dd1ba73d69ab164fa88895943bb80e1553eee32
+SHA512:
+  metadata.gz: 9a74383d8fc09440f1a53ecf03dccc6900c16a0db9633292d80ab06a8751452accbb4f4ad91ce4b41474d58e52a5f77b79acf555c7c354dfb984664da182610a
+  data.tar.gz: af569f855ea9d98b72909e6b4b9d607d8072bcd33b040e8a5eb434e26c4d3be75c9470d41fc6f1ac7d60e4ea4470ef8080358b5a95b2bb11518966abfb50ece5

data/.gitignore

@@ -0,0 +1,30 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# Ignore vim files
+.*.swp
+
+# Ignore t.* files
+t
+t.*
+tt
+tt.*
+s
+s.*
+r.rb
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Claus Rasmussen
+
+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,29 @@
+# Dsort
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dsort'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dsort
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/dsort.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dsort/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dsort"
+  spec.version       = Dsort::VERSION
+  spec.authors       = ["Claus Rasmussen"]
+  spec.email         = ["claus.l.rasmussen@gmail.com"]
+  spec.description   = %q{dsort - an easier to use version of TSort}
+  spec.summary       = %q{
+                          dsort provide methods for topological sorting of
+                          data. It is intendended to be an easier-to-use
+                          alternative to the standard TSort module
+                      }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/dsort/version.rb

@@ -0,0 +1,3 @@
+module Dsort
+  VERSION = "0.2.1"
+end

data/lib/dsort.rb

@@ -0,0 +1,153 @@
+require "dsort/version"
+
+require 'tsort'
+
+module DSort
+  # Thrown if a cyclic dependency is detected
+  #
+  # DSort::Cyclic is inherited from TSort::Cyclic so that recue handling code
+  # written for TSort will still work. It provides a #cycles member that lists
+  # the cycles
+  class Cyclic < TSort::Cyclic
+    # List of detected cycles sorted from shortest to longest cycle
+    attr_reader :cycles
+
+    def initialize(dsort_object)
+      @cycles = 
+          dsort_object.each_strongly_connected_component \
+            .select { |e| e.size > 1 } \
+            .sort { |l,r| r <=> l }
+      gram = cycles.size > 1 ? "ies" : "y"
+      super("Cyclic depedendenc#{gram} detected")
+    end
+  end
+
+  # dsort sorts its input in "dependency" order: The input can be thought of
+  # depends-on relations between objects and the output as sorted in the order
+  # needed to safisfy those dependencies so that no object comes before an
+  # object it depends on
+  #
+  # dsort can take an array or a hash argument, or be supplied with a block
+  #
+  # The Array argument should consist of pairs (two-element Arrays) with the
+  # first element being the depending object and the second an object or an
+  # array of objects it depends on: For example [:a, :b] means that :a depends
+  # on :b, and [:b, [:c, :d]] that :b depends on both :c and :d
+  #
+  # The Hash argument should be a hash from depending object to an object or
+  # array of objects it depends on. If h is a Hash then dsort(h) is equivalent
+  # to dsort(h.to_a)
+  #
+  # Note that if the elements are arrays themselves, then you should use the
+  # array form to list the dependencies even if there is only one dependency.
+  # Ie. use [:a, [:b]] or {:a => [:b] } instead of [:a, :b] or {:a => :b}
+  #
+  # If dsort is given a block, the block is given an element as argument and
+  # should return an (possibly empty) array of the objects the argument depends
+  # on. The argument to dsort should be an element or an array of elements to
+  # be given to the block. Note that if the elements are arrays themselves,
+  # then the arguments to dsort should use the array form even if there is only
+  # one element. Ie.  Use dsort([:a]) instead of dsort(:a)
+  #
+  # dsort raise a DSort::Cyclic exception if a cycle detected 
+  #
+  # Example: If we have that dsort depends on ruby and rspec, ruby depends
+  # on C to compile, and rspec depends on ruby, then in what order should we
+  # build them ? Using dsort we could do
+  #
+  #   p dsort [[:dsort, [:ruby, :rspec]]], [:ruby, :C], [:rspec, :ruby]]
+  #       => [:C, :ruby, :rspec, :dsort]
+  #
+  # Using a hash
+  #
+  #   h = {
+  #     :dsort => [:ruby, :rspec],
+  #     :ruby => [:C],
+  #     :rspec => [:ruby]
+  #   }
+  #   p dsort(h) # Same as dsort(h.to_a)
+  #       => [:C, :ruby, :rspec, :dsort]
+  #
+  # or using a block
+  #
+  #   p dsort(:dsort) { |e| h[e] }
+  #       => [:C, :ruby, :rspec, :dsort]
+  #
+  def dsort(a, &block) 
+    sort_object = DSortPrivate::DSortObject.new(a, &block)
+    begin
+      sort_object.tsort 
+    rescue TSort::Cyclic
+      raise Cyclic.new(sort_object)
+    end
+  end
+
+  # tsort sort its input in topological order: The input can be thought of as
+  # comes-before relations between objects and the output will be in
+  # first-to-last order. This definition corresponds to the mathemacial
+  # defitionnn of topological sort. See
+  # http://en.wikipedia.org/wiki/Topological_sorting
+  #
+  # Arguments are the same as for dsort. tsort is equivalent to
+  # dsort(...).reverse
+  #
+  # tsort raise a DSort::Cyclic exception if a cycle is detected (DSort::Cyclic
+  # is an alias for TSort::Cyclic)
+  #
+  def tsort(a, &block) dsort(a, &block).reverse end
+
+  module_function :dsort, :tsort
+
+  module DSortPrivate
+    class DSortObject
+      include TSort
+
+      # Hash from element to array of dependencies
+      attr_reader :deps
+
+      # Create @deps hash from object to list of dependencies
+      def initialize(a, &block)
+        @deps = {}
+        if block_given?
+          a = [a] if !a.is_a?(Array)
+          a.each { |elem| find_dependencies(elem, &block) }
+        else
+          a.each { |obj, deps| 
+            (@deps[obj] ||= []).concat(deps.is_a?(Array) ? deps : [deps])
+          }
+        end
+
+        # Make sure all dependent objects are also represented as depending
+        # objects: If we're given [:a, :b] we want the @deps hash to include
+        # both :a and :b as keys
+        @deps.values.each { |deps|
+          (deps.is_a?(Array) ? deps : [deps]).each { |d|
+            @deps[d] = [] if !@deps.key?(d)
+          }
+        }
+      end
+
+      # TSort virtual methods
+      def tsort_each_node(&block) @deps.each_key(&block) end
+      def tsort_each_child(node, &block) @deps[node].each(&block) end
+
+    private
+      def find_dependencies(a, &block)
+        block.call(a).each { |d|
+          (@deps[a] ||= []) << d
+          find_dependencies(d, &block)
+        }
+      end
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+

data/spec/dsort_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper.rb'
+
+require 'dsort.rb'
+
+# Build a hierarchy of dependencies
+$HASH_DEPS = {
+  :a => [:b, :c],
+  :b => [:c, :d],
+  :c => :d
+}
+
+$BLOCK_DATA = {
+  :a => [:b, :c],
+  :b => [:c, :d],
+  :c => [:d]
+}
+
+describe DSort::Cyclic do
+  describe "#cycles" do
+    it "should be a list of cycles" do
+      pairs = [[:a, :b], [:b, :a]]
+      begin
+        DSort.dsort(pairs).should == 1
+      rescue DSort::Cyclic => e
+        e.cycles.size.should == 1
+        e.cycles[0].sort.should == [:a, :b]
+      end
+    end
+    it "should be sorted from shortest to longest cycle" do
+      pairs = [[:a, :b], [:b, :a], [:A, :B], [:B, :C], [:C, :A]]
+      begin
+        DSort.dsort(pairs).should == 1
+      rescue DSort::Cyclic => e
+        e.cycles.size.should == 2
+        e.cycles[0].sort.should == [:a, :b]
+        e.cycles[1].sort.should == [:A, :B, :C]
+      end
+    end
+  end
+end
+
+describe DSort do
+  describe "#dsort" do
+    context "with an array argument" do
+      it "should do a dependency sort" do
+        pairs = [[:a, :b], [:b, :c]]
+        DSort.dsort(pairs).should == [:c, :b, :a]
+      end
+      it "should accept self-dependencies" do
+        pairs = [[:a, :b], [:b, :c], [:c, :c]]
+        DSort.dsort(pairs).should == [:c, :b, :a]
+      end
+      it "should accept duplicate keys" do
+        pairs = [[:a, :b], [:b, :c], [:a, :c]]
+        DSort.dsort(pairs).should == [:c, :b, :a]
+      end
+      it "should accept duplicate dependencies" do
+        pairs = [[:a, :b], [:a, :b], [:b, :c], [:a, :c]]
+        DSort.dsort(pairs).should == [:c, :b, :a]
+      end
+      it "should accept lists of dependencies" do
+        pairs = [ [:a, [:b, :c]], [:b, [:c]] ]
+        DSort.dsort(pairs).should == [:c, :b, :a]
+      end
+      it "should accept empty lists of dependencies" do
+        pairs = [ [:a, [:b, :c]], [:b, [:c]], [:c, []] ]
+        DSort.dsort(pairs).should == [:c, :b, :a]
+      end
+      it "should accept arrays as values" do
+        a, b, c = [:a], [:b], [:c]
+        pairs = [ [a, [b, c]], [b, [c]] ]
+        DSort.dsort(pairs).should == [c, b, a]
+      end
+    end
+    context "with a hash argument" do
+      it "should do a dependency sort" do
+        DSort.dsort($HASH_DEPS).should == [:d, :c, :b, :a]
+      end
+    end
+    context "with objects and a block" do
+      it "should do a dependency sort" do
+        objs = [Integer, Numeric, Float, Object, BasicObject]
+        DSort.dsort(objs) { |obj| [obj.superclass].compact }.should == 
+            [BasicObject, Object, Numeric, Integer, Float]
+      end
+      it "should collect dependencies recursively" do
+        s = DSort.dsort(:a) { |obj| $BLOCK_DATA[obj] || [] }
+        s.should == [:d, :c, :b, :a]
+      end
+    end
+    context "with circular dependencies" do
+      it "should raise DSort::Cyclic" do
+       lambda {
+          pairs = [[:a, :b], [:b, :a]]
+          DSort.dsort(pairs).should == 1
+       }.should raise_error(DSort::Cyclic)
+      end
+    end
+  end
+  describe "#tsort" do
+    context "with an array argument pairs" do
+      it "should be equivalent to DSort::dsort(...).reverse" do
+        a, b, c = [:a], [:b], [:c]
+        test_pairs = [ # From the dsort tests above
+          [[:a, :b], [:b, :c]],
+          [[:a, :b], [:b, :c], [:c, :c]],
+          [[:a, :b], [:b, :c], [:a, :c]],
+          [[:a, :b], [:a, :b], [:b, :c], [:a, :c]],
+          [ [:a, [:b, :c]], [:b, [:c]] ],
+          [ [:a, [:b, :c]], [:b, [:c]], [:c, []] ],
+          [ [a, [b, c]], [b, [c]] ]
+        ]
+        test_pairs.each { |pairs|
+          DSort.tsort(pairs).should == DSort.dsort(pairs).reverse
+        }
+      end
+    end
+    context "with a hash argument" do
+      it "should be equivalent to DSort::dsort(...).reverse" do
+        pairs = { :a => :b, :b => :c }
+        DSort.tsort(pairs).should == DSort.dsort(pairs).reverse
+      end
+    end
+    context "with objects and a block" do
+      it "should be equivalent to DSort::dsort(...).reverse" do
+        objs = [Integer, Numeric, Float, Object, BasicObject]
+        DSort.tsort(objs) { |obj| [obj.superclass].compact }.should == 
+            DSort.dsort(objs) { |obj| [obj.superclass].compact }.reverse
+
+        s = DSort.tsort(:a) { |obj| $BLOCK_DATA [obj] || [] }
+        s.should == [:a, :b, :c, :d]
+      end
+    end
+    context "with circular dependencies" do
+      it "should raise DSort::Cyclic" do
+       lambda {
+          pairs = [[:a, :b], [:b, :a]]
+          DSort.tsort(pairs).should == 1
+       }.should raise_error(DSort::Cyclic)
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # Use old "should" syntax
+  config.expect_with(:rspec) { |c| c.syntax = [:should, :expect] }
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: dsort
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Claus Rasmussen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: dsort - an easier to use version of TSort
+email:
+- claus.l.rasmussen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dsort.gemspec
+- lib/dsort.rb
+- lib/dsort/version.rb
+- spec/dsort_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.3.18
+signing_key:
+specification_version: 4
+summary: dsort provide methods for topological sorting of data. It is intendended
+  to be an easier-to-use alternative to the standard TSort module
+test_files:
+- spec/dsort_spec.rb
+- spec/spec_helper.rb