kosmas58-cucumber 0.1.99.21 → 0.1.99.22

data/lib/cucumber/ast/tags.rb

@@ -1,40 +0,0 @@
-module Cucumber
-  module Ast
-    # Holds the names of tags parsed from a feature file:
-    #
-    #   @invoice @release_2
-    #
-    # This gets stored internally as <tt>["invoice", "release_2"]</tt>
-    #
-    class Tags
-      def initialize(line, tag_names)
-        @line, @tag_names = line, tag_names
-      end
-
-      def among?(tag_names)
-        no_tags, yes_tags = tag_names.partition{|tag| tag =~ /^\!/}
-        no_tags = no_tags.map{|tag| tag[1..-1]}
-
-        # Strip @
-        yes_tags = yes_tags.map{|tag| tag =~ /^@(.*)/ ? $1 : tag}
-        no_tags = no_tags.map{|tag| tag =~ /^@(.*)/ ? $1 : tag}
-
-        (@tag_names & yes_tags).any? && (@tag_names & no_tags).empty?
-      end
-
-      def at_lines?(lines)
-        lines.empty? || lines.index(@line)
-      end
-
-      def accept(visitor)
-        @tag_names.each do |tag_name|
-          visitor.visit_tag_name(tag_name)
-        end
-      end
-      
-      def to_sexp
-        @tag_names.map{|tag_name| [:tag, tag_name]}
-      end
-    end
-  end
-end

data/lib/cucumber/ast/visitor.rb

@@ -1,109 +0,0 @@
-module Cucumber
-  module Ast
-    # A dumb visitor that implements the whole Visitor API and just walks the tree.
-    class Visitor
-      attr_accessor :options
-
-      def initialize(step_mother)
-        @step_mother = step_mother
-      end
-
-      def world(scenario, world = nil, &proc)
-        @step_mother.world(scenario, world, &proc)
-      end
-
-      def new_world
-        @step_mother.new_world
-      end
-
-      def step_definition(step_name)
-        @step_mother.step_definition(step_name)
-      end
-
-      def current_feature_lines=(lines)
-        @current_feature_lines = lines
-      end
-
-      def current_feature_lines
-        @current_feature_lines || []
-      end
-
-      def visit_features(features)
-        features.accept(self)
-      end
-
-      def visit_feature(feature)
-        feature.accept(self)
-      end
-
-      def visit_comment(comment)
-        comment.accept(self)
-      end
-
-      def visit_comment_line(comment_line)
-      end
-
-      def visit_tags(tags)
-        tags.accept(self)
-      end
-
-      def visit_tag_name(tag_name)
-      end
-
-      def visit_feature_name(name)
-      end
-
-      # +feature_element+ is either Scenario or ScenarioOutline
-      def visit_feature_element(feature_element)
-        feature_element.accept(self)
-      end
-
-      def visit_background(background)
-        background.accept(self)
-      end
-
-      def visit_examples(examples)
-        examples.accept(self)
-      end
-
-      def visit_examples_name(keyword, name)
-      end
-
-      def visit_outline_table(outline_table)
-        outline_table.accept(self, nil)
-      end
-
-      def visit_scenario_name(keyword, name, file_line, source_indent)
-      end
-
-      def visit_steps(steps)
-        steps.accept(self)
-      end
-
-      def visit_step(step)
-        step.accept(self)
-      end
-
-      def visit_step_name(keyword, step_name, status, step_definition, source_indent)
-      end
-
-      def visit_multiline_arg(multiline_arg, status)
-        multiline_arg.accept(self, status)
-      end
-
-      def visit_py_string(string, status)
-      end
-
-      def visit_table_row(table_row, status)
-        table_row.accept(self, status)
-      end
-
-      def visit_table_cell(table_cell, status)
-        table_cell.accept(self, status)
-      end
-
-      def visit_table_cell_value(value, width, status)
-      end
-    end
-  end
-end

data/lib/cucumber/ast.rb

