mack 0.8.2 → 0.8.3

data/lib/gems/configatron-2.2.2/lib/configatron/errors.rb

@@ -0,0 +1,13 @@
+class Configatron
+  class ProtectedParameter < StandardError
+    def intialize(name)
+      super("Can not modify protected parameter: '#{name}'")
+    end
+  end
+
+  class LockedNamespace < StandardError
+    def initialize(name)
+      super("Cannot add new parameters to locked namespace: #{name.inspect}")
+    end
+  end
+end

data/lib/gems/{configatron-2.1.5 → configatron-2.2.2}/lib/configatron/store.rb

@@ -1,5 +1,6 @@
 class Configatron
   class Store
+    alias_method :send!, :send
     
     # Takes an optional Hash of parameters
     def initialize(options = {}, name = nil, parent = nil)
@@ -28,9 +29,9 @@ class Configatron
       f_out = []
       @_store.each do |k, v|
         if v.is_a?(Configatron::Store)
-          v.inspect.each do |line|
+          v.inspect.each_line do |line|
             if line.match(/\n/)
-              line.each do |l|
+              line.each_line do |l|
                 l.strip!
                 f_out << l
               end
@@ -93,7 +94,8 @@ class Configatron
     def method_missing(sym, *args) # :nodoc:
       if sym.to_s.match(/(.+)=$/)
         name = sym.to_s.gsub("=", '').to_sym
-        raise Configatron::ProtectedParameter.new(name) if @_protected.include?(name) || self.methods.include?(name.to_s)
+        raise Configatron::ProtectedParameter.new(name) if @_protected.include?(name) || methods_include?(name)
+        raise Configatron::LockedNamespace.new(@_name) if @_locked && !@_store.has_key?(name)
         @_store[name] = parse_options(*args)
       elsif @_store.has_key?(sym)
         return @_store[sym]
@@ -113,7 +115,7 @@ class Configatron
     def protect(name)
       @_protected << name.to_sym
     end
-    
+
     # Prevents all parameters from being reassigned.
     def protect_all!
       @_protected.clear
@@ -136,6 +138,20 @@ class Configatron
         val.unprotect_all! if val.class == Configatron::Store
       end
     end
+
+    # Prevents a namespace from having new parameters set. The lock is applied
+    # recursively to any namespaces below it.
+    def lock(name)
+      namespace = @_store[name.to_sym]
+      raise ArgumentError, "Namespace #{name.inspect} does not exist" if namespace.nil?
+      namespace.lock!
+    end
+
+    def unlock(name)
+      namespace = @_store[name.to_sym]
+      raise ArgumentError, "Namespace #{name.inspect} does not exist" if namespace.nil?
+      namespace.unlock!
+    end
     
     # = DeepClone
     #
@@ -196,7 +212,7 @@ class Configatron
             }
           end
           cl.instance_variables.each do |var|
-            v = cl.instance_eval( var )
+            v = cl.instance_eval( var.to_s )
             v_cl = deep_clone( v, cloned )
             cl.instance_eval( "#{var} = v_cl" )
           end
@@ -205,7 +221,22 @@ class Configatron
       end
     end
     
+    protected
+    def lock!
+      @_locked = true
+      @_store.values.each { |store| store.lock! if store.is_a?(Configatron::Store) }
+    end
+
+    def unlock!
+      @_locked = false
+      @_store.values.each { |store| store.unlock! if store.is_a?(Configatron::Store) }
+    end
+    
     private
+    def methods_include?(name)
+      self.methods.include?(RUBY_VERSION > '1.9.0' ? name.to_sym : name.to_s)
+    end
+    
     def parse_options(options)
       if options.is_a?(Hash)
         options.each do |k,v|
@@ -221,4 +252,4 @@ class Configatron
     end
     
   end
-end
+end

data/lib/gems/cucumber-0.1.15/lib/autotest/cucumber.rb

@@ -0,0 +1,6 @@
+require 'autotest'
+require 'autotest/cucumber_mixin'
+
+class Autotest::Cucumber < Autotest
+  include CucumberMixin
+end

data/lib/gems/cucumber-0.1.15/lib/autotest/cucumber_mixin.rb

