cobra_commander 0.5.1 → 0.8.1

data/lib/cobra_commander/cli.rb

@@ -1,62 +1,93 @@
 # frozen_string_literal: true
 
 require "thor"
+require "fileutils"
+
+require "cobra_commander"
+require "cobra_commander/affected"
+require "cobra_commander/change"
+require "cobra_commander/executor"
+require "cobra_commander/output"
 
 module CobraCommander
   # Implements the tool's CLI
   class CLI < Thor
-    desc "do [command]", "Executes the command in the context of each component in [app]"
-    method_option :app, default: Dir.pwd, aliases: "-a", desc: "App path (default: CWD)"
-    def do(command)
-      tree = CobraCommander.umbrella_tree(options.app)
-      executor = Executor.new(tree)
-      executor.exec(command)
-    end
-
-    desc "ls [app_path]", "Prints tree of components for an app"
-    method_option :app, default: Dir.pwd, aliases: "-a", desc: "App path (default: CWD)"
-    method_option :format, default: "tree", aliases: "-f", desc: "Format (list or tree, default: list)"
-    def ls(app_path = nil)
-      Output.print(
-        CobraCommander.umbrella_tree(app_path || options.app),
-        options.format
-      )
+    class_option :app, default: Dir.pwd, aliases: "-a", type: :string
+    class_option :js, default: false, type: :boolean, desc: "Consider only the JS dependency graph"
+    class_option :ruby, default: false, type: :boolean, desc: "Consider only the Ruby dependency graph"
+
+    desc "version", "Prints version"
+    def version
+      puts CobraCommander::VERSION
     end
 
-    desc "dependents_of [component]", "Outputs count of components in [app] dependent on [component]"
-    method_option :app, default: Dir.pwd, aliases: "-a", desc: "Path to the root app where the component is mounted"
-    method_option :format, default: "count", aliases: "-f", desc: "count or list"
-    def dependents_of(component)
-      dependents = CobraCommander.umbrella_tree(options.app).dependents_of(component)
-      puts "list" == options.format ? dependents.map(&:name) : dependents.size
+    desc "ls [component]", "Lists the components in the context of a given component or umbrella"
+    method_option :dependencies, type: :boolean, aliases: "-d",
+                                 desc: "Run the command on each dependency of a given component"
+    method_option :dependents, type: :boolean, aliases: "-D",
+                               desc: "Run the command on each dependency of a given component"
+    method_option :total, type: :boolean, aliases: "-t", desc: "Prints the total count of components"
+    def ls(component = nil)
+      components = components_filtered(component)
+      puts options.total ? components.size : CobraCommander::Output::FlatList.new(components).to_s
     end
 
-    desc "dependencies_of [component]", "Outputs a list of components that [component] depends on within [app] context"
-    method_option :app, default: Dir.pwd, aliases: "-a", desc: "App path (default: CWD)"
-    method_option :format, default: "list", aliases: "-f", desc: "Format (list or tree, default: list)"
-    def dependencies_of(component)
-      Output.print(
-        CobraCommander.umbrella_tree(options.app).subtree(component),
-        options.format
+    desc "exec [component] <command>", "Executes the command in the context of a given component or set thereof. " \
+                                       "Defaults to all components."
+    method_option :dependencies, type: :boolean, desc: "Run the command on each dependency of a given component"
+    method_option :dependents, type: :boolean, desc: "Run the command on each dependency of a given component"
+    def exec(command_or_component, command = nil)
+      CobraCommander::Executor.exec(
+        components_filtered(command && command_or_component),
+        command ? command : command_or_component
       )
     end
 
-    desc "version", "Prints version"
-    def version
-      puts CobraCommander::VERSION
+    desc "tree [component]", "Prints the dependency tree of a given component or umbrella"
+    def tree(component = nil)
+      component = find_component(component)
+      puts CobraCommander::Output::AsciiTree.new(component).to_s
     end
 
-    desc "graph APP_PATH [--format=FORMAT]", "Outputs graph"
-    method_option :format, default: "png", aliases: "-f", desc: "Accepts png or dot"
-    def graph(app_path)
-      Graph.new(app_path, options.format).generate!
+    desc "graph [component]", "Outputs a graph of a given component or umbrella"
+    method_option :output, default: File.join(Dir.pwd, "output.png"), aliases: "-o",
+                           desc: "Output file, accepts .png or .dot"
+    def graph(component = nil)
+      CobraCommander::Output::GraphViz.generate(
+        find_component(component),
+        options.output
+      )
+      puts "Graph generated at #{options.output}"
+    rescue ArgumentError => error
+      error error.message
     end
 
-    desc "changes APP_PATH [--results=RESULTS] [--branch=BRANCH]", "Prints list of changed files"
+    desc "changes [--results=RESULTS] [--branch=BRANCH]", "Prints list of changed files"
     method_option :results, default: "test", aliases: "-r", desc: "Accepts test, full, name or json"
     method_option :branch, default: "master", aliases: "-b", desc: "Specified target to calculate against"
-    def changes(app_path)
-      Change.new(app_path, options.results, options.branch).run!
+    def changes
+      Change.new(umbrella, options.results, options.branch).run!
+    end
+
+  private
+
+    def umbrella
+      @umbrella ||= CobraCommander.umbrella(options.app, yarn: options.js, bundler: options.ruby)
+    end
+
+    def find_component(name)
+      return umbrella.root unless name
+
+      umbrella.find(name) || error("Component #{name} not found, try one of `cobra ls`") || exit(1)
+    end
+
+    def components_filtered(component_name)
+      return umbrella.components unless component_name
+      component = find_component(component_name)
+
+      return component.deep_dependencies if options.dependencies
+      return component.deep_dependents if options.dependents
+      [component]
     end
   end
 end

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,17 @@
 
 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)
+      Bundler.with_original_env do
+        components.each do |component|
+          component.root_paths.each do |path|
+            printer.puts "===> #{component.name} (#{path})"
+            output, = Open3.capture2e(command, chdir: path)
+            printer.puts output
+          end
+        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"