cukedep 0.0.1

data/spec/cukedep/feature-model_spec.rb

@@ -0,0 +1,103 @@
+# File: feature-model_spec.rb
+
+require_relative '../spec_helper'
+
+
+require_relative 'file-parsing'
+require_relative '../../lib/cukedep/gherkin-listener'
+
+# Load the class under testing
+require_relative '../../lib/cukedep/feature-model'
+
+module Cukedep # Open module to get rid of long qualified names
+
+describe FeatureModel do
+  # An array of FeatureFile objects created after parsing sample files.
+  FeatureFiles = begin
+    listener = GherkinListener.new
+    self.extend(FileParsing)
+    parse_for(listener) # Use mixin module to parse of sample feature files
+    listener.feature_files
+  end
+  
+  # Default instantiation rule
+  subject { FeatureModel.new(FeatureFiles) }
+
+  context 'Creation and initialization:' do
+    it 'should be created with a list of feature files' do
+      expect { FeatureModel.new(FeatureFiles) }.not_to raise_error
+    end
+
+    it 'should know its feature file objects' do
+      expect(subject.feature_files).to eq(FeatureFiles)
+    end
+
+  end # context
+  
+  context 'Provided services:' do
+    it 'should list all features without identifiers' do
+      unidentified = subject.anonymous_features
+      expect(unidentified).to have(1).items
+      expect(unidentified[0].filepath).to match(/standalone\.feature$/)
+    end
+   
+    it 'should retrieve a feature file given its identifier' do
+      # Case of a single id argument
+      one_id = 'foo'
+      found = subject.select_by_ids(one_id)
+      expect(found).to have(1).items
+      expect(found[0].feature.identifier).to eq(one_id)
+      
+      # Case of multiple id arguments
+      second_id = 'qux'
+      found = subject.select_by_ids(one_id, second_id)
+      expect(found).to have(2).items
+      actual_ids = found.map {|ff| ff.feature.identifier}
+      expected_ids = [one_id, second_id]
+      expect(actual_ids.sort).to eq(expected_ids.sort)
+      
+      # Case of unknown id
+      wrong_id = 'does_not_exist'
+      err_type = StandardError
+      err_msg = "No feature file with identifier 'does_not_exist'."
+      expect { subject.select_by_ids(wrong_id) }.to raise_error(err_type, err_msg)
+    end
+
+
+    it 'should resolve dependency links' do
+      mapping = subject.send(:id2features)
+      deps = subject.dependency_links()
+      expect(deps).not_to be_empty
+      
+      # Case of an identified feature without dependencies
+      case1 = deps.find {|a_dep| a_dep.dependee == mapping['baz']} 
+      expect(case1.dependents).to be_empty
+      
+      # Case of a feature having dependencies
+      case2 = deps.find {|a_dep| a_dep.dependee == mapping['foo']}
+      expectations = subject.select_by_ids('bar', 'qux')
+      expect(case2.dependents).to eq(expectations)
+    end
+
+    it 'should sort the feature files' do
+     sorted_files = subject.sort_features_by_dep()
+     actual_order = sorted_files.map {|f| f.feature.identifier}
+     expected_order = %w[qux baz bar foo]
+    end
+    
+    it 'should generate mapping reports' do
+      subject.mapping_reports('feature2id.csv', 'id2feature.csv')
+    end
+    
+    it 'should generate dependency graph' do
+      subject.dependency_links()
+      subject.draw_dependency_graph('dependencies.dot')
+    end
+
+  end # context
+
+end # describe
+
+end # module
+
+# End of file

data/spec/cukedep/feature-rep_spec.rb

@@ -0,0 +1,53 @@
+# File: feature-rep_spec.rb
+
+require_relative '../spec_helper'
+
+# Load the class under testing
+require_relative '../../lib/cukedep/feature-rep'
+
+module Cukedep # Open module to get rid of long qualified names
+
+describe FeatureRep do
+  # Tag names as provided by Gherkin parser
+  RawTagNames = %w[@some @feature:CO801_foo @depends_on:CO201_bar @depends_on:CO001_qux]
+
+  SampleTagNames = RawTagNames.map { |t| t[1..-1] }
+
+  subject { FeatureRep.new(RawTagNames) }
+
+
+  context 'Creation and initialization:' do
+    it 'could be created with an empty list of tags' do
+      expect {FeatureRep.new([]) }.not_to raise_error
+    end
+
+    it 'could be created with a list of tag names' do
+      expect { FeatureRep.new(RawTagNames) }.not_to raise_error
+    end
+
+    it 'should know its tags' do
+      expect(subject.tags).to eq(SampleTagNames)
+    end
+
+    it 'should know its identifier' do
+      expect(subject.identifier).to eq('CO801_foo')
+    end
+
+    it 'should know whether is has an indentifier' do
+      expect(subject).not_to be_anonymous
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'should know the feature files it depends on' do
+      expected_values = %w[CO201_bar CO001_qux]
+
+      expect(subject.dependency_tags.sort).to eq(expected_values.sort)
+    end
+  end # context
+
+end # describe
+
+end # module
+
+# End of file

