featuremap 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86efa555940a3ecfa35430fd247a007583a72a05
-  data.tar.gz: c7eb0547652f637f9b6f8c4b305693d00c003c55
+  metadata.gz: 3e9b97e4894658a5d3d8f8dea733013c28c2a74e
+  data.tar.gz: 453f5df89b88b09fd3b6e67f50781a6044f12210
 SHA512:
-  metadata.gz: 66e19dfa9829ed6b5ff48a115f7f95ba31719acda098cc2ab7257c6cd83f2ca2dd87bd16287cfe5000237e1bc378a3ed9ce53c95a7b4f41847afff449f542295
-  data.tar.gz: d1dacaec2c48e46af63d0f138f1a6eb7a321f2e1cfc7f814b7913b667784fcbbd2cdda31738f606a43fe25a22225ea60727120d757a3331faae6802b5a59d84a
+  metadata.gz: c4b2b50674749818acee3d3f6ad6d3774f9afd6872ca005584a67f2941a030d8631c08c19c4d9a78cfadd53890fb06be525541b72de996cac30c265ca8cc643c
+  data.tar.gz: 14436d3a64bbf81b951c374fb9baf82b88282f6b2c04ad17747f05be34e53b3f4c3a8a2f21bc07724548d2eb4f475f0043f9cebc55a21b4e5e91d5ceb9a4689f

data/bin/featuremap

@@ -28,8 +28,9 @@ else
   else
     output_file = "STDOUT"
   end
-  featuremap = Featuremap.new(feature_dir,options[:verbose])
-  featuremap.create_featuremap(output_file)
-  puts featuremap.err_msg.join("\n")
+  featuremap = Featuremap.new(feature_dir, output_file, options[:verbose])
+  if featuremap.exit_status == 0
+    featuremap.create_featuremap()
+  end
   exit featuremap.exit_status
 end

data/features/give_feedback.feature

@@ -0,0 +1,75 @@
+
+Ability: give feedback
+  To run featuremap the user have to provide certain parameters (e.g. the location
+    of the Gherkn feature files). If those parameters are missing or faulty,
+    featuremap will provide helpful feedback.
+
+  # rule: show an error message if the feature dir is not accessible
+
+  Scenario: feature dir does not exist
+    Given "invalid-path" as a non existing location for the feature dir
+     When the user runs featuremap
+     Then featuremap exits with 66
+      And featuremap shows the message "can't find >>invalid-path<< as feature dir"
+
+  Scenario: access rights are not sufficient to read the feature dir
+    Given a feature dir "secret_features"
+      And the user rights for the feature dir don't allow access
+     When the user runs featuremap
+     Then featuremap exits with 66
+      And featuremap shows the message "can't access >>secret_features/<< as feature dir"
+
+
+  # rule: show an error message if the featuremap can't write the mindmap
+
+  Scenario: mindmap name contains an non-existing path
+    Given a feature dir "features"
+      And "invalid-path/featuremap.mm" as a non existing location for the mindmap
+     When the user runs featuremap
+     Then featuremap exits with 74
+      And featuremap shows the message "can't write to invalid-path/featuremap.mm"
+
+  Scenario: access rights are not sufficient for the mindmap
+    Given a feature dir "features"
+      And "readonly-path/" as a read-only location for the mindmap
+      And the user rights for the mindmaps don't have access for writing
+     When the user runs featuremap
+     Then featuremap exits with 74
+      And featuremap shows the message "can't write to readonly-path/featuremap.mm"
+
+
+  # rule: add a number to the mindmaps name if the file already exists
+
+  Scenario: a file with the same name as the mindmap already exists
+    Given a mindmap file "featuremap.mm" already exists
+      And a feature dir "existing_name_features"
+      And it contains a feature
+      And "featuremap.mm" is used as an argument for the featuremap script
+     When the user runs featuremap
+     Then featuremap shows the message "given mindmap name is already in use, created featuremap-1.mm"
+      And a new mindmap with name "featuremap-1.mm" was created
+
+  Scenario: multiple files with the same name as the mindmap already exists
+    Given 6 multiple mindmap file with the name "featuremap" distinguished only by number exist
+      And a feature dir "existing_name_features"
+      And it contains a feature
+      And "featuremap.mm" is used as an argument for the featuremap script
+     When the user runs featuremap
+     Then featuremap shows the message "given mindmap name is already in use, created featuremap-6.mm"
+      And a new mindmap with name "featuremap-6.mm" was created
+
+
+  # rule: if the result is written on stdout messages should appear on stderr
+
+  Scenario: user does omit the name for the feature file
+    Given a feature dir "features"
+      And it contains a feature
+      And the argument for the mindmap file name is missing
+     When the user runs featuremap
+     Then the content of the mindmap file is redirected to stdout
+
+  Scenario: user does omit the name for the feature file and the feature dir does not exists
+    Given "invalid-path" as a non existing location for the feature dir
+      And the argument for the mindmap file name is missing
+     When the user runs featuremap
+     Then featuremap shows the message "can't find >>invalid-path<< as feature dir" on stderr

