cobra_commander 0.5.0 → 0.8.0

data/lib/cobra_commander/component.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  # Represents a component withing an Umbrella
+  class Component
+    attr_reader :name, :dependencies, :sources
+
+    def initialize(umbrella, name)
+      @umbrella = umbrella
+      @name = name
+      @dependency_names = []
+      @sources = {}
+    end
+
+    def add_source(key, path, dependency_names)
+      @sources[key] = path
+      @dependency_names |= dependency_names
+    end
+
+    def root_paths
+      @sources.values.map(&File.method(:dirname)).uniq
+    end
+
+    def inspect
+      "#<CobraCommander::Component:#{object_id} #{name} dependencies=#{dependencies.map(&:name)} packages=#{sources}>"
+    end
+
+    def deep_dependents
+      @deep_dependents ||= @umbrella.components.find_all do |dep|
+        dep.deep_dependencies.include?(self)
+      end
+    end
+
+    def deep_dependencies
+      @deep_dependencies ||= dependencies.reduce(dependencies) do |deps, dep|
+        deps | dep.deep_dependencies
+      end
+    end
+
+    def dependents
+      @dependents ||= @umbrella.components.find_all do |dep|
+        dep.dependencies.include?(self)
+      end
+    end
+
+    def dependencies
+      @dependencies ||= @dependency_names.sort
+                                         .map(&@umbrella.method(:find))
+                                         .compact
+    end
+  end
+end

data/lib/cobra_commander/dependencies.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "dependencies/yarn_workspace"
+require_relative "dependencies/bundler"

data/lib/cobra_commander/dependencies/bundler.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Dependencies
+    # Calculates ruby bundler dependencies
+    class Bundler
+      def initialize(root)
+        @definition = ::Bundler::Definition.build(
+          Pathname.new(File.join(root, "Gemfile")).realpath,
+          Pathname.new(File.join(root, "Gemfile.lock")).realpath,
+          false
+        )
+      end
+
+      def path
+        @definition.lockfile
+      end
+
+      def dependencies
+        @definition.dependencies.map(&:name)
+      end
+
+      def components
+        components_source.specs.map do |spec|
+          { path: spec.loaded_from, name: spec.name, dependencies: spec.dependencies.map(&:name) }
+        end
+      end
+
+    private
+
+      def components_source
+        @components_source ||= @definition.send(:sources).path_sources.find do |source|
+          source.path.to_s.eql?("components")
+        end
+      end
+    end
+  end
+end

data/lib/cobra_commander/dependencies/yarn/package.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "json"
+
+module CobraCommander
+  module Dependencies
+    module Yarn
+      # Represents an Yarn package.json file
+      class Package
+        attr_reader :path
+
+        def initialize(path)
+          @path = Pathname.new(File.join(path, "package.json")).realpath
+        end
+
+        def project_tag
+          name.match(%r{^@[\w-]+\/}).to_s
+        end
+
+        def name
+          json["name"]
+        end
+
+        def dependencies
+          json.fetch("dependencies", {})
+              .merge(json.fetch("devDependencies", {}))
+        end
+
+      private
+
+        def json
+          @json ||= JSON.parse(File.read(@path))
+        end
+      end
+    end
+  end
+end

