archsight 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0c195f805808234600e39cd6a3f80cf2ee105c9aaec92d29aca78795f634c4e
-  data.tar.gz: c0ecdcd65b22cd03567fc3e28a03b5b7eb0607114ba5e5950e05b744b3dd7a5f
+  metadata.gz: a648a562357c7e62c60c815f87e7ef83dbae73b545c0ee3f1ef21e983e705728
+  data.tar.gz: b2770c7f3d769a8fc45c9a3d8dfe947454a2054bccf0075206865b1a4b8dbbf5
 SHA512:
-  metadata.gz: 5380e24d80507b0bb223f9351e5e0efc18cd3d9119dd0c34ee810404992da87714e7d444fd7a3d70f8dfa4dada77edb989018d4b21914100fb1782d5df4f8177
-  data.tar.gz: b88868e7b3656eb45920b92a7eed4ea7ae453bacff1b41a659b95bea52210d7c789f05184db51a3de9590b42f4a854b33a64f22f42fce4fc40519a8a18b89e99
+  metadata.gz: 1cb930e83f808190b15c487226b84db7152981497f0a81746ee96bebd3e10c3b717f2be3765f95e0c42f07725d51cdfdb7bfcfda972b0dd0b76d7108dd99d4d9
+  data.tar.gz: a7384b1d52afbe08c5108d0fba87d7c5407eb70c52a7bf6db782ff66036b224637405c49bf105b6afb46f815e5daa3c6cb5a191f69d14834638998a757fa185b

data/lib/archsight/cli.rb

@@ -176,8 +176,14 @@ module Archsight
       require_import_handlers
 
       # Create database that loads from resources directory
-      # Only load Import resources to avoid validation errors on incomplete resources
-      db = Archsight::Database.new(resources_dir, verbose: options[:verbose], only_kinds: %w[Import BusinessActor], verify: false)
+      # Only load the kinds that import handlers inspect at runtime (ApplicationComponent
+      # and ApplicationInterface for GoGrapher/GoDepResolver cross-referencing, BusinessActor
+      # for repository handler owner lookup). Validation is disabled because resources may be
+      # in an incomplete state during an in-progress import run.
+      db = Archsight::Database.new(resources_dir,
+                                   verbose: options[:verbose],
+                                   only_kinds: %w[Import BusinessActor ApplicationComponent ApplicationInterface],
+                                   verify: false)
 
       if options[:dry_run]
         puts "Execution Plan:"

data/lib/archsight/import/handlers/go_dep_resolver.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "../handler"
+require_relative "go_module_parser"
+require_relative "../registry"
+
+# GoDepResolver handler - second-pass resolver that patches dependsOn relations
+# onto ApplicationComponents generated by GoGrapher.
+#
+# Runs after all GoGraphers complete (iteration 2 of the executor loop) so the
+# database contains the full set of freshly-generated ApplicationComponents.
+# Output goes to a single shared generated/relationships.yaml file (all repos
+# combined), loaded after modules.yaml alphabetically so its version of each
+# component — with dependsOn — takes precedence.
+#
+# One Import:GoDepResolver:* resource is emitted by each GoGrapher run; this
+# handler is registered as a child of GoGrapher via the generates relation so
+# the executor knows to wait until GoGrapher has completed.
+#
+# Configuration:
+#   import/config/path - Path to the Go repository root (same as GoGrapher)
+class Archsight::Import::Handlers::GoDepResolver < Archsight::Import::Handler
+  include Archsight::Import::Handlers::GoModuleParser
+
+  def execute
+    @path = config("path")
+    raise "Missing required config: path" unless @path
+    raise "Directory not found: #{@path}" unless File.directory?(@path)
+
+    import_resource.annotations["import/outputPath"] ||= "generated/relationships.yaml"
+
+    modules = discover_modules(@path)
+    return write_yaml(YAML.dump(self_marker)) if modules.empty?
+
+    existing_components = database&.instances_by_kind("ApplicationComponent") || {}
+    output = +""
+
+    modules.each do |rel_dir, mod_name|
+      mod_dir = rel_dir == "." ? @path : File.join(@path, rel_dir)
+      dep_names = compute_deps(mod_dir, mod_name, existing_components)
+      next if dep_names.empty?
+
+      comp_name = component_name(mod_name)
+      existing = existing_components[comp_name]
+      next unless existing
+
+      # Rebuild the full ApplicationComponent merging dependsOn into the existing
+      # spec (which carries realizedThrough, exposes, etc. from GoGrapher).
+      spec = existing.raw.fetch("spec", {}).dup
+      spec["dependsOn"] = { "applicationComponents" => dep_names }
+
+      component = {
+        "apiVersion" => "architecture/v1alpha1",
+        "kind" => "ApplicationComponent",
+        "metadata" => {
+          "name" => comp_name,
+          "annotations" => existing.annotations.merge(
+            "generated/script" => import_resource.name,
+            "generated/at" => Time.now.utc.iso8601
+          )
+        },
+        "spec" => spec
+      }
+      output << YAML.dump(component)
+    end
+
+    write_yaml(output + YAML.dump(self_marker))
+  end
+
+  private
+
+  def compute_deps(mod_dir, mod_name, existing_components)
+    prefix = same_origin_prefix(mod_name)
+    return [] unless prefix
+
+    go_mod_requires(mod_dir)
+      .select { |r| r.start_with?(prefix) && r != mod_name }
+      .filter_map { |r| component_name(r) if existing_components.key?(component_name(r)) }
+      .sort.uniq
+  end
+end
+
+Archsight::Import::Registry.register("go-dep-resolver", Archsight::Import::Handlers::GoDepResolver)

