cobra_commander 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfee6f7a8cb59dfa182b31bb4ef7b95615c76336150e6519facb0c5d2deb2eb5
-  data.tar.gz: 492bde3922963729f4765a1ab245467429167135fb8d431d8a3461db4d86c1b7
+  metadata.gz: '037980fd32c80d6ea74549f570cf31cf88d92d4a2702f4ab6568a68bf6160893'
+  data.tar.gz: 46da654f6a423723487f595bfe1f397cb32208ef995634396e508594fd51b5fd
 SHA512:
-  metadata.gz: e2a87ebda5fcf0d6570714ec750cb3b9eba61d5f8afa89e5a9ab090a0e5aa2248f498048d1253a344052d6aca59f7cb69ca6be0179472ae0a2317a433f071f89
-  data.tar.gz: f3dcbceadec7c318d5311aee82faa2bfd30f97a27b2f245485e25139de685659a7b1d0112d0c51dca13f387676afd41cc322ddb1b3f1445dc809821208e20578
+  metadata.gz: aa50298aacd18c53e98f73859e3bd787def474fbd7854f67c014b6c35ca1ea2ee82b84d8af1ac25d47ff8b3317410951a2e021fead7d19eb4d0dabfafd8e89ab
+  data.tar.gz: b8b5e75884f2c3b49839c14654f0b729ba9247fb67e90d86b4946fe896f5bfe4da39149f5a79a2d6bb63507e862a91b30817b99905ebd77d95a04a8b839163e0

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## Version 0.6.0 - 2019-07-03
+
+* Tracks package.json `workspaces` in addition to `dependencies` and `devDependencies`. PR [#31](https://github.com/powerhome/cobra_commander/pull/31)
+* Permits caching the component tree of a project on disk to avoid calculating it repeatedly on subsequent cobra invocations.
+
 ## Version 0.5.1 - 2018-10-15
 
 * Fix a bug with dependencies_of where it wouldn't match components further down the list of umbrella's dependencies

data/README.md

@@ -28,20 +28,20 @@ Or install it yourself as:
 
 ```bash
 Commands:
-  cobra changes APP_PATH [--results=RESULTS] [--branch=BRANCH]                # Prints list of changed files
-  cobra graph APP_PATH [--format=FORMAT]                                      # Outputs graph
-  cobra help [COMMAND]                                                        # Describe available commands or one specific command
-  cobra ls APP_PATH  [--format=list|tree]                                     # Prints tree of components for an app
-  cobra version                                                               # Prints version
-  cobra do [command]                                                          # Executes the command in the context of each component
-  cobra dependencies_of [component] [--app=/path/to/app] [--format=list|tree] # Lists the dependencies of the component in the app context
-  cobra dependents_of [component] [--app=/path/to/app] [--format=list|count]  # Lists or counts the components that depend directly or indirectly on the given component
-  cobra version                                                               # Prints version
+  cobra cache APP_PATH CACHE_PATH                                                # Caches a representation of the component structure of the app
+  cobra changes APP_PATH [--results=RESULTS] [--branch=BRANCH] [--cache=nil]     # Prints list of changed files
+  cobra dependencies_of [component] [--app=pwd] [--format=FORMAT] [--cache=nil]  # Outputs a list of components that [component] depends on within [app] context
+  cobra dependents_of [component] [--app=pwd] [--format=FORMAT] [--cache=nil]    # Outputs count of components in [app] dependent on [component]
+  cobra do [command] [--app=pwd] [--cache=nil]                                   # Executes the command in the context of each component in [app]
+  cobra graph APP_PATH [--format=FORMAT] [--cache=nil]                           # Outputs graph
+  cobra help [COMMAND]                                                           # Describe available commands or one specific command
+  cobra ls [app_path] [--app=pwd] [--format=FORMAT] [--cache=nil]                # Prints tree of components for an app
+  cobra version                                                                  # Prints version
 ```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. You will also need to install `graphviz` by running `brew install graphviz`. Then, run `rake spec` to run the tests. 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`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/lib/cobra_commander.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require "cobra_commander/cli"
-require "cobra_commander/component_tree"
+require "cobra_commander/cached_component_tree"
+require "cobra_commander/calculated_component_tree"
 require "cobra_commander/version"
 require "cobra_commander/graph"
 require "cobra_commander/change"
@@ -16,6 +17,10 @@ module CobraCommander
   UMBRELLA_APP_NAME = "App"
 
   def self.umbrella_tree(path)
-    ComponentTree.new(UMBRELLA_APP_NAME, path)
+    CalculatedComponentTree.new(UMBRELLA_APP_NAME, path)
+  end
+
+  def self.tree_from_cache(cache_file)
+    CachedComponentTree.from_cache_file(cache_file)
   end
 end

data/lib/cobra_commander/cached_component_tree.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "cobra_commander/component_tree"
+
+module CobraCommander
+  # Represents a dependency tree in a given context, built from a cache
+  class CachedComponentTree < ComponentTree
+    attr_reader :dependencies
+
+    def self.from_cache_file(cache_file)
+      cache = JSON.parse(File.read(cache_file), symbolize_names: true)
+      new(cache)
+    end
+
+    def initialize(cache)
+      super(cache[:name], cache[:path])
+      @type = cache[:type]
+      @ancestry = Set.new(cache[:ancestry])
+      @dependencies = (cache[:dependencies] || []).map do |dep|
+        CachedComponentTree.new(dep)
+      end
+    end
+  end
+end

data/lib/cobra_commander/calculated_component_tree.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "cobra_commander/component_tree"
+
+module CobraCommander
+  # Represents a dependency tree in a given context
+  class CalculatedComponentTree < ComponentTree
+    attr_reader :name, :path
+
+    def initialize(name, path, ancestry = Set.new)
+      super(name, path)
+      @ancestry = ancestry
+      @ruby = Ruby.new(path)
+      @js = Js.new(path)
+      @type = type_of_component
+    end
+
+    def dependencies
+      @deps ||= begin
+        deps = @ruby.dependencies + @js.dependencies
+        deps.sort_by { |dep| dep[:name] }
+            .map(&method(:dep_representation))
+      end
+    end
+
+  private
+
+    def type_of_component
+      return "Ruby & JS" if @ruby.gem? && @js.node?
+      return "Ruby" if @ruby.gem?
+      return "JS" if @js.node?
+    end
+
+    def dep_representation(dep)
+      full_path = File.expand_path(File.join(path, dep[:path]))
+      ancestry = @ancestry + [{ name: @name, path: path, type: @type }]
+      CalculatedComponentTree.new(dep[:name], full_path, ancestry)
+    end
+
+    # Calculates ruby dependencies
+    class Ruby
+      def initialize(root_path)
+        @root_path = root_path
+      end
+
+      def dependencies
+        @deps ||= begin
+          return [] unless gem?
+          gems = bundler_definition.dependencies.select { |dep| path?(dep.source) }
+          format(gems)
+        end
+      end
+
+      def path?(source)
+        return if source.nil?
+        source_has_path = source.respond_to?(:path?) ? source.path? : source.is_a_path?
+        source_has_path && source.path.to_s != "."
+      end
+
+      def format(deps)
+        deps.map do |dep|
+          path = File.join(dep.source.path, dep.name)
+          { name: dep.name, path: path }
+        end
+      end
+
+      def gem?
+        @gem ||= File.exist?(gemfile_path)
+      end
+
+      def bundler_definition
+        ::Bundler::Definition.build(gemfile_path, gemfile_lock_path, nil)
+      end
+
+      def gemfile_path
+        File.join(@root_path, "Gemfile")
+      end
+
+      def gemfile_lock_path
+        File.join(@root_path, "Gemfile.lock")
+      end
+    end
+
+    # Calculates js dependencies
+    class Js
+      def initialize(root_path)
+        @root_path = root_path
+      end
+
+      def dependencies
+        @deps ||= begin
+          return [] unless node?
+          json = JSON.parse(File.read(package_json_path))
+          combined_deps(json)
+        end
+      end
+
+      def format_dependencies(deps)
+        return [] if deps.nil?
+        linked_deps = deps.select { |_, v| v.start_with? "link:" }
+        linked_deps.map do |_, v|
+          relational_path = v.split("link:")[1]
+          dep_name = relational_path.split("/")[-1]
+          { name: dep_name, path: relational_path }
+        end
+      end
+
+      def node?
+        @node ||= File.exist?(package_json_path)
+      end
+
+      def package_json_path
+        File.join(@root_path, "package.json")
+      end
+
+      def combined_deps(json)
+        worskpace_dependencies = build_workspaces(json["workspaces"])
+        dependencies = format_dependencies Hash(json["dependencies"]).merge(Hash(json["devDependencies"]))
+        (dependencies + worskpace_dependencies).uniq
+      end
+
+      def build_workspaces(workspaces)
+        return [] if workspaces.nil?
+        workspaces.map do |workspace|
+          glob = "#{@root_path}/#{workspace}/package.json"
+          workspace_dependencies = Dir.glob(glob)
+          workspace_dependencies.map do |wd|
+            { name: component_name(wd), path: component_path(wd) }
+          end
+        end.flatten
+      end
+
+    private
+
+      def component_name(dir)
+        component_path(dir).split("/")[-1]
+      end
+
+      def component_path(dir)
+        return dir.split("/package.json")[0] if @root_path == "."
+
+        dir.split(@root_path)[-1].split("/package.json")[0]
+      end
+    end
+  end
+end

data/lib/cobra_commander/change.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "cobra_commander/component_tree"
 require "cobra_commander/affected"
 require "open3"
 
@@ -9,12 +8,12 @@ module CobraCommander
   class Change
     InvalidSelectionError = Class.new(StandardError)
 
-    def initialize(path, results, branch)
-      @root_dir = Dir.chdir(path) { `git rev-parse --show-toplevel`.chomp }
+    def initialize(tree, results, branch)
+      @root_dir = Dir.chdir(tree.path) { `git rev-parse --show-toplevel`.chomp }
       @results = results
       @branch = branch
-      @tree = CobraCommander.umbrella_tree(path).to_h
-      @affected = Affected.new(@tree, changes, path)
+      @tree = tree.to_h
+      @affected = Affected.new(@tree, changes, tree.path)
     end
 
     def run!

data/lib/cobra_commander/cli.rb

@@ -1,42 +1,55 @@
 # frozen_string_literal: true
 
 require "thor"
+require "fileutils"
 
 module CobraCommander
   # Implements the tool's CLI
   class CLI < Thor
-    desc "do [command]", "Executes the command in the context of each component in [app]"
+    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 = CobraCommander.umbrella_tree(options.app)
+      tree = maybe_cached_tree(options.app, options.cache)
       executor = Executor.new(tree)
       executor.exec(command)
     end
 
-    desc "ls [app_path]", "Prints tree of components for an app"
+    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(
-        CobraCommander.umbrella_tree(app_path || options.app),
+        tree,
         options.format
       )
     end
 
-    desc "dependents_of [component]", "Outputs count of components in [app] dependent on [component]"
+    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)
-      dependents = CobraCommander.umbrella_tree(options.app).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
     end
 
-    desc "dependencies_of [component]", "Outputs a list of components that [component] depends on within [app] context"
+    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(
-        CobraCommander.umbrella_tree(options.app).subtree(component),
+        tree.subtree(component),
         options.format
       )
     end
@@ -46,17 +59,47 @@ module CobraCommander
       puts CobraCommander::VERSION
     end
 
-    desc "graph APP_PATH [--format=FORMAT]", "Outputs graph"
+    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)
-      Graph.new(app_path, options.format).generate!
+      tree = maybe_cached_tree(app_path, options.cache)
+      Graph.new(tree, options.format).generate!
     end
 
-    desc "changes APP_PATH [--results=RESULTS] [--branch=BRANCH]", "Prints list of changed files"
+    desc "changes APP_PATH [--results=RESULTS] [--branch=BRANCH] [--cache=nil]", "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)
-      Change.new(app_path, options.results, options.branch).run!
+      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}"
+    end
+
+  private
+
+    def maybe_cached_tree(app_path, cache_path)
+      return CobraCommander.umbrella_tree(app_path) unless cache_path
+
+      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
+    end
+
+    def write_tree_cache(tree, cache_path)
+      FileUtils.mkdir_p(File.dirname(cache_path))
+      File.write(cache_path, tree.to_json)
     end
   end
 end

data/lib/cobra_commander/component_tree.rb

@@ -8,13 +8,9 @@ module CobraCommander
   class ComponentTree
     attr_reader :name, :path
 
-    def initialize(name, path, ancestry = Set.new)
+    def initialize(name, path)
       @name = name
       @path = path
-      @ancestry = ancestry
-      @ruby = Ruby.new(path)
-      @js = Js.new(path)
-      @type = type_of_component
     end
 
     def flatten
@@ -39,22 +35,18 @@ module CobraCommander
       [depends, dependents_below].flatten.compact.uniq(&:name)
     end
 
-    def to_h
+    def to_h(json_compatible: false)
       {
         name: @name,
         path: path,
         type: @type,
-        ancestry: @ancestry,
-        dependencies: dependencies.map(&:to_h),
+        ancestry: json_compatible ? @ancestry.to_a : @ancestry,
+        dependencies: dependencies.map { |dep| dep.to_h(json_compatible: json_compatible) },
       }
     end
 
-    def dependencies
-      @deps ||= begin
-        deps = @ruby.dependencies + @js.dependencies
-        deps.sort_by { |dep| dep[:name] }
-            .map(&method(:dep_representation))
-      end
+    def to_json
+      JSON.dump(to_h(json_compatible: true))
     end
 
   private
@@ -73,98 +65,5 @@ module CobraCommander
       end
       nil
     end
-
-    def type_of_component
-      return "Ruby & JS" if @ruby.gem? && @js.node?
-      return "Ruby" if @ruby.gem?
-      return "JS" if @js.node?
-    end
-
-    def dep_representation(dep)
-      full_path = File.expand_path(File.join(path, dep[:path]))
-      ancestry = @ancestry + [{ name: @name, path: path, type: @type }]
-      ComponentTree.new(dep[:name], full_path, ancestry)
-    end
-
-    # Calculates ruby dependencies
-    class Ruby
-      def initialize(root_path)
-        @root_path = root_path
-      end
-
-      def dependencies
-        @deps ||= begin
-          return [] unless gem?
-          gems = bundler_definition.dependencies.select { |dep| path?(dep.source) }
-          format(gems)
-        end
-      end
-
-      def path?(source)
-        return if source.nil?
-        source_has_path = source.respond_to?(:path?) ? source.path? : source.is_a_path?
-        source_has_path && source.path.to_s != "."
-      end
-
-      def format(deps)
-        deps.map do |dep|
-          path = File.join(dep.source.path, dep.name)
-          { name: dep.name, path: path }
-        end
-      end
-
-      def gem?
-        @gem ||= File.exist?(gemfile_path)
-      end
-
-      def bundler_definition
-        ::Bundler::Definition.build(gemfile_path, gemfile_lock_path, nil)
-      end
-
-      def gemfile_path
-        File.join(@root_path, "Gemfile")
-      end
-
-      def gemfile_lock_path
-        File.join(@root_path, "Gemfile.lock")
-      end
-    end
-
-    # Calculates js dependencies
-    class Js
-      def initialize(root_path)
-        @root_path = root_path
-      end
-
-      def dependencies
-        @deps ||= begin
-          return [] unless node?
-          json = JSON.parse(File.read(package_json_path))
-          format combined_deps(json)
-        end
-      end
-
-      def format(deps)
-        return [] if deps.nil?
-        linked_deps = deps.select { |_, v| v.start_with? "link:" }
-        linked_deps.map do |_, v|
-          relational_path = v.split("link:")[1]
-          dep_name = relational_path.split("/")[-1]
-          { name: dep_name, path: relational_path }
-        end
-      end
-
-      def node?
-        @node ||= File.exist?(package_json_path)
-      end
-
-      def package_json_path
-        File.join(@root_path, "package.json")
-      end
-
-      def combined_deps(json)
-        Hash(json["dependencies"]).merge(Hash(json["devDependencies"]))
-      end
-    end
   end
 end

data/lib/cobra_commander/graph.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
 require "graphviz"
-require "cobra_commander/component_tree"
 
 module CobraCommander
   # Generates graphs of components
   class Graph
-    def initialize(app_path, format)
+    def initialize(tree, format)
       @format = format
-      @tree = CobraCommander.umbrella_tree(app_path).to_h
+      @tree = tree.to_h
     end
 
     def generate!

data/lib/cobra_commander/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CobraCommander
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cobra_commander
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Ben Langfeld
@@ -9,28 +9,28 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-16 00:00:00.000000000 Z
+date: 2019-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.18.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.18.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: ruby-graphviz
   requirement: !ruby/object:Gem::Requirement
@@ -173,6 +173,8 @@ files:
 - exe/cobra
 - lib/cobra_commander.rb
 - lib/cobra_commander/affected.rb
+- lib/cobra_commander/cached_component_tree.rb
+- lib/cobra_commander/calculated_component_tree.rb
 - lib/cobra_commander/change.rb
 - lib/cobra_commander/cli.rb
 - lib/cobra_commander/component_tree.rb
@@ -199,8 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Tools for working with Component Based Rails Apps