@@ -0,0 +1,130 @@
+require 'autotest'
+require 'tempfile'
+require File.dirname(__FILE__) + '/../cucumber/platform'
+
+module Autotest::CucumberMixin
+  def self.included(receiver)
+    receiver::ALL_HOOKS << [:run_features, :ran_features]
+  end
+  
+  attr_accessor :scenarios_to_run
+  
+  def initialize
+    super
+    reset_features
+  end
+  
+  def run
+    hook :initialize
+    reset
+    reset_features
+    add_sigint_handler
+
+    self.last_mtime = Time.now if $f
+
+    loop do # ^c handler
+      begin
+        get_to_green
+        if self.tainted then
+          rerun_all_tests
+          rerun_all_features if all_good
+        else
+          hook :all_good
+        end
+        wait_for_changes
+        # Once tests and features are green, reset features every
+        # time a file is changed to see if anything breaks.
+        reset_features
+      rescue Interrupt
+        break if self.wants_to_quit
+        reset
+        reset_features
+      end
+    end
+    hook :quit
+  end
+  
+  def all_features_good
+    scenarios_to_run == []
+  end
+  
+  def get_to_green
+    begin
+      super
+      run_features
+      wait_for_changes unless all_features_good
+    end until all_features_good
+  end
+  
+  def rerun_all_features
+    reset_features
+    run_features
+  end
+  
+  def reset_features
+    self.scenarios_to_run = :all
+  end
+    
+  def run_features
+    hook :run_features
+    Tempfile.open('autotest-cucumber') do |dirty_scenarios_file|
+      cmd = self.make_cucumber_cmd self.scenarios_to_run, dirty_scenarios_file.path
+      return if cmd.empty?
+      puts cmd unless $q
+      old_sync = $stdout.sync
+      $stdout.sync = true
+      self.results = []
+      line = []
+      begin
+        open("| #{cmd}", "r") do |f|
+          until f.eof? do
+            c = f.getc
+            putc c
+            line << c
+            if c == ?\n then
+              self.results << if RUBY_VERSION >= "1.9" then
+                                line.join
+                              else
+                                line.pack "c*"
+                              end
+              line.clear
+            end
+          end
+        end
+      ensure
+        $stdout.sync = old_sync
+      end
+      self.scenarios_to_run = dirty_scenarios_file.readlines.map { |l| l.chomp }
+      self.tainted = true unless self.scenarios_to_run == []
+    end
+    hook :ran_features
+  end
+  
+  def make_cucumber_cmd(scenarios_to_run, dirty_scenarios_filename)
+    return '' if scenarios_to_run == []
+    
+    profiles = YAML.load_file("cucumber.yml").keys rescue []
+    
+    profile ||= "autotest-all" if profiles.include?("autotest-all") and scenarios_to_run == :all
+    profile ||= "autotest"     if profiles.include?("autotest")
+    profile ||= nil
+    
+    if profile
+      args = ["--profile", profile]
+    else
+      args = %w{features --format} << (scenarios_to_run == :all ? "progress" : "pretty")
+    end
+    args += %w{--format autotest --color --out} << dirty_scenarios_filename
+    args = args.join(' ')
+    
+    if scenarios_to_run == :all
+      scenario_args = nil
+    else
+      # We escape scenario names for the shell by wrapping them in $'...' and replacing
+      # every single quote with an escaped version, "\'".  We use a double backslash for
+      # Ruby, and we put it in a block or gsub interpolates the sequence "\'" as $'.
+      scenario_args = scenarios_to_run.map { |s| "-s $'#{s.gsub("'") {"\\'"} }'" }.join(' ')
+    end
+    return "#{Cucumber::RUBY_BINARY} #{Cucumber::BINARY} #{args} #{scenario_args}"
+  end
+end

data/lib/gems/cucumber-0.1.15/lib/autotest/cucumber_rails.rb

@@ -0,0 +1,6 @@
+require 'autotest/rails'
+require 'autotest/cucumber_mixin'
+
+class Autotest::CucumberRails < Autotest::Rails
+  include CucumberMixin
+end

data/lib/gems/cucumber-0.1.15/lib/autotest/cucumber_rails_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rails_rspec'
+
+class Autotest::CucumberRailsRspec < Autotest::RailsRspec
+  include CucumberMixin
+end

data/lib/gems/cucumber-0.1.15/lib/autotest/cucumber_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rspec'
+
+class Autotest::CucumberRspec < Autotest::Rspec
+  include CucumberMixin
+end

data/lib/gems/cucumber-0.1.15/lib/autotest/discover.rb

@@ -0,0 +1,9 @@
+Autotest.add_discovery do
+  if File.directory?('features')
+    if ENV['AUTOFEATURE'] =~ /true/i
+      "cucumber"
+    else
+      puts "(Not running features.  To run features in autotest, set AUTOFEATURE=true.)"
+    end
+  end
+end