data/features/show features and subdirs/show-features.feature

@@ -0,0 +1,42 @@
+Ability: show features
+  Calling the mapper will result in a new freemind mindmap. The mindmap will
+  show all feature files as separate nodes.
+
+  # rule: every feature file is shown as a node in the mindmap^
+
+  Scenario Outline: show features
+    Given a feature dir is <feature_dir_type>
+      And it contains <nr_of_features>
+     When the mapper is called
+     Then a mindmap file without any validation error is created
+      And the mindmap contains a root node named "featuremap"
+      And the mindmap contains <nr_of_features> nodes
+
+      Examples:
+      |nr_of_features|feature_dir_type|
+      |0             |empty           |
+      |1             |single          |
+      |3             |multiple        |
+
+
+  # rule: other files than .feature files are ignored
+  
+  Scenario: ignore other file types
+    Given a feature dir "mixed_files"
+      And it contains <nr_of_files> files of <file_type>
+            |nr_of_files|file_type|
+            |3          |feature  |
+            |1          |txt      |
+            |1          |csv      |
+     When the mapper is called
+     Then a mindmap file without any validation error is created
+      And the mindmap contains only 3 feature nodes
+
+
+  # rule: feature names are using a bold font
+
+  Scenario: format feature names in bold
+    Given a feature dir containing a feature file
+     When the mapper is called
+     Then a mindmap file without any validation error is created
+      And the feature node in this mindmap is using a bold font

data/features/show features and subdirs/show-scenarios.feature

@@ -0,0 +1,30 @@
+Ability: show scenarios
+  Calling the mapper will result in a new freemind mindmap. The mindmap will
+  show all feature files as separate nodes. Every feature node will contain
+  sub-nodes for all scenarios.
+
+  # rule: if a feature has scenario, scenario name will be shown as subnodes to
+
+  Scenario Outline: show plain scenarios
+    Given a feature dir with a feature containing <nr_of_scenarios> scenarios
+     When the mapper is called
+     Then a mindmap file without any validation error is created
+      And the mindmap contains a feature node
+      And the feature node contains <nr_of_scenarios> scenario subnodes
+
+      Examples:
+      |nr_of_scenarios|
+      |0              |
+      |1              |
+      |3              |
+
+
+  # rule: outline scenarios are marked by an list icon
+  
+  Scenario: show outline scenario
+    Given a feature dir with a feature containing an outline scenario
+     When the mapper is called
+     Then a mindmap file without any validation error is created
+      And the mindmap contains a feature node
+      And the feature node contains a scenario subnode
+      And the scenario subnode is marked with an list icon

data/features/show features and subdirs/show-subdirs.feature