@@ -1,29 +0,0 @@
-require 'cucumber/ast/comment'
-require 'cucumber/ast/tags'
-require 'cucumber/ast/features'
-require 'cucumber/ast/feature'
-require 'cucumber/ast/scenario'
-require 'cucumber/ast/scenario_outline'
-require 'cucumber/ast/background'
-require 'cucumber/ast/steps'
-require 'cucumber/ast/step'
-require 'cucumber/ast/table'
-require 'cucumber/ast/py_string'
-require 'cucumber/ast/outline_table'
-require 'cucumber/ast/examples'
-require 'cucumber/ast/visitor'
-require 'cucumber/ast/filter'
-
-module Cucumber
-  # Classes in this module represent the Abstract Syntax Tree (AST)
-  # that gets built when feature files are parsed.
-  #
-  # AST classes don't expose any internal data directly. This is
-  # in order to encourage a less coupled design in the classes
-  # that operate on the AST. The only public method is #accept.
-  #
-  # The AST can be traversed with a visitor. See Cucumber::Format::Pretty
-  # for an example.
-  module Ast
-  end
-end

data/lib/cucumber/broadcaster.rb

@@ -1,15 +0,0 @@
-module Cucumber
-  class Broadcaster
-
-    def initialize(receivers = [])
-      @receivers = receivers
-    end
-
-    def method_missing(method_name, *args)
-      @receivers.each  do |receiver|
-        receiver.__send__(method_name, *args)
-      end
-    end
-
-  end
-end

data/lib/cucumber/cli/configuration.rb