data/lib/gems/cucumber-0.1.15/lib/cucumber.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'cucumber/platform'
+require 'rubygems'
+require 'treetop/runtime'
+require 'treetop/ruby_extensions'
+require 'cucumber/version'
+require 'cucumber/step_methods'
+require 'cucumber/tree'
+require 'cucumber/model'
+require 'cucumber/executor'
+require 'cucumber/step_mother'
+require 'cucumber/formatters'
+require 'cucumber/treetop_parser/feature_parser'
+require 'cucumber/cli'
+require 'cucumber/broadcaster'
+require 'cucumber/world'
+require 'cucumber/core_ext/exception'

data/lib/gems/cucumber-0.1.15/lib/cucumber/broadcaster.rb

@@ -0,0 +1,20 @@
+module Cucumber
+  class Broadcaster
+
+    def initialize(receivers = [])
+      @receivers = receivers
+    end
+
+    def register(receiver)
+      @receivers << receiver
+    end
+
+    def method_missing(method_name, *args)
+      @receivers.each  do |receiver|
+        r = (receiver == STDOUT) ? Kernel : receiver # Needed to make colors work on Windows
+        r.__send__(method_name, *args) if receiver.respond_to?(method_name)
+      end
+    end
+
+  end
+end

data/lib/gems/cucumber-0.1.15/lib/cucumber/cli.rb