@@ -0,0 +1,58 @@
+
+Ability: show subdirs
+  Calling the mapper will result in a new freemind mindmap. The mindmap will
+  show every subdir from the feature dir as a separate node and attach all
+  features from the subdir as children nodes.
+
+  # rule: turn subdirs into mindmap nodes
+  # - show subdirs as mindmap nodes
+  # - add a folder icon to mark them as subdirs
+
+
+  Scenario: feature dir without subdirs
+    Given a feature dir "subdirs_none"
+      And it contains a feature file
+     When the mapper is called
+     Then a mindmap file without any validation error is created
+      And the mindmap contains a node with the feature name
+
+  
+  Scenario: feature dir with one level of subdirs
+    Given a feature dir "subdirs_one_level"
+      And it contains at least one subdir
+      And the subdir contains a feature file
+     When the mapper is called
+     Then a mindmap file without any validation error is created
+      And the mindmap contains a node with the subdir
+      And the subdir node contains a node with the feature
+      And the subdir node is marked by a folder icon
+
+
+  Scenario: feature dir with multiple levels of subdirs
+    Given a feature dir "subdirs_multiple_levels"
+      And the feature dir contains subdirs with a different amount of features
+          |subdirs            |nr_of_features|
+          |sub1/sub1_1        |1             |
+          |sub2               |2             |
+          |sub3/sub3_1/sub3_2 |2             |
+          |sub1/sub1_2        |0             |
+     When the mapper is called
+     Then a mindmap file without any validation error is created
+      And the mindmap shows nodes with a folder icon for every subdir
+      And the node of every subdir contains the corresponding number of feature nodes
+
+
+  # rule: don't show subdirs used for code and configuration
+
+  Scenario: ignore step_definitions and support folders
+    Given a feature dir "subdirs_code_config"
+      And the feature dir contains subdirs with a different amount of features
+          |subdirs            |nr_of_features|
+          |sub1/sub1_1        |1             |
+          |sub2               |2             |
+          |step_definitions   |0             |
+          |support            |0             |
+     When the mapper is called
+     Then a mindmap file without any validation error is created
+      And the minmap does not contain a folder node "step_definitions"
+      And the minmap does not contain a folder node "support"

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,44 @@
+Before do
+  @log = Logger.new(STDOUT)
+  @log.datetime_format = "%H:%M:%S"
+  if ENV['LOG_LEVEL'] == 'debug'
+    @log.level = Logger::DEBUG
+  elsif ENV['LOG_LEVEL'] == 'info'
+    @log.level = Logger::INFO
+  else
+    # default log level
+    @log.level = Logger::ERROR
+  end
+  @featuremap_file = nil
+  delete_path("test_data")
+  @path_to_results = "test_data/out"
+  @path_to_testdata = "test_data/in"
+end
+
+Given("a feature dir {string}") do |feature_dir|
+  @feature_dir = feature_dir
+  create_path("#{@path_to_testdata}/#{@feature_dir}")
+end
+
+When("the mapper is called") do
+  create_path(@path_to_results)
+  @featuremap_file = "#{@path_to_results}/featuremap.mm"
+  @mapper = Featuremap.new("#{@path_to_testdata}/#{@feature_dir}", @featuremap_file)
+  @mapper.create_featuremap()
+end
+
+When("the user runs featuremap") do
+  @log.debug "run script: bin/featuremap #{@path_to_testdata}/#{@feature_dir} #{@featuremap_file}"
+  if @featuremap_file
+    @stdout, @stderr, @exit_status = Open3.capture3("bin/featuremap", "#{@path_to_testdata}/#{@feature_dir}", @featuremap_file)
+  else
+    @stdout, @stderr, @exit_status = Open3.capture3("bin/featuremap", "#{@path_to_testdata}/#{@feature_dir}")
+  end
+end
+
+Then("a mindmap file without any validation error is created") do
+  #validate generated mm file with freemind.xsd
+  #validate_mm returns array containing validation errors
+  expect(validate_mm(@featuremap_file).count).to eq(0)
+  @mindmap = Nokogiri::XML(File.read(@featuremap_file))
+end

data/features/step_definitions/give_feedback_steps.rb

