lucid 0.0.4 → 0.0.5

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

@@ -0,0 +1,36 @@
+AfterConfiguration do |config|
+  puts("Specs are being executed from: #{config.spec_location}")
+end
+
+Before('~@practice') do
+  @browser = Symbiont::Browser.start
+end
+
+AfterStep('@pause') do
+  print "Press ENTER to continue..."
+  STDIN.getc
+end
+
+After do |scenario|
+  if scenario.failed?
+    Dir::mkdir('results') if not File.directory?('results')
+    screenshot = "./results/FAILED_#{scenario.name.gsub(' ','_').gsub(/[^0-9A-Za-z_]/, '')}.png"
+
+    if @browser
+      # This way attempts to save the screenshot as a file.
+      #@browser.driver.save_screenshot(screenshot)
+
+      # This way the image is encoded into the results.
+      encoded_img = @browser.driver.screenshot_as(:base64)
+      embed("data:image/png;base64,#{encoded_img}", 'image/png')
+    end
+
+    # This is an alternative way to embed.
+    #embed screenshot, 'image/png'
+  end
+  Symbiont::Browser.stop
+end
+
+at_exit do
+  Symbiont::Browser.stop
+end

data/lib/lucid/generators/project/lucid-symbiont.yml

@@ -0,0 +1,6 @@
+<% browser = "BROWSER=firefox" %>
+<% std_opts = "-r common -r pages -r steps" %>
+<% rpt_opts = "--format html --out output/specs-report.html" %>
+
+default: <%= std_opts %>
+report: <%= std_opts %> <%= rpt_opts %>

data/lib/lucid/interface.rb

@@ -0,0 +1,8 @@
+module Lucid
+  # This module defines the API for programming language support in Lucid.
+  # While Lucid itself is written in Ruby, any programming language can
+  # be supported by implementing this API. Each language implementation
+  # must manage its own events and must execute them at appropriate times.
+  module Interface
+  end
+end

data/lib/lucid/interface_methods.rb

@@ -0,0 +1,125 @@
+require 'lucid/step_match'
+require 'lucid/step_definition_light'
+
+module Lucid
+  module Interface
+    module InterfaceMethods
+      def around(scenario)
+        execute_around(scenario) do
+          yield
+        end
+      end
+
+      def before(scenario)
+        begin_scenario(scenario)
+        execute_before(scenario)
+      end
+
+      def after(scenario)
+        execute_after(scenario)
+        end_scenario
+      end
+
+      def after_configuration(configuration)
+        hooks[:after_configuration].each do |hook|
+          hook.invoke('AfterConfiguration', configuration)
+        end
+      end
+
+      def execute_after_step(scenario)
+        hooks_for(:after_step, scenario).each do |hook|
+          invoke(hook, 'AfterStep', scenario, false)
+        end
+      end
+
+      def execute_transforms(args)
+        args.map do |arg|
+          matching_transform = transforms.detect {|transform| transform.match(arg) }
+          matching_transform ? matching_transform.invoke(arg) : arg
+        end
+      end
+
+      def add_hook(phase, hook)
+        hooks[phase.to_sym] << hook
+        hook
+      end
+
+      def clear_hooks
+        @hooks = nil
+      end
+
+      def add_transform(transform)
+        transforms.unshift transform
+        transform
+      end
+
+      def hooks_for(phase, scenario) #:nodoc:
+        hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
+      end
+
+      def unmatched_step_definitions
+        available_step_definition_hash.keys - invoked_step_definition_hash.keys
+      end
+
+      def available_step_definition(regexp_source, file_colon_line)
+        available_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      end
+
+      def invoked_step_definition(regexp_source, file_colon_line)
+        invoked_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      end
+
+      private
+
+      def available_step_definition_hash
+        @available_step_definition_hash ||= {}
+      end
+
+      def invoked_step_definition_hash
+        @invoked_step_definition_hash ||= {}
+      end
+
+      def hooks
+        @hooks ||= Hash.new{|h,k| h[k] = []}
+      end
+
+      def transforms
+        @transforms ||= []
+      end
+
+      def execute_around(scenario, &block)
+        hooks_for(:around, scenario).reverse.inject(block) do |blk, hook|
+          proc do
+            invoke(hook, 'Around', scenario, true) do
+              blk.call(scenario)
+            end
+          end
+        end.call
+      end
+
+      def execute_before(scenario)
+        hooks_for(:before, scenario).each do |hook|
+          invoke(hook, 'Before', scenario, true)
+        end
+      end
+
+      def execute_after(scenario)
+        hooks_for(:after, scenario).reverse_each do |hook|
+          invoke(hook, 'After', scenario, true)
+        end
+      end
+
+      def invoke(hook, location, scenario, exception_fails_scenario, &block)
+        begin
+          hook.invoke(location, scenario, &block)
+        rescue Exception => exception
+          if exception_fails_scenario
+            scenario.fail!(exception)
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lucid/interface_rb/matcher.rb

