cobra_commander 0.6.1 → 0.9.1

data/lib/cobra_commander/change.rb

@@ -8,12 +8,12 @@ module CobraCommander
   class Change
     InvalidSelectionError = Class.new(StandardError)
 
-    def initialize(tree, results, branch)
-      @root_dir = Dir.chdir(tree.path) { `git rev-parse --show-toplevel`.chomp }
+    def initialize(umbrella, results, branch)
+      @root_dir = Dir.chdir(umbrella.path) { `git rev-parse --show-toplevel`.chomp }
       @results = results
       @branch = branch
-      @tree = tree.to_h
-      @affected = Affected.new(@tree, changes, tree.path)
+      @umbrella = umbrella
+      @affected = Affected.new(@umbrella, changes)
     end
 
     def run!
@@ -42,16 +42,16 @@ module CobraCommander
           Open3.capture3("git", "diff", "--name-only", @branch)
         end
 
-        if result.exitstatus == 128
-          raise InvalidSelectionError, "Specified --branch could not be found"
-        end
+        raise InvalidSelectionError, "Specified --branch could not be found" if result.exitstatus == 128
 
         diff.split("\n").map { |f| File.join(@root_dir, f) }
       end
     end
 
     def assert_valid_result_choice
-      raise InvalidSelectionError, "--results must be 'test', 'full', 'name' or 'json'" unless %w[test full name json].include?(@results) # rubocop:disable Metrics/LineLength
+      return if %w[test full name json].include?(@results)
+
+      raise InvalidSelectionError, "--results must be 'test', 'full', 'name' or 'json'"
     end
 
     def selected_result?(result)
@@ -85,8 +85,8 @@ module CobraCommander
       end
     end
 
-    def display(component)
-      "#{component[:name]} - #{component[:type]}"
+    def display(name:, type:, **)
+      "#{name} - #{type}"
     end
 
     def blank_line

data/lib/cobra_commander/cli.rb

@@ -3,103 +3,93 @@
 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
-    CACHE_DESCRIPTION = "Path to a cache file to use (default: nil). If specified, this file will be used to store " \
-      "the component tree for the app to speed up subsequent invocations. Must be rotated any time the component " \
-      "dependency structure changes."
-    COMMON_OPTIONS = "[--app=pwd] [--format=FORMAT] [--cache=nil]"
-
-    desc "do [command] [--app=pwd] [--cache=nil]", "Executes the command in the context of each component in [app]"
-    method_option :app, default: Dir.pwd, aliases: "-a", desc: "App path (default: CWD)"
-    method_option :cache, default: nil, aliases: "-c", desc: CACHE_DESCRIPTION
-    def do(command)
-      tree = maybe_cached_tree(options.app, options.cache)
-      executor = Executor.new(tree)
-      executor.exec(command)
-    end
+    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 "ls [app_path] #{COMMON_OPTIONS}", "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)"
-    method_option :cache, default: nil, aliases: "-c", desc: CACHE_DESCRIPTION
-    def ls(app_path = nil)
-      tree = maybe_cached_tree(app_path || options.app, options.cache)
-      Output.print(
-        tree,
-        options.format
-      )
+    desc "version", "Prints version"
+    def version
+      puts CobraCommander::VERSION
     end
 
-    desc "dependents_of [component] #{COMMON_OPTIONS}", "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"
-    method_option :cache, default: nil, aliases: "-c", desc: CACHE_DESCRIPTION
-    def dependents_of(component)
-      tree = maybe_cached_tree(options.app, options.cache)
-      dependents = tree.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] #{COMMON_OPTIONS}", "Outputs a list of components that [component] depends on"
-    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)"
-    method_option :cache, default: nil, aliases: "-c", desc: CACHE_DESCRIPTION
-    def dependencies_of(component)
-      tree = maybe_cached_tree(options.app, options.cache)
-      Output.print(
-        tree.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_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] [--cache=nil]", "Outputs graph"
-    method_option :format, default: "png", aliases: "-f", desc: "Accepts png or dot"
-    method_option :cache, default: nil, aliases: "-c", desc: CACHE_DESCRIPTION
-    def graph(app_path)
-      tree = maybe_cached_tree(app_path, options.cache)
-      Graph.new(tree, 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 => e
+      error e.message
     end
 
-    desc "changes APP_PATH [--results=RESULTS] [--branch=BRANCH] [--cache=nil]", "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"
-    method_option :cache, default: nil, aliases: "-c", desc: CACHE_DESCRIPTION
-    def changes(app_path)
-      tree = maybe_cached_tree(app_path, options.cache)
-      Change.new(tree, options.results, options.branch).run!
-    end
-
-    desc "cache APP_PATH CACHE_PATH", "Caches a representation of the component structure of the app"
-    def cache(app_path, cache_path)
-      tree = CobraCommander.umbrella_tree(app_path)
-      write_tree_cache(tree, cache_path)
-      puts "Created cache of component tree at #{cache_path}"
+    def changes
+      Change.new(umbrella, options.results, options.branch).run!
     end
 
   private
 
-    def maybe_cached_tree(app_path, cache_path)
-      return CobraCommander.umbrella_tree(app_path) unless cache_path
+    def umbrella
+      @umbrella ||= CobraCommander.umbrella(options.app, yarn: options.js, bundler: options.ruby)
+    end
+
+    def find_component(name)
+      return umbrella.root unless name
 
-      if File.exist?(cache_path)
-        CobraCommander.tree_from_cache(cache_path)
-      else
-        tree = CobraCommander.umbrella_tree(app_path)
-        write_tree_cache(tree, cache_path)
-        tree
-      end
+      umbrella.find(name) || error("Component #{name} not found, try one of `cobra ls`") || exit(1)
     end
 
-    def write_tree_cache(tree, cache_path)
-      FileUtils.mkdir_p(File.dirname(cache_path))
-      File.write(cache_path, tree.to_json)
+    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, :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,42 @@
+# frozen_string_literal: true
+
+require "bundler"
+require "bundler/lockfile_parser"
+require "pathname"
+
+module CobraCommander
+  module Dependencies
+    # Calculates ruby bundler dependencies
+    class Bundler
+      attr_reader :path
+
+      def initialize(root)
+        @root = root
+        @path = Pathname.new(File.join(root, "Gemfile.lock")).realpath
+      end
+
+      def dependencies
+        lockfile.dependencies.values.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 lockfile
+        @lockfile ||= ::Bundler::LockfileParser.new(::Bundler.read_file(path))
+      end
+
+      def components_source
+        @components_source ||= begin
+          source = @lockfile.sources.find { |s| s.path.to_s.eql?("components") }
+          ::Bundler::Source::Path.new(source.options.merge("root_path" => @root))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+
+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,32 @@
+# 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.each_value 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

@@ -1,30 +1,19 @@
 # frozen_string_literal: true
 
+require_relative "executor/component_exec"
+require_relative "executor/multi_exec"
+
 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)
-      end
-    end
-
-    def env_vars(component)
-      { "CURRENT_COMPONENT" => component.name, "CURRENT_COMPONENT_PATH" => component.path }
+  module Executor
+    def self.exec(components, command, output = $stdout, status_output = $stderr)
+      components = Array(components)
+      exec = if components.size == 1
+               ComponentExec.new(components.first)
+             else
+               MultiExec.new(components)
+             end
+      exec.run(command, output: output, spin_output: status_output)
     end
   end
 end