@@ -0,0 +1,69 @@
+Given("{string} as a non existing location for the feature dir") do |feature_dir|
+  @feature_dir = feature_dir
+end
+
+Given("the user rights for the feature dir don't allow access") do
+  FileUtils.chmod("a=xw", "#{@path_to_testdata}/#{@feature_dir}")
+end
+
+Given("{string} as a non existing location for the mindmap") do |mindmap_file|
+  @featuremap_file = mindmap_file
+end
+
+Given("{string} as a read-only location for the mindmap") do |path_to_mindmap|
+  @featuremap_file = "#{path_to_mindmap}featuremap.mm"
+  @path_to_mindmap = path_to_mindmap
+  create_path("#{@path_to_results}/#{@path_to_mindmap}")
+end
+
+Given("the user rights for the mindmaps don't have access for writing") do
+  FileUtils.chmod("a=r", "#{@path_to_results}/#{@path_to_mindmap}")
+end
+
+Given("a mindmap file {string} already exists") do |mindmap_file_name|
+  create_file(@path_to_results, mindmap_file_name, "")
+end
+
+Given("it contains a feature") do
+  create_feature("#{@path_to_testdata}/#{@feature_dir}", "dummy feature.feature")
+end
+
+Given("{string} is used as an argument for the featuremap script") do |mindmap_file_name|
+  @featuremap_file = "#{@path_to_results}/#{mindmap_file_name}"
+end
+
+Given("{int} multiple mindmap file with the name {string} distinguished only by number exist") do |duplicate_count, mindmap_file_name|
+  create_file(@path_to_results, "#{mindmap_file_name}.mm", "")
+  (1..duplicate_count-1).each do |file_nr|
+    create_file(@path_to_results, "#{mindmap_file_name}-#{file_nr}.mm", "")
+  end
+end
+
+Given("the argument for the mindmap file name is missing") do
+  @featuremap_file = nil
+end
+
+Then("featuremap exits with {int}") do |exit_status|
+  expect(@exit_status.exitstatus).to eq(exit_status)
+end
+
+Then("featuremap shows the message {string}") do |err_msg|
+  script_output = @stdout + @stderr
+  script_output = script_output.sub("#{@path_to_testdata}/", "")
+  script_output = script_output.sub("#{@path_to_results}/", "")
+  expect(script_output).to include(err_msg)
+end
+
+Then("a new mindmap with name {string} was created") do |mindmap_file_name|
+  expect(File.exists?("#{@path_to_results}/#{mindmap_file_name}")).to be_truthy
+  expect(validate_mm("#{@path_to_results}/#{mindmap_file_name}").count).to eq(0)
+end
+
+Then("the content of the mindmap file is redirected to stdout") do
+  expect(validate_content(@stdout).count).to eq(0)
+end
+
+Then("featuremap shows the message {string} on stderr") do |warning_msg|
+  @stderr = @stderr.sub("#{@path_to_testdata}/", "")
+  expect(@stderr).to include(warning_msg)
+end

data/features/step_definitions/show_features_steps.rb

@@ -0,0 +1,57 @@
+Given("a feature dir is empty") do
+  @path_to_testdata = "#{@path_to_testdata}/feature_dir_empty"
+  create_path(@path_to_testdata)
+end
+
+Given("a feature dir is single") do
+  @path_to_testdata = "#{@path_to_testdata}/feature_dir_single"
+end
+
+Given("a feature dir is multiple") do
+  @path_to_testdata = "#{@path_to_testdata}/feature_dir_multiple"
+end
+
+Given("a feature dir containing a feature file") do
+  @path_to_testdata = "#{@path_to_testdata}/feature_dir_simple"
+  create_feature(@path_to_testdata, "dummy feature.feature")
+end
+
+Given("it contains {int}") do |int|
+  for file_nr in 1..int
+    create_feature(@path_to_testdata, "dummy feature #{file_nr}.feature")
+  end
+end
+
+Given("it contains <nr_of_files> files of <file_type>") do |table|
+  @featuredir_setup = table.hashes
+  table.hashes.each do |table_row|
+    if table_row["file_type"] == "feature"
+      for file_nr in 1..table_row["nr_of_files"].to_i
+        create_feature("#{@path_to_testdata}/#{@feature_dir}", "dummy feature #{file_nr}.feature")
+      end
+    else
+      for file_nr in 1..table_row["nr_of_files"].to_i
+        create_other_file("#{@path_to_testdata}/#{@feature_dir}", "dummy no_feature #{file_nr}.#{table_row["file_type"]}")
+      end
+    end
+  end
+end
+
+Then("the mindmap contains a root node named {string}") do |string|
+  expect(@mindmap.xpath("/map/node/@TEXT").first.to_s).to match("featuremap")
+
+end
+
+Then("the mindmap contains {int} nodes") do |int|
+  for file_nr in 1..int
+    expect(@mindmap.xpath("/map/node/node").count).to eq(int)
+  end
+end
+
+Then("the mindmap contains only {int} feature nodes") do |int|
+  expect(@mindmap.xpath("//node[starts-with(@ID, 'feature_')]").count).to eq(int)
+end
+
+Then("the feature node in this mindmap is using a bold font") do
+  expect(@mindmap.xpath("//node[starts-with(@ID, 'feature_')]/font[@BOLD = 'true']").count).to eq(1)
+end