data/lib/archsight/import/handlers/go_grapher.rb

@@ -1,19 +1,33 @@
 # frozen_string_literal: true
 
+require "json"
 require "open3"
-require "find"
 require_relative "grapher"
+require_relative "go_module_parser"
 require_relative "../registry"
 
 # GoGrapher handler - analyses a Go repository and generates a GraphViz DOT
-# graph of its module/package structure, stored as architecture/modules on
+# graph of its module/package structure, stored as architecture/go/modules on
 # the TechnologyArtifact so it can be rendered in the frontend.
 #
+# Also emits one ApplicationComponent per go.mod module, linked to the repo
+# artifact via realizedThrough. If OpenAPI spec files are found in a module
+# directory, the component gains an exposes relation to the matching interface.
+#
+# dependsOn relations between components are resolved in a second pass by the
+# GoDepResolver handler, which runs after all graphers have seeded the database.
+#
 # Configuration:
-#   import/config/path     - Path to the Go repository root (go.mod or go.work)
-#   import/config/ranksep  - Horizontal gap between rank columns (default: 0.6)
-#   import/config/nodesep  - Vertical gap between nodes in a column (default: 0.15)
+#   import/config/path                 - Path to the Go repository root (go.mod or go.work)
+#   import/config/ranksep              - Horizontal gap between rank columns (default: 0.6)
+#   import/config/nodesep              - Vertical gap between nodes in a column (default: 0.15)
+#   import/config/interface_visibility - Visibility prefix for detected interfaces (default: Private)
 class Archsight::Import::Handlers::GoGrapher < Archsight::Import::Handlers::Grapher
+  include Archsight::Import::Handlers::GoModuleParser
+
+  OPENAPI_FILENAMES = %w[openapi.yaml openapi.yml openapi.json swagger.yaml swagger.yml swagger.json].freeze
+  OPENAPI_SUBDIRS   = %w[api docs spec].freeze
+
   def self.language_name = "go"
 
   def self.applicable?(path)
@@ -34,56 +48,44 @@ class Archsight::Import::Handlers::GoGrapher < Archsight::Import::Handlers::Grap
     has_children.include?(dep) && !pkg_set.include?(dep)
   end
 