@@ -1,339 +0,0 @@
-module Cucumber
-  module Cli
-    class YmlLoadError < StandardError; end
-  
-    class Configuration
-      FORMATS = %w{pretty profile progress rerun}
-      DEFAULT_FORMAT = 'pretty'
-    
-      attr_reader :paths
-      attr_reader :options
-    
-      def initialize(out_stream = STDOUT, error_stream = STDERR)
-        @out_stream   = out_stream
-        @error_stream = error_stream
-      
-        @paths          = []
-        @options        = default_options
-        @active_format  = DEFAULT_FORMAT
-      end
-    
-      def parse!(args)
-        @args = args
-        return parse_args_from_profile('default') if @args.empty?
-        @args.extend(::OptionParser::Arguable)
-      
-        @args.options do |opts|
-          opts.banner = ["Usage: cucumber [options] [ [FILE|DIR|URL][:LINE[:LINE]*] ]+", "",
-            "Examples:",
-            "cucumber examples/i18n/en/features",
-            "cucumber --language it examples/i18n/it/features/somma.feature:6:98:113",
-            "cucumber -n -i http://rubyurl.com/eeCl", "", "",
-          ].join("\n")
-          opts.on("-r LIBRARY|DIR", "--require LIBRARY|DIR", 
-            "Require files before executing the features. If this",
-            "option is not specified, all *.rb files that are",
-            "siblings or below the features will be loaded auto-",
-            "matically. Automatic loading is disabled when this",
-            "option is specified, and all loading becomes explicit.",
-            "Files under directories named \"support\" are always",
-            "loaded first.",
-            "This option can be specified multiple times.") do |v|
-            @options[:require] ||= []
-            @options[:require] << v
-          end
-          opts.on("-l LANG", "--language LANG", 
-            "Specify language for features (Default: #{@options[:lang]})",
-            %{Run with "--language help" to see all languages},
-            %{Run with "--language LANG help" to list keywords for LANG}) do |v|
-            if v == 'help'
-              list_languages
-            elsif args==['help']
-              list_keywords(v)
-            else
-              @options[:lang] = v
-            end
-          end
-          opts.on("-f FORMAT", "--format FORMAT", 
-            "How to format features (Default: #{DEFAULT_FORMAT})",
-            "Available formats: #{FORMATS.join(", ")}",
-            "You can also provide your own formatter classes as long",
-            "as they have been previously required using --require or",
-            "if they are in the folder structure such that cucumber",
-            "will require them automatically.", 
-            "This option can be specified multiple times.") do |v|
-            @options[:formats][v] = @out_stream
-            @active_format = v
-          end
-          opts.on("-o", "--out FILE", 
-            "Write output to a file instead of STDOUT. This option",
-            "applies to the previously specified --format, or the",
-            "default format if no format is specified.") do |v|
-            @options[:formats][@active_format] = v
-          end
-          opts.on("-t TAGS", "--tags TAGS", 
-            "Only execute the features or scenarios with the specified tags.",
-            "TAGS must be comma-separated without spaces. Prefix tags with ! to",
-            "exclude features or scenarios having that tag. tags can be specified",
-            "with or without the @ prefix.") do |v|
-            @options[:tags] = v.split(",")
-          end
-          opts.on("-s SCENARIO", "--scenario SCENARIO", 
-            "Only execute the scenario with the given name. If this option",
-            "is given more than once, run all the specified scenarios.") do |v|
-            @options[:scenario_names] << v
-          end
-          opts.on("-e", "--exclude PATTERN", "Don't run feature files matching PATTERN") do |v|
-            @options[:excludes] << v
-          end
-          opts.on("-p", "--profile PROFILE", "Pull commandline arguments from cucumber.yml.") do |v|
-            parse_args_from_profile(v)
-          end
-          opts.on("-c", "--[no-]color",
-            "Whether or not to use ANSI color in the output. Cucumber decides",
-            "based on your platform and the output destination if not specified.") do |v|
-            Term::ANSIColor.coloring = v
-          end
-          opts.on("-d", "--dry-run", "Invokes formatters without executing the steps.",
-            "Implies --quiet.") do
-            @options[:dry_run] = true
-            @quiet = true
-          end
-          opts.on("-a", "--autoformat DIRECTORY", 
-            "Reformats (pretty prints) feature files and write them to DIRECTORY.",
-            "Be careful if you choose to overwrite the originals.",
-            "Implies --dry-run --formatter pretty.") do |directory|
-            @options[:autoformat] = directory
-            Term::ANSIColor.coloring = false
-            @options[:dry_run] = true
-            @quiet = true
-          end
-          opts.on("-m", "--no-multiline", 
-            "Don't print multiline strings and tables under steps.") do
-            @options[:no_multiline] = true
-          end
-          opts.on("-n", "--no-source", 
-            "Don't print the file and line of the step definition with the steps.") do
-            @options[:source] = false
-          end
-          opts.on("-i", "--no-snippets", "Don't print snippets for pending steps.") do
-            @options[:snippets] = false
-          end
-          opts.on("-q", "--quiet", "Alias for --no-snippets --no-source.") do
-            @quiet = true
-          end
-          opts.on("-b", "--backtrace", "Show full backtrace for all errors.") do
-            Exception.cucumber_full_backtrace = true
-          end
-          opts.on("--strict", "Fail if there are any undefined steps.") do
-            @options[:strict] = true
-          end
-          opts.on("-v", "--verbose", "Show the files and features loaded.") do
-            @options[:verbose] = true
-          end
-          opts.on("-g", "--guess", "Guess best match for Ambiguous steps.") do
-            @options[:guess] = true
-          end
-          opts.on_tail("--version", "Show version.") do
-            @out_stream.puts VERSION::STRING
-            Kernel.exit
-          end
-          opts.on_tail("--help", "You're looking at it.") do
-            @out_stream.puts opts.help
-            Kernel.exit
-          end
-        end.parse!
-
-        @options[:formats]['pretty'] = @out_stream if @options[:formats].empty?
-
-        @options[:snippets] = true if !@quiet && @options[:snippets].nil?
-        @options[:source]   = true if !@quiet && @options[:source].nil?
-
-        # Whatever is left after option parsing is the FILE arguments
-        @paths += args
-      end
-    
-      def ast_filter
-        Ast::Filter.new(@options)
-      end
-    
-      def verbose?
-        @options[:verbose]
-      end
-    
-      def strict?
-        @options[:strict]
-      end
-      
-      def guess?
-        !!@options[:guess]
-      end
-    
-      def load_language
-        Cucumber.load_language(@options[:lang])
-      
-        if Cucumber.language_incomplete?
-          list_keywords(Cucumber.lang)
-        end
-      end
-    
-      def build_formatter_broadcaster(step_mother)
-        return Formatter::Pretty.new(step_mother, nil, @options) if @options[:autoformat]
-        formatters = @options[:formats].map do |format, out|
-          if String === out # file name
-            out = File.open(out, Cucumber.file_mode('w'))
-            at_exit do
-              out.flush
-              out.close
-            end
-          end
-        
-          begin
-            formatter_class = formatter_class(format)
-            formatter_class.new(step_mother, out, @options)
-          rescue Exception => e
-            exit_with_error("Error creating formatter: #{format}", e)
-          end
-        end
-      
-        broadcaster = Broadcaster.new(formatters)
-        broadcaster.options = @options
-        return broadcaster
-      end
-    
-      def formatter_class(format)
-        case format
-          when 'pretty'   then Formatter::Pretty
-          when 'progress' then Formatter::Progress
-          when 'profile'  then Formatter::Profile
-          when 'rerun'    then Formatter::Rerun
-          when 'html'     then Formatter::Html
-        else
-          constantize(format)
-        end
-      end
-    
-      def files_to_require
-        requires = @options[:require] || feature_dirs
-        files = requires.map do |path|
-          path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
-          File.directory?(path) ? Dir["#{path}/**/*.rb"] : path
-        end.flatten.uniq
-        files.sort { |a,b| (b =~ %r{/support/} || -1) <=>  (a =~ %r{/support/} || -1) }.reject{|f| f =~ /^http/}
-      end
-    
-      def feature_files
-        potential_feature_files = @paths.map do |path|
-          path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
-          path = path.chomp('/')
-          File.directory?(path) ? Dir["#{path}/**/*.feature"] : path
-        end.flatten.uniq
-
-        @options[:excludes].each do |exclude|
-          potential_feature_files.reject! do |path|
-            path =~ /#{Regexp.escape(exclude)}/
-          end
-        end
-
-        potential_feature_files
-      end
-    
-    protected
-  
-      def feature_dirs
-        feature_files.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
-      end
-    
-      def constantize(camel_cased_word)
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
-
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-        end
-        constant
-      end
-    
-      def parse_args_from_profile(profile)
-        unless cucumber_yml.has_key?(profile)
-          return(exit_with_error <<-END_OF_ERROR)
-Could not find profile: '#{profile}'
-
-Defined profiles in cucumber.yml:
-  * #{cucumber_yml.keys.join("\n  * ")}
-        END_OF_ERROR
-        end
-
-        args_from_yml = cucumber_yml[profile] || ''
-
-        if !args_from_yml.is_a?(String)
-          exit_with_error "Profiles must be defined as a String.  The '#{profile}' profile was #{args_from_yml.inspect} (#{args_from_yml.class}).\n"
-        elsif args_from_yml =~ /^\s*$/
-          exit_with_error "The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml.\n"
-        else
-          parse!(args_from_yml.split(' '))
-        end
-
-      rescue YmlLoadError => e
-        exit_with_error(e.message)
-      end
-    
-      def cucumber_yml
-        return @cucumber_yml if @cucumber_yml
-        unless File.exist?('cucumber.yml')
-          raise(YmlLoadError,"cucumber.yml was not found.  Please refer to cucumber's documentaion on defining profiles in cucumber.yml.  You must define a 'default' profile to use the cucumber command without any arguments.\nType 'cucumber --help' for usage.\n")
-        end
-
-        require 'yaml'
-        begin
-          @cucumber_yml = YAML::load(IO.read('cucumber.yml'))
-        rescue Exception => e
-          raise(YmlLoadError,"cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentaion on correct profile usage.\n")
-        end
-
-        if @cucumber_yml.nil? || !@cucumber_yml.is_a?(Hash)
-          raise(YmlLoadError,"cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentaion on correct profile usage.\n")
-        end
-
-        return @cucumber_yml
-      end
-    
-      def list_keywords(lang)
-        unless Cucumber::LANGUAGES[lang]
-          exit_with_error("No language with key #{lang}")
-        end
-        LanguageHelpFormatter.list_keywords(@out_stream, lang)
-        Kernel.exit
-      end
-    
-      def list_languages
-        LanguageHelpFormatter.list_languages(@out_stream)
-        Kernel.exit
-      end
-    
-      def default_options
-        {
-          :strict   => false,
-          :require  => nil,
-          :lang     => 'en',
-          :dry_run  => false,
-          :formats  => {},
-          :excludes => [],
-          :tags     => [],
-          :scenario_names => []
-        }
-      end
-    
-      def exit_with_error(error_message, e=nil)
-        @error_stream.puts(error_message)
-        if e
-          @error_stream.puts("#{e.message} (#{e.class})")
-          @error_stream.puts(e.backtrace.join("\n"))
-        end
-        Kernel.exit 1
-      end
-    end
-  
-  end
-end

