cuporter 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 ThoughtWorks, Inc.
+
+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.textile

@@ -0,0 +1,72 @@
+h1. Cuporter
+
+Scrapes your feature files and shows scenarios per tag, with their context.  Formats Pretty Text, HTML (not styled yet) and CSV.
+
+Consider this a stop-gap until we get this functionality in a proper cucumber formatter.
+
+---------
+h3. Example Output
+
+<pre>
+@failing
+  Feature: Abominable Aardvark
+    Scenario: An Aardvark eats ants
+    Scenario: Zee Zebra eats zee aardvark
+  Feature: Wired
+    Scenario: Everybody's Wired
+    Scenario Outline: Why is everybody so wired?
+      Examples: loosely wired
+      Examples: tightly wired
+@ignore
+  Feature: Wired
+    Scenario Outline: Why is everybody so wired?
+      Examples: tightly wired
+@wip
+  Feature: HTML formatter
+    Scenario: Everything in fixtures/self_test
+  Feature: not everyone is involved
+    Scenario: Failure is not an option, people
+  Feature: sample
+    Scenario: And yet another Example
+  Feature: search examples
+    Scenario: Generate PDF with pdf formatter
+
+</pre>
+
+---------
+
+h3. Command Lines
+
+h4. help
+
+<pre>
+  $ ./bin/cuporter.rb -h
+
+  Usage: cuporter.rb [options]
+  
+      -i, --in DIR                     directory of *.feature files
+  					Default: features/**/*.feature
+  
+          --input-file FILE            full file name with extension: 'path/to/file.feature'
+  
+      -o, --out FILE                   Output file path
+  
+      -f, --format [pretty|html|csv]   Output format
+  					Default: pretty text
+</pre>
+
+h4. run script directly
+
+<pre>
+  $ ./bin/cuporter.rb -i fixtures/self_text               # pretty-print demo report to stdout
+
+  $ ./bin/cuporter.rb -f html -o feature_tag_report.html  # default input features/**/*.feature to named output file
+</pre>
+
+h4. run via rake
+
+<pre>
+  $ rake cuporter:run["-i fixtures/self_text"]
+
+  $ rake cuporter:run["-f html -o feature_tag_report.html"]
+</pre>

data/Rakefile

@@ -0,0 +1,86 @@
+require 'rubygems'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+task :default do
+  Rake.application.tasks_in_scope(["cuporter:test"]).each do |t|
+    t.invoke
+  end
+end
+
+namespace :cuporter do
+
+  # $ rake cuporter:run["-f html cucumber_tag_report.html"]
+  desc "run cuporter command line with options"
+  task :run, [:options] do |t, args|
+    sh "ruby ./bin/cuporter #{args.options}"
+  end
+
+  task :readme do
+    require 'redcloth'
+    puts RedCloth.new(File.read("README.textile")).to_html
+  end
+
+  namespace :test do
+    desc "unit specs"
+    RSpec::Core::RakeTask.new(:unit) do |t|
+      t.pattern = "spec/cuporter/*_spec.rb"
+      t.spec_opts = ["--color" , "--format" , "doc" ]
+    end
+
+    desc "functional specs against feature fixtures"
+    RSpec::Core::RakeTask.new(:functional) do |t|
+      t.pattern = "spec/cuporter/functional/**/*_spec.rb"
+      t.spec_opts = ["--color" , "--format" , "doc" ]
+    end
+
+    desc "cucumber features"
+    task :cucumber do
+      sh "cucumber"
+    end
+  end
+
+  RDOC_OPTS = ["--all" , "--quiet" , "--line-numbers" , "--inline-source", 
+    "--main", "README.textile", 
+    "--title", "Cuporter: cucumber tag reporting"]
+  XTRA_RDOC = %w{README.textile LICENSE }
+
+  Rake::RDocTask.new do |rd|
+    rd.rdoc_dir = "doc/rdoc"
+    rd.rdoc_files.include("**/*.rb")
+    rd.rdoc_files.add(XTRA_RDOC)
+    rd.options = RDOC_OPTS
+  end
+
+  spec = Gem::Specification.new do |s|
+    s.name = 'cuporter'
+    s.version = '0.1.0'
+    s.rubyforge_project = s.name
+
+    s.platform = Gem::Platform::RUBY
+    s.has_rdoc = true
+    s.extra_rdoc_files = XTRA_RDOC
+    s.rdoc_options += RDOC_OPTS
+    s.summary = "Scrapes Cucumber *.feature files to build report on tag usage"
+    s.description = s.summary
+    s.author = "Tim Camper"
+    s.email = 'twcamper@thoughtworks.com'
+    s.homepage = 'http://github.com/twcamper/cuporter'
+    s.required_ruby_version = '>= 1.8.7'
+    s.default_executable = "cuporter"
+    s.executables = [s.default_executable]
+
+    s.files =  %w(LICENSE README.textile Rakefile) + 
+      FileList["lib/**/*.rb", "spec/**/*.rb", "features/**/*.{feature,rb}", "bin/*"].to_a
+
+    s.require_path = "lib"
+  end
+
+  Rake::GemPackageTask.new(spec) do |p|
+    p.need_zip = true
+    p.need_tar = true
+    p.gem_spec = spec
+  end
+end