data/spec/cukedep/file-parsing.rb

@@ -0,0 +1,40 @@
+# File: file-parsing.rb
+
+require 'gherkin/parser/parser'
+
+module Cukedep # This module is used as a namespace
+
+  # Mixin module used in tests.
+  # Purpose: to parse a sample of feature files.
+  module FileParsing
+    # The list of sample feature file names.
+    SampleFileNames = [ "a_few_tests.feature", 
+        "some_tests.feature",
+        "still_other_tests.feature",
+        "yet_other_tests.feature",
+        "more_tests.feature",
+        "standalone.feature"
+      ]
+
+    # Helper method. It parses sample feature files and
+    # notifies the provided listener of its progress.
+    def parse_for(aListener)
+      # Determine the folder where the sample files reside
+      my_dir = File.dirname(__FILE__)
+      sample_dir = File.expand_path(my_dir + '/sample_features')
+      
+      # Create a Gherkin parser
+      parser = Gherkin::Parser::Parser.new(aListener)
+      
+      # Let it parse the requested files
+      SampleFileNames.each do |sample|
+        path = sample_dir + '/' + sample
+        File::open(path, 'r') { |f| parser.parse(f.read, path, 0) }
+      end
+    end
+  
+  end # module
+
+end # module
+
+# End of file

data/spec/cukedep/gherkin-listener_spec.rb

@@ -0,0 +1,59 @@
+# File: gherkin-listener_spec.rb
+
+require_relative '../spec_helper'
+
+
+require_relative 'file-parsing'
+
+# Load the class under testing
+require_relative '../../lib/cukedep/gherkin-listener'
+
+module Cukedep # Open module to get rid of long qualified names
+
+describe GherkinListener do
+  include FileParsing # Use mixin module to parse of sample feature files
+  
+  subject { GherkinListener.new }
+
+  context 'Creation and initialization:' do
+    it 'should be created without argument' do
+      expect {GherkinListener.new }.not_to raise_error
+    end
+    
+    it 'should have no feature file at start' do
+      expect(subject).to have(0).feature_files
+    end
+  end # context
+  
+  context 'Provided services:' do
+    it 'should build a FeatureFileRep per parsed file' do
+      parse_for(subject)
+      expect(subject).to have(FileParsing::SampleFileNames.size).feature_files
+    end
+    
+    it 'should know the tags of each feature' do
+      parse_for(subject)
+      
+      expectations = [
+        %w[a_few feature:qux],
+        %w[some feature:foo depends_on:bar depends_on:qux],
+        %w[still_other feature:baz],
+        %w[yet_other feature:bar depends_on:baz depends_on:qux depends_on:quux],
+        %w[feature:quux more],
+        []
+      ]
+
+      # Sort the expectations to ease further comparison
+      expectations.map! { |tags| tags.sort }
+      
+      subject.feature_files.each_with_index do |file, i|
+        expect(file.feature.tags.sort).to eq(expectations[i])
+      end
+    end
+  end # context
+
+end # describe
+
+end # module
+
+# End of file

data/spec/cukedep/sample_features/a_few_tests.feature

@@ -0,0 +1,24 @@
+
+@a_few @feature:qux
+Feature: Registering user credentials
+  As a video rental employee
+  I want to enter my credentials
+  So I can identify myself when use the rental application
+
+  Scenario: Start without credentials
+    Given there is no registered user
+    When I enter the credentials "it's me"
+    Then I should not be authorized
+
+
+  Scenario Outline: Registering some credentials
+    When I register my credentials "<credentials>"
+    When I enter the credentials "<credentials>"
+    Then I should see a welcome message
+  
+  Examples:
+  |credentials|
+  |it's me|
+  |himself|
+  |nemo|
+

data/spec/cukedep/sample_features/more_tests.feature