@@ -0,0 +1,108 @@
+module Lucid
+  module InterfaceRb
+    module Matcher
+
+      ARGUMENT_PATTERNS = ['"(.*?)"', '(\d+)']
+
+      class BaseMatcher
+
+        def initialize(code_keyword, pattern, multiline_argument_class)
+          @number_of_arguments = 0
+          @code_keyword = code_keyword
+          @pattern = replace_and_count_capturing_groups(pattern)
+          @multiline_argument_class = multiline_argument_class
+        end
+
+        def to_s
+          "#{step} #{do_block}"
+        end
+
+        def step
+          "#{code_keyword}#{typed_pattern}"
+        end
+
+        def self.cli_option_string(type)
+          "%-7s: %-28s Example: %s" % [type, description, example]
+        end
+
+        private
+
+        attr_reader :code_keyword, :pattern, :multiline_argument_class, :number_of_arguments
+
+        def replace_and_count_capturing_groups(pattern)
+          modified_pattern = ::Regexp.escape(pattern).gsub('\ ', ' ').gsub('/', '\/')
+
+          ARGUMENT_PATTERNS.each do |argument_pattern|
+            modified_pattern.gsub!(::Regexp.new(argument_pattern), argument_pattern)
+            @number_of_arguments += modified_pattern.scan(argument_pattern).length
+          end
+
+          modified_pattern
+        end
+
+        def do_block
+          do_block = ""
+          do_block << "do#{arguments}\n"
+          do_block << multiline_comment if multiline_argument_class?
+          do_block << "  pending\n"
+          do_block << "end"
+          do_block
+        end
+
+        def arguments
+          block_args = (0...number_of_arguments).map { |n| "arg#{n+1}" }
+
+          if multiline_argument_class
+            block_args << multiline_argument_class.default_arg_name
+          end
+
+          block_args.empty? ? "" : " |#{block_args.join(", ")}|"
+        end
+
+        def multiline_comment
+          "  # #{multiline_argument_class.default_arg_name} is a #{multiline_argument_class.to_s}\n"
+        end
+
+        def multiline_argument_class?
+          multiline_argument_class == AST::Table
+        end
+
+        def self.example
+          new("Given", "some phrase", nil).step
+        end
+
+      end
+
+      class Regexp < BaseMatcher
+        def typed_pattern
+          " (/^#{pattern}$/)"
+        end
+
+        def self.description
+          "Matchers with parentheses."
+        end
+      end
+
+      class Classic < BaseMatcher
+        def typed_pattern
+          " /^#{pattern}$/"
+        end
+
+        def self.description
+          "Matchers without parentheses."
+        end
+      end
+
+      class Percent < BaseMatcher
+        def typed_pattern
+          " %r{^#{pattern}$}"
+        end
+
+        def self.description
+          "Matchers with delimited regexp."
+        end
+      end
+
+    end
+  end
+end

data/lib/lucid/interface_rb/rb_hook.rb

@@ -0,0 +1,18 @@
+module Lucid
+  module InterfaceRb
+    # Wrapper for Before, After and AfterStep hooks
+    class RbHook
+      attr_reader :tag_expressions
+
+      def initialize(rb_language, tag_expressions, proc)
+        @rb_language = rb_language
+        @tag_expressions = tag_expressions
+        @proc = proc
+      end
+
+      def invoke(location, argument, &block)
+        @rb_language.current_domain.lucid_instance_exec(false, location, *[argument, block].compact, &@proc)
+      end
+    end
+  end
+end

data/lib/lucid/interface_rb/rb_language.rb

