archimate 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4adaa55a050dfda4d29150a63c15860a21f50932
-  data.tar.gz: 78c4c98ef53b79704018ef5b761377ac01e4497d
+SHA256:
+  metadata.gz: 24983cbe0a25eb6b4fdd4592faf9d424f3f6dab8a0a28495cfa0c79f81bf6f18
+  data.tar.gz: 91796ec52b8680a1449c8a9e424894e786191a82b2e96679ca767dee69ffa04a
 SHA512:
-  metadata.gz: ad77b807f9800be3bd0b4cde9a8dffa00161b94925aa2fdaf7519bfbcd80a71a63acc80ef294647b6d442cbb92b41113c50de10397bd7b9831a52acfb5d35a38
-  data.tar.gz: ef2e775c6067f3a9b097c853083d687af9289ce28f68d7d36a166257e2572af06089bab38513f4c7661cb0d30810bba271f89a4be82b0724beeafa46e225b66a
+  metadata.gz: 6b3d2698127d1aad4f6f729ef1735322658670e8527ab0d7a746ca23c9c7d77669ccb9751d731a4efe431355bf376904237f3a85fd60edf260f252a411a1a6be
+  data.tar.gz: 530ce2ba4cb376a6120fcb2c80c7aab6f2eed57c02a6dff21825de3018079c3714e39fec69728bc6dd38bbc0e8433e87d9c9d9fd458c9a4914738af2ad1cb0c5

data/.travis.yml

@@ -1,4 +1,4 @@
 language: ruby
 rvm:
-  - 2.3.1
+  - 2.4.2
 before_install: gem install bundler -v 1.14.5

data/Gemfile

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in archimate.gemspec

data/README.md

@@ -26,62 +26,17 @@ Or install it yourself as:
 
 The example scripts are (some are planned):
 
-command        | description
-------------- | -----------
-`archimate help [COMMAND]` | Describe available commands or one specific command
+command                       | description
+----------------------------- | -----------
+`archimate clean ARCHIFILE`   | Clean up unreferenced elements and relations
 `archimate convert ARCHIFILE` | Convert the incoming file to the desired type
-`archimate dedupe ARCHIFILE` | de-duplicate elements in Archi file
-`archimate map ARCHIFILE` | *EXPERIMENTAL:* Produce a map of diagram links to a diagram
-`archimate merge ARCHIFILE1 ARCHIFILE2` | *EXPERIMENTAL:*Merge two archimate files
-`archimate project ARCHIFILE PROJECTFILE` | *EXPERIMENTAL:*Synchronize an Archi file and an MSProject XML file
-`archimate svg ARCHIFILE` | Produce semantically meaningful SVG files from an Archi file
-`archimate lint ARCHIFILE` | Produce a report of warnings and issues in the Archi file
-
-### archidiff & archimerge
-
-Archidiff is a set of tools to help with versioning an `.archimate` file from Archi in a version control system (like git). Eventually I want to provide diff and (3-way) merge tools that understand how *Archi* files are structured and avoid problems that happen when multiple people collaborate on a model.
-
-To enable using these from the command line git, add these lines to your `~/.gitconfig` replacing `{PATH_TO_ARCHIDIFF}` with the path to the archidiff binaries.
-
-```
-[difftool "archidiff"]
-    cmd = {PATH_TO_ARCHIDIFF}/archidiff $LOCAL $REMOTE
-
-[difftool "archidiff-summary"]
-    cmd = {PATH_TO_ARCHIDIFF}/archidiff-summary $LOCAL $REMOTE
-
-[mergetool "archimerge"]
-	cmd = {PATH_TO_ARCHIDIFF}/archimerge $PWD/$BASE $PWD/$REMOTE $PWD/$LOCAL $PWD/$MERGED
-	trustExitCode = false
-```
-
-Then to use the tool for diffing you can do this:
-
-```sh
-git difftool --tool archidiff 833cbb7 HEAD  -- path_to/my.archimate
-```
-
-or to see a summary of what changed between versions:
-
-```sh
-git difftool --tool archidiff-summary 833cbb7 HEAD  -- path_to/my.archimate
-```
-
-Finally, if you have a merge conflict, you can use archimerge to help make the merge sane:
-
-```sh
-git mergetool --tool archimerge -- path_to/my.archimate
-```
-
-### fmtxml
-
-Can be used as a `textconv` filter in .gitconfig to pre-format files for better diff use (for visual scanning). You'd set this up in your `$HOME/.gitconfig` file like this.
-
-```
-[diff "archimate"]
-    textconv = fmtxml
-    cachetextconv = true
-```
+`archimate dedupe ARCHIFILE`  | de-duplicate elements in Archi file
+`archimate dupes ARCHIFILE`   | List (potential) duplicate elements in Archi file
+`archimate help [COMMAND]`    | Describe available commands or one specific command
+`archimate lint ARCHIFILE`    | Examine the ArchiMate file for potential problems
+`archimate map ARCHIFILE`     | Produce a map of diagram links to a diagram
+`archimate stats ARCHIFILE`   | Show some statistics about the model
+`archimate svg -o OUTPUTDIR ARCHIFILE o, --output=OUTPUT` | Produce semantically meaningful SVG files from an Archi file
 
 ## Development
 

