lucid 0.0.4 → 0.0.5

data/lib/lucid/formatter/stepdefs.rb

@@ -0,0 +1,14 @@
+require 'lucid/formatter/usage'
+
+module Lucid
+  module Formatter
+    class Stepdefs < Usage
+      def print_steps(stepdef_key)
+      end
+
+      def max_step_length
+        0
+      end
+    end
+  end
+end

data/lib/lucid/formatter/steps.rb

@@ -0,0 +1,49 @@
+module Lucid
+  module Formatter
+    # The formatter used for <tt>--format steps</tt>
+    class Steps
+
+      def initialize(runtime, path_or_io, options)
+        @io = ensure_io(path_or_io, "steps")
+        @options = options
+        @step_definition_files = collect_steps(runtime)
+      end
+
+      def after_features(features)
+        print_summary
+      end
+
+      private
+
+      def print_summary
+        count = 0
+        @step_definition_files.keys.sort.each do |step_definition_file|
+          @io.puts step_definition_file
+
+          sources = @step_definition_files[step_definition_file]
+          source_indent = source_indent(sources)
+          sources.sort.each do |file_colon_line, regexp_source|
+            @io.print regexp_source.indent(2)
+            @io.print " # #{file_colon_line}".indent(source_indent - regexp_source.unpack('U*').length)
+            @io.puts
+          end
+          @io.puts
+          count += sources.size
+        end
+        @io.puts "#{count} step definition(s) in #{@step_definition_files.size} source file(s)."
+      end
+
+      def collect_steps(runtime)
+        runtime.step_definitions.inject({}) do |step_definitions, step_definition|
+          step_definitions[step_definition.file] ||= []
+          step_definitions[step_definition.file] << [ step_definition.file_colon_line, step_definition.regexp_source ]
+          step_definitions
+        end
+      end
+
+      def source_indent(sources)
+        sources.map { |file_colon_line, regexp| regexp.size }.max + 1
+      end
+    end
+  end
+end

data/lib/lucid/formatter/summary.rb

@@ -0,0 +1,35 @@
+module Lucid
+  module Formatter
+    module Summary
+
+      def scenario_summary(runtime, &block)
+        scenarios_proc = lambda{|status| runtime.scenarios(status)}
+        dump_count(runtime.scenarios.length, "scenario") + dump_status_counts(scenarios_proc, &block)
+      end
+
+      def step_summary(runtime, &block)
+        steps_proc = lambda{|status| runtime.steps(status)}
+        dump_count(runtime.steps.length, "step") + dump_status_counts(steps_proc, &block)
+      end
+
+      private
+
+      def dump_status_counts(find_elements_proc)
+        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
+          elements = find_elements_proc.call(status)
+          elements.any? ? yield("#{elements.length} #{status.to_s}", status) : nil
+        end.compact
+        if counts.any?
+          " (#{counts.join(', ')})"
+        else
+          ""
+        end
+      end
+
+      def dump_count(count, what, state=nil)
+        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      end
+
+    end
+  end
+end

data/lib/lucid/formatter/unicode.rb

@@ -0,0 +1,53 @@
+# Require this file if you need Unicode support.
+# Tips for improvement - esp. ruby 1.9: http://www.ruby-forum.com/topic/184730
+require 'lucid/platform'
+require 'lucid/formatter/ansicolor'
+
+if Lucid::WINDOWS
+  if ENV['LUCID_OUTPUT_ENCODING']
+    Lucid::CODEPAGE = ENV['LUCID_OUTPUT_ENCODING']
+  elsif `cmd /c chcp` =~ /(\d+)/
+    if [65000, 65001].include? $1.to_i
+      Lucid::CODEPAGE = 'UTF-8'
+      ENV['ANSICON_API'] = 'ruby'
+    else
+      Lucid::CODEPAGE = "cp#{$1.to_i}"
+    end
+  else
+    Lucid::CODEPAGE = "cp1252"
+    STDERR.puts("WARNING: Unable to detect your output codepage; assuming it is 1252. You may have to chcp 1252 or SET LUCID_OUTPUT_ENCODING=cp1252.")
+  end
+
+  module Lucid
+    # @private
+    module WindowsOutput
+      def self.extended(o)
+        o.instance_eval do
+
+          def lucid_preprocess_output(*a)
+            begin
+              a.map{|arg| arg.to_s.encode(Encoding.default_external)}
+            rescue Encoding::UndefinedConversionError => e
+              STDERR.lucid_puts("WARNING: #{e.message}")
+              a
+            end
+          end
+
+          alias lucid_print print
+          def print(*a)
+            lucid_print(*lucid_preprocess_output(*a))
+          end
+
+          alias lucid_puts puts
+          def puts(*a)
+            lucid_puts(*lucid_preprocess_output(*a))
+          end
+        end
+      end
+
+      Kernel.extend(self)
+      STDOUT.extend(self)
+      STDERR.extend(self)
+    end
+  end
+end