@@ -0,0 +1,24 @@
+# Notice how we specify the identifier of this feature file (quux)
+@more @feature:quux
+Feature: Subscribing member
+  As a video rental owner
+  I want to register future customers 
+  So I can rent videos to authorized people 
+  
+  Scenario: Start with an empty membership
+    Given there is no member yet
+    Then I should see member "John Doe" as unknown
+  
+
+  Scenario Outline: Adding videos to the catalogue
+    Given I subscribe "<name>"
+    Then I should see member "<name>" as registered
+  
+  Examples:
+  |name|
+  |John Doe|
+  |Jed Eye|
+  |Bill Bo|
+  |Jack Orjones|
+  |Mary Gherkin|
+  |Waldo Cuke|

data/spec/cukedep/sample_features/other_tests.feature

@@ -0,0 +1,15 @@
+# Notice how dependencies between feature files are specified
+@other @feature:corge @depends_on:foo
+Feature: Deleting videos
+  As a video rental employee
+  I want to remove old/damaged videos 
+  So I keep the quality of videos in the shelves
+
+  Scenario Outline: Renting videos to a member 
+    When I remove the video "<title>"
+    Then I should see the video "<title>" as unknown
+    
+  Examples:
+  |title|
+  |The world of Cucumber|
+  |Cucumber vs. Gherkin|

data/spec/cukedep/sample_features/some_tests.feature

@@ -0,0 +1,13 @@
+
+@some @feature:foo @depends_on:bar @depends_on:qux
+Feature: Check-in
+  As a video rental employee
+  I want to register return of rented videos
+  So that other members can them too 
+
+
+  Scenario: Registering return of rented video
+    When I enter the credentials "it's me"
+    When I register the return of "The world of Cucumber" from "John Doe"
+    Then I should see the return confirmed
+    

data/spec/cukedep/sample_features/standalone.feature

@@ -0,0 +1,19 @@
+# This feature has no identifier and no explicit dependencies
+Feature: Registering new videos
+  As a video rental owner
+  I want to add more videos to my catalogue
+  So I can offer newer videos for rental
+  
+  Background:
+    Given the catalogue is empty
+    
+  Scenario: Start with an empty catalogue
+    Then I should see the video "Othello" as unknown
+    
+    # Let's do something
+    When I add the video "Othello" to the catalogue
+    Then I should see the video "Othello" as available
+    
+    # Undo what we just did
+    When I remove the video "Othello"
+    Then I should see the video "Othello" as unknown

data/spec/cukedep/sample_features/still_other_tests.feature

@@ -0,0 +1,24 @@
+# Notice how we specify the identifier of this feature file (baz)
+@still_other @feature:baz
+Feature: Registering new videos
+  As a video rental owner
+  I want to add more videos to my catalogue
+  So I can offer newer videos for rental
+  
+  Scenario: Start with an empty catalogue
+    Given the catalogue is empty
+    Then I should see the video "The world of Cucumber" as unknown
+  
+
+  Scenario Outline: Adding videos to the catalogue
+    Given I add the video "<title>" to the catalogue
+    Then I should see the video "<title>" as available
+  
+  Examples:
+  |title|
+  | The world of Cucumber |
+  | The empire of Cucumber |
+  | The revenge of the Cucumber |
+  | The peeled Cucumber |
+  | The masked Cucumber|
+  | Cucumber vs. Gherkin|

data/spec/cukedep/sample_features/yet_other_tests.feature

@@ -0,0 +1,19 @@
+
+# Notice how dependencies between feature files are specified
+@yet_other @feature:bar @depends_on:baz @depends_on:qux @depends_on:quux
+Feature: Renting videos
+  As a video rental employee
+  I want to register rentals made by a member 
+  So I can run my business
+
+  Scenario Outline: Renting videos to a member 
+    When I enter the credentials "it's me"
+    When I register the rental of "<title>" for "John Doe"
+    Then I should see the rental confirmed
+    
+  Examples:
+  |title|
+  |The world of Cucumber|
+  |The masked Cucumber|
+    
+    

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# File: spec_helper.rb
+# Purpose: utility file that is loaded by all our RSpec files
+
+require 'simplecov' # Use SimpleCov for test coverage measurement
+
+
+require 'rspec'	# Use the RSpec framework
+require 'pp'	# Use pretty-print for debugging purposes
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    # Disable the `should` syntax...
+    c.syntax = :expect
+  end
+end
+
+
+# End of file

data/templates/rake.erb

