lucid 0.0.4 → 0.0.5

data/lib/lucid/runtime/interface_io.rb

@@ -0,0 +1,60 @@
+require 'timeout'
+
+module Lucid
+  class Runtime
+
+    module InterfaceIO
+      attr_writer :visitor
+
+      def puts(*messages)
+        @visitor.puts(*messages)
+      end
+
+      def ask(question, timeout_seconds)
+        STDOUT.puts(question)
+        STDOUT.flush
+        puts(question)
+
+        if(Lucid::JRUBY)
+          answer = jruby_gets(timeout_seconds)
+        else
+          answer = mri_gets(timeout_seconds)
+        end
+
+        if(answer)
+          puts(answer)
+          answer
+        else
+          raise("Lucid waited for input for #{timeout_seconds} seconds, then timed out.")
+        end
+      end
+
+      def embed(src, mime_type, label)
+        @visitor.embed(src, mime_type, label)
+      end
+
+    private
+
+      def mri_gets(timeout_seconds)
+        begin
+          Timeout.timeout(timeout_seconds) do
+            STDIN.gets
+          end
+        rescue Timeout::Error
+          nil
+        end
+      end
+
+      def jruby_gets(timeout_seconds)
+        answer = nil
+        t = java.lang.Thread.new do
+          answer = STDIN.gets
+        end
+        t.start
+        t.join(timeout_seconds * 1000)
+        answer
+      end
+    end
+
+  end
+end

data/lib/lucid/runtime/orchestrator.rb

