cobra_commander 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb2f9f51193bd4ec022e4f12eae0b43f02d0f4f7adac086ac8c38f2bd7f3bf56
-  data.tar.gz: bb44e1c12845cab98efdcb8cf1da499f67fa335bd781bf14f4c07d11ed3c9eb5
+  metadata.gz: 0a05f3e1ab4ccff9ca040dcf4d694aebc28df0f50160067cf73eaea89f4bad59
+  data.tar.gz: d0132e226b7527e72ebb84e3844116dd3a0c2ed8ecc1394d9df5f7fad5f777d8
 SHA512:
-  metadata.gz: fd838a67943d9e2ae8cc7038b81ccacaaea719f8cc08cea7704df5147ffc1609ef2a91622549d423954003465d1ec310b0d09bf10ec8f3cf915850e0dbdbe39c
-  data.tar.gz: a4dec3544d6a5fbcd258b759b9ba143955acf054b4ff44af1fb25d0f3391f37741e9c2d9e31221fd192ec08c843f39b62833a6741de6313e17453e37ca82722b
+  metadata.gz: 1cb90f61448f1bc69088418fc86dafbc25fce09d069507e22fc22f0a2d9a63eccf95ce3edeb13b6ee2657e19303489c2b59087944ddc07597c7d0e201c36a307
+  data.tar.gz: '023961e1f0abe297e0d0cacc169b3da23fac68f833627d01d480f06d0822019877cd1ac78bb20bf7f951b2bbdce04a0c0ddbb7b3b444a90669f18c967a43775c'

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## Version 0.5.0 - 2018-09-20
+
+* Renames `dependencies_of` to `dependents_of`. PR [#25](https://github.com/powerhome/cobra_commander/pull/25)
+* Add `dependencies_of` command list the direct and indirect dependencies of one component. PR [#25](https://github.com/powerhome/cobra_commander/pull/25)
+* Add `do` command allow executing a command in the context of each component. PR [#26](https://github.com/powerhome/cobra_commander/pull/26)
+
 ## Version 0.4.0 - 2018-09-06
 
 * Add `dependencies_of` command to permit listing or counting the dependencies of a particular component. PR [#24](https://github.com/powerhome/cobra_commander/pull/24)

data/README.md

@@ -28,11 +28,15 @@ 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                                             # Prints tree of components for an app
-  cobra version                                                 # Prints version
+  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
 ```
 
 ## Development

data/lib/cobra_commander.rb

@@ -3,14 +3,19 @@
 require "cobra_commander/cli"
 require "cobra_commander/component_tree"
 require "cobra_commander/version"
-require "cobra_commander/formatted_output"
 require "cobra_commander/graph"
 require "cobra_commander/change"
 require "cobra_commander/affected"
+require "cobra_commander/output"
+require "cobra_commander/executor"
 
 # Tools for working with Component Based Rails Apps (see http://shageman.github.io/cbra.info/).
 # Includes tools for graphing the components of an app and their relationships, as well as selectively
 # testing components based on changes made.
 module CobraCommander
   UMBRELLA_APP_NAME = "App"
+
+  def self.umbrella_tree(path)
+    ComponentTree.new(UMBRELLA_APP_NAME, path)
+  end
 end

data/lib/cobra_commander/change.rb

@@ -13,7 +13,7 @@ module CobraCommander
       @root_dir = Dir.chdir(path) { `git rev-parse --show-toplevel`.chomp }
       @results = results
       @branch = branch
-      @tree = ComponentTree.new(path).to_h
+      @tree = CobraCommander.umbrella_tree(path).to_h
       @affected = Affected.new(@tree, changes, path)
     end
 

data/lib/cobra_commander/cli.rb

@@ -5,16 +5,40 @@ require "thor"
 module CobraCommander
   # Implements the tool's CLI
   class CLI < Thor
-    desc "ls APP_PATH", "Prints tree of components for an app"
-    def ls(app_path)
-      puts FormattedOutput.new(app_path).run!
+    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 "dependencies_of APP_PATH", "Outputs count of components in APP_PATH dependent on COMPONENT"
-    method_option :component, required: true, aliases: "-c", desc: "Name of component. Ex: my_component"
+    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
+      )
+    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 dependencies_of(app_path)
-      puts FormattedOutput.new(app_path).dependencies_of!(@options[:component], @options[:format])
+    def dependents_of(component)
+      dependents = CobraCommander.umbrella_tree(options.app).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"
+    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
+      )
     end
 
     desc "version", "Prints version"
@@ -25,14 +49,14 @@ module CobraCommander
     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!
+      Graph.new(app_path, options.format).generate!
     end
 
     desc "changes APP_PATH [--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!
+      Change.new(app_path, options.results, options.branch).run!
     end
   end
 end

data/lib/cobra_commander/component_tree.rb

@@ -1,139 +1,167 @@
 # frozen_string_literal: true
 
+require "bundler"
 require "json"
 
 module CobraCommander
-  # Representation of the tree of components and their dependencies
+  # Represents a dependency tree in a given context
   class ComponentTree
-    def initialize(path)
-      @root_path = path
+    attr_reader :name, :path
+
+    def initialize(name, path, ancestry = Set.new)
+      @name = name
+      @path = path
+      @ancestry = ancestry
+      @ruby = Ruby.new(path)
+      @js = Js.new(path)
+      @type = type_of_component
+    end
+
+    def flatten
+      _flatten(self)
+    end
+
+    def subtree(name)
+      _subtree(name, self)
+    end
+
+    def depends_on?(component_name)
+      dependencies.any? do |component|
+        component.name == component_name || component.depends_on?(component_name)
+      end
+    end
+
+    def dependents_of(component_name)
+      depends = depends_on?(component_name) ? self : nil
+      dependents_below = dependencies.map do |component|
+        component.dependents_of(component_name)
+      end
+      [depends, dependents_below].flatten.compact.uniq(&:name)
     end
 
     def to_h
-      Tree.new(UMBRELLA_APP_NAME, @root_path).to_h
+      {
+        name: @name,
+        path: path,
+        type: @type,
+        ancestry: @ancestry,
+        dependencies: dependencies.map(&:to_h),
+      }
     end
 
-    # Generates component tree
-    class Tree
-      def initialize(name, path, ancestry = Set.new)
-        @name = name
-        @root_path = path
-        @ancestry = ancestry
-        @ruby = Ruby.new(path)
-        @js = Js.new(path)
-        @type = type_of_component
+    def dependencies
+      @deps ||= begin
+        deps = @ruby.dependencies + @js.dependencies
+        deps.sort_by { |dep| dep[:name] }
+            .map(&method(:dep_representation))
       end
+    end
 
-      def to_h
-        {
-          name: @name,
-          path: @root_path,
-          type: @type,
-          ancestry: @ancestry,
-          dependencies: dependencies.map(&method(:dep_representation)),
-        }
+  private
+
+    def _flatten(component)
+      component.dependencies.map do |dep|
+        [dep] + _flatten(dep)
+      end.flatten.uniq(&:name)
+    end
+
+    def _subtree(name, tree)
+      return tree if tree.name == name
+      tree.dependencies.each do |component|
+        return _subtree(name, component)
       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 type_of_component
-        return "Ruby & JS" if @ruby.gem? && @js.node?
-        return "Ruby" if @ruby.gem?
-        return "JS" if @js.node?
+    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
-          deps = @ruby.dependencies + @js.dependencies
-          deps.sort_by { |dep| dep[:name] }
+          return [] unless gem?
+          gems = bundler_definition.dependencies.select { |dep| path?(dep.source) }
+          format(gems)
         end
       end
 
-      def dep_representation(dep)
-        full_path = File.expand_path(File.join(@root_path, dep[:path]))
-        ancestry = @ancestry + [{ name: @name, path: @root_path, type: @type }]
-        self.class.new(dep[:name], full_path, ancestry).to_h
+      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
 
-      # 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
+      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 gem?
+        @gem ||= File.exist?(gemfile_path)
+      end
 
-        def bundler_definition
-          ::Bundler::Definition.build(gemfile_path, gemfile_lock_path, nil)
-        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_path
+        File.join(@root_path, "Gemfile")
+      end
 
-        def gemfile_lock_path
-          File.join(@root_path, "Gemfile.lock")
-        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
+    # 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
+      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
+      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 node?
+        @node ||= File.exist?(package_json_path)
+      end
 
-        def package_json_path
-          File.join(@root_path, "package.json")
-        end
+      def package_json_path
+        File.join(@root_path, "package.json")
+      end
 
-        def combined_deps(json)
-          Hash(json["dependencies"]).merge(Hash(json["devDependencies"]))
-        end
+      def combined_deps(json)
+        Hash(json["dependencies"]).merge(Hash(json["devDependencies"]))
       end
     end
   end

data/lib/cobra_commander/executor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+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 }
+    end
+  end
+end

data/lib/cobra_commander/graph.rb

@@ -8,7 +8,7 @@ module CobraCommander
   class Graph
     def initialize(app_path, format)
       @format = format
-      @tree = ComponentTree.new(app_path).to_h
+      @tree = CobraCommander.umbrella_tree(app_path).to_h
     end
 
     def generate!

data/lib/cobra_commander/output.rb

@@ -0,0 +1,74 @@
+# 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

data/lib/cobra_commander/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cobra_commander
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Ben Langfeld
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-06 00:00:00.000000000 Z
+date: 2018-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -170,8 +170,9 @@ files:
 - lib/cobra_commander/change.rb
 - lib/cobra_commander/cli.rb
 - lib/cobra_commander/component_tree.rb
-- lib/cobra_commander/formatted_output.rb
+- lib/cobra_commander/executor.rb
 - lib/cobra_commander/graph.rb
+- lib/cobra_commander/output.rb
 - lib/cobra_commander/version.rb
 homepage: http://tech.powerhrg.com/cobra_commander/
 licenses:
@@ -193,7 +194,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Tools for working with Component Based Rails Apps

data/lib/cobra_commander/formatted_output.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require "cobra_commander/component_tree"
-
-module CobraCommander
-  # Formats CLI ls output
-  class FormattedOutput
-    attr_accessor :tree
-
-    SPACE  = "    "
-    BAR    = "│   "
-    TEE    = "├── "
-    CORNER = "└── "
-
-    def initialize(app_path)
-      @tree = ComponentTree.new(app_path).to_h
-    end
-
-    def run!
-      puts @tree[:name]
-      list_dependencies(@tree)
-      nil
-    end
-
-    def dependencies_of!(component_name, format)
-      @component_name = component_name
-
-      results = @tree[:dependencies].map do |component|
-        if @component_name == component[:name]
-          @tree[:name]
-        elsif dependency?(component)
-          component[:name]
-        end
-      end.compact
-
-      "list" == format ? results : results.size
-    end
-
-  private
-
-    def dependency?(deps)
-      deps[:dependencies].each do |dep|
-        return true if @component_name == dep[:name] || dependency?(dep)
-      end
-      false
-    end
-
-    def list_dependencies(deps, outdents = [])
-      deps[:dependencies].each do |dep|
-        decide_on_line(deps, dep, outdents)
-      end
-    end
-
-    def decide_on_line(parent, dep, outdents)
-      if parent[:dependencies].last != dep
-        add_tee(outdents, dep)
-      else
-        add_corner(outdents, dep)
-      end
-    end
-
-    def add_tee(outdents, dep)
-      puts line(outdents, TEE, dep[:name])
-      list_dependencies(dep, (outdents + [BAR]))
-    end
-
-    def add_corner(outdents, dep)
-      puts line(outdents, CORNER, dep[:name])
-      list_dependencies(dep, (outdents + [SPACE]))
-    end
-
-    def line(outdents, sym, name)
-      (outdents + [sym] + [name]).join
-    end
-  end
-end