data/features/step_definitions/show_scenarios_steps.rb

@@ -0,0 +1,32 @@
+Given("a feature dir with a feature containing {int} scenarios") do |nr_of_scenarios|
+  @path_to_testdata = "#{@path_to_testdata}/scenarios_basic"
+  create_path(@path_to_testdata)
+  scenarios = []
+  for scenario_index in 1..nr_of_scenarios
+    scenarios.unshift(["scenario nr #{scenario_index}", "Scenario"])
+  end
+  create_feature(@path_to_testdata, "dummy feature with scenarios.feature", scenarios)
+end
+
+Given("a feature dir with a feature containing an outline scenario") do
+  @path_to_testdata = "#{@path_to_testdata}/scenarios_outline"
+  create_path(@path_to_testdata)
+  scenarios = [['sample outline', 'Scenario Outline']]
+  create_feature(@path_to_testdata, "dummy feature with scenarios.feature", scenarios)
+end
+
+Then("the mindmap contains a feature node") do
+  expect(@mindmap.xpath("/map/node/node[starts-with(@ID,'feature_')]").count).to eq(1)
+end
+
+Then("the feature node contains {int} scenario subnodes") do |nr_of_subnodes|
+  expect(@mindmap.xpath("/map/node/node[starts-with(@ID,'feature_')]/node[starts-with(@ID,'scenario_')]").count).to eq(nr_of_subnodes)
+end
+
+Then("the feature node contains a scenario subnode") do
+  expect(@mindmap.xpath("/map/node/node[starts-with(@ID,'feature_')]/node[starts-with(@ID,'scenario_')]").count).to eq(1)
+end
+
+Then("the scenario subnode is marked with an list icon") do
+  expect(@mindmap.xpath("//node[starts-with(@ID,'scenario_')]/icon[@BUILTIN = 'list']").count).to eq(1)
+end

data/features/step_definitions/show_subdirs_steps.rb

@@ -0,0 +1,61 @@
+Given("it contains at least one subdir") do
+  create_path("#{@path_to_testdata}/#{@feature_dir}/subdir")
+end
+
+Given("it contains a feature file") do
+  create_feature("#{@path_to_testdata}/#{@feature_dir}", "dummy.feature")
+end
+
+Given("the subdir contains a feature file") do
+  create_feature("#{@path_to_testdata}/#{@feature_dir}/subdir", "subdir.feature")
+end
+
+Given("the feature dir contains subdirs with a different amount of features") do |table|
+  @subdir_setup = table.hashes
+  table.hashes.each do |table_row|
+    subdir_path = "#{@path_to_testdata}/#{@feature_dir}/#{table_row["subdirs"]}"
+    create_path(subdir_path)
+    for feature_count in 1..table_row["nr_of_features"].to_i
+      create_feature(subdir_path, "dummy_#{feature_count}.feature")
+    end
+  end
+end
+
+Then("the mindmap contains a node with the feature name") do
+  expect(@mindmap.xpath("/map/node/node/@TEXT").first.to_s).to match("dummy feature for testing")
+end
+
+Then("the mindmap contains a node with the subdir") do
+  expect(@mindmap.xpath("/map/node/node/@TEXT").first.to_s).to match("subdir")
+end
+
+Then("the subdir node contains a node with the feature") do
+  expect(@mindmap.xpath("/map/node/node[starts-with(@ID,'subdir_')]/node[starts-with(@ID,'feature_')]").count).to eq(1)
+end
+
+Then("the subdir node is marked by a folder icon") do
+  expect(@mindmap.xpath("/map/node/node/icon").count).to eq(1)
+end
+
+Then("the mindmap shows nodes with a folder icon for every subdir") do
+  @subdir_setup.each do |table_row|
+    subdir_path = table_row["subdirs"]
+    subdir_path.split("/").each do |subdir|
+      expect(@mindmap.xpath("//node[@TEXT = '#{subdir}']").count).to eq(1)
+      expect(@mindmap.xpath("//node[@TEXT = '#{subdir}']/icon").first.to_s).to match("<icon BUILTIN=\"folder\"/>")
+    end
+  end
+end
+
+Then("the node of every subdir contains the corresponding number of feature nodes") do
+  @subdir_setup.each do |table_row|
+    subdir_path = table_row["subdirs"]
+    subdir = subdir_path.split("/").pop
+    @log.debug "xpath: //node[@TEXT = '#{subdir}']/node[starts-with(@ID, 'feature_')]"
+    expect(@mindmap.xpath("//node[@TEXT = '#{subdir}']/node[starts-with(@ID, 'feature_')]").count).to eq(table_row["nr_of_features"].to_i)
+  end
+end
+
+Then("the minmap does not contain a folder node {string}") do |node_name|
+  expect(@mindmap.xpath("//node[starts-with(@ID, 'subdir_') and @TEXT = '#{node_name}']").count).to eq(0)
+end

