cukedep 0.1.10 → 0.1.11

data/lib/cukedep/gherkin-facade.rb

@@ -4,25 +4,24 @@ require 'gherkin'
 require 'gherkin/lexer/encoding'
 
 module Cukedep # This module is used as a namespace
-
   # Facade design pattern: A facade is an object that provides
   # a simplified interface to a larger body of code.
   # Here the GherkinFacade class provides basic parsing service.
   class GherkinFacade
     # Indicate whether the parsing must be verbose or silent
     attr_reader(:verbose)
-    
+
     # (External) encoding of the feature files.
     # It is a string that represents the name of an encoding
     # as expected by the mode argument of the IO#new method
     attr_reader(:external_encoding)
-    
+
 
     def initialize(isVerbose, anExternalEncoding)
       @verbose = isVerbose
       @external_encoding = anExternalEncoding
     end
-    
+
     # Parse feature files from the work directory that match
     # one of the given file name patterns.
     # Parse events are sent to the passed listener object.
@@ -34,22 +33,20 @@ module Cukedep # This module is used as a namespace
       # List all .feature files in work directory that match the pattern
       filenames = []
       file_patterns.each { |patt| filenames.concat(Dir.glob(patt)) }
-      
+
       # Parse them
       filenames.each do |fname|
         puts "  #{fname}" if verbose
         # To prevent encoding issue, open the file
         # with an explicit external encoding
-        File.open(fname, "r:#{external_encoding}") do |f| 
-          parser.parse(f.read, fname, 0) 
+        File.open(fname, "r:#{external_encoding}") do |f|
+          parser.parse(f.read, fname, 0)
         end
       end
-      
+
       return aListener
     end
-  
   end # class
-
 end # module
 
 # End of file

data/lib/cukedep/gherkin-listener.rb

@@ -4,95 +4,88 @@ require_relative 'feature-rep'
 
 
 module Cukedep # This module is used as a namespace
-
-
-class FeatureFileRep 
-  attr_reader(:filepath)
-  attr(:feature, true)
-  
-  def initialize(aFilepath)
-    @filepath = aFilepath
-  end
-  
-  def basename()
-    File.basename(filepath)
-  end
-end # class
-
-# A ParserListener listens to all the formatting events
-# emitted by the Gherkin parser.
-# It converts the received the feature file elements and builds
-# a representation of the feature files that is appropriate
-# for the Cukedep application.
-class GherkinListener
-  # The list of feature files encountered so far
-  attr_reader(:feature_files)
-
-  # Internal representation of the feature being parsed
-  attr(:current_feature, true)
-  
-  def initialize()
-    @feature_files = []
-  end
-  
-  ######################################
-  # Event listening methods
-  ######################################
-
-  # Called when beginning the parsing of a feature file.
-  # featureURI: path + filename of feature file.
-  def uri(featureURI)
-    new_file = FeatureFileRep.new(featureURI)
-    feature_files << new_file
-  end
-
-  # aFeature is a Gherkin::Formatter::Model::Feature instance
-  def feature(aFeature)
-    tag_names = aFeature.tags.map(&:name)
-    @current_feature = feature_files.last.feature = FeatureRep.new(tag_names)
-  end
-
-  # aBackground is a Gherkin::Formatter::Model::Background instance
-  def background(_aBackground)
-    ; # Do nothing
-  end
-  
-  # aScenario is a Gherkin::Formatter::Model::Scenario instance
-  def scenario(_aScenario)
-    ; # Do nothing
-  end
-  
-  # aScenarioOutline is a Gherkin::Formatter::Model::ScenarioOutline instance
-  def scenario_outline(_aScenarioOutline)
-    ; # Do nothing  
-  end
-  
-  # theExamples is a Gherkin::Formatter::Model::Examples instance
-  def examples(_theExamples)
-    ; # Do nothing 
-  end
-
-  # aStep is a Gherkin::Formatter::Model::Step instance
-  def step(_aStep)
-    ; # Do nothing
-  end
-  
-  # End of feature file notification.
-  def eof()
-    ; # Do nothing
-  end
-
-
-  # Catch all method
-  def method_missing(message, *_args)
-    puts "Method #{message} is not implemented (yet)."
-  end
-
-end # class
-
+  class FeatureFileRep 
+    attr_reader(:filepath)
+    attr(:feature, true)
+    
+    def initialize(aFilepath)
+      @filepath = aFilepath
+    end
+    
+    def basename()
+      File.basename(filepath)
+    end
+  end # class
+
+  # A ParserListener listens to all the formatting events
+  # emitted by the Gherkin parser.
+  # It converts the received the feature file elements and builds
+  # a representation of the feature files that is appropriate
+  # for the Cukedep application.
+  class GherkinListener
+    # The list of feature files encountered so far
+    attr_reader(:feature_files)
+
+    # Internal representation of the feature being parsed
+    attr(:current_feature, true)
+    
+    def initialize()
+      @feature_files = []
+    end
+    
+    ######################################
+    # Event listening methods
+    ######################################
+
+    # Called when beginning the parsing of a feature file.
+    # featureURI: path + filename of feature file.
+    def uri(featureURI)
+      new_file = FeatureFileRep.new(featureURI)
+      feature_files << new_file
+    end
+
+    # aFeature is a Gherkin::Formatter::Model::Feature instance
+    def feature(aFeature)
+      tag_names = aFeature.tags.map(&:name)
+      @current_feature = feature_files.last.feature = FeatureRep.new(tag_names)
+    end
+
+    # aBackground is a Gherkin::Formatter::Model::Background instance
+    def background(_aBackground)
+      ; # Do nothing
+    end
+    
+    # aScenario is a Gherkin::Formatter::Model::Scenario instance
+    def scenario(_aScenario)
+      ; # Do nothing
+    end
+    
+    # aScenarioOutline is a Gherkin::Formatter::Model::ScenarioOutline instance
+    def scenario_outline(_aScenarioOutline)
+      ; # Do nothing  
+    end
+    
+    # theExamples is a Gherkin::Formatter::Model::Examples instance
+    def examples(_theExamples)
+      ; # Do nothing 
+    end
+
+    # aStep is a Gherkin::Formatter::Model::Step instance
+    def step(_aStep)
+      ; # Do nothing
+    end
+    
+    # End of feature file notification.
+    def eof()
+      ; # Do nothing
+    end
+
+
+    # Catch all method
+    def method_missing(message, *_args)
+      puts "Method #{message} is not implemented (yet)."
+    end
+  end # class
 end # module
 