@@ -0,0 +1,360 @@
+require 'optparse'
+require 'cucumber'
+require 'ostruct'
+
+module Cucumber
+  class YmlLoadError < StandardError; end
+
+  class CLI
+    class << self
+      attr_writer :step_mother, :executor, :features
+
+      def execute(args)
+        @execute_called = true
+        parse(args).execute!(@step_mother, @executor, @features)
+      end
+
+      def execute_called?
+        @execute_called
+      end
+
+      def parse(args)
+        cli = new
+        cli.parse_options!(args)
+        cli
+      end
+    end
+
+    attr_reader :options, :paths
+    FORMATS = %w{pretty profile progress html autotest}
+    DEFAULT_FORMAT = 'pretty'
+
+    def initialize(out_stream = STDOUT, error_stream = STDERR)
+      @out_stream = out_stream
+      @error_stream = error_stream
+      @paths = []
+      @options = {
+        :require => nil,
+        :lang    => 'en',
+        :dry_run => false,
+        :source  => true,
+        :snippets => true,
+        :formats => {},
+        :excludes => [],
+        :scenario_names => nil
+      }
+      @active_format = DEFAULT_FORMAT
+    end
+
+    def parse_options!(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[:LINE[:LINE]*]] | [FILES|DIRS]]", "",
+          "Examples:",
+          "cucumber examples/i18n/en/features",
+          "cucumber --language it examples/i18n/it/features/somma.feature:6:98:113", "", ""
+        ].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 autorequired",
+          "This option can be specified multiple times.") do |v|
+          @options[:require] ||= []
+          @options[:require] << v
+        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] ||= []
+          @options[:scenario_names] << v
+        end
+        opts.on("-l LANG", "--language LANG", "Specify language for features (Default: #{@options[:lang]})",
+          "Available languages: #{Cucumber.languages.join(", ")}",
+          "Look at #{Cucumber::LANGUAGE_FILE} for keywords") do |v|
+          @options[:lang] = v
+        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] ||= []
+          @options[:formats][v] << @out_stream
+          @active_format = v
+        end
+        opts.on("-o", "--out FILE", "Write output to a file instead of @out_stream.",
+          "This option can be specified multiple times, and applies to the previously",
+          "specified --format.") do |v|
+          @options[:formats][@active_format] ||= []
+          if @options[:formats][@active_format].last == @out_stream
+            @options[:formats][@active_format][-1] = File.open(v, 'w')
+          else
+            @options[:formats][@active_format] << File.open(v, 'w')
+          end
+        end
+        opts.on("-c", "--[no-]color", "Use ANSI color in the output, if formatters use it.  If",
+                                      "these options are given multiple times, the last one is",
+                                      "used.  If neither --color or --no-color is given cucumber",
+                                      "decides based on your platform and the output destination") do |v|
+          @options[:color] = v
+        end
+        opts.on("-e", "--exclude PATTERN", "Don't run features matching a 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("-d", "--dry-run", "Invokes formatters without executing the steps.") do
+          @options[:dry_run] = true
+        end
+        opts.on("-n", "--no-source", "Don't show the file and line of the step definition with the steps.") do
+          @options[:source] = false
+        end
+        opts.on("-i", "--no-snippets", "Don't show the snippets for pending steps") do
+          @options[:snippets] = false
+        end
+        opts.on("-q", "--quiet", "Don't show any development aid information") do
+          @options[:snippets] = false
+          @options[:source] = false
+        end
+        opts.on("-b", "--backtrace", "Show full backtrace for all errors") do
+          Exception.cucumber_full_backtrace = true
+        end
+        opts.on("-v", "--verbose", "Show the files and features loaded") do
+          @options[:verbose] = 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!
+
+      if @options[:formats].empty?
+        @options[:formats][DEFAULT_FORMAT] = [@out_stream]
+      end
+      
+      # Whatever is left after option parsing is the FILE arguments
+      args = extract_and_store_line_numbers(args)
+      @paths += args
+    end
+
+
+    def execute!(step_mother, executor, features)
+      Term::ANSIColor.coloring = @options[:color] unless @options[:color].nil?
+      Cucumber.load_language(@options[:lang])
+      require_files
+      enable_diffing
+      executor.formatters = build_formatter_broadcaster(step_mother)
+      load_plain_text_features(features)
+      executor.lines_for_features = @options[:lines_for_features]
+      executor.scenario_names = @options[:scenario_names] if @options[:scenario_names]
+      executor.visit_features(features)
+      exit 1 if executor.failed
+    end
+
+    private
+
+    def extract_and_store_line_numbers(file_arguments)
+      @options[:lines_for_features] = Hash.new{|k,v| k[v] = []}
+      file_arguments.map do |arg|
+        _, file, lines = */^([\w\W]*?):([\d:]+)$/.match(arg)
+        unless file.nil?
+          @options[:lines_for_features][file] += lines.split(':').map { |line| line.to_i }
+          arg = file          
+        end
+        arg
+      end
+    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 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_options!(args_from_yml.split(' '))
+      end
+      
+    rescue YmlLoadError => e
+      exit_with_error(e.message)
+    end
+
+
+    # Requires files - typically step files and ruby feature files.
+    def require_files
+      @args.clear # Shut up RSpec
+      require "cucumber/treetop_parser/feature_#{@options[:lang]}"
+      require "cucumber/treetop_parser/feature_parser"
+
+      verbose_log("Ruby files required:")
+      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 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) }
+    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
+
+    def feature_dirs
+      feature_files.map{|f| File.directory?(f) ? f : File.dirname(f)}.uniq
+    end
+
+    def load_plain_text_features(features)
+      parser = TreetopParser::FeatureParser.new
+
+      verbose_log("Features:")
+      feature_files.each do |f|
+        features << parser.parse_feature(f)
+        verbose_log("  * #{f}")
+      end
+      verbose_log("\n"*2)
+    end
+
+    def build_formatter_broadcaster(step_mother)
+      formatter_broadcaster = Broadcaster.new
+      @options[:formats].each do |format, output_list|
+        output_broadcaster = build_output_broadcaster(output_list)
+        case format
+        when 'pretty'
+          formatter_broadcaster.register(Formatters::PrettyFormatter.new(output_broadcaster, step_mother, @options))
+        when 'progress'
+          formatter_broadcaster.register(Formatters::ProgressFormatter.new(output_broadcaster))
+        when 'profile'
+          formatter_broadcaster.register(Formatters::ProfileFormatter.new(output_broadcaster, step_mother))
+        when 'html'
+          formatter_broadcaster.register(Formatters::HtmlFormatter.new(output_broadcaster, step_mother))
+        when 'autotest'
+          formatter_broadcaster.register(Formatters::AutotestFormatter.new(output_broadcaster))
+        else
+          begin
+            formatter_class = constantize(format)
+            formatter_broadcaster.register(formatter_class.new(output_broadcaster, step_mother, @options))
+          rescue NameError => e
+            @error_stream.puts "Invalid format: #{format}\n"
+            exit_with_help
+          rescue Exception => e
+            exit_with_error("Error creating formatter: #{format}\n#{e}\n")
+          end
+        end
+      end
+      formatter_broadcaster
+    end
+
+    def build_output_broadcaster(output_list)
+      output_broadcaster = Broadcaster.new
+      output_list.each do |output|
+        output_broadcaster.register(output)
+      end
+      output_broadcaster
+    end
+    
+  private
+
+    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 verbose_log(string)
+      @out_stream.puts(string) if @options[:verbose]
+    end
+
+    def exit_with_help
+      parse_options!(%w{--help})
+    end
+
+    def exit_with_error(error_message)
+      @error_stream << error_message
+      Kernel.exit 1
+    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
+
+extend Cucumber::StepMethods
+Cucumber::CLI.step_mother = step_mother
+Cucumber::CLI.executor = executor
+
+extend Cucumber::Tree
+Cucumber::CLI.features = features