cucumber-gherkin 23.0.1 → 24.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/lib/gherkin/ast_builder.rb +1 -0
- data/lib/gherkin/dialect.rb +1 -0
- data/lib/gherkin/gherkin-languages.json +8 -5
- data/lib/gherkin/pickles/compiler.rb +30 -19
- data/lib/gherkin/token.rb +1 -1
- data/lib/gherkin/token_formatter_builder.rb +1 -1
- data/lib/gherkin/token_matcher.rb +29 -4
- data/spec/gherkin/gherkin_spec.rb +3 -3
- metadata +7 -7
    
        checksums.yaml
    CHANGED
    
    | @@ -1,7 +1,7 @@ | |
| 1 1 | 
             
            ---
         | 
| 2 2 | 
             
            SHA256:
         | 
| 3 | 
            -
              metadata.gz:  | 
| 4 | 
            -
              data.tar.gz:  | 
| 3 | 
            +
              metadata.gz: 7f066daa131750379a87000be3403923d23d19bce878eb1691b0da2186097a89
         | 
| 4 | 
            +
              data.tar.gz: aae3d31b3e3228638813562d1f6574f2d886fe82b8bded9758703979f0f33b6c
         | 
| 5 5 | 
             
            SHA512:
         | 
| 6 | 
            -
              metadata.gz:  | 
| 7 | 
            -
              data.tar.gz:  | 
| 6 | 
            +
              metadata.gz: fb1517adbea8387bf7a9cd079943bac765c97ee258bf121b0fe0bdaeeba5851434c37ec0c1131923b7bd969e6abf49ee9aa18880d623383b04de882fccc750fd
         | 
| 7 | 
            +
              data.tar.gz: d0e28f48adc93600dc502485c1ea935198bab88246545b792f36b7080b3deeab84ec5e683dcfd42623eb2e394328bd8fe37912958923bc2df2bcb21d481a41b5
         | 
    
        data/lib/gherkin/ast_builder.rb
    CHANGED
    
    | @@ -116,6 +116,7 @@ module Gherkin | |
| 116 116 | 
             
                    step = Cucumber::Messages::Step.new(
         | 
| 117 117 | 
             
                      location: get_location(step_line, 0),
         | 
| 118 118 | 
             
                      keyword: step_line.matched_keyword,
         | 
| 119 | 
            +
                      keyword_type: step_line.matched_keyword_type,
         | 
| 119 120 | 
             
                      text: step_line.matched_text,
         | 
| 120 121 | 
             
                      data_table: data_table,
         | 
| 121 122 | 
             
                      doc_string: doc_string,
         | 
    
        data/lib/gherkin/dialect.rb
    CHANGED
    
    
| @@ -967,9 +967,12 @@ | |
| 967 967 | 
             
                ],
         | 
| 968 968 | 
             
                "when": [
         | 
| 969 969 | 
             
                  "* ",
         | 
| 970 | 
            -
                  " | 
| 971 | 
            -
                  " | 
| 972 | 
            -
                  " | 
| 970 | 
            +
                  "Bæþsealf ",
         | 
| 971 | 
            +
                  "Bæþsealfa ",
         | 
| 972 | 
            +
                  "Bæþsealfe ",
         | 
| 973 | 
            +
                  "Ciricæw ",
         | 
| 974 | 
            +
                  "Ciricæwe ",
         | 
| 975 | 
            +
                  "Ciricæwa "
         | 
| 973 976 | 
             
                ]
         | 
| 974 977 | 
             
              },
         | 