data/lib/cobra_commander/dependencies/yarn/package_repo.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Dependencies
+    module Yarn
+      # Yarn package repository to load and cache package.json files
+      class PackageRepo
+        def initialize
+          @specs ||= {}
+        end
+
+        def specs
+          @specs.values
+        end
+
+        def load_linked_specs(package)
+          package.dependencies.values.each do |spec|
+            next unless spec =~ /link:(.+)/
+            load_spec(File.join(package.path, "..", Regexp.last_match(1)))
+          end
+        end
+
+        def load_spec(path)
+          @specs[path] ||= Package.new(path).tap do |package|
+            load_linked_specs(package)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cobra_commander/dependencies/yarn_workspace.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "open3"
+
+require_relative "yarn/package"
+require_relative "yarn/package_repo"
+
+module CobraCommander
+  module Dependencies
+    # Yarn workspace components source for an umbrella
+    class YarnWorkspace
+      attr_reader :packages
+
+      def initialize(root_path)
+        @repo = Yarn::PackageRepo.new
+        @root_package = Yarn::Package.new(root_path)
+        @repo.load_linked_specs(@root_package)
+        load_workspace_packages
+      end
+
+      def path
+        @root_package.path
+      end
+
+      def dependencies
+        (workspace_spec.keys | @root_package.dependencies.keys).map(&method(:untag))
+      end
+
+      def components
+        @repo.specs.map do |spec|
+          { path: spec.path, name: untag(spec.name), dependencies: spec.dependencies.keys.map(&method(:untag)) }
+        end
+      end
+
+    private
+
+      def load_workspace_packages
+        workspace_spec.map do |_name, spec|
+          @repo.load_spec File.expand_path(File.join(@root_package.path, "..", spec["location"]))
+        end
+      end
+
+      def workspace_spec
+        @workspace_spec ||= begin
+          output, = Open3.capture2("yarn workspaces --json info", chdir: File.dirname(@root_package.path))
+          JSON.parse(JSON.parse(output)["data"])
+        end
+      end
+
+      def untag(name)
+        name.gsub(@root_package.project_tag, "")
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor.rb

@@ -2,29 +2,15 @@
 
 module CobraCommander
   # Execute commands on all components of a ComponentTree
-  class Executor
-    def initialize(tree)
-      @tree = tree
-    end
-
-    def exec(command, printer = $stdout)
-      @tree.flatten.each do |component|
-        printer.puts "===> #{component.name} (#{component.path})"
-        output, = run_in_component(component, command)
-        printer.puts output
-      end
-    end
-
-  private
-
-    def run_in_component(component, command)
-      Dir.chdir(component.path) do
-        Open3.capture2e(env_vars(component), command)
+  module Executor
+    def self.exec(components, command, printer = $stdout)
+      components.each do |component|
+        component.root_paths.each do |path|
+          printer.puts "===> #{component.name} (#{path})"
+          output, = Open3.capture2e(command, chdir: path, unsetenv_others: true)
+          printer.puts output
+        end
       end
     end
-
-    def env_vars(component)
-      { "CURRENT_COMPONENT" => component.name, "CURRENT_COMPONENT_PATH" => component.path }
-    end
   end
 end

data/lib/cobra_commander/output.rb

@@ -1,74 +1,5 @@
 # frozen_string_literal: true
 
-module CobraCommander
-  # Module for pretty printing dependency trees
-  module Output
-    def self.print(tree, format)
-      output = format == "list" ? Output::FlatList.new(tree) : Output::Tree.new(tree)
-      puts output.to_s
-    end
-
-    # Flattens a tree and prints unique items
-    class FlatList
-      def initialize(tree)
-        @tree = tree
-      end
-
-      def to_s
-        @tree.flatten.map(&:name)
-      end
-    end
-
-    # Prints the tree in a nice tree form
-    class Tree
-      attr_accessor :tree
-
-      SPACE  = "    "
-      BAR    = "│   "
-      TEE    = "├── "
-      CORNER = "└── "
-
-      def initialize(tree)
-        @tree = tree
-      end
-
-      def to_s
-        StringIO.new.tap do |io|
-          io.puts @tree.name
-          list_dependencies(io, @tree)
-        end.string
-      end
-
-    private
-
-      def list_dependencies(io, deps, outdents = [])
-        deps.dependencies.each do |dep|
-          decide_on_line(io, deps, dep, outdents)
-        end
-        nil
-      end
-
-      def decide_on_line(io, parent, dep, outdents)
-        if parent.dependencies.last != dep
-          add_tee(io, outdents, dep)
-        else
-          add_corner(io, outdents, dep)
-        end
-      end
-
-      def add_tee(io, outdents, dep)
-        io.puts line(outdents, TEE, dep.name)
-        list_dependencies(io, dep, (outdents + [BAR]))
-      end
-
-      def add_corner(io, outdents, dep)
-        io.puts line(outdents, CORNER, dep.name)
-        list_dependencies(io, dep, (outdents + [SPACE]))
-      end
-
-      def line(outdents, sym, name)
-        (outdents + [sym] + [name]).join
-      end
-    end
-  end
-end
+require_relative "output/flat_list"
+require_relative "output/ascii_tree"
+require_relative "output/graph_viz"