data/lib/lucid/formatter/usage.rb

@@ -0,0 +1,132 @@
+require 'lucid/formatter/progress'
+require 'lucid/step_definition_light'
+
+module Lucid
+  module Formatter
+    class Usage < Progress
+      include Console
+
+      class StepDefKey < StepDefinitionLight
+        attr_accessor :mean_duration, :status
+      end
+
+      def initialize(runtime, path_or_io, options)
+        @runtime = runtime
+        @io = ensure_io(path_or_io, "usage")
+        @options = options
+        @stepdef_to_match = Hash.new{|h,stepdef_key| h[stepdef_key] = []}
+      end
+
+      def before_features(features)
+        print_profile_information
+      end
+
+      def before_step(step)
+        @step = step
+        @start_time = Time.now
+      end
+
+      def before_step_result(*args)
+        @duration = Time.now - @start_time
+      end
+
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+        step_definition = step_match.step_definition
+        unless step_definition.nil? # nil if it's from a scenario outline
+          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
+
+          @stepdef_to_match[stepdef_key] << {
+            :keyword => keyword,
+            :step_match => step_match,
+            :status => status,
+            :file_colon_line => @step.file_colon_line,
+            :duration => @duration
+          }
+        end
+        super
+      end
+
+      def print_summary(features)
+        add_unused_stepdefs
+        aggregate_info
+
+        if @options[:dry_run]
+          keys = @stepdef_to_match.keys.sort {|a,b| a.regexp_source <=> b.regexp_source}
+        else
+          keys = @stepdef_to_match.keys.sort {|a,b| a.mean_duration <=> b.mean_duration}.reverse
+        end
+
+        keys.each do |stepdef_key|
+          print_step_definition(stepdef_key)
+
+          if @stepdef_to_match[stepdef_key].any?
+            print_steps(stepdef_key)
+          else
+            @io.puts("  " + format_string("NOT MATCHED BY ANY STEPS", :failed))
+          end
+        end
+        @io.puts
+        super
+      end
+
+      def print_step_definition(stepdef_key)
+        @io.print format_string(sprintf("%.7f", stepdef_key.mean_duration), :skipped) + " " unless @options[:dry_run]
+        @io.print format_string(stepdef_key.regexp_source, stepdef_key.status)
+        if @options[:source]
+          indent = max_length - stepdef_key.regexp_source.unpack('U*').length
+          line_comment = "   # #{stepdef_key.file_colon_line}".indent(indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+      end
+
+      def print_steps(stepdef_key)
+        @stepdef_to_match[stepdef_key].each do |step|
+          @io.print "  "
+          @io.print format_string(sprintf("%.7f", step[:duration]), :skipped) + " " unless @options[:dry_run]
+          @io.print format_step(step[:keyword], step[:step_match], step[:status], nil)
+          if @options[:source]
+            indent = max_length - (step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length)
+            line_comment = " # #{step[:file_colon_line]}".indent(indent)
+            @io.print(format_string(line_comment, :comment))
+          end
+          @io.puts
+        end
+      end
+
+      def max_length
+        [max_stepdef_length, max_step_length].compact.max
+      end
+
+      def max_stepdef_length
+        @stepdef_to_match.keys.flatten.map{|key| key.regexp_source.unpack('U*').length}.max
+      end
+
+      def max_step_length
+        @stepdef_to_match.values.to_a.flatten.map do |step|
+          step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length
+        end.max
+      end
+
+      def aggregate_info
+        @stepdef_to_match.each do |key, steps|
+          if steps.empty?
+            key.status = :skipped
+            key.mean_duration = 0
+          else
+            key.status = AST::StepInvocation.worst_status(steps.map{|step| step[:status]})
+            total_duration = steps.inject(0) {|sum, step| step[:duration] + sum}
+            key.mean_duration = total_duration / steps.length
+          end
+        end
+      end
+
+      def add_unused_stepdefs
+        @runtime.unmatched_step_definitions.each do |step_definition|
+          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
+          @stepdef_to_match[stepdef_key] = []
+        end
+      end
+    end
+  end
+end

data/lib/lucid/generator.rb

@@ -0,0 +1,21 @@
+require 'thor'
+require 'lucid/generators/project'
+
+module Lucid
+  class Generator < Thor
+    desc "project NAME", "Create a new project."
+
+    #method_option :browser, aliases: "-b", type: :boolean, desc: "Use for browser-based testing."
+    method_option :driver, aliases: "-d", type: :string, required: false, desc: "Framework driver to use. (Default value is 'symbiont'.)"
+
+    def project(name)
+      puts "Name of project: #{name}"
+
+      driver = options[:driver].nil? ? 'symbiont' : options[:driver]
+      #browser = options[:browser] == true ? 'true' : 'false'
+
+      #Lucid::Generators::Project.start([name, browser, driver])
+      Lucid::Generators::Project.start([name, driver])
+    end
+  end
+end

data/lib/lucid/generators/project.rb

@@ -0,0 +1,70 @@
+require 'thor/group'
+
+module Lucid
+  module Generators
+    class Project < Thor::Group
+      include Thor::Actions
+
+      argument :name,    type: :string,  desc: "Name of the project."
+      argument :driver,  type: :string,  desc: "Framework driver to use."
+
+      desc "Generates a project structure."
+
+      def self.source_root
+        File.dirname(__FILE__) + "/project"
+      end
+
+      def spit_back_values
+        puts "Create project '#{name}' using #{driver}."
+      end
+
+      def create_project_directory
+        empty_directory(name)
+      end
+
+      def create_project_structure
+        empty_directory("#{name}/specs")
+        empty_directory("#{name}/common")
+        empty_directory("#{name}/common/helpers")
+        empty_directory("#{name}/common/support")
+        empty_directory("#{name}/common/config")
+        empty_directory("#{name}/common/data")
+        empty_directory("#{name}/steps")
+        empty_directory("#{name}/pages")
+      end
+
+      def copy_errors
+        copy_file "errors.rb", "#{name}/common/support/errors.rb"
+      end
+
+      def copy_browser
+        if driver.downcase == 'symbiont'
+          copy_file "browser-symbiont.rb", "#{name}/common/support/browser.rb"
+        end
+      end
+
+      def copy_driver
+        if driver.downcase == 'symbiont'
+          copy_file "driver-symbiont.rb", "#{name}/common/support/driver.rb"
+        end
+      end
+
+      def copy_events
+        if driver.downcase == 'symbiont'
+          copy_file "events-symbiont.rb", "#{name}/common/support/events.rb"
+        end
+      end
+
+      def copy_gemfile
+        template "Gemfile.tt", "#{name}/Gemfile"
+      end
+
+      def copy_lucid_yml
+        if driver.downcase == 'symbiont'
+          copy_file "lucid-symbiont.yml", "#{name}/lucid.yml"
+        end
+      end
+
+    end
+  end
+end

data/lib/lucid/generators/project/Gemfile.tt

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'lucid'
+<% if driver.downcase == 'symbiont' -%>gem 'symbiont'<% end -%>
+gem 'syntax'
+gem 'rspec'

data/lib/lucid/generators/project/browser-symbiont.rb

@@ -0,0 +1,24 @@
+module Symbiont
+  module Browser
+
+    @@browser = false
+
+    def self.start
+      unless @@browser
+        target = ENV['BROWSER']
+        @@browser = watir_browser(target)
+      end
+      @@browser
+    end
+
+    def self.stop
+      @@browser.quit if @@browser
+    end
+
+  private
+
+    def self.watir_browser(target)
+      Watir::Browser.new(target.to_sym)
+    end
+  end
+end

data/lib/lucid/generators/project/driver-symbiont.rb

@@ -0,0 +1,4 @@
+require 'symbiont'
+require 'symbiont/factory'
+
+Domain(Symbiont::Factory)

data/lib/lucid/generators/project/errors.rb

@@ -0,0 +1,26 @@
+class InvalidDataConditionError < StandardError
+end
+
+class NecessaryDataNotAvailableError < StandardError
+end
+
+class NecessaryDataAlreadyAvailableError < StandardError
+end
+
+class NotSpecificEnoughDataError < StandardError
+end
+
+class PossibleDataContextError < StandardError
+end
+
+class ContextCannotBeFulfilledError < StandardError
+end
+
+class DataValidationError < StandardError
+end
+
+class UnexpectedDataFoundError < StandardError
+end
+
+class TestDataNotFoundError < StandardError
+end