-  # ── Module discovery ─────────────────────────────────────────────────────
-
-  def discover_modules(repo_root)
-    work_file = File.join(repo_root, "go.work")
-    modules = []
-
-    if File.exist?(work_file)
-      content = File.read(work_file)
-      dirs = if (block_match = content.match(/\buse\s*\((.*?)\)/m))
-               block_match[1].split.map(&:strip).reject(&:empty?)
-             else
-               content.scan(/\buse\s+(\S+)/).flatten
-             end
-      dirs.each do |d|
-        rel = d == "." ? "" : d.delete_prefix("./")
-        abs_dir = rel.empty? ? repo_root : File.join(repo_root, rel)
-        mod_name = read_module_name(abs_dir)
-        modules << [rel.empty? ? "." : rel, mod_name] if mod_name
-      end
-    else
-      mod_name = read_module_name(repo_root)
-      if mod_name
-        modules << [".", mod_name]
-      else
-        # No root go.mod: scan subdirectories for go.mod files (monorepo without go.work)
-        Find.find(repo_root) do |path|
-          bn = File.basename(path)
-          Find.prune if File.directory?(path) && %w[vendor testdata .git node_modules].include?(bn)
-          next unless bn == "go.mod"
-
-          mod_dir = File.dirname(path)
-          rel = mod_dir.delete_prefix("#{repo_root}/")
-          name = read_module_name(mod_dir)
-          modules << [rel, name] if name
-        end
-      end
+  # ── Application resources ─────────────────────────────────────────────────
+
+  def additional_resources(path, modules, artifact_name)
+    visibility = config("interface_visibility", default: "Private")
+    output = +""
+
+    modules.each do |rel_dir, mod_name|
+      mod_dir = rel_dir == "." ? path : File.join(path, rel_dir)
+      specs = detect_openapi_specs(mod_dir)
+      existing_interfaces = database&.instances_by_kind("ApplicationInterface") || {}
+      interface_names = specs.filter_map { |s| interface_name_from_spec(s, visibility: visibility) }
+                             .select { |n| existing_interfaces.key?(n) }
+
+      comp_spec = { "realizedThrough" => { "technologyArtifacts" => [artifact_name] } }
+      comp_spec["exposes"] = { "applicationInterfaces" => interface_names } if interface_names.any?
+
+      # Build directly without resource_yaml so the component is not tracked in
+      # the generates spec — ApplicationComponents are seed resources the user
+      # is expected to keep and refine, not auto-regenerated on each run.
+      component = untracked_resource_yaml(
+        kind: "ApplicationComponent",
+        name: component_name(mod_name),
+        spec: comp_spec
+      )
+      output << YAML.dump(component)
     end
 
-    modules
-  end
-
-  def read_module_name(mod_dir)
-    gomod = File.join(mod_dir, "go.mod")
-    return nil unless File.exist?(gomod)
-
-    File.foreach(gomod) do |line|
-      m = line.match(/^\s*module\s+(\S+)/)
-      return m[1] if m
-    end
-    nil
+    # Emit a GoDepResolver import so dependsOn relations can be resolved in a
+    # second pass, after all graphers have run and the database has been reloaded
+    # with the full set of ApplicationComponents.
+    resolver_name = "Import:GoDepResolver:#{artifact_name.delete_prefix("Repo:")}"
+    output << YAML.dump(import_yaml(
+                          name: resolver_name,
+                          handler: "go-dep-resolver",
+                          config: { "path" => path }
+                        ))
+
+    output
   end
 
   # ── Package collection ────────────────────────────────────────────────────
@@ -93,7 +95,7 @@ class Archsight::Import::Handlers::GoGrapher < Archsight::Import::Handlers::Grap
     mod_names = modules.map { |_, mod_name| mod_name }
     all_pkgs = {}
 
-    modules.each_key do |rel_dir|
+    modules.map(&:first).each do |rel_dir|
       mod_dir = rel_dir == "." ? repo_root : File.join(repo_root, rel_dir)
       cmd = ["go", "list", "-e", "-f", "{{.ImportPath}}|||{{join .Imports \" \"}}", "./..."]
       cmd.insert(2, "-mod=vendor") if File.directory?(File.join(mod_dir, "vendor"))
@@ -122,6 +124,54 @@ class Archsight::Import::Handlers::GoGrapher < Archsight::Import::Handlers::Grap
 
     all_pkgs
   end
