cuketagger 1.5 → 1.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aca5d51f29ef842db370f4ebcfdf6637c1b04d84
+  data.tar.gz: 8a654ad26ef3eb1f9d516d192061c12a9c1c2ad5
+SHA512:
+  metadata.gz: 455c33a05e17c3ade2dbcec02fab34d1a04152580ce2bd3fbed451eee5908ae1b0d637824e261bda2d3953e1de3719875cf7fe52a8f061cd43aae53a17c28f76
+  data.tar.gz: 06be308f0f01bf9cf1be6b076e0594e5d13b1afaa436e865262effcd447f547e02e35e6a8ad6a8e024e32bf2614de76e5ae7e7b6a49cb8b7830fa88a53bbbefb

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - 2.1.6
+  - 2.2.2
+
+# todo - Remove this once TravisCI fixes their bundler issue (https://github.com/alphagov/govuk_template/pull/186)
+before_install:
+  - gem install bundler -v 1.9.10
+
+script: bundle exec rake cuketagger:ci_build

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cuketagger.gemspec
+gemspec
+
+if RUBY_VERSION =~ /^1\.8/
+  gem 'cucumber', '<1.3.0'
+  gem 'gherkin', '<2.12.0'
+  gem 'rake', '< 11.0' # Rake dropped 1.8.x support after this version
+elsif RUBY_VERSION =~ /^1\./
+  gem 'cucumber', '<2.0.0'
+end
+
+if RUBY_VERSION =~ /^1\./
+  gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
+  gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
+  gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
+end

data/History.md

@@ -0,0 +1,11 @@
+### Version 1.6.0 / 2016-12-11
+
+* Updated the dependencies used by the gem in order to be compatible with current 
+  libraries.
+* File modification has been minimized. Only the lines of a file that are affected 
+  by tagging are modified. Previously, the entire file was potentially reformatted.
+
+
+### Version 1.5.0 / 2011-04-17
+
+* The Great Before Times...