-
-
-
 # End of file

data/lib/cukedep/hook-dsl.rb

@@ -2,7 +2,6 @@
 
 
 module Cukedep # Module used as a namespace
-
 # Mix-in module that defines the DSL (Domain-Specific Language)
 # for specifying Cukedep hooks.
 # A hook is a custom code block that is executed when 
@@ -74,9 +73,6 @@ module HookDSL
     handler = hooks.nil? ? nil : hooks.fetch(aScope)
     return handler
   end
-
 end # module
-
 end # module
-
 # End of file

data/lib/cukedep/sandbox.rb

@@ -2,10 +2,8 @@
 
 
 module Cukedep # This module is used as a namespace
-
   # A context in which hook block codes are run.
   class Sandbox
-
     attr_reader(:base_dir)
     attr_reader(:proj_dir)
 
@@ -13,9 +11,6 @@ module Cukedep # This module is used as a namespace
       @base_dir = theBaseDir.dup.freeze
       @proj_dir = theProjectDir.dup.freeze
     end
-
   end # class
-
 end # module
-
 # End of file

data/sample/features/step_definitions/steps.rb

@@ -1,50 +1,54 @@
 # File: steps.rb
 # Step definitions for a sample Cucumber application
 
+def store()
+  $store
+end
+
 Given(/^the catalogue is empty$/) do
-  $store.zap_catalogue!()
+  store.zap_catalogue!
 end
 
 Given(/^I add the video "(.*?)" to the catalogue$/) do |a_title|
-  $store.add_video(a_title)
+  store.add_video(a_title)
 end
 
 Then(/^I should see the video "(.*?)" as unknown$/) do |a_title|
-  expect($store.search_video(a_title)).to be_nil
+  expect(store.search_video(a_title)).to be_nil
 end
 
 Then(/^I should see the video "(.*?)" as (available)$/) do |a_title, a_state|
-  found_video = $store.search_video(a_title)
+  found_video = store.search_video(a_title)
   expect(found_video.state).to eq(a_state.to_sym)
 end
 
 When(/^I remove the video "(.*?)"$/) do |a_title|
-  found_video = $store.search_video(a_title)
+  found_video = store.search_video(a_title)
   expect(found_video).not_to be_nil
   expect(found_video.state).to eq(:available)
-  $store.remove_video(found_video)
+  store.remove_video(found_video)
 end
 
 Given(/^there is no member yet$/) do
-  $store.send(:zap_members!)  # Why is this method seen as private?
+  store.send(:zap_members!)  # Why is this method seen as private?
 end
 
 Then(/^I should see member "(.*?)" as unknown$/) do |member_name|