data/bin/cuporter

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'cuporter'
+
+tag_report = Cuporter::TagReport.new(Cuporter::Options[:input_file] || Cuporter::Options[:input_dir])
+
+formatter = Cuporter::Formatters.const_get(Cuporter::Options[:format])
+formatter.new(tag_report.scenarios_per_tag, Cuporter::Options[:output]).write

data/features/pretty_print.feature

@@ -0,0 +1,7 @@
+Feature: Pretty print report on 3 features
+
+  @just_me
+  Scenario: Everything in fixtures/self_test
+    When I run cuporter --in fixtures/self_test
+    Then the output should have the same contents as "features/reports/pretty_with_outlines.txt"
+    

data/features/step_definitions/cuporter_steps.rb

@@ -0,0 +1,8 @@
+When /^I run cuporter (.*)$/ do |cuporter_opts|
+  @output = `bin#{File::SEPARATOR}cuporter #{cuporter_opts}`
+end
+
+
+Then /^.* should have the same contents as "([^"]*)"$/ do |expected_file|
+  @output.should == IO.read(File.expand_path(expected_file))
+end

data/features/support/env.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH << File.expand_path('../../../lib' , __FILE__)
+require 'cuporter'

data/lib/cuporter/cli/options.rb

@@ -0,0 +1,46 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+require 'optparse'
+require 'fileutils'
+
+module Cuporter
+  class Options
+
+    def self.[](key)
+      self.options[key]
+    end
+
+    def self.options
+      self.parse unless @options
+      @options
+    end
+
+    def self.parse
+      @options = {}
+      OptionParser.new(ARGV.dup) do |opts|
+        opts.banner = "Usage: cuporter [options]\n\n"
+
+        opts.on("-i", "--in DIR", "directory of *.feature files\n\t\t\t\t\tDefault: features/**/*.feature\n\n") do |i|
+          @options[:input_dir] = "#{i}/**/*.feature"
+        end
+        opts.on("--input-file FILE", "full file name with extension: 'path/to/file.feature'\n\n") do |file|
+          @options[:input_file] = file
+        end
+        opts.on("-o", "--out FILE", "Output file path\n\n") do |o|
+          full_path = File.expand_path(o)
+          path = full_path.split(File::SEPARATOR)
+          file = path.pop
+          FileUtils.makedirs(path.join(File::SEPARATOR))
+
+          @options[:output] = full_path
+        end
+        opts.on("-f", "--format [pretty|html|csv]", "Output format\n\t\t\t\t\tDefault: pretty text\n\n") do |f|
+          @options[:format] = f.downcase.to_class_name
+        end
+        @options[:format] ||= :Text
+        
+      end.parse!
+
+
+    end
+  end
+end

data/lib/cuporter/extensions/string.rb

@@ -0,0 +1,10 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+module StringExtensions
+  def to_class_name
+    gsub(/(^|_)([a-zA-Z])/) {$2.upcase}
+  end
+end
+
+class String
+  include(StringExtensions)
+end

data/lib/cuporter/feature_parser.rb