data/lib/cucumber/cli/language_help_formatter.rb

@@ -1,59 +0,0 @@
-require 'cucumber/formatter/pretty'
-
-module Cucumber
-  module Cli
-    class LanguageHelpFormatter < Formatter::Pretty
-      INCOMPLETE = %{
-The Cucumber grammar has evolved since this translation was written.
-Please help us complete the translation by translating the missing words in
-
-#{Cucumber::LANGUAGE_FILE}
-
-Then contribute back to the Cucumber project. Details here:
-http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
-}
-
-      def self.list_languages(io)
-        raw = Cucumber::LANGUAGES.keys.sort.map do |lang|
-          [lang, Cucumber::LANGUAGES[lang]['name'], Cucumber::LANGUAGES[lang]['native']]
-        end
-        table = Ast::Table.new(raw)
-        new(nil, io, {:check_lang=>true}, '').visit_multiline_arg(table, :passed)
-      end
-
-      def self.list_keywords(io, lang)
-        raw = Cucumber::KEYWORD_KEYS.map do |key|
-          [key, Cucumber::LANGUAGES[lang][key]]
-        end
-        table = Ast::Table.new(raw)
-        new(nil, io, {:incomplete => Cucumber.language_incomplete?(lang)}, '').visit_multiline_arg(table, :passed)
-      end
-
-      def visit_multiline_arg(table, status)
-        if @options[:incomplete]
-          @io.puts(format_string(INCOMPLETE, :failed))
-        end
-        super
-      end
-
-      def visit_table_row(table_row, status)
-        @col = 1
-        super
-      end
-
-      def visit_table_cell_value(value, width, status)
-        if @col == 1
-          if(@options[:check_lang])
-            @incomplete = Cucumber.language_incomplete?(value)
-          end
-          status = :comment 
-        elsif @incomplete
-          status = :failed
-        end
-        
-        @col += 1
-        super(value, width, status)
-      end
-    end
-  end
-end