-  expect($store.search_member(member_name)).to be_nil
+  expect(store.search_member(member_name)).to be_nil
 end
 
 Then(/^I should see member "(.*?)" as registered$/) do |member_name|
-  expect($store.search_member(member_name)).not_to be_nil
+  expect(store.search_member(member_name)).not_to be_nil
   puts "Member #{member_name} is registered."
 end
 
 Given(/^I subscribe "(.*?)"$/) do |member_name|
-  $store.add_member(member_name)
+  store.add_member(member_name)
 end
 
 
 Given(/^there is no registered user$/) do
-  $store.zap_users!
+  store.zap_users!
 end
 
 When(/^I enter the credentials "(.*?)"$/) do |credential|
@@ -52,54 +56,54 @@ When(/^I enter the credentials "(.*?)"$/) do |credential|
 end
 
 Then(/^I should not be authorized$/) do
-  expect($store.search_user(@entered_credential)).to be_nil
-  puts "Invalid user credential" 
+  expect(store.search_user(@entered_credential)).to be_nil
+  puts 'Invalid user credential'
 end
 
 When(/^I register my credentials "(.*?)"$/) do |credential|
-  $store.add_user(credential)
+  store.add_user(credential)
 end
 
 Then(/^I should see a welcome message$/) do
-  expect($store.search_user(@entered_credential)).not_to be_nil  
-  puts "Welcome to the rental application."
+  expect(store.search_user(@entered_credential)).not_to be_nil
+  puts 'Welcome to the rental application.'
 end
 
 
 When(/^I register the rental of "(.*?)" for "(.*?)"$/) do |a_title, member_name|
-  found_video = $store.search_video(a_title)
+  found_video = store.search_video(a_title)
   expect(found_video).not_to be_nil
   expect(found_video.state).to eq(:available)
 
-  member = $store.search_member(member_name)
+  member = store.search_member(member_name)
   expect(member).not_to be_nil
-  $store.add_rental(found_video, member)
+  store.add_rental(found_video, member)
   @confirm_rental = true
 end
 
 Then(/^I should see the rental confirmed$/) do
-  puts "Rental registered." if @confirm_rental
+  puts 'Rental registered.' if @confirm_rental
   @confirm_rental = nil
 end
 
 Then(/^I should see the rental refused$/) do
-  puts "Rental refused." unless @confirm_rental
+  puts 'Rental refused.' unless @confirm_rental
 end
 
 
-When(/^I register the return of "(.*?)" from "(.*?)"$/) do |a_title, member_name|
-  rental = $store.search_rental(a_title)
+When(/^I register the return of "(.*?)" from "(.*?)"$/) do |title, member_name|
+  rental = store.search_rental(title)
   expect(rental).not_to be_nil
   expect(rental.member).to eq(member_name)
-  $store.close_rental(rental)
+  store.close_rental(rental)
   @confirm_return = true
 end
 
 Then(/^I should see the return confirmed$/) do
-  puts "Return registered." if @confirm_return
+  puts 'Return registered.' if @confirm_return
   @confirm_return = nil
 end
 
 
 
-# End of file
+# End of file

data/sample/features/support/env.rb

@@ -9,4 +9,4 @@ AfterConfiguration do |_|
   $store = Sample::RentalStore.new
 end
 
-# End of file
+# End of file

data/sample/model/model.rb

@@ -1,216 +1,209 @@
 # File: model.rb
 
 require 'pp'
-require 'yaml'  # Rely on YAML for object persistence 
+require 'yaml'  # Rely on YAML for object persistence
 
 
 # Module used as a namespace
 module Sample