@@ -0,0 +1,190 @@
+require 'lucid/core_ext/instance_exec'
+require 'lucid/interface_rb/rb_lucid'
+require 'lucid/interface_rb/rb_world'
+require 'lucid/interface_rb/rb_step_definition'
+require 'lucid/interface_rb/rb_hook'
+require 'lucid/interface_rb/rb_transform'
+require 'lucid/interface_rb/matcher'
+
+begin
+  require 'rspec/expectations'
+rescue LoadError
+  begin
+    require 'spec/expectations'
+    require 'spec/runner/differs/default'
+    require 'ostruct'
+  rescue LoadError
+    require 'test/unit/assertions'
+  end
+end
+
+module Lucid
+  module InterfaceRb
+    class NilDomain < StandardError
+      def initialize
+        super("Domain procs should never return nil")
+      end
+    end
+
+    # Raised if there are 2 or more Domain blocks.
+    class MultipleDomain < StandardError
+      def initialize(first_proc, second_proc)
+        message = "You can only pass a proc to #Domain once, but it's happening\n"
+        message << "in two places:\n\n"
+        message << first_proc.backtrace_line('Domain') << "\n"
+        message << second_proc.backtrace_line('Domain') << "\n\n"
+        message << "Use Ruby modules instead to extend your worlds. See the Lucid::InterfaceRb::RbLucid#Domain RDoc\n"
+        super(message)
+      end
+    end
+
+    # This module is the Ruby implementation of the TDL API.
+    class RbLanguage
+      include Interface::InterfaceMethods
+      attr_reader :current_domain, :step_definitions
+
+      # Get the expressions of various I18n translations of TDL keywords.
+      # In this case the TDL is based on Gherkin.
+      Gherkin::I18n.code_keywords.each do |adverb|
+        RbLucid.alias_adverb(adverb)
+      end
+
+      def initialize(runtime)
+        @runtime = runtime
+        @step_definitions = []
+        RbLucid.rb_language = self
+        @domain_proc = @domain_modules = nil
+        @assertions_module = find_best_assertions_module
+      end
+
+      def find_best_assertions_module
+        begin
+          ::RSpec::Matchers
+        rescue NameError
+          # RSpec >=1.2.4
+          begin
+            options = OpenStruct.new(:diff_format => :unified, :context_lines => 3)
+            Spec::Expectations.differ = Spec::Expectations::Differs::Default.new(options)
+            ::Spec::Matchers
+          rescue NameError
+            ::Test::Unit::Assertions
+          end
+        end
+      end
+
+      def step_matches(name_to_match, name_to_format)
+        @step_definitions.map do |step_definition|
+          if(arguments = step_definition.arguments_from(name_to_match))
+            StepMatch.new(step_definition, name_to_match, name_to_format, arguments)
+          else
+            nil
+          end
+        end.compact
+      end
+
+      def matcher_text(code_keyword, step_name, multiline_arg_class, matcher_type = :regexp)
+        matcher_class = typed_matcher_class(matcher_type)
+        matcher_class.new(code_keyword, step_name, multiline_arg_class).to_s
+      end
+
+      def begin_rb_scenario(scenario)
+        create_domain
+        extend_domain
+        connect_domain(scenario)
+      end
+
+      def register_rb_hook(phase, tag_expressions, proc)
+        add_hook(phase, RbHook.new(self, tag_expressions, proc))
+      end
+
+      def register_rb_transform(regexp, proc)
+        add_transform(RbTransform.new(self, regexp, proc))
+      end
+
+      def register_rb_step_definition(regexp, proc_or_sym, options)
+        step_definition = RbStepDefinition.new(self, regexp, proc_or_sym, options)
+        @step_definitions << step_definition
+        step_definition
+      end
+
+      def build_rb_world_factory(domain_modules, proc)
+        if(proc)
+          raise MultipleDomain.new(@domain_proc, proc) if @domain_proc
+          @domain_proc = proc
+        end
+        @domain_modules ||= []
+        @domain_modules += domain_modules
+      end
+
+      def load_code_file(code_file)
+        # This is what will allow self.add_step_definition, self.add_hook,
+        # and self.add_transform to be called from RbLucid.
+        load File.expand_path(code_file)
+      end
+
+      protected
+
+      def begin_scenario(scenario)
+        begin_rb_scenario(scenario)
+      end
+
+      def end_scenario
+        @current_domain = nil
+      end
+
+      private
+
+      def create_domain
+        if(@domain_proc)
+          @current_domain = @domain_proc.call
+          check_nil(@current_domain, @domain_proc)
+        else
+          @current_domain = Object.new
+        end
+      end
+
+      def extend_domain
+        @current_domain.extend(RbDomain)
+        @current_domain.extend(@assertions_module)
+        (@domain_modules || []).each do |mod|
+          @current_domain.extend(mod)
+        end
+      end
+
+      def connect_domain(scenario)
+        @current_domain.__lucid_runtime = @runtime
+        @current_domain.__natural_language = scenario.language
+      end
+
+      def check_nil(o, proc)
+        if o.nil?
+          begin
+            raise NilDomain.new
+          rescue NilDomain => e
+            e.backtrace.clear
+            e.backtrace.push(proc.backtrace_line("Domain"))
+            raise e
+          end
+        else
+          o
+        end
+      end
+
+      MATCHER_TYPES = {
+        :regexp => Matcher::Regexp,
+        :classic => Matcher::Classic,
+        :percent => Matcher::Percent
+      }
+
+      def typed_matcher_class(type)
+        MATCHER_TYPES.fetch(type || :regexp)
+      end
+
+      def self.cli_matcher_type_options
+        MATCHER_TYPES.keys.sort_by(&:to_s).map do |type|
+          MATCHER_TYPES[type].cli_option_string(type)
+        end
+      end
+    end
+  end
+end