data/lib/cucumber/cli/main.rb

@@ -1,100 +0,0 @@
-require 'optparse'
-require 'cucumber'
-require 'ostruct'
-require 'cucumber/parser'
-require 'cucumber/formatter'
-require 'cucumber/cli/language_help_formatter'
-require 'cucumber/cli/configuration'
-
-module Cucumber
-  module Cli
-    class Main
-      class << self
-        def step_mother=(step_mother)
-          @step_mother = step_mother
-          @step_mother.extend(StepMother)
-          @step_mother.snippet_generator = StepDefinition
-        end
-
-        def execute(args)
-          new(args).execute!(@step_mother)
-        end
-      end
-
-      def initialize(args, out_stream = STDOUT, error_stream = STDERR)
-        @args         = args
-        @out_stream   = out_stream == STDOUT ? Formatter::ColorIO.new : out_stream
-        @error_stream = error_stream
-      end
-      
-      def execute!(step_mother)
-        configuration.load_language
-        step_mother.options = configuration.options
-
-        require_files
-        enable_diffing
-      
-        features = load_plain_text_features
-
-        visitor = configuration.build_formatter_broadcaster(step_mother)
-        visitor.visit_features(features)
-      
-        failure = features.steps[:failed].any? || (configuration.strict? && features.steps[:undefined].length)
-        Kernel.exit(failure ? 1 : 0)
-      end
-
-      private
-
-      def configuration
-        return @configuration if @configuration
-      
-        @configuration = Configuration.new(@out_stream, @error_stream)
-        @configuration.parse!(@args)
-        @configuration
-      end
-    
-      def require_files
-        verbose_log("Ruby files required:")
-        configuration.files_to_require.each do |lib|
-          begin
-            require lib
-            verbose_log("  * #{lib}")
-          rescue LoadError => e
-            e.message << "\nFailed to load #{lib}"
-            raise e
-          end
-        end
-        verbose_log("\n")
-      end
-
-      def load_plain_text_features
-        filter = configuration.ast_filter
-        features = Ast::Features.new(filter)
-        parser = Parser::FeatureParser.new
-
-        verbose_log("Features:")
-        configuration.feature_files.each do |f|
-          features.add_feature(parser.parse_file(f))
-          verbose_log("  * #{f}")
-        end
-        verbose_log("\n"*2)
-        features
-      end
-
-      def verbose_log(string)
-        @out_stream.puts(string) if configuration.verbose?
-      end
-
-      def enable_diffing
-        if defined?(::Spec)
-          require 'spec/expectations/differs/default'
-          options = OpenStruct.new(:diff_format => :unified, :context_lines => 3)
-          ::Spec::Expectations.differ = ::Spec::Expectations::Differs::Default.new(options)
-        end
-      end
-    
-    end
-  end
-end
-
-Cucumber::Cli::Main.step_mother = self