data/features/support/includes.rb

@@ -0,0 +1,6 @@
+require 'logger'
+require 'english'       # this is for speaking built-in variable names e.g. $CHILD_STATUS instead of $?
+require 'featuremap'    # include the featuremap main class
+require 'nokogiri'      # include xml creation and validation lib
+require 'fileutils'     # for setting access rights to test_data files and dirs
+require 'open3'         # to read from stderr

data/features/support/testdata_gen.rb

@@ -0,0 +1,68 @@
+# generate feature files as test data
+# path: location of  tthe feature file
+# name: name of the feature
+def create_feature(path, name, scenarios = [])
+
+  feature = <<DUMMY_FEATURE
+Feature: dummy feature for testing
+  This is a dummy just for testing purposes
+DUMMY_FEATURE
+
+
+  scenarios.each do |scenario_name, scenario_type|
+    feature += <<DUMMY_SCENARIO
+
+#{scenario_type}: #{scenario_name}
+  Given something
+  When action
+  Then result
+
+DUMMY_SCENARIO
+  end
+
+  create_file(path, name, feature)
+end
+
+
+def create_other_file(path, name)
+
+  content = <<DUMMY_TEXT
+1,dummy,22
+2,dummy,23
+DUMMY_TEXT
+
+  create_file(path, name, content)
+end
+
+
+def create_file(path, name, content)
+  create_path(path)
+  # file anlegen
+  file = File.open("#{path}/#{name}", "w")
+  file.print(content)
+  file.close
+end
+
+
+def create_path(path)
+  currentDir = Dir.getwd
+
+  #Schleife for each item in path
+  path.split('/').each do |dirname|
+    currentDir = "#{currentDir}/#{dirname}"
+    # prüfen ob Verzeichnis existiert
+    if not Dir.exists?(currentDir)
+      # wenn nicht anlegen
+      Dir.mkdir(currentDir)
+    end
+  end
+end
+
+
+def delete_path(path)
+  currentDir = Dir.getwd
+
+  if Dir.exists?("#{currentDir}/#{path}")
+    FileUtils.rm_rf(path)
+  end
+end

data/features/support/validate_xml.rb

@@ -0,0 +1,13 @@
+def validate_mm(p_featuremap_path)
+  mindmap_content = File.read(p_featuremap_path)
+  validation_messages = validate_content(mindmap_content)
+  return validation_messages
+end
+
+def validate_content(p_mindmap_content)
+  schema = Nokogiri::XML::Schema(File.read("doc/definitions/freemind.xsd"))
+  document = Nokogiri::XML(p_mindmap_content)
+  validation_messages = schema.validate(document)
+  validation_messages.each { |error_msg| @log.info "schema err: #{error_msg}"}
+  return validation_messages
+end

data/lib/featuremap.rb

@@ -6,106 +6,131 @@ require_relative 'mindmap'
 
 class Featuremap
 
-  attr_reader :nodes, :exit_status, :err_msg
+  attr_reader :nodes, :exit_status, :mindmap_path, :features_path
 