+
+  # ── OpenAPI detection ─────────────────────────────────────────────────────
+
+  def untracked_resource_yaml(kind:, name:, spec: {})
+    {
+      "apiVersion" => "architecture/v1alpha1",
+      "kind" => kind,
+      "metadata" => {
+        "name" => name,
+        "annotations" => {
+          "generated/script" => import_resource.name,
+          "generated/at" => Time.now.utc.iso8601
+        }
+      },
+      "spec" => spec
+    }
+  end
+
+  def detect_openapi_specs(mod_dir)
+    candidates = OPENAPI_FILENAMES.map { |f| File.join(mod_dir, f) }
+    OPENAPI_SUBDIRS.each do |sub|
+      OPENAPI_FILENAMES.each { |f| candidates << File.join(mod_dir, sub, f) }
+    end
+
+    candidates.filter_map do |path|
+      next unless File.file?(path)
+
+      begin
+        content = File.read(path)
+        doc = path.end_with?(".json") ? JSON.parse(content) : YAML.safe_load(content)
+        doc.is_a?(Hash) ? doc : nil
+      rescue StandardError
+        nil
+      end
+    end
+  end
+
+  def interface_name_from_spec(spec, visibility: "Private")
+    info = spec["info"] || {}
+    title = (info["title"] || "").strip
+    return nil if title.empty?
+
+    version = (info["version"] || "1.0").to_s
+    api_name = title.split(/[\s\-_]/).map(&:capitalize).join
+    version_str = version.split(".").first.to_s.sub(/^v/i, "")
+    vis = visibility.split("-").map(&:capitalize).join
+    "#{vis}:#{api_name}:v#{version_str}:RestAPI"
+  end
 end
 
 Archsight::Import::Registry.register("go-grapher", Archsight::Import::Handlers::GoGrapher)

data/lib/archsight/import/handlers/go_module_parser.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "find"
+
+# Shared Go module parsing utilities included by GoGrapher and GoDepResolver.
+#
+# Provides go.mod discovery, module name reading, require parsing, and the
+# component_name convention (strip SCM host, join path segments with ":").
+module Archsight::Import::Handlers::GoModuleParser
+  # Discover all Go modules in a repository root.
+  # Handles go.work workspaces, single-module repos, and multi-module monorepos
+  # (root go.mod plus subdirectory go.mod files without go.work).
+  #
+  # @param repo_root [String] Absolute path to the repository root
+  # @return [Array<Array<String>>] List of [rel_dir, mod_name] pairs
+  def discover_modules(repo_root)
+    work_file = File.join(repo_root, "go.work")
+    modules = []
+
+    if File.exist?(work_file)
+      content = File.read(work_file)
+      dirs = if (block_match = content.match(/\buse\s*\((.*?)\)/m))
+               block_match[1].split.map(&:strip).reject(&:empty?)
+             else
+               content.scan(/\buse\s+(\S+)/).flatten
+             end
+      dirs.each do |d|
+        rel = d == "." ? "" : d.delete_prefix("./")
+        abs_dir = rel.empty? ? repo_root : File.join(repo_root, rel)
+        mod_name = read_module_name(abs_dir)
+        modules << [rel.empty? ? "." : rel, mod_name] if mod_name
+      end
+    else
+      root_mod = read_module_name(repo_root)
+      modules << [".", root_mod] if root_mod
+
+      # Also scan subdirectories for additional go.mod files (multi-module monorepo without go.work)
+      Find.find(repo_root) do |path|
+        bn = File.basename(path)
+        Find.prune if File.directory?(path) && %w[vendor testdata .git node_modules].include?(bn)
+        next unless bn == "go.mod"
+
+        mod_dir = File.dirname(path)
+        next if mod_dir == repo_root # already added above
+
+        rel = mod_dir.delete_prefix("#{repo_root}/")
+        name = read_module_name(mod_dir)
+        modules << [rel, name] if name
+      end
+    end
+
+    modules
+  end
+
+  # Read the module name declared in go.mod.
+  # @return [String, nil] Module path or nil if go.mod absent / no module line
+  def read_module_name(mod_dir)
+    gomod = File.join(mod_dir, "go.mod")
+    return nil unless File.exist?(gomod)
+
+    File.foreach(gomod) do |line|
+      m = line.match(/^\s*module\s+(\S+)/)
+      return m[1] if m
+    end
+    nil
+  end
+
+  # Parse require directives from go.mod, handling both block and single-line forms.
+  # @return [Array<String>] Unique module paths listed in require directives
+  def go_mod_requires(mod_dir)
+    gomod = File.join(mod_dir, "go.mod")
+    return [] unless File.exist?(gomod)
+
+    content = File.read(gomod)
+    paths = []
+
+    # Block form: require ( ... )
+    content.scan(/\brequire\s*\(([^)]*)\)/m) do |block|
+      block[0].each_line do |line|
+        stripped = line.strip.split("//").first&.strip
+        mod_path = stripped&.split&.first
+        paths << mod_path if mod_path && !mod_path.empty?
+      end
+    end
+
+    # Single-line form: require module/path vX.Y.Z (strip block forms first to avoid double-counting)
+    content.gsub(/\brequire\s*\([^)]*\)/m, "").scan(/^\s*require\s+(\S+)/) do |m|
+      paths << m[0]
+    end
+
+    paths.uniq
+  end
+
+  # Return the SCM host+org prefix shared by modules in the same org, e.g. "github.com/ionos-cloud/".
+  # @return [String, nil] Prefix with trailing slash, or nil for single-segment names
+  def same_origin_prefix(mod_name)
+    parts = mod_name.split("/")
+    return nil if parts.length < 2
+
+    "#{parts[0, 2].join("/")}/"
+  end
+
+  # Convert a Go module path to an ApplicationComponent name.
+  # Strips the SCM host segment and joins remaining path segments with ":".
+  # "github.com/ionos-cloud/event-gateway/pkg" → "ionos-cloud:event-gateway:pkg"
+  def component_name(mod_name)
+    parts = mod_name.split("/")
+    parts.shift
+    parts.join(":")
+  end
+end