data/Rakefile

@@ -1,4 +1,5 @@
-# frozen_string_literal: true
+# frozen_string_literal: false
+
 require "bundler/gem_tasks"
 require "rake/testtask"
 require "yard"
@@ -9,6 +10,23 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
+namespace :test do
+  desc "Run only integration tests."
+  Rake::TestTask.new(:integration) do |t|
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList['test/integration/**/*_test.rb']
+  end
+
+  desc "Run tests and report slowest tests."
+  Rake::TestTask.new(:profile) do |t|
+    t.libs << "test"
+    t.libs << "lib"
+    t.options = "--profile"
+    t.test_files = FileList['test/**/*_test.rb']
+  end
+end
+
 YARD::Rake::YardocTask.new do |t|
   t.options += ['--title', "YARD #{YARD::VERSION} Documentation"]
 end

data/archimate.gemspec

@@ -21,32 +21,34 @@ Gem::Specification.new do |spec|
   spec.metadata["yard.run"] = "yri" # use "yard" to build full HTML docs.
   spec.required_ruby_version = '>= 2.3.0'
 
-  spec.add_runtime_dependency "nokogiri", "~> 1.6"
-  spec.add_runtime_dependency "thor", "~> 0.19"
   spec.add_runtime_dependency "highline", "~> 1.7"
-  spec.add_runtime_dependency "ruby-progressbar", "~>1.8.1"
+  spec.add_runtime_dependency "nokogiri", "~> 1.6"
   spec.add_runtime_dependency "parallel", "~> 1.11"
   spec.add_runtime_dependency "ruby-enum", "~> 0.7.1"
+  spec.add_runtime_dependency "ruby-progressbar", "~>1.8.1"
+  spec.add_runtime_dependency "thor", "~> 0.19"
 
+  spec.add_development_dependency "awesome_print"
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency "faker"
+  spec.add_development_dependency "kramdown"
   spec.add_development_dependency "minitest"
-  spec.add_development_dependency "minitest-matchers"
   spec.add_development_dependency "minitest-color"
+  spec.add_development_dependency "minitest-matchers"
   spec.add_development_dependency "minitest-profile"
   spec.add_development_dependency "pry"
-  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "yard"
+
+  # TODO: These should be in an MRI block
   spec.add_development_dependency "guard"
-  spec.add_development_dependency "guard-minitest"
   spec.add_development_dependency "guard-bundler"
+  spec.add_development_dependency "guard-ctags-bundler"
+  spec.add_development_dependency "guard-minitest"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rsense"
   spec.add_development_dependency "ruby-prof"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "simplecov-json"
-  spec.add_development_dependency "kramdown"
-  spec.add_development_dependency "yard"
-  spec.add_development_dependency "guard-ctags-bundler"
-  spec.add_development_dependency "faker"
-  spec.add_development_dependency "rsense"
-  spec.add_development_dependency "awesome_print"
-  spec.add_development_dependency "rubocop"
 end

data/bin/archimate

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
 #
 # This file was generated by Bundler.
 #