@@ -0,0 +1,163 @@
+# File: <%=rakefile%>
+# Generated by Cukedep <%=Cukedep::Version%>
+
+require 'rake'
+require 'pp'
+
+# Run Cucumber via specialized Rake task
+require 'cucumber/rake/task'
+# UGLY workaround for bug in Cucumber's rake task
+if Gem::VERSION[0].to_i >= 2 && Cucumber::VERSION <= '1.3.2'
+  # Monkey-patch a buggy method
+  class Cucumber::Rake::Task::ForkedCucumberRunner
+    def gem_available?(gemname)
+      if Gem::VERSION[0].to_i >= 2 
+        gem_available_new_rubygems?(gemname)
+      else
+        gem_available_old_rubygems?(gemname)
+      end
+    end  
+  end # class
+end
+
+# Create a task called cucumber
+Cucumber::Rake::Task.new do |t|
+end
+
+
+# Constant holding the location of the original feature files
+SOURCE_DIR = '<%=source_dir%>'
+
+# Constant holding the location of the project
+CUKE_PROJECT = '<%=proj_dir%>'
+
+# Helper method. Calculate the filepath of a file with given name
+# if it is located in the source dir.
+def source_path_of(aFilename)
+  SOURCE_DIR + '/' + aFilename
+end
+
+# Helper method. Calculate the filepath of a file with given name
+# if it is located in the project featurers dir.
+def project_path_of(aFilename)
+  CUKE_PROJECT + '/features/' + aFilename
+end
+
+# Helper method. Given the name of files in the source dir, copy them 
+# into the project dir.
+def copy_to_project(filenames)
+  filenames.each do |fname|
+    source_path = source_path_of(fname)
+    dest_path = project_path_of(fname)
+    FileUtils.copy_file(source_path, dest_path)
+  end
+end
+
+
+# Helper method. Given the name of files in the features dir of the project, 
+# copy them into the source dir.
+def copy_from_project(*filenames)
+  filenames.each do |fname|
+    source_path =  project_path_of(fname)
+    dest_path = source_path_of(fname)
+    FileUtils.copy_file(source_path, dest_path)
+  end
+end
+
+def del_from_project(filenames)
+  filenames.each do |fname|
+    dest_path = project_path_of(fname)
+    FileUtils.remove_file(dest_path)
+  end
+end
+
+# Helper method. Delete all the files in the 
+# the project's features dir that match one of 
+# the file name pattern
+def clean_project_dir(fname_patterns)
+  curr_dir = Dir.getwd()
+  begin
+    Dir.chdir(CUKE_PROJECT + '/features')
+    fname_patterns.each do |patt|
+      filenames = Dir.glob(patt)
+      pp filenames
+      filenames.each { |fn| FileUtils.remove_file(fn) }
+    end
+  ensure  #Always restore previous working dir.
+    Dir.chdir(curr_dir)
+  end
+end
+
+
+def process_files(filenames)
+  copy_to_project(filenames)
+  curr_dir = Dir.getwd()
+  Dir.chdir(CUKE_PROJECT)
+  begin
+    do_cuke = Rake::Task[:cucumber]
+    do_cuke.reenable
+    do_cuke.invoke
+  ensure
+    Dir.chdir(curr_dir)
+  end
+  del_from_project(filenames)
+end
+
+def process_a_feature(filename)
+  process_files([filename])
+end
+
+
+AllUnidentifiedFeatures = [<%anonymous_list = anonymous.map { |name| "'#{name}'"}%>
+  <%=anonymous_list.join(",\n  ")%>
+]
+  
+
+AllFeatureIdentifiers = [ <%identifier_list = feature_ids.map {|f_id| ":#{f_id}"}%>
+  <%=identifier_list.join(",\n  ")%>
+]
+
+# Default rake task is also top-level task
+task :default => :run_all_features
+
+
+desc 'Run all features'
+task :run_all_features => [:before_all, :all_features, :after_all] do
+  ; # Do nothing
+end
+
+
+# Remove feature files from a cuke project
+task :dir_cleanup do
+  clean_project_dir(['*.feature'])
+end
+
+
+
+desc 'Before all' 
+task :before_all => [:dir_cleanup] do
+  ; # Do nothing
+end
+
+desc 'After_all'
+task :after_all do
+  ; # Do nothing
+end
+
+
+task :unidentified do
+  process_files(AllUnidentifiedFeatures)
+end
+
+# Tasks for feature files involved in dependencies
+<%deps.each do |dep|%>
+<%dep_list = dep.dependents.map { |ff| ":#{ff.feature.identifier}" } %>
+task :<%=dep.dependee.feature.identifier%> <%= dep_list.empty? ? '' : %Q|=> [#{dep_list.join(', ') }]| %> do
+  process_a_feature('<%=dep.dependee.basename%>')
+end
+<%end%>
+
+task :all_features => ([:unidentified] + AllFeatureIdentifiers) do
+end
+
+# End of file