| 975 978 | 
             
              "en-pirate": {
         | 
| @@ -2395,7 +2398,7 @@ | |
| 2395 2398 | 
             
                "and": [
         | 
| 2396 2399 | 
             
                  "* ",
         | 
| 2397 2400 | 
             
                  "र ",
         | 
| 2398 | 
            -
                  " | 
| 2401 | 
            +
                  "अनि "
         | 
| 2399 2402 | 
             
                ],
         | 
| 2400 2403 | 
             
                "background": [
         | 
| 2401 2404 | 
             
                  "पृष्ठभूमी"
         | 
| @@ -3459,7 +3462,7 @@ | |
| 3459 3462 | 
             
                ],
         | 
| 3460 3463 | 
             
                "given": [
         | 
| 3461 3464 | 
             
                  "* ",
         | 
| 3462 | 
            -
                  " | 
| 3465 | 
            +
                  "Belgilangan "
         | 
| 3463 3466 | 
             
                ],
         | 
| 3464 3467 | 
             
                "name": "Uzbek",
         | 
| 3465 3468 | 
             
                "native": "Узбекча",
         | 
| @@ -1,3 +1,5 @@ | |
| 1 | 
            +
            require 'cucumber/messages'
         | 
| 2 | 
            +
             | 
| 1 3 | 
             
            module Gherkin
         | 
| 2 4 | 
             
              module Pickles
         | 
| 3 5 | 
             
                class Compiler
         | 
| @@ -56,12 +58,17 @@ module Gherkin | |
| 56 58 | 
             
                  end
         | 
| 57 59 |  | 
| 58 60 | 
             
                  def compile_scenario(inherited_tags, background_steps, scenario, language, pickles, source)
         | 
| 59 | 
            -
                    steps = scenario.steps.empty? ? [] : [].concat(pickle_steps(background_steps))
         | 
| 60 | 
            -
             | 
| 61 61 | 
             
                    tags = [].concat(inherited_tags).concat(scenario.tags)
         | 
| 62 62 |  | 
| 63 | 
            -
                     | 
| 64 | 
            -
             | 
| 63 | 
            +
                    last_keyword_type = Cucumber::Messages::PickleStepType::UNKNOWN
         | 
| 64 | 
            +
                    steps = []
         | 
| 65 | 
            +
                    unless scenario.steps.empty?
         | 
| 66 | 
            +
                      [].concat(background_steps).concat(scenario.steps).each do |step|
         | 
| 67 | 
            +
                        last_keyword_type =
         | 
| 68 | 
            +
                          step.keyword_type == Cucumber::Messages::StepKeywordType::CONJUNCTION ?
         | 
| 69 | 
            +
                            last_keyword_type : step.keyword_type
         | 
| 70 | 
            +
                        steps.push(Cucumber::Messages::PickleStep.new(**pickle_step_props(step, [], nil, last_keyword_type)))
         | 
| 71 | 
            +
                      end
         | 
| 65 72 | 
             
                    end
         | 
| 66 73 |  | 
| 67 74 | 
             
                    pickle = Cucumber::Messages::Pickle.new(
         | 
| @@ -81,12 +88,25 @@ module Gherkin | |
| 81 88 | 
             
                      variable_cells = examples.table_header.cells
         | 
| 82 89 | 
             
                      examples.table_body.each do |values_row|
         | 
| 83 90 | 
             
                        value_cells = values_row.cells
         | 
| 84 | 
            -
                        steps = scenario.steps.empty? ? [] : [].concat(pickle_steps(background_steps))
         | 
| 85 91 | 
             
                        tags = [].concat(inherited_tags).concat(scenario.tags).concat(examples.tags)
         | 
| 86 92 |  | 
| 87 | 
            -
                         | 
| 88 | 
            -
             | 
| 89 | 
            -
             | 
| 93 | 
            +
                        last_keyword_type = nil
         | 
| 94 | 
            +
                        steps = []
         | 
| 95 | 
            +
                        unless scenario.steps.empty?
         | 
| 96 | 
            +
                          background_steps.each do |step|
         | 
| 97 | 
            +
                            last_keyword_type =
         | 
| 98 | 
            +
                              step.keyword_type == Cucumber::Messages::StepKeywordType::CONJUNCTION ?
         | 
| 99 | 
            +
                                last_keyword_type : step.keyword_type
         | 
| 100 | 
            +
                            step_props = pickle_step_props(step, [], nil, last_keyword_type)
         | 
| 101 | 
            +
                            steps.push(Cucumber::Messages::PickleStep.new(**step_props))
         | 
| 102 | 
            +
                          end
         | 
| 103 | 
            +
                          scenario.steps.each do |step|
         | 
| 104 | 
            +
                            last_keyword_type =
         | 
| 105 | 
            +
                              step.keyword_type == Cucumber::Messages::StepKeywordType::CONJUNCTION ?
         | 
| 106 | 
            +
                                last_keyword_type : step.keyword_type
         | 
| 107 | 
            +
                            step_props = pickle_step_props(step, variable_cells, values_row, last_keyword_type)
         | 
| 108 | 
            +
                            steps.push(Cucumber::Messages::PickleStep.new(**step_props))
         | 
| 109 | 
            +
                          end
         | 
| 90 110 | 
             
                        end
         | 
| 91 111 |  | 
| 92 112 | 
             
                        pickle = Cucumber::Messages::Pickle.new(
         | 
| @@ -115,21 +135,12 @@ module Gherkin | |
| 115 135 | 
             
                    name
         | 
| 116 136 | 
             
                  end
         | 
| 117 137 |  | 
| 118 | 
            -
                  def  | 
| 119 | 
            -
                    steps.map do |step|
         | 
| 120 | 
            -
                      pickle_step(step)
         | 
| 121 | 
            -
                    end
         | 
| 122 | 
            -
                  end
         | 
| 123 | 
            -
             | 
| 124 | 
            -
                  def pickle_step(step)
         | 
| 125 | 
            -
                    Cucumber::Messages::PickleStep.new(**pickle_step_props(step, [], nil))
         | 
| 126 | 
            -
                  end
         | 
| 127 | 
            -
             | 
| 128 | 
            -
                  def pickle_step_props(step, variable_cells, values_row)
         | 
| 138 | 
            +
                  def pickle_step_props(step, variable_cells, values_row, keyword_type)
         | 
| 129 139 | 
             
                    value_cells = values_row ? values_row.cells : []
         | 
| 130 140 | 
             
                    props = {
         | 
| 131 141 | 
             
                      id: @id_generator.new_id,
         | 
| 132 142 | 
             
                      ast_node_ids: [step.id],
         | 
| 143 | 
            +
                      type: keyword_type,
         | 
| 133 144 | 
             
                      text: interpolate(step.text, variable_cells, value_cells),
         | 
| 134 145 | 
             
                    }
         | 
| 135 146 | 
             
                    if values_row
         | 
    
        data/lib/gherkin/token.rb
    CHANGED
    
    | @@ -1,7 +1,7 @@ | |
| 1 1 | 
             
            module Gherkin
         | 
| 2 2 | 
             
              class Token < Struct.new(:line, :location)
         | 
| 3 3 | 
             
                attr_accessor :matched_type, :matched_text, :matched_keyword, :matched_indent,
         | 
| 4 | 
            -
                              :matched_items, :matched_gherkin_dialect
         | 
| 4 | 
            +
                              :matched_items, :matched_gherkin_dialect, :matched_keyword_type
         | 
| 5 5 |  | 
| 6 6 | 
             
                def eof?
         | 
| 7 7 | 
             
                  line.nil?
         | 
| @@ -30,7 +30,7 @@ module Gherkin | |
| 30 30 | 
             
                    token.location[:line],
         | 
| 31 31 | 
             
                    token.location[:column],
         | 
| 32 32 | 
             
                    token.matched_type,
         | 
| 33 | 
            -
                    token.matched_keyword,
         | 
| 33 | 
            +
                    token.matched_keyword ? sprintf("(%s)%s", token.matched_keyword_type, token.matched_keyword) : "",
         | 
| 34 34 | 
             
                    token.matched_text,
         | 
| 35 35 | 
             
                    Array(token.matched_items).map { |i| "#{i.column}:#{i.text}"}.join(',')
         | 
| 36 36 | 
             
                end
         | 
| @@ -1,3 +1,4 @@ | |
| 1 | 
            +
            require 'cucumber/messages'
         | 
| 1 2 | 
             
            require_relative 'dialect'
         | 
| 2 3 | 
             
            require_relative 'errors'
         | 
| 3 4 |  | 
| @@ -20,7 +21,7 @@ module Gherkin | |
| 20 21 | 
             
                def match_TagLine(token)
         | 
| 21 22 | 
             
                  return false unless token.line.start_with?('@')
         | 
| 22 23 |  | 
| 23 | 
            -
                  set_token_matched(token, :TagLine, nil, nil, nil, token.line.tags)
         | 
| 24 | 
            +
                  set_token_matched(token, :TagLine, nil, nil, nil, nil, token.line.tags)
         | 
| 24 25 | 
             
                  true
         | 
| 25 26 | 
             
                end
         | 
| 26 27 |  | 
| @@ -48,7 +49,8 @@ module Gherkin | |
| 48 49 | 
             
                def match_TableRow(token)
         | 
| 49 50 | 
             
                  return false unless token.line.start_with?('|')
         | 
| 50 51 | 
             
                  # TODO: indent
         | 
| 51 | 
            -
                  set_token_matched(token, :TableRow, nil, nil, nil,  | 
| 52 | 
            +
                  set_token_matched(token, :TableRow, nil, nil, nil, nil,
         | 
| 53 | 
            +
                                    token.line.table_cells)
         | 
| 52 54 | 
             
                  true
         | 
| 53 55 | 
             
                end
         | 
| 54 56 |  | 
| @@ -128,18 +130,40 @@ module Gherkin | |
| 128 130 | 
             
                  return false unless keyword
         | 
| 129 131 |  | 
| 130 132 | 
             
                  title = token.line.get_rest_trimmed(keyword.length)
         | 
| 131 | 
            -
                   | 
| 133 | 
            +
                  keyword_types = @keyword_types[keyword]
         | 
| 134 | 
            +
                  keyword_type = keyword_types[0]
         | 
| 135 | 
            +
                  if keyword_types.length() > 1
         | 
| 136 | 
            +
                    keyword_type = Cucumber::Messages::StepKeywordType::UNKNOWN
         | 
| 137 | 
            +
                  end
         | 
| 138 | 
            +
             | 
| 139 | 
            +
                  set_token_matched(token,
         | 
| 140 | 
            +
                                    :StepLine, title, keyword, nil, keyword_type)
         | 
| 132 141 | 
             
                  return true
         | 
| 133 142 | 
             
                end
         | 
| 134 143 |  | 
| 135 144 | 
             
                private
         | 
| 136 145 |  | 
| 146 | 
            +
                def add_keyword_type_mappings(keywords, type)
         | 
| 147 | 
            +
                  keywords.each do |keyword|
         | 
| 148 | 
            +
                    if not @keyword_types.has_key?(keyword)
         | 
| 149 | 
            +
                      @keyword_types[keyword] = []
         | 
| 150 | 
            +
                    end
         | 
| 151 | 
            +
                    @keyword_types[keyword] += [type]
         | 
| 152 | 
            +
                  end
         | 
| 153 | 
            +
                end
         | 
| 154 | 
            +
             | 
| 137 155 | 
             
                def change_dialect(dialect_name, location)
         | 
| 138 156 | 
             
                  dialect = Dialect.for(dialect_name)
         | 
| 139 157 | 
             
                  raise NoSuchLanguageException.new(dialect_name, location) if dialect.nil?
         | 
| 140 158 |  | 
| 141 159 | 
             
                  @dialect_name = dialect_name
         | 
| 142 160 | 
             
                  @dialect = dialect
         | 
| 161 | 
            +
                  @keyword_types = {}
         | 
| 162 | 
            +
                  add_keyword_type_mappings(@dialect.given_keywords, Cucumber::Messages::StepKeywordType::CONTEXT)
         | 
| 163 | 
            +
                  add_keyword_type_mappings(@dialect.when_keywords, Cucumber::Messages::StepKeywordType::ACTION)
         | 
| 164 | 
            +
                  add_keyword_type_mappings(@dialect.then_keywords, Cucumber::Messages::StepKeywordType::OUTCOME)
         | 
| 165 | 
            +
                  add_keyword_type_mappings(@dialect.and_keywords + @dialect.but_keywords,
         | 
| 166 | 
            +
                                            Cucumber::Messages::StepKeywordType::CONJUNCTION)
         | 
| 143 167 | 
             
                end
         | 
| 144 168 |  | 
| 145 169 | 
             
                def match_title_line(token, token_type, keywords)
         | 
| @@ -152,12 +176,13 @@ module Gherkin | |
| 152 176 | 
             
                  true
         | 
| 153 177 | 
             
                end
         | 
| 154 178 |  | 
| 155 | 
            -
                def set_token_matched(token, matched_type, text = nil, keyword = nil, indent = nil, items = [])
         | 
| 179 | 
            +
                def set_token_matched(token, matched_type, text = nil, keyword = nil, indent = nil, keyword_type = nil, items = [])
         | 
| 156 180 | 
             
                  token.matched_type = matched_type
         | 
| 157 181 | 
             
                  token.matched_text = text && text.chomp
         | 
| 158 182 | 
             
                  token.matched_keyword = keyword
         | 
| 159 183 | 
             
                  token.matched_indent = indent || (token.line && token.line.indent) || 0
         | 
| 160 184 | 
             
                  token.matched_items = items
         | 
| 185 | 
            +
                  token.matched_keyword_type = keyword_type
         | 
| 161 186 | 
             
                  token.location[:column] = token.matched_indent + 1
         | 
| 162 187 | 
             
                  token.matched_gherkin_dialect = @dialect_name
         | 
| 163 188 | 
             
                end
         | 
| @@ -4,7 +4,7 @@ require 'gherkin' | |
| 4 4 | 
             
            describe Gherkin do
         | 
| 5 5 | 
             
              it "can process feature file paths" do
         | 
| 6 6 | 
             
                messages = Gherkin.from_paths(
         | 
| 7 | 
            -
                  ["testdata/good/minimal.feature"],
         | 
| 7 | 
            +
                  ["../testdata/good/minimal.feature"],
         | 
| 8 8 | 
             
                  {include_source: true,
         | 
| 9 9 | 
             
                   include_gherkin_document: true,
         | 
| 10 10 | 
             
                   include_pickles: true}
         | 
| @@ -14,7 +14,7 @@ describe Gherkin do | |
| 14 14 | 
             
              end
         | 
| 15 15 |  | 
| 16 16 | 
             
              it "can process feature file content" do
         | 
| 17 | 
            -
                data = File.open("testdata/good/minimal.feature", 'r:UTF-8', &:read)
         | 
| 17 | 
            +
                data = File.open("../testdata/good/minimal.feature", 'r:UTF-8', &:read)
         | 
| 18 18 |  | 
| 19 19 | 
             
                messages = Gherkin.from_source(
         | 
| 20 20 | 
             
                  "uri",
         | 
| @@ -28,7 +28,7 @@ describe Gherkin do | |
| 28 28 | 
             
              end
         | 
| 29 29 |  | 
| 30 30 | 
             
              it "can set the default dialect for the feature file content" do
         | 
| 31 | 
            -
                data = File.open("testdata/good/i18n_no.feature", 'r:UTF-8', &:read)
         | 
| 31 | 
            +
                data = File.open("../testdata/good/i18n_no.feature", 'r:UTF-8', &:read)
         | 
| 32 32 | 
             
                data_without_language_header = data.split("\n")[1..-1].join("\n")
         | 
| 33 33 |  | 
| 34 34 | 
             
                messages = Gherkin.from_source(
         | 
    
        metadata
    CHANGED
    
    | @@ -1,7 +1,7 @@ | |
| 1 1 | 
             
            --- !ruby/object:Gem::Specification
         | 
| 2 2 | 
             
            name: cucumber-gherkin
         | 
| 3 3 | 
             
            version: !ruby/object:Gem::Version
         | 
| 4 | 
            -
              version:  | 
| 4 | 
            +
              version: 24.0.0
         | 
| 5 5 | 
             
            platform: ruby
         | 
| 6 6 | 
             
            authors:
         | 
| 7 7 | 
             
            - Gáspár Nagy
         | 
| @@ -10,7 +10,7 @@ authors: | |
| 10 10 | 
             
            autorequire: 
         | 
| 11 11 | 
             
            bindir: bin
         | 
| 12 12 | 
             
            cert_chain: []
         | 
| 13 | 
            -
            date: 2022- | 
| 13 | 
            +
            date: 2022-05-31 00:00:00.000000000 Z
         | 
| 14 14 | 
             
            dependencies:
         | 
| 15 15 | 
             
            - !ruby/object:Gem::Dependency
         | 
| 16 16 | 
             
              name: cucumber-messages
         | 
| @@ -18,20 +18,20 @@ dependencies: | |
| 18 18 | 
             
                requirements:
         | 
| 19 19 | 
             
                - - "~>"
         | 
| 20 20 | 
             
                  - !ruby/object:Gem::Version
         | 
| 21 | 
            -
                    version: ' | 
| 21 | 
            +
                    version: '19.0'
         | 
| 22 22 | 
             
                - - ">="
         | 
| 23 23 | 
             
                  - !ruby/object:Gem::Version
         | 
| 24 | 
            -
                    version:  | 
| 24 | 
            +
                    version: 19.0.0
         | 
| 25 25 | 
             
              type: :runtime
         | 
| 26 26 | 
             
              prerelease: false
         | 
| 27 27 | 
             
              version_requirements: !ruby/object:Gem::Requirement
         | 
| 28 28 | 
             
                requirements:
         | 
| 29 29 | 
             
                - - "~>"
         | 
| 30 30 | 
             
                  - !ruby/object:Gem::Version
         | 
| 31 | 
            -
                    version: ' | 
| 31 | 
            +
                    version: '19.0'
         | 
| 32 32 | 
             
                - - ">="
         | 
| 33 33 | 
             
                  - !ruby/object:Gem::Version
         | 
| 34 | 
            -
                    version:  | 
| 34 | 
            +
                    version: 19.0.0
         | 
| 35 35 | 
             
            - !ruby/object:Gem::Dependency
         | 
| 36 36 | 
             
              name: rake
         | 
| 37 37 | 
             
              requirement: !ruby/object:Gem::Requirement
         | 
| @@ -134,7 +134,7 @@ requirements: [] | |
| 134 134 | 
             
            rubygems_version: 3.1.2
         | 
| 135 135 | 
             
            signing_key: 
         | 
| 136 136 | 
             
            specification_version: 4
         | 
| 137 | 
            -
            summary: cucumber-gherkin- | 
| 137 | 
            +
            summary: cucumber-gherkin-24.0.0
         | 
| 138 138 | 
             
            test_files:
         | 
| 139 139 | 
             
            - spec/capture_warnings.rb
         | 
| 140 140 | 
             
            - spec/gherkin/gherkin_line_spec.rb
         |