@@ -11,6 +12,17 @@ require "pathname"
 ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
   Pathname.new(__FILE__).realpath)
 
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
 require "rubygems"
 require "bundler/setup"
 

data/lib/archimate/cli/archi.rb

@@ -48,7 +48,7 @@ module Archimate
         ).map
       end
 
-      desc "svg -o OUTPUTDIR ARCHIFILE", "IN DEVELOPMENT: Produce semantically meaningful SVG files from an Archi file"
+      desc "svg -o OUTPUTDIR ARCHIFILE", "Produce semantically meaningful SVG files from an Archi file"
       option :output,
              aliases: :o,
              required: true,
@@ -58,39 +58,53 @@ module Archimate
              type: :boolean,
              default: false,
              desc: "Don't provide interactive feedback"
+      option :name,
+             type: :boolean,
+             default: false,
+             desc: "Use diagram name for filename (default: diagram id)"
       def svg(archifile)
         Config.instance.interactive = !options.fetch("noninteractive", false)
         Archimate::Cli::Svger.export_svgs(
           archifile,
-          options.fetch("output", Dir.pwd)
+          options.fetch("output", Dir.pwd),
+          options["name"] ? :name : :id
         )
       end
 
       desc "clean ARCHIFILE", "Clean up unreferenced elements and relations"
       option :output,
              aliases: :o,
-             desc: "Write output to FILE instead of replacing ARCHIFILE"
+             desc: "Write output to OUTPUT instead of replacing ARCHIFILE"
       option :saveremoved,
              aliases: :r,
-             desc: "Write removed elements into FILE"
+             desc: "Write removed elements into SAVEREMOVED"
       option :noninteractive,
              aliases: :n,
              type: :boolean,
              default: false,
              desc: "Don't provide interactive feedback"
+      option :force,
+             aliases: :f,
+             type: :boolean,
+             default: false,
+             desc: "Force overwriting of existing output file"
       def clean(archifile)
         Config.instance.interactive = !options.fetch("noninteractive", false)
-        outfile = options.key?(:output) ? options[:output] : archifile
+        output_io = Cli.output_io(
+          options.fetch("output", archifile),
+          options.fetch("force", false)
+        )
         Archimate::MaybeIO.new(options.fetch(:saveremoved, nil)) do |removed_element_io|
-          Archimate::Cli::Cleanup.new(Archimate.read(archifile), outfile, removed_element_io)
+          Archimate::Cli::Cleanup.new(Archimate.read(archifile), output_io, removed_element_io).clean
         end
+        output_io.close
       end
 
       desc "dupes ARCHIFILE", "List (potential) duplicate elements in Archi file"
       def dupes(archifile)
         Archimate::Cli::Duper.new(
-          archimate.read(archifile),
-          STDOUT
+          Archimate.read(archifile),
+          $stdout
         ).list
       end
 
@@ -115,27 +129,32 @@ module Archimate
              desc: "Don't provide interactive feedback"
       def dedupe(archifile)
         Config.instance.interactive = !options.fetch("noninteractive", false)
+        output_io = Cli.output_io(
+          options.fetch("output", archifile),
+          options[:force]
+        )
         Archimate::Cli::Duper.new(
           Archimate.read(archifile),
-          Cli.output_io(
-            options.fetch("output", archifile),
-            options[:force]
-          ),
+          output_io,
           options[:mergeall]
         ).merge
+        output_io.close
       end
 
       desc "convert ARCHIFILE", "Convert the incoming file to the desired type"