-  def initialize(p_features_path, p_verbose = false)
-    @exit_status = 0
-    @err_msg = []
-    @log = Logger.new(STDOUT)
+  def initialize(p_features_path, p_mindmap_path, p_verbose = false)
+    if p_mindmap_path == "STDOUT"
+      @log = Logger.new(STDERR)
+    else
+      @log = Logger.new(STDOUT)
+    end
+    @log.formatter = proc do |severity, datetime, progname, msg|
+      date_format = datetime.strftime("%Y-%m-%d %H:%M:%S")
+      "[#{date_format}] #{severity.ljust(5,' ')}: #{msg}\n"
+    end
     @log.datetime_format = "%H:%M:%S"
     if ENV['LOG_LEVEL'] == 'debug'
       @log.level = Logger::DEBUG
     elsif ENV['LOG_LEVEL'] == 'info'
       @log.level = Logger::INFO
+    elsif ENV['LOG_LEVEL'] == 'warn'
+      @log.level = Logger::WARN
     else
       # default log level
       @log.level = Logger::ERROR
     end
-    if p_verbose
+    if p_verbose && @log.level != Logger::DEBUG && p_mindmap_path != "STDOUT"
       @log.level = Logger::INFO
+      @log.info "set log level to verbose"
     end
+    @exit_status = 0
+    @mindmap_path = p_mindmap_path
     if Dir.exists?(p_features_path)
       @features_path = p_features_path
+      @log.info("create a new featuremap")
+      @mindmap = Mindmap.new(@log)
     else
       @exit_status = 66  # see https://www.freebsd.org/cgi/man.cgi?query=sysexits&sektion=3 for more info
-      @err_msg.push("can't find >>#{p_features_path}<< as feature dir")
+      @log.error("can't find >>#{p_features_path}<< as feature dir")
+      return
     end
-    @log.info("create a new featuremap")
-    @mindmap = Mindmap.new(@log)
   end
 
   # class entry point - create a mindmap for a given path
-  def create_featuremap(p_featuremap_path)
-    if p_featuremap_path
-      featuremap_path = p_featuremap_path
-    else
-      featuremap_path = Dir.pwd + "/featuremap.mm"
+  def create_featuremap()
+    mindmap_path = @mindmap_path
+    if mindmap_path != "STDOUT"
+      while File.exists?(mindmap_path)
+        filename_parts = mindmap_path.split(".")
+        if filename_parts[0] =~ /-\d+$/
+          filename_parts = filename_parts[0].split("-")
+          mindmap_path = "#{filename_parts[0]}-#{filename_parts[1].to_i + 1}.mm"
+        else
+          mindmap_path = "#{filename_parts[0]}-1.mm"
+        end
+      end
+      if mindmap_path != @mindmap_path
+        @log.warn("given mindmap name is already in use, created #{mindmap_path}")
+      end
+      begin
+        IO.write("#{mindmap_path}","")
+      rescue Exception
+        @log.error("can't write to #{mindmap_path}")
+        @exit_status = 74
+        return
+      end
     end
-    while File.exists?(featuremap_path)
-      filename_parts = featuremap_path.split(".")
-      if filename_parts[0] =~ /-\d+$/
-        filename_parts = filename_parts[0].split("-")
-        featuremap_path = "#{filename_parts[0]}-#{filename_parts[1].to_i + 1}.mm"
+    read_features(@features_path)
+    if @exit_status == 0
+      if mindmap_path != "STDOUT"
+        mindmap_file = File.open(mindmap_path,"w")
+        mindmap_file.write(@mindmap.to_s)
+        mindmap_file.close
       else
-        featuremap_path = "#{filename_parts[0]}-1.mm"
+        puts @mindmap.to_s
       end
     end
-    if featuremap_path != p_featuremap_path
-      @err_msg.push("given mindmap name is already in use, created #{featuremap_path}")
-    end
-    begin
-      IO.write("#{featuremap_path}","")
-    rescue Exception
-      @err_msg.push("can't write to #{featuremap_path}")
-      @log.warn @err_msg
-      @exit_status = 74
-      return
-    end
-    read_features(@features_path)
-    mindmap_file = File.open(featuremap_path,"w")
-    mindmap_file.write(@mindmap.to_s)
-    mindmap_file.close
   end
 
   # scan feature folder for feature files and subdirs
