How to use pickle_tag method of Gherkin.Pickles Package

...26        scenario[:steps].each do |step|27          steps.push(pickle_step(step))28        end29        pickle = {30          tags: pickle_tags(tags),31          name: scenario[:name],32          language: language,33          locations: [pickle_location(scenario[:location])],34          steps: steps35        }36        pickles.push(pickle)37      end38      def compile_scenario_outline(feature_tags, background_steps, scenario_outline, language, pickles)39        return if scenario_outline[:steps].empty?40        scenario_outline[:examples].reject { |examples| examples[:tableHeader].nil? }.each do |examples|41          variable_cells = examples[:tableHeader][:cells]42          examples[:tableBody].each do |values|43            value_cells = values[:cells]44            steps = [].concat(background_steps)45            tags = [].concat(feature_tags).concat(scenario_outline[:tags]).concat(examples[:tags])46            scenario_outline[:steps].each do |scenario_outline_step|47              step_text = interpolate(scenario_outline_step[:text], variable_cells, value_cells);48              arguments = create_pickle_arguments(scenario_outline_step[:argument], variable_cells, value_cells)49              pickle_step = {50                text: step_text,51                arguments: arguments,52                locations: [53                  pickle_location(values[:location]),54                  pickle_step_location(scenario_outline_step)55                ]56              }57              steps.push(pickle_step)58            end59            pickle = {60              name: interpolate(scenario_outline[:name], variable_cells, value_cells),61              language: language,62              steps: steps,63              tags: pickle_tags(tags),64              locations: [65                pickle_location(values[:location]),66                pickle_location(scenario_outline[:location])67              ]68            }69            pickles.push(pickle);70          end71        end72      end73      def create_pickle_arguments(argument, variable_cells, value_cells)74        result = []75        return result if argument.nil?76        if (argument[:type] == :DataTable)77          table = {78            rows: argument[:rows].map do |row|79              {80                cells: row[:cells].map do |cell|81                  {82                    location: pickle_location(cell[:location]),83                    value: interpolate(cell[:value], variable_cells, value_cells)84                  }85                end86              }87            end88          }89          result.push(table)90        elsif (argument[:type] == :DocString)91          doc_string = {92            location: pickle_location(argument[:location]),93            content: interpolate(argument[:content], variable_cells, value_cells)94          }95          result.push(doc_string)96        else97          raise 'Internal error'98        end99        result100      end101      def interpolate(name, variable_cells, value_cells)102        variable_cells.each_with_index do |variable_cell, n|103          value_cell = value_cells[n]104          name = name.gsub('<' + variable_cell[:value] + '>', value_cell[:value])105        end106        name107      end108      def pickle_steps(scenario_definition)109        scenario_definition[:steps].map do |step|110          pickle_step(step)111        end112      end113      def pickle_step(step)114        {115          text: step[:text],116          arguments: create_pickle_arguments(step[:argument], [], []),117          locations: [pickle_step_location(step)]118        }119      end120      def pickle_step_location(step)121        {122          line: step[:location][:line],123          column: step[:location][:column] + (step[:keyword] ? step[:keyword].length : 0)124        }125      end126      def pickle_location(location)127        {128          line: location[:line],129          column: location[:column]130        }131      end132      def pickle_tags(tags)133        tags.map {|tag| pickle_tag(tag)}134      end135      def pickle_tag(tag)136        {137          name: tag[:name],138          location: pickle_location(tag[:location])139        }140      end141    end142  end143end...

1  def initialize(formatter)2  def uri(uri)3    @formatter.uri(uri)4  def feature(feature)5    @formatter.feature(feature)6  def scenario(scenario)7    @formatter.scenario(scenario)8  def step(step)9    @formatter.step(step)10  def pickle(pickle)11    @formatter.pickle(pickle)12formatter = Gherkin::Formatter::PrettyFormatter.new(PickleFormatter.new($stdout))13parser.parse(File.read('test.feature'), 'test.feature', 0, formatter)

1formatter = Gherkin::Formatter::PrettyFormatter.new(STDOUT)2parser.parse(File.read('feature.feature'), formatter, 'feature.feature')3pickles = Gherkin::Pickles.pikles(parser.gherkin_dcuent, 'feature.feature')4formatter = Gherkin::Formatter::PrettyFormatter.new(STDOUT)5parser.parse(File.read('feature.feature'), formatter, 'feature.feature')6pickles = Gherkin::Pickles.pickles(parser.gherkin_document, 'feature.feature)

1feature = File.read('feature_file.feature')2parsed = parser.parse(feature)3pickle_tag = pickle.pickle_tag(tag)

1formatter = Gherkin::Formatter::PrettyFormatter.new(STDOUT)2parser.parse(File.read('feature.feature'), formatter, 'feature.feature')3pickles = Gherkin::Pickles.pickles(parser.gherkin_document, 'feature.feature')

1feature = Gherkin.from_paths(['features/1.feature'], {include_source: true})2pickle = Gherkin::Pickles.pickle_tag(feature[0], 'tag1')3feature = Gherkin.from_paths(['features/1.feature'], {include_source: true})4pickles = Gherkin::Pickles.pickle_tags(feature[0], ['tag1', 'tag2'])5feature = Gherkin.from_paths(['features/1.feature'], {include_source: true})6pickles = Gherkin::Pickles.pickle_filter(feature[0], 'tag1 and tag2')7formatter = Gherkin::Formatter::PrettyFormatter.new(STDOUT)8parser.parse(File.read('feature.feature'), formatter, 'feature.feature')9pickles = Gherkin::Pickles.pickles(parser.gherkin_document, 'feature.feature')

1feature = File.read("feature.feature")2ast = parser.parse(feature)3pickles = compiler.compile(ast)

1feature = Gherkin.from_paths(['features/1.feature'], {include_source: true})2pickle = Gherkin::Pickles.pickle_tag(feature[0], 'tag1')3feature = Gherkin.from_paths(['features/1.feature'], {include_source: true})4pickles = Gherkin::Pickles.pickle_tags(feature[0], ['tag1', 'tag2'])5feature = Gherkin.from_paths(['features/1.feature'], {include_source: true})6pickles = Gherkin::Pickles.pickle_filter(feature[0], 'tag1 and tag2')