+      long_desc <<~CONVERT_DESC
+        Converts the input ArchiMate file into another format. Options are:
+        \x5  • 'archi'   for Archi file format (http://archimatetool.com),
+        \x5  • 'meff2.1' for Open Group Model Exchange File Format for ArchiMate 2.1,
+        \x5  • 'nquads'  for RDF 1.1 N-Quads format https://www.w3.org/TR/n-quads/,
+        \x5  • 'graphml' for GraphML,
+        \x5  • 'csv'     for CSV files (one file per element/relationship type)
+      CONVERT_DESC
       option :to,
              aliases: :t,
              default: Archimate::Cli::Convert::SUPPORTED_FORMATS.first,
-             desc: "File type to convert to. Options are: " \
-                   "'meff2.1' for Open Group Model Exchange File Format for ArchiMate 2.1 " \
-                   "'archi' for Archi http://archimatetool.com/ file format " \
-                   "'nquads' for RDF 1.1 N-Quads format https://www.w3.org/TR/n-quads/" \
-                   "'graphml' for GraphML" \
-                   "'csv' for CSV files (one file per element/relationship type",
-             enum: Archimate::Cli::Convert::SUPPORTED_FORMATS
+             enum: Archimate::Cli::Convert::SUPPORTED_FORMATS,
+             desc: "Output format to convert to"
       option :output,
              aliases: :o,
              desc: "Write output to FILE instead of stdout."

data/lib/archimate/cli/cleanup.rb

@@ -1,52 +1,68 @@
 # frozen_string_literal: true
+
 require "nokogiri"
 
 #
 # The point of this script is to identify elements that aren't a part of any
 # relationship and not referenced on any diagrams.
-
 module Archimate
   module Cli
     class Cleanup
       attr_reader :model
 
-      def self.cleanup(input, output, options)
-        cleaner = new(Archimate.read(input), output, options)
-        cleaner.clean
-      end
-
-      def initialize(model, output, options)
+      def initialize(model, output, removed_items_io)
         @model = model
         @output = output
-        @options = options
-        @trash = Nokogiri::XML::Document.new("<deleted></deleted>")
+        @removed_items_io = removed_items_io
         @model_set = nil
-        @progressbar = ProgressIndicator.new(total: model.unreferenced_nodes.size, title: "Elements")
+        @progressbar = ProgressIndicator.new(total: unreferenced_nodes.size, title: "Unreferenced Elements and Relationships")
+        @unref_set = []
       end
 
-      def remove_unreferenced_nodes
-        model.unreferenced_nodes.each do |unreferenced_node|
-          raise "This functionality is not implemeted yet"
+      # detects elements not referenced by a relationship or a diagram
+      def unreferenced_elements
+        model
+          .elements
+          .select { |el| el.references.none?(&ref_is_relationship_or_diagram) }
+      end
 
-          # TODO: this needs to be the XML serialization of the node
-          trash.root.add_child unreferenced_node.dup
-          # TODO: implement this
-          # model.delete(unreferenced_node)
-          @progressbar.increment
-        end
+      def unreferenced_relationships
+        model
+          .relationships
+          .select { |rel| rel.references.none?(&ref_is_relationship_or_diagram) }
       end
 
-      def write_trash
-        options[:saveremoved].write(trash)
+      def unreferenced_nodes
+        unreferenced_relationships + unreferenced_elements
+      end
+
+      def destroy_nodes(nodes)
+        nodes.each do |unreferenced_node|
+          unreferenced_node.destroy
+          @removed_items_io.write(Color.uncolor(unreferenced_node.to_s) + "\n")
+          @unref_set << unreferenced_node
+          @progressbar.increment
+        end
       end
 
       def clean
         return unless model
 
-        remove_unreferenced_nodes
-        puts "Found #{unref_set.size} model items unreferenced by diagram or relationships"
-        Archimate::ArchiFileWriter.write(model, output)
-        write_trash
+        rels = unreferenced_relationships
+        $stdout.puts "Unreferenced Relationships: #{rels.size}"
+        destroy_nodes rels
+        els = unreferenced_elements
+        $stdout.puts "Unreferenced Elements: #{els.size}"
+        destroy_nodes els
+
+        $stdout.puts "Found #{@unref_set.size} model items unreferenced by diagram or relationships"
+        Archimate::FileFormats::ArchiFileWriter.write(model, @output)
+      end
+
+      private
+
+      def ref_is_relationship_or_diagram
+        ->(ref) { ref.is_a?(DataModel::Relationship) || ref.is_a?(DataModel::Diagram) }
       end
     end
   end

data/lib/archimate/cli/duper.rb

@@ -33,7 +33,6 @@ module Archimate
           handle_duplicate(element_type, name, entities)
         end
 
-        # TODO: make the output writer be an argument
         Archimate::FileFormats::ArchiFileWriter.new(@model).write(@output)
       end
 

data/lib/archimate/cli/mapper.rb

@@ -13,34 +13,57 @@ module Archimate
         @output = output_io
       end
 
+      def map
+        widths = compute_column_widths(process_diagrams(model.diagrams), HEADERS)
+        adjusted_widths = widths.inject(COL_DIVIDER.size * (HEADERS.size - 1), &:+)
+        header_row(widths, HEADERS)
+        organization_paths = build_organization_hash(model.organizations)
+        organization_paths.keys.sort.each do |organization_name|
+          diagrams = organization_paths[organization_name].select { |i| i.is_a?(DataModel::Diagram) }
+          next if diagrams.empty?
+          @output.puts(Color.color(format("%-#{adjusted_widths}s", organization_name), %i[bold green on_light_black]))
+          output_diagrams(process_diagrams(diagrams), widths)
+        end
+
+        @output.puts "\n#{model.diagrams.size} Diagrams"
+      end
+
+      private
+
       def header_row(widths, headers)
-        titles = []
-        widths.each_with_index { |w, i| titles << format("%-#{w}s", headers[i]) }
-        @output.puts titles.map { |t| Color.color(t.capitalize, %i[bold blue]) }.join(Color.color(COL_DIVIDER, :light_black))
-        @output.puts Color.color(widths.map { |w| "-" * w }.join("-+-"), :light_black)
+        titles = widths
+                 .zip(headers)
+                 .map(&header_cell_format)
+                 .join(col_divider)
+        @output.puts titles
+        @output.puts header_border(widths)
+      end
+
+      def col_divider
+        Color.color(COL_DIVIDER, :light_black)
+      end
+
+      def header_border(widths)
+        Color.color(widths.map { |w| "-" * w }.join("-+-"), :light_black)
+      end
+
+      def header_cell_format
+        ->((width, header)) { Color.color(format("%-#{width}s", header).capitalize, %i[bold blue]) }
       end
 
       def process_diagrams(diagrams)
-        diagrams.map { |e| [e.id, e.name, e.viewpoint, e.type] }.map do |row|
-          row[2] = case row[3]
-                   when "canvas:CanvasModel"
-                     ["Canvas", row[4]].compact.join(": ")
-                   when "archimate:SketchModel"
-                     "Sketch"
-                   when "archimate:ArchimateDiagramModel"
-                     DataModel::ViewpointType.values[(row[2] || 0).to_i].to_s
-                   else
-                     row[3]
-                   end
-          row[0] = Color.color("#{row[0]}.png", :underline)
-          row
+        diagrams.map do |diagram|
+          [
+            "#{diagram.id}.png",
+            diagram.name.to_s,
+            diagram.viewpoint_description
+          ]
         end
       end
 
       def compute_column_widths(diagrams, headers)
-        initial_widths = headers.map(&:size)
-        diagrams.each_with_object(initial_widths) do |diagram, memo|
-          diagram.slice(0, headers.size).each_with_index do |o, i|
+        diagrams.each_with_object(headers.map(&:size)) do |diagram, memo|
+          diagram.each_with_index do |o, i|
             memo[i] = !o.nil? && Color.uncolor(o).size > memo[i] ? Color.uncolor(o).size : memo[i]
           end
           memo
@@ -49,33 +72,23 @@ module Archimate
 
       def output_diagrams(diagrams, widths)
         diagrams.sort_by { |a| a[1] }.each do |m|
-          row = []
-          m.slice(0, widths.size).each_with_index { |c, i| row << format("%-#{widths[i]}s", c) }
-          @output.puts row.join(Color.color(COL_DIVIDER, :light_black))
+          @output.puts(
+            widths
+              .zip(m)
+              .map { |(width, col)| format("%-#{width}s", col) }
+              .join(Color.color(COL_DIVIDER, :light_black))
+          )
         end
       end
 
       def build_organization_hash(organizations, parent = "", hash = {})
-        organizations.each_with_object(hash) do |i, a|
+        organization_paths = organizations.each_with_object(hash) do |i, a|
           organization_path = [parent, i.name].join("/")
-          a[organization_path] = i
+          a[organization_path] = i.items
           build_organization_hash(i.organizations, organization_path, a)
         end
-      end
-
-      def map
-        widths = compute_column_widths(process_diagrams(model.diagrams), HEADERS)
-        adjusted_widths = widths.inject(COL_DIVIDER.size * (HEADERS.size - 1), &:+)
-        header_row(widths, HEADERS)
-        organization_paths = build_organization_hash(model.organizations)
-        organization_paths.keys.sort.each do |organization_name|
-          diagrams = organization_paths[organization_name].items.map { |i| model.lookup(i) }.select { |i| i.is_a?(DataModel::Diagram) }
-          next if diagrams.empty?
-          @output.puts(Color.color(format("%-#{adjusted_widths}s", organization_name), %i[bold green on_light_black]))
-          output_diagrams(process_diagrams(diagrams), widths)
-        end
-
-        @output.puts "\n#{model.diagrams.size} Diagrams"
+        organization_paths = { "/" => model.diagrams } if organization_paths.empty?
+        organization_paths
       end
     end
   end

data/lib/archimate/cli/svger.rb

@@ -2,21 +2,26 @@
 
 module Archimate
   module Cli
+    SVG_NAME_OPTION = [:id, :name] # TODO: add a way to export in folders with :folder_name]
+
     # This class is used to export SVG diagrams as defined in the given model
     class Svger
-      def self.export_svgs(archi_file, output_dir)
-        new(Archimate.read(archi_file).diagrams, output_dir).export_svgs
+      def self.export_svgs(archi_file, output_dir, name_option = :id)
+        new(Archimate.read(archi_file).diagrams, output_dir, name_option).export_svgs
       end
 
-      def initialize(diagrams, output_dir)
+      def initialize(diagrams, output_dir, name_option = :id)
         @diagrams = diagrams
         @output_dir = output_dir
+        @name_option = name_option
+        @diagram_base_names = {}
       end
 
       def export_svgs
+        @diagram_base_names = {}
         progress = ProgressIndicator.new(total: @diagrams.size, title: "Writing SVGs")
         @diagrams.each do |diagram|
-          export(diagram)
+          export(diagram, filename_for(diagram, @name_option))
           progress.increment
         end
       ensure
@@ -29,6 +34,30 @@ module Archimate
           svg_file.write(Svg::Diagram.new(diagram).to_svg)
         end
       end
+
+      # TODO: in case of duplicate name in a model, we need to extend the filename with a numeric or something.
+      def filename_for(diagram, name_option)
+        base_name = diagram_base_name(diagram, name_option)
+        if @diagram_base_names.include?(base_name)
+          idx = 2
+          while @diagram_base_names.include?(base_name + " - #{idx}") do
+            idx += 1
+          end
+          base_name = base_name + " - #{idx}"
+        end
+        base_name
+      end
+
+      def diagram_base_name(diagram, name_option)
+        case name_option
+        when :name
+          diagram.name
+        # when :folder_name
+        #   diagram.name # TODO: add the path
+        else
+          diagram.id
+        end
+      end
     end
 
     def self.process_svg_filename(name)

data/lib/archimate/core_refinements.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Archimate
+  module CoreRefinements
+    refine String do
+      # Converts a mixed case string to a snake case string
+      # @return String
+      def snake_case
+        gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, "")
+      end
+
+      def to_method_name(suffix = nil)
+        [tr(' ', '_'), suffix]
+          .compact
+          .join("_")
+          .to_sym
+      end
+
+      # A helper that makes it easier to compare a string to a DataModel::LangString
+      # @param [String, DataModel::LangString] other string to compare
+      # @returns [Boolean]
+      def ==(other)
+        super(other.to_s)
+      end
+    end
+
+    refine Range do
+      # Returns midpoint of overlap between numeric ranges or nil if there
+      # is no overlap
+      # @param r [Range] a numeric range
+      # @return [Numeric] if the ranges overlap, the midpoint of the overlap
+      # @return [Nil] if the ranges do not overlap
+      def overlap_midpoint(r)
+        begin_max = [self, r].map(&:begin).max
+        end_min = [self, r].map(&:end).min
+        return nil if begin_max > end_min
+        (begin_max + end_min) / 2.0
+      end
+    end
+  end
+end