-  def read_features(p_features_path, p_parent_node = nil)
+  def read_features(p_features_path = @features_path, p_parent_node = nil)
     # don't read features if some error happened before
     if @exit_status == 0
       feature_node = nil
       begin
-        features = Dir.entries(p_features_path)
+        if p_features_path.end_with?("/")
+          features_path = p_features_path
+        else
+          features_path = p_features_path + "/"
+        end
+        features = Dir.entries(features_path)
       rescue Exception
-        @err_msg.push("can't access >>#{p_features_path}<< as feature dir")
-        @log.warn @err_msg
+        @log.error("can't access >>#{features_path}<< as feature dir")
         @exit_status = 66
         return
       end
+      @log.info "start reading features from dir #{features_path}"
+      feature_count = 0
+      scenario_count = 0
       features.each do |feature_file|
         #ignore files starting with .
         if feature_file =~ /^[^\.]/
           #look for features in only in .feature files
           if feature_file =~ /\.feature$/
-            feature = File.read("#{p_features_path}/#{feature_file}")
+            feature = File.read("#{features_path}#{feature_file}")
             feature.scan(/^\s*(Feature|Ability|Business Need):\s*(\S.*)$/) do |feature_type, feature_name|
               feature_node = @mindmap.add_node(feature_name, "feature", p_parent_node)
+              feature_count += 1
             end
             feature.scan(/^\s*(Scenario|Scenario Outline):\s*(\S.*)$/) do |scenario_type, scenario_name|
               case scenario_type
-              when "Scenario Outline" then @mindmap.add_node(scenario_name, "scenario_outline", feature_node)
+                when "Scenario Outline" then @mindmap.add_node(scenario_name, "scenario_outline", feature_node)
                 when "Scenario"  then @mindmap.add_node(scenario_name, "scenario", feature_node)
               end
+              scenario_count += 1
             end
           end
           # look for subdirs
-          if File.directory?("#{p_features_path}/#{feature_file}")
+          if File.directory?("#{features_path}#{feature_file}")
             # ignore step_definitions and support folders because those are used for code
             if feature_file != "step_definitions" && feature_file != "support"
               subdir_node = @mindmap.add_node(feature_file, "subdir", p_parent_node)
-              read_features("#{p_features_path}/#{feature_file}", subdir_node)
+              read_features("#{features_path}#{feature_file}", subdir_node)
             end
           end
         end
       end
+      @log.info "found #{feature_count} feature(s) and #{scenario_count} scenarios in dir #{features_path}"
     end
   end
 

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Featuremap
+  VERSION = '0.0.2'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: featuremap
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Matthias Carell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-12 00:00:00.000000000 Z
+date: 2019-06-13 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Featurmaps helps you to visualize the functionality of your \
@@ -21,8 +21,21 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/featuremap
+- features/give_feedback.feature
+- features/show features and subdirs/show-features.feature
+- features/show features and subdirs/show-scenarios.feature
+- features/show features and subdirs/show-subdirs.feature
+- features/step_definitions/common_steps.rb
+- features/step_definitions/give_feedback_steps.rb
+- features/step_definitions/show_features_steps.rb
+- features/step_definitions/show_scenarios_steps.rb
+- features/step_definitions/show_subdirs_steps.rb
+- features/support/includes.rb
+- features/support/testdata_gen.rb
+- features/support/validate_xml.rb
 - lib/featuremap.rb
 - lib/mindmap.rb
+- lib/version.rb
 homepage: https://github.com/mckryton/featuremap
 licenses: []
 metadata: {}
@@ -46,4 +59,16 @@ rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: A script to convert Gherkin features into a mindmap
-test_files: []
+test_files:
+- features/give_feedback.feature
+- features/show features and subdirs/show-features.feature
+- features/show features and subdirs/show-scenarios.feature
+- features/show features and subdirs/show-subdirs.feature
+- features/step_definitions/common_steps.rb
+- features/step_definitions/give_feedback_steps.rb
+- features/step_definitions/show_features_steps.rb
+- features/step_definitions/show_scenarios_steps.rb
+- features/step_definitions/show_subdirs_steps.rb
+- features/support/includes.rb
+- features/support/testdata_gen.rb
+- features/support/validate_xml.rb