cobra_commander 0.6.0 → 0.9.0

data/lib/cobra_commander/cached_component_tree.rb

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

@@ -1,146 +0,0 @@
-# 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/component_tree.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler"
-require "json"
-
-module CobraCommander
-  # Represents a dependency tree in a given context
-  class ComponentTree
-    attr_reader :name, :path
-
-    def initialize(name, path)
-      @name = name
-      @path = path
-    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(json_compatible: false)
-      {
-        name: @name,
-        path: path,
-        type: @type,
-        ancestry: json_compatible ? @ancestry.to_a : @ancestry,
-        dependencies: dependencies.map { |dep| dep.to_h(json_compatible: json_compatible) },
-      }
-    end
-
-    def to_json
-      JSON.dump(to_h(json_compatible: true))
-    end
-
-  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|
-        presence = _subtree(name, component)
-        return presence if presence
-      end
-      nil
-    end
-  end
-end

data/lib/cobra_commander/graph.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "graphviz"
-
-module CobraCommander
-  # Generates graphs of components
-  class Graph
-    def initialize(tree, format)
-      @format = format
-      @tree = tree.to_h
-    end
-
-    def generate!
-      return unless valid_format?
-
-      g = GraphViz.new(:G, type: :digraph, concentrate: true)
-
-      app_node = g.add_nodes(@tree[:name])
-      map_nodes(g, app_node, @tree)
-      output(g)
-    end
-
-  private
-
-    def map_nodes(g, parent_node, tree)
-      tree[:dependencies].each do |dep|
-        node = g.find_node(dep[:name]) || g.add_nodes(dep[:name])
-        g.add_edges(parent_node, node)
-        map_nodes(g, node, dep)
-      end
-    end
-
-    def output(g)
-      graph = "graph.#{@format}"
-      g.output(@format => graph)
-      puts "Graph generated at #{`pwd`.chomp}/#{graph}"
-    end
-
-    def valid_format?
-      return true if @format == "png" || @format == "dot"
-      puts "FORMAT must be 'png' or 'dot'"
-      false
-    end
-  end
-end