data/LICENSE.txt

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2009-2012 Jari Bakken
+Copyright (c) 2015 Eric Kessler
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -1,8 +1,60 @@
-
-<pre><code>
-  $ sudo gem install jarib-cuketagger
-  $ cuketagger add:wip features/foo.feature:6 features/bar.feature         
-      // check that the output is as expected
-  $ cuketagger --force add:wip features/foo.feature:6 features/bar.feature
-      // --force rewrites your files
-</code></pre>  
+[![Gem Version](https://badge.fury.io/rb/cuketagger.svg)](https://rubygems.org/gems/cuketagger)
+[![Build Status](https://travis-ci.org/enkessler/cuketagger.svg?branch=dev)](https://travis-ci.org/enkessler/cuketagger)
+[![Dependency Status](https://gemnasium.com/enkessler/cuketagger.svg)](https://gemnasium.com/enkessler/cuketagger)
+
+
+# Cuketagger
+
+This gem provides the ability to manipulate, in bulk, the tags in a Cucumber test 
+suite. 
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cuketagger'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cuketagger
+
+
+## Usage
+
+Tags can be added,
+
+    $ cuketagger add:foo path/to/some.feature
+
+removed,
+
+    $ cuketagger remove:foo path/to/some.feature
+
+or replaced.
+
+    $ cuketagger replace:old_tag:new_tag path/to/some.feature
+
+Multiple tags and files can be manipulated at the same time
+
+    $ cuketagger remove:wip add:release5 replace:qa:prod features/foo.feature:6 features/bar.feature
+
+and the modified file content will be output to the console. To modify the files 
+themselves, add the explicit `force` tag.
+
+    $ cuketagger --force remove:wip add:release5 replace:qa:prod features/foo.feature:6 features/bar.feature
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (off of the development branch)
+   `git checkout -b my-new-feature`
+3. Commit your changes
+   `git commit -am 'Add some feature'`
+4. Push to the branch
+   `git push origin my-new-feature`
+5. Create new Pull Request

data/Rakefile

@@ -1,55 +1,21 @@
-# encoding: utf-8
-
-require "rake/clean"
-require "rake/gempackagetask"
-require File.expand_path("../lib/cuketagger/version", __FILE__)
-require "cucumber/rake/task"
-CLEAN.include %w[pkg]
-
-GEM_NAME = "cuketagger"
-GEM_VERSION = CukeTagger::Version
-
-spec = Gem::Specification.new do |s|
-  s.name             = GEM_NAME
-  s.version          = GEM_VERSION
-  s.has_rdoc         = false
-  s.summary          = "batch tagging of cucumber features and scenarios"
-  s.description      = s.summary
-  s.authors          = %w[Jari Bakken]
-  s.email            = "jari.bakken@gmail.com"
-  s.homepage         = "http://cukes.info"
-  s.files            = %w[Rakefile README.markdown] + Dir['lib/**/*']
-  s.bindir           = 'bin'
-  s.executables      = Dir['bin/*'].map { |f| File.basename(f) }
-
-  s.add_runtime_dependency 'cucumber', '>= 0.9.2'
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-end
-
-namespace :gem do
-  desc "install the gem locally"
-  task :install => [:package] do
-    sh %{sudo #{Gem.ruby} -S gem install pkg/#{GEM_NAME}-#{GEM_VERSION}}
-  end
-
-  desc "Create a .gemspec file"
-  task :spec do
-    file = "#{GEM_NAME.downcase}.gemspec"
-    File.unlink file if ::File.exists?(file)
-    File.open(file, "w+") { |f| f << spec.to_ruby }
-  end
-
-  desc "Release cuketagger-#{GEM_VERSION}"
-  task :release => [:clean, :gem] do
-    sh "gem push pkg/#{GEM_NAME}-#{GEM_VERSION}.gem"
-  end
-end
-
-Cucumber::Rake::Task.new(:features) do |t|
-  t.cucumber_opts = "--format pretty"
-end
-
-task :default => :features
+require 'racatt'
+
+
+namespace 'cuketagger' do
+  Racatt.create_tasks
+
+  # The task that CI will use
+  task :ci_build => [:smart_test]
+
+
+  task :smart_test do |t, args|
+    rspec_args = '--pattern testing/rspec/spec/**/*_spec.rb'
+    cucumber_args = 'testing/cucumber/features -r testing/cucumber/features -f progress'
+
+    Rake::Task['cuketagger:test_everything'].invoke(rspec_args, cucumber_args)
+  end
+
+end
+
+
+task :default => 'cuketagger:smart_test'

data/bin/cuketagger

@@ -1,5 +1,5 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require File.expand_path("../../lib/cuketagger", __FILE__)
-CukeTagger::Tagger.execute(ARGV)
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require File.expand_path("../../lib/cuketagger", __FILE__)
+CukeTagger::Tagger.execute(ARGV)

data/cuketagger.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cuketagger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cuketagger"
+  spec.version       = CukeTagger::VERSION
+  spec.authors       = ["Jari Bakken", "Eric Kessler"]
+  spec.email         = ["morrow748@gmail.com"]
+
+  # todo - Update summary and description
+  spec.summary       = "batch tagging of cucumber features and scenarios"
+  # spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/jarib/cuketagger"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'cuke_modeler', '~>1.0'
+  spec.add_runtime_dependency 'cql', '~>1.0', '>= 1.3.0'
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "racatt", '~> 1.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'cucumber', '< 3.0.0'
+end

data/lib/cuketagger.rb

@@ -1,18 +1,13 @@
-$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-require "set"
-
-require "gherkin"
-require "gherkin/formatter/pretty_formatter"
-require "stringio"
-
-require "cuketagger/version"
-require "cuketagger/tag_formatter"
-require "cuketagger/tagger"
-require "cuketagger/array_list_extension" if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-
-module CukeTagger
-  def self.log(*args)
-    File.open("/tmp/cuketagger.log", "a") { |file| file.puts args.inspect } if $DEBUG
-  end
-end
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "set"
+require 'cuke_modeler'
+require 'cql'
+require 'cql/model_dsl'
+
+require "cuketagger/version"
+require "cuketagger/tagger"
+require "cuketagger/array_list_extension" if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+
+module CukeTagger
+end

data/lib/cuketagger/array_list_extension.rb

@@ -1,13 +1,13 @@
-require 'java'
-
-class Java::JavaUtil::ArrayList
-  alias_method :delete, :remove
-  alias_method :push, :add
-
-  def index(obj)
-    idx = indexOf(obj)
-    return if idx == -1
-    idx
-  end
-end
-
+require 'java'
+
+class Java::JavaUtil::ArrayList
+  alias_method :delete, :remove
+  alias_method :push, :add
+
+  def index(obj)
+    idx = indexOf(obj)
+    return if idx == -1
+    idx
+  end
+end
+

data/lib/cuketagger/tagger.rb

@@ -1,130 +1,231 @@
-module CukeTagger
-  class Tagger
-    USAGE = "#{File.basename $0} [-v|--version] [-f|--force] [add|remove|replace]:TAG[:REPLACEMENT] [FILE[:LINE]]+"
-
-    def self.execute(args)
-      new.execute(args)
-    end
-
-    def execute(args)
-      abort(USAGE) if args.empty? || args.first =~ /^(-h|--help)$/
-      CukeTagger.log :args, args
-
-      force = false
-
-      args.each do |arg|
-        case arg
-        when /^-v|--version$/
-          puts CukeTagger::Version
-        when /^(.+?\.feature)((:\d+)*)$/
-         add_feature $1, $2.to_s
-        when /^(add|remove):(.+?)$/
-          alterations << [$1.to_sym, $2]
-        when /^(replace):(.+?):(.+)$/
-          alterations << [$1.to_sym, [$2, $3]]
-        when /^(-f|--force)$/
-          force = true
-        else
-          abort(USAGE)
-        end
-      end
-
-      alterations.uniq!
-
-      CukeTagger.log :alterations, alterations
-
-      files = features_to_change.map { |file, line| file }.uniq
-      files.each { |file| parse file, force }
-    end
-
-    def parse(file, write)
-      content = File.read(file)
-
-      io = write ? File.open(file, "w") : $stdout
-      begin
-        pretty_formatter = Gherkin::Formatter::PrettyFormatter.new(io,
-                                                                  !(io == $stdout && $stdout.tty?), # monochrome
-                                                                  false) # executing
-        pretty_formatter.extend TagFormatter
-        pretty_formatter.tagger = self
-
-        parser = Gherkin::Parser::Parser.new(pretty_formatter, true)
-        parser.parse content, file, 0
-      ensure
-        io.close unless io == $stdout
-      end
-    end
-
-    def process(uri, element)
-      CukeTagger.log :process, :element => element.class
-      return unless should_alter?(uri, element)
-
-      @uri = uri
-
-      alterations.each do |op, tag_name|
-        case op
-        when :add
-          push_tag element, "@#{tag_name}"
-        when :remove
-          remove_tag element, "@#{tag_name}"
-        when :replace
-          replace_tag element, tag_name
-        end
-      end
-    end
-
-    def push_tag(element, tag_name)
-      element.tags << Gherkin::Formatter::Model::Tag.new(tag_name, element.line)
-    end
-
-    def remove_tag(element, tag_name)
-      element.tags.delete_if { |tag| tag.name == tag_name }
-    end
-
-    def replace_tag(element, tag_name)
-      to_replace, replacement = tag_name
-      to_replace  = "@#{to_replace}"
-      replacement = "@#{replacement}"
-
-      idx = element.tags.find_index { |tag| tag.name == to_replace }
-
-      if idx.nil?
-        $stderr.puts "expected #{to_replace.inspect} at #{@uri}:#{element.line}, skipping"
-      else
-        element.tags[idx] = Gherkin::Formatter::Model::Tag.new(replacement, element.line)
-      end
-    end
-
-    def should_alter?(uri, element)
-      CukeTagger.log(:file_and_line => [uri, element.line], :features_to_change => features_to_change)
-
-      features_to_change.any? do |file, line|
-        file == uri && (element.line == line || (line.nil? && element.kind_of?(Gherkin::Formatter::Model::Feature)))
-      end
-    end
-
-    private
-
-    def add_feature(path, lines)
-      lines = lines.split(":")
-      lines.delete ""
-
-      if lines.empty?
-        features_to_change << [path, nil]
-      else
-        lines.each do |line|
-          features_to_change << [path, Integer(line)]
-        end
-      end
-    end
-
-    def alterations
-      @alterations ||= []
-    end
-
-    def features_to_change
-      @features_to_change ||= Set.new
-    end
-
-  end
-end
+module CukeTagger
+  class Tagger
+    USAGE = "#{File.basename $0} [-v|--version] [-f|--force] [add|remove|replace]:TAG[:REPLACEMENT] [FILE[:LINE]]+"
+
+    def self.execute(args)
+      new.execute(args)
+    end
+
+    def execute(args)
+      abort(USAGE) if args.empty? || args.first =~ /^(-h|--help)$/
+
+      force = false
+
+      args.each do |arg|
+        case arg
+        when /^-v|--version$/
+          puts CukeTagger::Version
+        when /^(.+?\.feature)((:\d+)*)$/
+         add_feature $1, $2.to_s
+        when /^(add|remove):(.+?)$/
+          alterations << [$1.to_sym, $2]
+        when /^(replace):(.+?):(.+)$/
+          alterations << [$1.to_sym, [$2, $3]]
+        when /^(-f|--force)$/
+          force = true
+        else
+          abort(USAGE)
+        end
+      end
+
+      alterations.uniq!
+
+      files = features_to_change.map { |file, line| file }.uniq
+      files.each { |file| parse file, force }
+    end
+
+
+    private
+
+
+    def parse(file_path, write)
+      return unless feature_to_change?(file_path)
+
+      content = File.open(file_path) { |file| file.readlines }
+
+      feature_model = CukeModeler::FeatureFile.new(file_path).feature
+
+      io = write ? File.open(file_path, "w") : $stdout
+
+      begin
+        taggable_things = collect_taggable_models(feature_model)
+
+        # Elements must be altered in the order that they appear in the file in order to
+        # guarantee that any line adjustments are applied appropriately.
+        taggable_things.sort!{|a,b| a.source_line <=> b.source_line}
+
+        taggable_things.each do |thing|
+          if thing_to_tag?(thing)
+            alterations.each do |alteration|
+              alter_thing(thing, alteration, content)
+            end
+          end
+        end
+
+        content = content.join
+
+        io.write(content)
+      ensure
+        io.close unless io == $stdout
+      end
+    end
+
+    def should_alter?(uri, element)
+      features_to_change.any? do |file, line|
+        file == uri && (element.line == line || (line.nil? && element.kind_of?(Gherkin::Formatter::Model::Feature)))
+      end
+    end
+
+    def add_feature(path, lines)
+      lines = lines.split(":")
+      lines.delete ""
+
+      if lines.empty?
+        features_to_change << [path, nil]
+      else
+        lines.each do |line|
+          features_to_change << [path, Integer(line)]
+        end
+      end
+    end
+
+    def alterations
+      @alterations ||= []
+    end
+
+    # todo - add warning if there are features that do not get changed (e.g. the user provided an incorrect file/line number or replaces a non-existant tag)
+    def features_to_change
+      @features_to_change ||= Set.new
+    end
+
+    def feature_to_change?(file_name)
+      features_to_change.any? { |name, line_number| name == file_name }
+    end
+
+    def thing_to_tag?(thing)
+      #todo - pass in file name as well for performance?
+      features_to_change.any? { |name, line_number|
+        name_match = (name == thing.get_ancestor(:feature_file).path)
+        number_match = (thing.source_line == line_number)
+
+        (name_match && number_match) || (name_match && thing.is_a?(CukeModeler::Feature) && line_number.nil?
+        )
+      }
+    end
+
+    def collect_taggable_models(feature_model)
+      results = feature_model.query do
+        select :model
+        from scenarios, outlines, examples
+      end
+      [feature_model] + results.collect { |result| result[:model] }
+    end
+
+    def alter_thing(thing, alteration, content)
+
+      case alteration.first
+        when :add
+          add_tag(thing, alteration.last, content)
+        when :remove
+          remove_tag(thing, alteration.last, content)
+        when :replace
+          replace_tag(thing, alteration.last.first, alteration.last.last, content)
+        else
+          raise "Unknown alteration type: #{alteration.first}"
+      end
+    end
+
+    def replace_tag(thing, old_tag, new_tag, content)
+      @file_offset ||= Hash.new(0)
+      @line_removed ||= {}
+
+      relevant_tag = thing.tags.select { |tag_model| tag_model.name == "@#{old_tag}" }.first
+
+      if relevant_tag
+        insertion_index = relevant_tag.source_line + @file_offset[thing.get_ancestor(:feature_file).path] - 1
+        content[insertion_index] = content[insertion_index].sub("@#{old_tag}", "@#{new_tag}")
+      else
+        $stderr.puts "expected \"@#{old_tag}\" at #{thing.get_ancestor(:feature_file).name}:#{thing.source_line}, skipping"
+      end
+    end
+
+    def add_tag(thing, tag, content)
+      @file_offset ||= Hash.new(0)
+      @line_removed ||= {}
+
+      insertion_index = thing.source_line + @file_offset[thing.get_ancestor(:feature_file).path] - 2
+
+      if new_line_needed?(thing, content, insertion_index)
+        insertion_index += 1
+        content.insert(insertion_index, '')
+
+        @line_removed[thing] = false
+        @file_offset[thing.get_ancestor(:feature_file).path] += 1
+      end
+
+      empty_line = content[insertion_index].chomp =~ /^\s*$/
+      trim_line(content, insertion_index, !empty_line)
+
+      content[insertion_index] = content[insertion_index].chomp + "#{tag_spacing(content, insertion_index)}@#{tag}\n"
+    end
+
+    def remove_tag(thing, tag, content)
+      @file_offset ||= Hash.new(0)
+      @line_removed ||= {}
+
+      relevant_tag = thing.tags.select { |tag_model| tag_model.name == "@#{tag}" }.first
+
+      return unless relevant_tag
+
+      insertion_index = relevant_tag.source_line + @file_offset[thing.get_ancestor(:feature_file).path] - 1
+      content[insertion_index] = content[insertion_index].sub(/@#{Regexp.escape(tag)} ?/, '')
+
+      trim_line(content, insertion_index, true)
+
+      if content[insertion_index] =~ /^\s*$/
+        content[insertion_index] = nil
+        content.compact!
+        @file_offset[thing.get_ancestor(:feature_file).path] -= 1
+        @line_removed[thing] = true
+      end
+    end
+
+    def trim_line(content, insertion_index, keep_indentation)
+      line_match = content[insertion_index].match(/^(\s*)(\S.*)?/)
+      indentation = line_match[1]
+      line_content = line_match[2]
+
+      trimmed_line = keep_indentation ? indentation : ''
+      trimmed_line += line_content.squeeze(' ').strip if line_content
+      trimmed_line = "#{trimmed_line.chomp}\n"
+
+      content[insertion_index] = trimmed_line
+    end
+
+    def tag_spacing(content, insertion_index)
+      if content[insertion_index] =~ /\S/
+        ' '
+      else
+        next_line_leading_spaces = content[insertion_index + 1].match(/^(\s*)/)[1]
+        ' ' * next_line_leading_spaces.length
+      end
+    end
+
+    def new_line_needed?(thing, content, insertion_index)
+      line_was_removed?(thing) || (non_tag_line?(content, insertion_index) && non_empty_line?(content, insertion_index))
+    end
+
+    def line_was_removed?(thing)
+      @line_removed[thing]
+    end
+
+    def non_tag_line?(content, insertion_index)
+      content[insertion_index] !~ /^\s*@/
+    end
+
+    def non_empty_line?(content, insertion_index)
+      content[insertion_index] !~ /^\s*$/
+    end
+
+  end
+end