Class: YARD::Handlers::Cucumber::FeatureHandler

Inherits:
Base
  • Object
show all
Defined in:
lib/yard/handlers/cucumber/feature_handler.rb

Constant Summary collapse

@@step_definitions = 
nil
@@step_transforms = 
nil

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

handles?

Class Method Details

.cache(type) ⇒ Object

Store all comparable items with their compare_value as the key and the item as the value

  • Reject any compare values that contain escapes #{} as that means they have unpacked constants



81
82
83
84
85
86
 
# File 'lib/yard/handlers/cucumber/feature_handler.rb', line 81

def cache(type)
  YARD::Registry.all(type).inject({}) do |hash,item|
    hash[item.regex] = item if item.regex
    hash
  end
end

.match_step_to_step_definition_and_transforms(step) ⇒ Object

Given a step object, attempt to match that step to a step transformation



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/yard/handlers/cucumber/feature_handler.rb', line 102

def match_step_to_step_definition_and_transforms(step)
  @@step_definitions.each_pair do |stepdef,stepdef_object|
    stepdef_matches = step.value.match(stepdef)

    if stepdef_matches
      step.definition = stepdef_object
      stepdef_matches[1..-1].each do |match|
        @@step_transforms.each do |steptrans,steptransform_object|
          if steptrans.match(match)
            step.transforms << steptransform_object
            steptransform_object.steps << step
          end
        end
      end

      # Step has been matched to step definition and step transforms
      # TODO: If the step were to match again then we would be able to display ambigous step definitions
      break

    end

  end

end

.match_steps_to_step_definitions(statement) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/yard/handlers/cucumber/feature_handler.rb', line 45

def match_steps_to_step_definitions(statement)
  # Create a cache of all of the step definitions and the step transforms
  @@step_definitions = cache(:stepdefinition) unless @@step_definitions
  @@step_transforms = cache(:steptransform) unless @@step_transforms

  if statement
    # For the background and the scenario, find the steps that have definitions
    process_scenario(statement.background) if statement.background

    statement.scenarios.each do |scenario|
      if scenario.outline?
        #log.info "Scenario Outline: #{scenario.value}"
        scenario.scenarios.each_with_index do |example,index|
          #log.info " * Processing Example #{index + 1}"
          process_scenario(example)
        end
      else
        process_scenario(scenario)
      end
    end


  else
    log.warn "Empty feature file.  A feature failed to process correctly or contains no feature"
  end

rescue YARD::Handlers::NamespaceMissingError
rescue Exception => exception
  log.error "Skipping feature because an error has occurred."
  log.debug "\n#{exception}\n#{exception.backtrace.join("\n")}\n"
end

.process_scenario(scenario) ⇒ Object

process a scenario



89
90
91
 
# File 'lib/yard/handlers/cucumber/feature_handler.rb', line 89

def process_scenario(scenario)
  scenario.steps.each {|step| process_step(step) }
end

.process_step(step) ⇒ Object

process a step



94
95
96
 
# File 'lib/yard/handlers/cucumber/feature_handler.rb', line 94

def process_step(step)
  match_step_to_step_definition_and_transforms(step)
end

Instance Method Details

#process ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/yard/handlers/cucumber/feature_handler.rb', line 8

def process
  #
  # Features have already been created when they were parsed. So there
  # is no need to process the feature further. Previously this is where
  # feature steps were matched to step definitions and step definitions
  # were matched to step transforms. This only worked if the feature
  # files were were assured to be processed last which was accomplished
  # by overriding YARD::SourceParser to make it load file in a similar
  # order as Cucumber.
  #
  # As of YARD 0.7.0 this is no longer necessary as there are callbacks
  # that can be registered after all the files have been loaded. That
  # callback _after_parse_list_ is defined below and performs the
  # functionality described above.
  #
end