+  # Assumption: the store has one examplar only of a video title
+  Video = Struct.new(
+    :title, # Title of the video (as an identifier)
+    :state  # Current state of the video
+  )
+
+  # A member of the video store, i.e. a person that is allowed
+  # to rent a video from the store.
+  Member = Struct.new(
+    :name # As an identifier
+  )
+
+  # Association object between a Video and a Member.
+  # In our sample model, no rental history is performed
+  Rental = Struct.new(
+    :video, # Use the title of the rented video as key
+    :member   # Use the name of the Member as key
+  )
+
+  # The identification of a store rental employee
+  # that is authorized to use the rental software.
+  User = Struct.new(
+    :credential # user credential
+  )
+
+  # Simplistic domain model of a video rental store.
+  class RentalStore
+    MyDir = File.dirname(__FILE__) + '/'
+    CatalogueFile = 'catalogue.yml'
+    MembersFile = 'members.yml'
+    RentalsFile = 'rentals.yml'
+    UsersFile = 'users.yml'
+
+
+    # The list of all videos owned by the store.
+    attr_reader(:catalogue)
+
+    # The list of all Members
+    attr_reader(:members)
+
+    # The list of all open-standing rentals
+    attr_reader(:rentals)
+
+    # The list of application user (credentials)
+    attr_reader(:users)
+
+    def initialize()
+      init_catalogue
+      init_members
+      init_rentals
+      init_users
+    end
+
+
+    # Clear the catalogue (= make it empty).
+    def zap_catalogue!()
+      catalogue.clear
+      save_catalogue
+      zap_rentals!
+    end
+
+    def zap_members!()
+      members.clear
+      save_members
+      zap_rentals!
+    end
+
+    def zap_users!()
+      users.clear
+      save_users
+    end
+
+    # Search a Video object having the given title
+    def search_video(aTitle)
+      result = catalogue.find { |video| video.title.strip == aTitle.strip }
+      if result.nil?
+        msg = "Video with title '#{aTitle}' isn't in the catalogue."
+        $stderr.puts msg
+      end
+
+      return result
+    end
+
+    def remove_video(aVideo)
+      catalogue.delete(aVideo)
+      save_catalogue
+    end
+
+    # Add a new video to the catalogue
+    def add_video(aTitle)
+      # Simplification: no check for title collision
+      catalogue << Video.new(aTitle, :available)
+      save_catalogue
+    end
+
+    def search_member(aName)
+      mb = members.find { |person| person.name.strip == aName.strip }
+      puts "No member with name #{aName}." if mb.nil?
+
+      return mb
+    end
 
-# Assumption: the store has one examplar only of a video title
-Video = Struct.new(
-  :title, # Title of the video (as an identifier)
-  :state  # Current state of the video
-)
-
-# A member of the video store, i.e. a person that is allowed 
-# to rent a video from the store.
-Member = Struct.new(
-  :name # As an identifier
-)
-
-# Association object between a Video and a Member.
-# In our sample model, no rental history is performed
-Rental = Struct.new(
-  :video, # Use the title of the rented video as key
-  :member   # Use the name of the Member as key
-)
-
-# The identification of a store rental employee
-# that is authorized to use the rental software.
-User = Struct.new(
-  :credential # user credential
-)
-
-# Simplistic domain model of a video rental store.
-class RentalStore
-  MyDir = File.dirname(__FILE__) + '/'
-  CatalogueFile = 'catalogue.yml'
-  MembersFile = 'members.yml'
-  RentalsFile = 'rentals.yml'
-  UsersFile = 'users.yml'
-
-
-  # The list of all videos owned by the store.
-  attr_reader(:catalogue)
-  
-  # The list of all Members
-  attr_reader(:members)
-  
-  # The list of all open-standing rentals
-  attr_reader(:rentals)
-  
-  # The list of application user (credentials)
-  attr_reader(:users)
-  
-  def initialize()
-    init_catalogue()
-    init_members()
-    init_rentals()
-    init_users()
-  end
-  
-
-  # Clear the catalogue (= make it empty).
-  def zap_catalogue!()
-    catalogue.clear()
-    save_catalogue()
-    zap_rentals!()
-  end
-  
-  def zap_members!()
-    members.clear()
-    save_members()
-    zap_rentals!()
-  end
-  
-  def zap_users!()
-    users.clear()
-    save_users()
-  end
-
-  # Search a Video object having the given title
-  def search_video(aTitle)
-    result = catalogue.find {|video| video.title.strip == aTitle.strip}
-    if result.nil?
-      msg = "Video with title '#{aTitle}' isn't in the catalogue."
-      $stderr.puts msg
-    end
-    
-    return result
-  end
-  
-  def remove_video(aVideo)
-    catalogue.delete(aVideo)
-    save_catalogue()
-  end
-
-  # Add a new video to the catalogue
-  def add_video(aTitle)
-    # Simplification: no check for title collision
-    catalogue << Video.new(aTitle, :available)
-    save_catalogue()
-  end
-  
-  def search_member(aName)
-    mb = members.find {|person| person.name.strip == aName.strip}
-    puts "No member with name #{aName}." if mb.nil?
-    
-    return mb
-  end
-
-  def add_member(aName)
-    # Simplification: no check for name collision
-    members << Member.new(aName)
-    save_members()
-  end
-  
-  def search_user(aCredential)
-    users.find {|user| user.credential.strip == aCredential.strip}
-  end
-  
-  def add_user(aCredential)
-    # Simplification: no check for credential collision
-    users << User.new(aCredential)
-    save_users()
-  end
-  
-  def search_rental(aTitle)
-    rentals.find {|r| r.video.strip == aTitle.strip}
-  end
-  
-  def add_rental(aVideo, aMember)
-    rentals << Rental.new(aVideo.title, aMember.name)
-    aVideo.state = :rented
-    save_rentals
-  end
-  
-  def close_rental(aRental)
-    returned_video = search_video(aRental.video)
-    returned_video.state = :available
-    rentals.delete(aRental)
-    save_rentals
-  end
-
-  private
-  def init_catalogue()
-    filepath = MyDir + CatalogueFile
-    if File.exist?(filepath)
-      @catalogue = YAML.load_file(filepath)
-    else
-      @catalogue = []
-    end
-  end
-  
-  def init_members()
-    filepath = MyDir + MembersFile
-    if File.exist?(filepath)
-      @members = YAML.load_file(filepath)
-    else
-      @members = []
-    end
-  end
-  
-  def init_users()
-    filepath = MyDir + UsersFile
-    if File.exist?(filepath)
-      @users = YAML.load_file(filepath)
-    else
-      @users = []
-    end  
-  end
-  
-  def init_rentals()
-    filepath = MyDir + RentalsFile
-    if File.exist?(filepath)
-      @rentals = YAML.load_file(filepath)
-    else
-      @rentals = []
-    end
-  end
-  
-  def zap_rentals!()
-    rentals.clear
-    save_rentals()
-  end
-  
-  def zap_members!()
-    members.clear
-    save_members()
-  end
-  
-  def save_catalogue()
-    filepath = MyDir + CatalogueFile
-    File.open(filepath, 'w') {|f| YAML.dump(catalogue, f)}
-  end
-
-  def save_members()
-    filepath = MyDir + MembersFile
-    File.open(filepath, 'w') {|f| YAML.dump(members, f)}
-  end
-
-  def save_users()
-    filepath = MyDir + UsersFile
-    File.open(filepath, 'w') {|f| YAML.dump(users, f)}
-  end
-
-  def save_rentals()
-    filepath = MyDir + RentalsFile
-    File.open(filepath, 'w') {|f| YAML.dump(rentals, f)}
-  end
-
-end # class
+    def add_member(aName)
+      # Simplification: no check for name collision
+      members << Member.new(aName)
+      save_members
+    end
+
+    def search_user(aCredential)
+      users.find { |user| user.credential.strip == aCredential.strip }
+    end
 