@@ -0,0 +1,218 @@
+require 'lucid/factory'
+require 'lucid/ast/multiline_argument'
+require 'lucid/runtime/facade'
+
+module Lucid
+
+  class Runtime
+
+    class Orchestrator
+
+      require 'forwardable'
+      class StepInvoker
+        include Gherkin::Rubify
+
+        def initialize(orchestrator)
+          @orchestrator = orchestrator
+        end
+
+        def uri(uri)
+        end
+
+        def step(step)
+          @orchestrator.invoke(step.name, AST::MultilineArgument.from(step.doc_string || step.rows))
+        end
+
+        def eof
+        end
+      end
+
+      include ObjectFactory
+
+      def initialize(user_interface, configuration={})
+        @configuration = Configuration.parse(configuration)
+        @runtime_facade = Runtime::Facade.new(self, user_interface)
+        @unsupported_languages = []
+        @supported_languages = []
+        @language_map = {}
+      end
+
+      def configure(new_configuration)
+        @configuration = Configuration.parse(new_configuration)
+      end
+
+      # Invokes a series of steps +steps_text+. Example:
+      #
+      #   invoke(%Q{
+      #     Given I have 8 cukes in my belly
+      #     Then I should not be thirsty
+      #   })
+      def invoke_steps(steps_text, i18n, file_colon_line)
+        file, line = file_colon_line.split(':')
+        parser = Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps', false, i18n.iso_code)
+        parser.parse(steps_text, file, line.to_i)
+      end
+
+      def invoke(step_name, multiline_argument=nil)
+        multiline_argument = Lucid::AST::MultilineArgument.from(multiline_argument)
+        # It is very important to leave multiline_argument=nil as a vararg. Cuke4Duke needs it that way.
+        begin
+          step_match(step_name).invoke(multiline_argument)
+        rescue Exception => e
+          e.nested! if Undefined === e
+          raise e
+        end
+      end
+
+      # The orchestrator will register the the code language and load up an
+      # implementation of that language. There is a provision to make sure
+      # that the language is not already registered.
+      def load_code_language(code)
+        return @language_map[code] if @language_map[code]
+        lucid_language = create_object_of("Lucid::Interface#{code.capitalize}::#{code.capitalize}Language")
+        language = lucid_language.new(@runtime_facade)
+        @supported_languages << language
+        @language_map[code] = language
+        language
+      end
+
+      # The orchestrator will load only the loadable execution context files.
+      # This is how the orchestrator will, quite literally, orchestrate the
+      # execution of specs with the code logic that supports those specs.
+      # @see Lucid::Runtime.load_execution_context
+      def load_files(files)
+        log.info("Orchestrator Load Files:\n")
+        files.each do |file|
+          load_file(file)
+        end
+        log.info("\n")
+      end
+
+      def load_files_from_paths(paths)
+        files = paths.map { |path| Dir["#{path}/**/*"] }.flatten
+        load_files files
+      end
+
+      def unmatched_step_definitions
+        @supported_languages.map do |programming_language|
+          programming_language.unmatched_step_definitions
+        end.flatten
+      end
+
+      def matcher_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+        load_code_language('rb') if unknown_programming_language?
+        @supported_languages.map do |programming_language|
+          programming_language.matcher_text(step_keyword, step_name, multiline_arg_class, @configuration.matcher_type)
+        end.join("\n")
+      end
+
+      def unknown_programming_language?
+        @supported_languages.empty?
+      end
+
+      def fire_hook(name, *args)
+        @supported_languages.each do |programming_language|
+          programming_language.send(name, *args)
+        end
+      end
+
+      def around(scenario, block)
+        @supported_languages.reverse.inject(block) do |blk, programming_language|
+          proc do
+            programming_language.around(scenario) do
+              blk.call(scenario)
+            end
+          end
+        end.call
+      end
+
+      def step_definitions
+        @supported_languages.map do |programming_language|
+          programming_language.step_definitions
+        end.flatten
+      end
+
+      def step_match(step_name, name_to_report=nil) #:nodoc:
+        @match_cache ||= {}
+
+        match = @match_cache[[step_name, name_to_report]]
+        return match if match
+
+        @match_cache[[step_name, name_to_report]] = step_match_without_cache(step_name, name_to_report)
+      end
+
+      private
+
+      def step_match_without_cache(step_name, name_to_report=nil)
+        matches = matches(step_name, name_to_report)
+        raise Undefined.new(step_name) if matches.empty?
+        matches = best_matches(step_name, matches) if matches.size > 1 && guess_step_matches?
+        raise Ambiguous.new(step_name, matches, guess_step_matches?) if matches.size > 1
+        matches[0]
+      end
+
+      def guess_step_matches?
+        @configuration.guess?
+      end
+
+      def matches(step_name, name_to_report)
+        @supported_languages.map do |programming_language|
+          programming_language.step_matches(step_name, name_to_report).to_a
+        end.flatten
+      end
+
+      def best_matches(step_name, step_matches) #:nodoc:
+        no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
+        max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
+        top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
+
+        if no_groups.any?
+          longest_regexp_length = no_groups.map {|step_match| step_match.text_length }.max
+          no_groups.select {|step_match| step_match.text_length == longest_regexp_length }
+        elsif top_groups.any?
+          shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } }.min
+          top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } == shortest_capture_length }
+        else
+          top_groups
+        end
+      end
+
+      # For each execution context file, the orchestrator will determine the
+      # code language associated with the file.
+      def load_file(file)
+        if language = get_language_for(file)
+          log.info("  * #{file}\n")
+          language.load_code_file(file)
+        else
+          log.info("  * #{file} [NOT SUPPORTED]\n")
+        end
+      end
+
+      def log
+        Lucid.logger
+      end
+
+      # The orchestrator will attempt to get the programming language for a
+      # specific code file, unless that code file is marked as being an
+      # unsupported language. An object is returned if the code file was part
+      # of a supported language. If an object is returned it will be an
+      # object of this sort:
+      #     Lucid::InterfaceRb::RbLanguage
+      def get_language_for(file)
+        if extension = File.extname(file)[1..-1]
+          return nil if @unsupported_languages.index(extension)
+          begin
+            load_code_language(extension)
+          rescue LoadError => e
+            log.info("Unable to load '#{extension}' language for file #{file}: #{e.message}\n")
+            @unsupported_languages << extension
+            nil
+          end
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/lucid/runtime/results.rb