data/lib/archsight/import/handlers/grapher.rb

@@ -53,6 +53,11 @@ class Archsight::Import::Handlers::Grapher < Archsight::Import::Handler
     raise "Missing required config: path" unless @path
     raise "Directory not found: #{@path}" unless File.directory?(@path)
 
+    # Consolidate all grapher output into a single shared file unless an
+    # explicit output path is already set (e.g. via grapherOutputPath on the
+    # parent Repository import).
+    import_resource.annotations["import/outputPath"] ||= "generated/modules.yaml"
+
     @ranksep = config("ranksep", default: "0.6").to_f
     @nodesep = config("nodesep", default: "0.15").to_f
 
@@ -71,14 +76,16 @@ class Archsight::Import::Handlers::Grapher < Archsight::Import::Handler
                            ranksep: @ranksep, nodesep: @nodesep)
 
     progress.update("Generating resource")
+    repo_name = artifact_name(@path)
     resource = resource_yaml(
       kind: "TechnologyArtifact",
-      name: artifact_name(@path),
+      name: repo_name,
       annotations: { annotation_key => dot_content },
       spec: {}
     )
 
-    write_yaml(YAML.dump(resource) + YAML.dump(self_marker))
+    extra = additional_resources(@path, modules, repo_name)
+    write_yaml(YAML.dump(resource) + extra + YAML.dump(self_marker))
     write_generates_meta
   end
 
@@ -535,6 +542,12 @@ class Archsight::Import::Handlers::Grapher < Archsight::Import::Handler
     has_children.include?(dep)
   end
 
+  # Hook: subclasses may override to emit additional YAML resources (as a
+  # concatenated YAML string) alongside the TechnologyArtifact in the output.
+  def additional_resources(_path, _modules, _artifact_name)
+    ""
+  end
+
   # ── Artifact name ─────────────────────────────────────────────────────────
 
   def artifact_name(path)

data/lib/archsight/import/handlers/repository.rb

@@ -115,9 +115,12 @@ class Archsight::Import::Handlers::Repository < Archsight::Import::Handler
     run_git(%w[git fetch --quiet], @path)
     return if empty_repository? # Skip merge for empty repos
 
-    # Check if update is needed
+    # FETCH_HEAD may be absent when git fetch brings nothing new (e.g. no
+    # tracking refs configured, or the remote has no branches). Skip merge.
+    fetch_head = resolve_ref("FETCH_HEAD")
+    return unless fetch_head
+
     current_head = run_git(%w[git rev-parse HEAD], @path).strip
-    fetch_head = run_git(%w[git rev-parse FETCH_HEAD], @path).strip
     return if current_head == fetch_head # Already up-to-date
 
     run_git(%w[git merge --ff-only FETCH_HEAD], @path)