+    def add_user(aCredential)
+      # Simplification: no check for credential collision
+      users << User.new(aCredential)
+      save_users
+    end
+
+    def search_rental(aTitle)
+      rentals.find { |r| r.video.strip == aTitle.strip }
+    end
+
+    def add_rental(aVideo, aMember)
+      rentals << Rental.new(aVideo.title, aMember.name)
+      aVideo.state = :rented
+      save_rentals
+    end
+
+    def close_rental(aRental)
+      returned_video = search_video(aRental.video)
+      returned_video.state = :available
+      rentals.delete(aRental)
+      save_rentals
+    end
+
+    private
+
+    def init_catalogue()
+      filepath = MyDir + CatalogueFile
+      if File.exist?(filepath)
+        @catalogue = YAML.load_file(filepath)
+      else
+        @catalogue = []
+      end
+    end
+
+    def init_members()
+      filepath = MyDir + MembersFile
+      if File.exist?(filepath)
+        @members = YAML.load_file(filepath)
+      else
+        @members = []
+      end
+    end
+
+    def init_users()
+      filepath = MyDir + UsersFile
+      if File.exist?(filepath)
+        @users = YAML.load_file(filepath)
+      else
+        @users = []
+      end
+    end
+
+    def init_rentals()
+      filepath = MyDir + RentalsFile
+      if File.exist?(filepath)
+        @rentals = YAML.load_file(filepath)
+      else
+        @rentals = []
+      end
+    end
+
+    def zap_rentals!()
+      rentals.clear
+      save_rentals
+    end
+
+    def save_catalogue()
+      filepath = MyDir + CatalogueFile
+      File.open(filepath, 'w') { |f| YAML.dump(catalogue, f) }
+    end
+
+    def save_members()
+      filepath = MyDir + MembersFile
+      File.open(filepath, 'w') { |f| YAML.dump(members, f) }
+    end
+
+    def save_users()
+      filepath = MyDir + UsersFile
+      File.open(filepath, 'w') { |f| YAML.dump(users, f) }
+    end
+
+    def save_rentals()
+      filepath = MyDir + RentalsFile
+      File.open(filepath, 'w') { |f| YAML.dump(rentals, f) }
+    end
+  end # class
 end # module
 
-# End of file
+# End of file