@@ -0,0 +1,64 @@
+module Lucid
+  class Runtime
+
+    class Results
+      def initialize(configuration)
+        @configuration = configuration
+
+        # Optimization - quicker lookup.
+        @inserted_steps = {}
+        @inserted_scenarios = {}
+      end
+
+      def configure(new_configuration)
+        @configuration = Configuration.parse(new_configuration)
+      end
+
+      def step_visited(step) #:nodoc:
+        step_id = step.object_id
+
+        unless @inserted_steps.has_key?(step_id)
+          @inserted_steps[step_id] = step
+          steps.push(step)
+        end
+      end
+
+      def scenario_visited(scenario) #:nodoc:
+        scenario_id = scenario.object_id
+
+        unless @inserted_scenarios.has_key?(scenario_id)
+          @inserted_scenarios[scenario_id] = scenario
+          scenarios.push(scenario)
+        end
+      end
+
+      def steps(status = nil) #:nodoc:
+        @steps ||= []
+        if(status)
+          @steps.select{|step| step.status == status}
+        else
+          @steps
+        end
+      end
+
+      def scenarios(status = nil) #:nodoc:
+        @scenarios ||= []
+        if(status)
+          @scenarios.select{|scenario| scenario.status == status}
+        else
+          @scenarios
+        end
+      end
+
+      def failure?
+        if @configuration.wip?
+          scenarios(:passed).any?
+        else
+          scenarios(:failed).any? || steps(:failed).any? ||
+          (@configuration.strict? && (steps(:undefined).any? || steps(:pending).any?))
+        end
+      end
+    end
+
+  end
+end

data/lib/lucid/runtime/specs_loader.rb

@@ -0,0 +1,79 @@
+require 'lucid/errors'
+
+module Lucid
+  class Runtime
+    class SpecsLoader
+      include Formatter::Duration
+
+      def initialize(spec_files, filters, tag_expression)
+        @spec_files, @filters, @tag_expression = spec_files, filters, tag_expression
+      end
+
+      # @see Lucid::Runtime.specs
+      def specs
+        load unless (defined? @specs) and @specs
+        @specs
+      end
+
+    private
+
+      # The specs loader will call upon load to load up all specs that were
+      # found in the spec repository. During this process, a Specs instance
+      # is created that will hold instances of the high level construct,
+      # which is basically the feature.
+      def load
+        specs = AST::Specs.new
+
+        # Note that "specs" is going to be an instance of Lucid::AST::Specs.
+        # It will contain a @specs instance variable that is going to contain
+        # an specs found.
+
+        tag_counts = {}
+        start = Time.new
+        log.info("Specs:\n")
+
+        @spec_files.each do |f|
+          spec_file = SpecFile.new(f)
+
+          # The "spec_file" will contain a Lucid::SpecFile instance, a
+          # primary attribute of which will be a @location instance variable.
+
+          spec = spec_file.parse(@filters, tag_counts)
+
+          # The "spec" will contain an instance of Lucid::AST::Feature.
+
+          if spec
+            specs.add_feature(spec)
+            log.info("  * #{f}\n")
+          end
+        end
+
+        duration = Time.now - start
+        log.info("Parsing spec files took #{format_duration(duration)}\n\n")
+
+        check_tag_limits(tag_counts)
+
+        @specs = specs
+      end
+
+      def check_tag_limits(tag_counts)
+        error_messages = []
+        @tag_expression.limits.each do |tag_name, tag_limit|
+          tag_locations = (tag_counts[tag_name] || [])
+          tag_count = tag_locations.length
+          if tag_count > tag_limit
+            error = "#{tag_name} occurred #{tag_count} times, but the limit was set to #{tag_limit}\n  " +
+              tag_locations.join("\n  ")
+            error_messages << error
+          end
+        end
+        raise TagExcess.new(error_messages) if error_messages.any?
+      end
+
+      def log
+        Lucid.logger
+      end
+    end
+
+  end
+end

data/lib/lucid/spec_file.rb