@@ -133,6 +136,11 @@ class Archsight::Import::Handlers::Repository < Archsight::Import::Handler
     !status.success?
   end
 
+  def resolve_ref(ref)
+    out, _, status = Open3.capture3("git", "rev-parse", ref, chdir: @path)
+    status.success? ? out.strip : nil
+  end
+
   # Run a git command safely using array form to prevent shell injection
   # @param command [Array<String>] Command and arguments as array
   # @param dir [String] Working directory

data/lib/archsight/import/handlers/rest_api.rb

@@ -44,6 +44,12 @@ class Archsight::Import::Handlers::RestApi < Archsight::Import::Handler
     progress.update("Downloading OpenAPI spec for #{@name}")
     openapi_doc = fetch_openapi_spec(@spec_url)
 
+    if openapi_doc.nil?
+      progress.warn("Spec not found (404) for #{@name} at #{@spec_url} — skipping")
+      write_yaml(YAML.dump(self_marker))
+      return
+    end
+
     # Parse schemas and generate DataObjects first (needed for interface relations)
     progress.update("Extracting DataObjects from #{@name} schemas")
     parser = Archsight::Import::Handlers::OpenAPISchemaParser.new(openapi_doc)
@@ -141,8 +147,9 @@ class Archsight::Import::Handlers::RestApi < Archsight::Import::Handler
     when Net::HTTPSuccess
       parse_spec_content(response.body)
     when Net::HTTPRedirection
-      # Follow redirect
       fetch_openapi_spec(response["location"])
+    when Net::HTTPNotFound
+      nil
     else
       raise "Failed to fetch OpenAPI spec from #{uri}: #{response.code} #{response.message}"
     end

data/lib/archsight/resources/application_component.rb

@@ -343,4 +343,5 @@ class Archsight::Resources::ApplicationComponent < Archsight::Resources::Base
   relation :servedBy, :technologyComponents, :TechnologySystemSoftware
   relation :exposes, :applicationInterfaces, :ApplicationInterface
   relation :dependsOn, :applicationInterfaces, :ApplicationInterface
+  relation :dependsOn, :applicationComponents, :ApplicationComponent
 end

data/lib/archsight/resources/import.rb

@@ -42,7 +42,10 @@ class Archsight::Resources::Import < Archsight::Resources::Base
                gitlab github repository
                rest-api rest-api-index
                jira-discover jira-metrics
-               go-grapher
+               go-grapher go-dep-resolver
+               cpp-grapher ruby-grapher python-grapher
+               java-grapher javascript-grapher
+               rust-grapher crystal-grapher elixir-grapher
              ]
 
   # Output configuration

data/lib/archsight/resources/technology_artifact.rb

@@ -229,7 +229,8 @@ class Archsight::Resources::TechnologyArtifact < Archsight::Resources::Base
     "go" => "Go", "python" => "Python", "java" => "Java",
     "typescript" => "TypeScript", "javascript" => "JavaScript",
     "rust" => "Rust", "ruby" => "Ruby", "crystal" => "Crystal",
-    "csharp" => "C#", "zig" => "Zig", "elixir" => "Elixir"
+    "csharp" => "C#", "zig" => "Zig", "elixir" => "Elixir",
+    "cpp" => "C++"
   }.each do |lang, label|
     annotation "architecture/#{lang}/modules",
                description: "GraphViz DOT — #{label} module/package structure",

data/lib/archsight/version.rb

@@ -4,5 +4,5 @@
 # Do not edit manually.
 
 module Archsight
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: archsight
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Vincent Landgraf
@@ -269,7 +269,9 @@ files:
 - lib/archsight/import/handlers/elixir_grapher.rb
 - lib/archsight/import/handlers/github.rb
 - lib/archsight/import/handlers/gitlab.rb
+- lib/archsight/import/handlers/go_dep_resolver.rb
 - lib/archsight/import/handlers/go_grapher.rb
+- lib/archsight/import/handlers/go_module_parser.rb
 - lib/archsight/import/handlers/grapher.rb
 - lib/archsight/import/handlers/java_grapher.rb
 - lib/archsight/import/handlers/javascript_grapher.rb