data/lib/cobra_commander/output/ascii_tree.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Output
+    # Prints the tree in a nice tree form
+    class AsciiTree
+      SPACE  = "    "
+      BAR    = "│   "
+      TEE    = "├── "
+      CORNER = "└── "
+
+      def initialize(component)
+        @component = component
+      end
+
+      def to_s
+        StringIO.new.tap do |io|
+          io.puts @component.name
+          list_dependencies(io, @component)
+        end.string
+      end
+
+    private
+
+      def list_dependencies(io, component, outdents = [])
+        component.dependencies.each do |dep|
+          decide_on_line(io, component, dep, outdents)
+        end
+        nil
+      end
+
+      def decide_on_line(io, parent, dep, outdents)
+        if parent.dependencies.last != dep
+          add_tee(io, outdents, dep)
+        else
+          add_corner(io, outdents, dep)
+        end
+      end
+
+      def add_tee(io, outdents, dep)
+        io.puts line(outdents, TEE, dep.name)
+        list_dependencies(io, dep, (outdents + [BAR]))
+      end
+
+      def add_corner(io, outdents, dep)
+        io.puts line(outdents, CORNER, dep.name)
+        list_dependencies(io, dep, (outdents + [SPACE]))
+      end
+
+      def line(outdents, sym, name)
+        (outdents + [sym] + [name]).join
+      end
+    end
+  end
+end

data/lib/cobra_commander/output/flat_list.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Output
+    # Prints a list of components' names sorted alphabetically
+    class FlatList
+      def initialize(components)
+        @components = components
+      end
+
+      def to_s
+        @components.map(&:name).sort
+      end
+    end
+  end
+end

data/lib/cobra_commander/output/graph_viz.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "graphviz"
+
+module CobraCommander
+  module Output
+    # Generates graphs of components
+    module GraphViz
+      def self.generate(component, output)
+        g = ::GraphViz.new(:G, type: :digraph, concentrate: true)
+        ([component] + component.deep_dependencies).each do |comp|
+          g.add_nodes comp.name
+          g.add_edges comp.name, comp.dependencies.map(&:name)
+        end
+
+        g.output(extract_format(output) => output)
+      end
+
+      private_class_method def self.extract_format(output)
+        format = output[-3..-1]
+        return format if format == "png" || format == "dot"
+
+        raise ArgumentError, "output format must be 'png' or 'dot'"
+      end
+    end
+  end
+end

data/lib/cobra_commander/umbrella.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  # An umbrella application
+  class Umbrella
+    attr_reader :name, :path
+
+    def initialize(name, path)
+      @root_component = Component.new(self, name)
+      @path = path
+      @components = {}
+    end
+
+    def find(name)
+      @components[name]
+    end
+
+    def root
+      @root_component
+    end
+
+    def resolve(component_root_path)
+      return root if root.root_paths.include?(component_root_path)
+      components.find do |component|
+        component.root_paths.include?(component_root_path)
+      end
+    end
+
+    def add_source(key, source)
+      @root_component.add_source key, source.path, source.dependencies
+      source.components.each do |path:, name:, dependencies:|
+        @components[name] ||= Component.new(self, name)
+        @components[name].add_source key, path, dependencies
+      end
+    end
+
+    def components
+      @components.values
+    end
+
+    def dependents_of(component)
+      find(component)&.deep_dependents
+                     &.sort_by(&:name)
+    end
+
+    def dependencies_of(name)
+      find(name)&.deep_dependencies
+                &.sort_by(&:name)
+    end
+  end
+end