@@ -0,0 +1,112 @@
+require 'lucid/tdl_builder'
+require 'gherkin/formatter/filter_formatter'
+require 'gherkin/formatter/tag_count_formatter'
+require 'gherkin/parser/parser'
+
+module Lucid
+  class SpecFile
+    SPEC_PATTERN     = /^([\w\W]*?):([\d:]+)$/ #:nodoc:
+    DEFAULT_ENCODING = "UTF-8" #:nodoc:
+    NON_EXEC_PATTERN = /^\s*#|^\s*$/ #:nodoc:
+    ENCODING_PATTERN = /^\s*#\s*encoding\s*:\s*([^\s]+)/ #:nodoc:
+
+    # The +uri+ argument is the location of the source. It can be a path
+    # or a path:line1:line2 etc.
+    def initialize(uri, source=nil)
+      @source = source
+      _, @path, @lines = *SPEC_PATTERN.match(uri)
+      if @path
+        @lines = @lines.split(':').map { |line| line.to_i }
+      else
+        @path = uri
+      end
+    end
+
+    # The parse action will parse a specific spec source and will return
+    # a the high level construct of the spec. If any filters are passed
+    # in, the result will be filtered accordingly.
+    # @see Lucid::Runtime::SpecsLoader.load
+    def parse(specified_filters, tag_counts)
+      filters = @lines || specified_filters
+
+      tdl_builder         = Lucid::Parser::TDLBuilder.new(@path)
+      filter_formatter    = filters.empty? ? tdl_builder : Gherkin::Formatter::FilterFormatter.new(tdl_builder, filters)
+      tag_count_formatter = Gherkin::Formatter::TagCountFormatter.new(filter_formatter, tag_counts)
+
+      # Gherkin Parser parameters:
+      # formatter, raise_on_error, machine_name, force_ruby
+      # The machine name refers to a state machine table.
+      parser              = Gherkin::Parser::Parser.new(tag_count_formatter, true, "root", false)
+
+      begin
+        # parse parameters:
+        # gherkin, feature_uri, line_offset
+        parser.parse(source, @path, 0)
+        tdl_builder.language = parser.i18n_language
+        tdl_builder.result
+      rescue Gherkin::Lexer::LexingError, Gherkin::Parser::ParseError => e
+        e.message.insert(0, "#{@path}: ")
+        raise e
+      end
+    end
+
+    # The source method is used to return a properly encoded spec file.
+    # If the spec source read in declares a different encoding, then this
+    # method will make sure to use Lucid's default encoding.
+    def source
+      @source ||= if @path =~ /^http/
+        require 'open-uri'
+        open(@path).read
+      else
+        begin
+          source = File.open(@path, Lucid.file_mode('r', DEFAULT_ENCODING)).read
+          encoding = encoding_for(source)
+          if(DEFAULT_ENCODING.downcase != encoding.downcase)
+            source = File.open(@path, Lucid.file_mode('r', encoding)).read
+            source = to_default_encoding(source, encoding)
+          end
+          source
+        rescue Errno::EACCES => e
+          e.message << "\nLucid was unable to access #{File.expand_path(@path)}."
+          raise e
+        rescue Errno::ENOENT => e
+          if @path == "specs"
+            e.message << ["\nYou don't have a 'specs' directory. This is the default specification",
+                          "directory that Lucid will use if one is not specified. So either create",
+                          "that directory or specify where your test repository is located."].join("\n")
+          else
+            e.message << ["\nThere is no '#{@path}' directory. Since that is what you specified as",
+                          "your spec repository, this directory must be present."].join("\n")
+          end
+          raise e
+        end
+      end
+    end
+
+    private
+
+    def encoding_for(source)
+      encoding = DEFAULT_ENCODING
+
+      source.each_line do |line|
+        break unless NON_EXEC_PATTERN =~ line
+        if ENCODING_PATTERN =~ line
+          encoding = $1
+          break
+        end
+      end
+
+      encoding
+    end
+
+    def to_default_encoding(string, encoding)
+      if string.respond_to?(:encode)
+        string.encode(DEFAULT_ENCODING)
+      else
+        require 'iconv'
+        Iconv.new(DEFAULT_ENCODING, encoding).iconv(string)
+      end
+    end
+
+  end
+end