@@ -0,0 +1,63 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+
+module Cuporter
+  class FeatureParser
+    FEATURE_LINE          = /^\s*(Feature:[^#]+)/
+    TAG_LINE              = /^\s*(@\w.+)/
+    SCENARIO_LINE         = /^\s*(Scenario:[^#]+)$/
+    SCENARIO_OUTLINE_LINE = /^\s*(Scenario Outline:[^#]+)$/
+    SCENARIOS_LINE        = /^\s*(Scenarios:[^#]*)$/
+    EXAMPLES_LINE         = /^\s*(Examples:[^#]*)$/
+
+    def initialize
+      @current_tags = []
+    end
+
+    def self.parse(feature_content)
+      self.new.parse(feature_content)
+    end
+
+    def parse(feature_content)
+      lines = feature_content.split(/\n/)
+
+      lines.each do |line|
+        case line
+        when TAG_LINE
+          # may be more than one tag line
+          @current_tags |= $1.strip.split(/\s+/)
+        when FEATURE_LINE
+          @feature = TagListNode.new($1.strip, @current_tags)
+          @current_tags = []
+        when SCENARIO_LINE
+          # How do we know when we have read all the lines from a "Scenario Outline:"?
+          # One way is when we encounter a "Scenario:"
+          if @scenario_outline
+            @feature.merge(@scenario_outline)
+            @scenario_outline = nil
+          end
+
+          @feature.add_to_tag_node(Node.new($1.strip), @current_tags)
+          @current_tags = []
+        when SCENARIO_OUTLINE_LINE
+          # ... another is when we hit a subsequent "Scenario Outline:"
+          if @scenario_outline
+            @feature.merge(@scenario_outline)
+            @scenario_outline = nil
+          end
+
+          @scenario_outline  = TagListNode.new($1.strip, @current_tags)
+          @current_tags = []
+        when EXAMPLES_LINE, SCENARIOS_LINE
+          @scenario_outline.add_to_tag_node(Node.new($1.strip), @feature.universal_tags | @current_tags)
+          @current_tags = []
+        end
+      end
+
+      # EOF is the final way that we know we are finished with a "Scenario Outline"
+      @feature.merge(@scenario_outline) if @scenario_outline
+      return @feature
+    end
+
+  end
+
+end

data/lib/cuporter/formatters/csv.rb

@@ -0,0 +1,11 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+module Cuporter
+  module Formatters
+    class Csv < Writer
+      include TextMethods
+      
+      TAB = ","
+
+    end
+  end
+end

data/lib/cuporter/formatters/html.rb

@@ -0,0 +1,70 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+require 'rubygems'
+require 'erb'
+require 'builder'
+
+module Cuporter
+  module Formatters
+    class Html < Writer
+
+      NODE_CLASS = [:tag, :feature, :scenario, :example]
+
+      def write_nodes
+        @report.children.sort.each do |tag_node|
+          write_node(tag_node, 0)
+        end
+        builder
+      end
+
+      def builder
+        @builder ||= Builder::XmlMarkup.new
+      end
+
+      def write_node(node, indent_level)
+        builder.li do |list_item|
+          list_item.span(node.name, :class => NODE_CLASS[indent_level])
+          if node.has_children?
+            list_item.ul do |list|
+              node.children.sort.each do |child|
+                if child.has_children?
+                  write_node(child, indent_level + 1)
+                else
+                  list.li(child.name, :class => NODE_CLASS[indent_level + 1])
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def get_binding
+        binding
+      end
+
+      def rhtml
+        ERB.new(RHTML)
+      end
+
+      def write
+        @output.puts rhtml.result(get_binding).reject {|line| /^\s+$/ =~ line}
+      end
+
+  RHTML = %{
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+    <title>Cucumber Tags</title>
+    <style type="text/css"></style>
+</head>
+<body>
+    <ul>
+      <%= write_nodes%>
+    </ul>
+</body>
+</html>
+  }
+  
+
+    end
+  end
+end

data/lib/cuporter/formatters/text.rb

@@ -0,0 +1,11 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+module Cuporter
+  module Formatters
+    class Text < Writer
+      include TextMethods
+
+      TAB = "  "
+
+    end
+  end
+end

data/lib/cuporter/formatters/text_methods.rb

@@ -0,0 +1,28 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+module Cuporter
+  module Formatters
+    module TextMethods
+    
+      def write
+        @report.children.sort.each do |tag_node|
+          write_node(tag_node, 0)
+        end
+      end
+
+      def write_node(node, tab_stops)
+        @output.puts "#{self.class::TAB * tab_stops}#{node.name}"
+        node.children.sort.each do |child|
+          @output.puts "#{self.class::TAB + (self.class::TAB * tab_stops)}#{child.name}"
+          child.children.sort.each do |grand_child|
+            if grand_child.has_children?
+              write_node(grand_child, tab_stops + 2)
+            else
+              @output.puts "#{self.class::TAB * tab_stops}#{self.class::TAB * 2}#{grand_child.name}"
+            end
+          end
+        end
+      end
+    
+    end
+  end
+end

data/lib/cuporter/formatters/writer.rb

@@ -0,0 +1,17 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+
+module Cuporter
+  module Formatters
+    class Writer
+
+      def initialize(report, output)
+        @report = report
+        if output
+          @output = File.open(output, "w")
+        else
+          @output = STDOUT
+        end
+      end
+    end
+  end
+end

data/lib/cuporter/node.rb

@@ -0,0 +1,72 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+module Cuporter
+  class Node
+    include Comparable
+
+    attr_reader :name, :children
+
+    def initialize(name)
+      @name = name
+      @children = []
+    end
+
+    def has_children?
+      @children.size > 0
+    end
+
+    # will not add duplicate
+    def add_child(node)
+      @children << node unless has_child?(node)
+    end
+
+    def find_or_create_child(name)
+      child_node = self[name]
+      unless child_node
+        children << Node.new(name)
+        child_node = children.last
+      end
+      child_node
+    end
+
+    def find_by_name(name)
+      children.find {|c| c.name == name.to_s}
+    end
+    alias :[] :find_by_name
+
+    def find(node)
+      children.find {|c| c == node}
+    end
+    alias :has_child? :find
+    
+    def name_without_title
+      @name_without_title ||= name.split(/:\s+/).last
+    end
+
+    # sort on name or substring of name after any ':'
+    def <=>(other)
+      name_without_title <=> other.name_without_title
+    end
+    
+    # value equivalence
+    def eql?(other)
+      name == other.name && children == other.children
+    end
+    alias :== :eql?
+
+    # Have my children adopt the other node's grandchildren.
+    #
+    # Copy children of other node's top-level, direct descendants to this 
+    # node's direct descendants of the same name.
+    def merge(other)
+      other.children.each do |other_child|
+        direct_child = find_or_create_child(other_child.name)
+        new_grandchild = Node.new(other.name)
+        other_child.children.collect do |c|
+          new_grandchild.add_child(c)
+        end
+        direct_child.add_child(new_grandchild)
+      end
+    end
+
+  end
+end

data/lib/cuporter/tag_list_node.rb

@@ -0,0 +1,25 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+module Cuporter
+  # a node with a list of tags that apply to all children
+  class TagListNode < Node
+
+    attr_reader :universal_tags
+
+    def initialize(name, universal_tags)
+      super(name)
+      @universal_tags = universal_tags
+    end
+
+    def has_universal_tags?
+      @universal_tags.size > 0
+    end
+
+    def add_to_tag_node(node, childs_tags = [])
+      (universal_tags | childs_tags).each do |tag|
+        tag_node = find_or_create_child(tag)
+        tag_node.add_child(node)
+      end
+    end
+
+  end
+end

data/lib/cuporter/tag_report.rb

@@ -0,0 +1,23 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+module Cuporter
+  class TagReport
+
+    def initialize(input_file_pattern)
+      @input_file_pattern = input_file_pattern || "features/**/*.feature"
+    end
+
+    def files
+      Dir[@input_file_pattern].collect {|f| File.expand_path f}
+    end
+
+    def scenarios_per_tag
+      tags = TagListNode.new("report",[])
+      files.each do |file|
+        content = File.read(file)
+        tags.merge(FeatureParser.parse(content)) unless content.empty?
+      end
+      tags
+    end
+
+  end
+end

data/lib/cuporter.rb

@@ -0,0 +1,12 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+require 'cuporter/node'
+require 'cuporter/tag_list_node'
+require 'cuporter/feature_parser'
+require 'cuporter/extensions/string'
+require 'cuporter/cli/options'
+require 'cuporter/tag_report'
+require 'cuporter/formatters/writer'
+require 'cuporter/formatters/text_methods'
+require 'cuporter/formatters/text'
+require 'cuporter/formatters/csv'
+require 'cuporter/formatters/html'

data/spec/cuporter/feature_parser_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Cuporter
+  describe FeatureParser do
+    context "#universal_tags" do
+      context "one tag" do
+        it "returns one tag" do
+          feature = FeatureParser.parse("@wip\nFeature: foo")
+          feature.universal_tags.should == ["@wip"]
+        end
+      end
+
+      context "two tags on one line" do
+        it "returns two tags" do
+          feature = FeatureParser.parse(" \n@smoke @wip\nFeature: foo")
+          feature.universal_tags.sort.should == %w[@smoke @wip].sort
+        end
+      end
+      context "two tags on two lines" do
+        it "returns two tags" do
+          feature = FeatureParser.parse(" \n@smoke\n @wip\nFeature: foo")
+          feature.universal_tags.sort.should == %w[@smoke @wip].sort
+        end
+      end
+      context "no tags" do
+        it "returns no tags" do
+          feature = FeatureParser.parse("\nFeature: foo")
+          feature.universal_tags.should == []
+        end
+      end
+
+    end
+
+    context "#name" do
+      let(:name) {"Feature: consume a fairly typical feature name, and barf it back up"}
+      context "sentence with comma" do
+        it "returns the full name" do
+          feature = FeatureParser.parse("\n#{name}\n  Background: blah")
+          feature.name.should == name
+        end
+      end
+      context "name followed by comment" do
+        it "returns only the full name" do
+          feature = FeatureParser.parse("# Here is a feature comment\n# And another comment\n #{name} # comment text here\n  Background: blah")
+          feature.name.should == name
+        end
+      end
+
+    end
+
+  end
+end
+