lucid 0.0.4 → 0.0.5

data/lib/lucid/step_definition_light.rb

@@ -0,0 +1,20 @@
+module Lucid
+  # Only used for keeping track of available and invoked step definitions
+  # in a way that also works for other programming languages (i.e. cuke4duke)
+  # Used for reporting purposes only (usage formatter).
+  class StepDefinitionLight
+    attr_reader :regexp_source, :file_colon_line
+
+    def initialize(regexp_source, file_colon_line)
+      @regexp_source, @file_colon_line = regexp_source, file_colon_line
+    end
+
+    def eql?(o)
+      regexp_source == o.regexp_source && file_colon_line == o.file_colon_line
+    end
+
+    def hash
+      regexp_source.hash + 31*file_colon_line.hash
+    end
+  end
+end

data/lib/lucid/step_definitions.rb

@@ -0,0 +1,13 @@
+module Lucid
+  class StepDefinitions
+    def initialize(configuration = Configuration.default)
+      configuration = Configuration.parse(configuration)
+      @orchestrator = Runtime::Orchestrator.new(nil, false)
+      @orchestrator.load_files_from_paths(configuration.autoload_code_paths)
+    end
+
+    def to_json
+      @orchestrator.step_definitions.map{|stepdef| stepdef.to_hash}.to_json
+    end
+  end
+end

data/lib/lucid/step_match.rb

@@ -0,0 +1,99 @@
+module Lucid
+  class StepMatch #:nodoc:
+    attr_reader :step_definition, :step_arguments
+
+    def initialize(step_definition, name_to_match, name_to_report, step_arguments)
+      raise "name_to_match can't be nil" if name_to_match.nil?
+      raise "step_arguments can't be nil (but it can be an empty array)" if step_arguments.nil?
+      @step_definition = step_definition
+      @name_to_match = name_to_match
+      @name_to_report = name_to_report
+      @step_arguments = step_arguments
+    end
+
+    def args
+      @step_arguments.map{|g| g.val}
+    end
+
+    def name
+      @name_to_report
+    end
+
+    def invoke(multiline_arg)
+      all_args = args
+      all_args << multiline_arg.to_step_definition_arg if multiline_arg
+      @step_definition.invoke(all_args)
+    end
+
+    def format_args(format = lambda{|a| a}, &proc)
+      @name_to_report || replace_arguments(@name_to_match, @step_arguments, format, &proc)
+    end
+
+    def file_colon_line
+      @step_definition.file_colon_line
+    end
+
+    def backtrace_line
+      "#{file_colon_line}:in `#{@step_definition.regexp_source}'"
+    end
+
+    def text_length
+      @step_definition.regexp_source.unpack('U*').length
+    end
+
+    def replace_arguments(string, step_arguments, format, &proc)
+      s = string.dup
+      offset = past_offset = 0
+      step_arguments.each do |step_argument|
+        next if step_argument.offset.nil? || step_argument.offset < past_offset
+
+        replacement = if block_given?
+          proc.call(step_argument.val)
+        elsif Proc === format
+          format.call(step_argument.val)
+        else
+          format % step_argument.val
+        end
+
+        s[step_argument.offset + offset, step_argument.val.length] = replacement
+        offset += replacement.unpack('U*').length - step_argument.val.unpack('U*').length
+        past_offset = step_argument.offset + step_argument.val.length
+      end
+      s
+    end
+
+    def inspect #:nodoc:
+      sprintf("#<%s:0x%x>", self.class, self.object_id)
+    end
+  end
+
+  class NoStepMatch #:nodoc:
+    attr_reader :step_definition, :name
+
+    def initialize(step, name)
+      @step = step
+      @name = name
+    end
+
+    def format_args(format)
+      @name
+    end
+
+    def file_colon_line
+      raise "No file:line for #{@step}" unless @step.file_colon_line
+      @step.file_colon_line
+    end
+
+    def backtrace_line
+      @step.backtrace_line
+    end
+
+    def text_length
+      @step.text_length
+    end
+
+    def step_arguments
+      []
+    end
+  end
+end

data/lib/lucid/tdl_builder.rb

@@ -0,0 +1,282 @@
+require 'lucid/ast'
+require 'gherkin/rubify'
+require 'lucid/ast/multiline_argument'
+require 'lucid/ast/empty_background'
+
+module Lucid
+  module Parser
+    # The TDL Builder conforms to the Gherkin event API.
+    class TDLBuilder
+      include Gherkin::Rubify
+
+      def initialize(path = 'UNKNOWN-FILE')
+        @path = path
+      end
+
+      def result
+        return nil unless @feature_builder
+        @feature_builder.result(language)
+      end
+
+      def language=(language)
+        @language = language
+      end
+
+      def uri(uri)
+        @path = uri
+      end
+
+      def feature(node)
+        @feature_builder = FeatureBuilder.new(file, node)
+      end
+
+      def background(node)
+        builder = BackgroundBuilder.new(file, node)
+        @feature_builder.background_builder = builder
+        @current = builder
+      end
+
+      def scenario(node)
+        builder = ScenarioBuilder.new(file, node)
+        @feature_builder.add_child builder
+        @current = builder
+      end
+
+      def scenario_outline(node)
+        builder = ScenarioOutlineBuilder.new(file, node)
+        @feature_builder.add_child builder
+        @current = builder
+      end
+
+      def examples(examples)
+        examples_fields = [
+          AST::Location.new(file, examples.line),
+          AST::Comment.new(examples.comments.map{|comment| comment.value}.join("\n")),
+          examples.keyword,
+          examples.name,
+          examples.description,
+          matrix(examples.rows)
+        ]
+        @current.add_examples examples_fields, examples
+      end
+
+      def step(node)
+        builder = StepBuilder.new(file, node)
+        @current.add_child builder
+      end
+
+      def eof
+      end
+
+      def syntax_error(state, event, legal_events, line)
+        # raise "SYNTAX ERROR"
+      end
+
+      private
+
+      if defined?(JRUBY_VERSION)
+        java_import java.util.ArrayList
+        ArrayList.__persistent__ = true
+      end
+
+      def matrix(gherkin_table)
+        gherkin_table.map do |gherkin_row|
+          row = gherkin_row.cells
+          class << row
+            attr_accessor :line
+          end
+          row.line = gherkin_row.line
+          row
+        end
+      end
+
+      def language
+        @language || raise("Language has not been set")
+      end
+
+      def file
+        if Lucid::WINDOWS && !ENV['LUCID_FORWARD_SLASH_PATHS']
+          @path.gsub(/\//, '\\')
+        else
+          @path
+        end
+      end
+
+      class Builder
+        def initialize(file, node)
+          @file, @node = file, node
+        end
+
+        private
+
+        def tags
+          AST::Tags.new(nil, node.tags)
+        end
+
+        def location
+          AST::Location.new(file, node.line)
+        end
+
+        def comment
+          AST::Comment.new(node.comments.map{ |comment| comment.value }.join("\n"))
+        end
+
+        attr_reader :file, :node
+      end
+
+      class FeatureBuilder < Builder
+        def result(language)
+          background = background(language)
+          feature = AST::Feature.new(
+            location,
+            background,
+            comment,
+            tags,
+            node.keyword,
+            node.name.lstrip,
+            node.description.rstrip,
+            children.map { |builder| builder.result(background, language, tags) }
+          )
+          feature.gherkin_statement(node)
+          feature.language = language
+          feature
+        end
+
+        def background_builder=(builder)
+          @background_builder = builder
+        end
+
+        def add_child(child)
+          children << child
+        end
+
+        def children
+          @children ||= []
+        end
+
+        private
+
+        def background(language)
+          return AST::EmptyBackground.new unless @background_builder
+          @background ||= @background_builder.result(language)
+        end
+      end
+
+      class BackgroundBuilder < Builder
+        def result(language)
+          background = AST::Background.new(
+            language,
+            location,
+            comment,
+            node.keyword,
+            node.name,
+            node.description,
+            steps(language)
+          )
+          background.gherkin_statement(node)
+          background
+        end
+
+        def steps(language)
+          children.map { |child| child.result(language) }
+        end
+
+        def add_child(child)
+          children << child
+        end
+
+        def children
+          @children ||= []
+        end
+
+      end
+
+      class ScenarioBuilder < Builder
+        def result(background, language, feature_tags)
+          scenario = AST::Scenario.new(
+            language,
+            location,
+            background,
+            comment,
+            tags,
+            feature_tags,
+            node.keyword,
+            node.name,
+            node.description,
+            steps(language)
+          )
+          scenario.gherkin_statement(node)
+          scenario
+        end
+
+        def steps(language)
+          children.map { |child| child.result(language) }
+        end
+
+        def add_child(child)
+          children << child
+        end
+
+        def children
+          @children ||= []
+        end
+      end
+
+      class ScenarioOutlineBuilder < Builder
+        def result(background, language, feature_tags)
+          scenario_outline = AST::ScenarioOutline.new(
+            language,
+            location,
+            background,
+            comment,
+            tags,
+            feature_tags,
+            node.keyword,
+            node.name,
+            node.description,
+            steps(language),
+            examples_sections
+          )
+          scenario_outline.gherkin_statement(node)
+          scenario_outline
+        end
+
+        def add_examples(examples_section, node)
+          @examples_sections ||= []
+          @examples_sections << [examples_section, node]
+        end
+
+        def steps(language)
+          children.map { |child| child.result(language) }
+        end
+
+        def add_child(child)
+          children << child
+        end
+
+        def children
+          @children ||= []
+        end
+
+        private
+
+        attr_reader :examples_sections
+      end
+
+      class StepBuilder < Builder
+        def result(language)
+          step = AST::Step.new(
+            language,
+            location,
+            node.keyword,
+            node.name,
+            AST::MultilineArgument.from(node.doc_string || node.rows)
+          )
+          step.gherkin_statement(node)
+          step
+        end
+      end
+
+    end
+  end
+end

data/lib/lucid/term/ansicolor.rb

@@ -0,0 +1,118 @@
+module Lucid
+  module Term
+    # The ANSIColor module can be used for namespacing and mixed into your own
+    # classes.
+    module ANSIColor
+      # :stopdoc:
+      ATTRIBUTES = [
+        [ :clear        ,   0 ],
+        [ :reset        ,   0 ],     # synonym for :clear
+        [ :bold         ,   1 ],
+        [ :dark         ,   2 ],
+        [ :italic       ,   3 ],     # not widely implemented
+        [ :underline    ,   4 ],
+        [ :underscore   ,   4 ],     # synonym for :underline
+        [ :blink        ,   5 ],
+        [ :rapid_blink  ,   6 ],     # not widely implemented
+        [ :negative     ,   7 ],     # no reverse because of String#reverse
+        [ :concealed    ,   8 ],
+        [ :strikethrough,   9 ],     # not widely implemented
+        [ :black        ,  30 ],
+        [ :red          ,  31 ],
+        [ :green        ,  32 ],
+        [ :yellow       ,  33 ],
+        [ :blue         ,  34 ],
+        [ :magenta      ,  35 ],
+        [ :cyan         ,  36 ],
+        [ :white        ,  37 ],
+        [ :on_black     ,  40 ],
+        [ :on_red       ,  41 ],
+        [ :on_green     ,  42 ],
+        [ :on_yellow    ,  43 ],
+        [ :on_blue      ,  44 ],
+        [ :on_magenta   ,  45 ],
+        [ :on_cyan      ,  46 ],
+        [ :on_white     ,  47 ],
+      ]
+
+      ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+      # :startdoc:
+
+      # Returns true, if the coloring function of this module
+      # is switched on, false otherwise.
+      def self.coloring?
+        @coloring
+      end
+
+      # Turns the coloring on or off globally, so you can easily do
+      # this for example:
+      #  Lucid::Term::ANSIColor::coloring = STDOUT.isatty
+      def self.coloring=(val)
+        @coloring = val
+      end
+      self.coloring = true
+
+      ATTRIBUTES.each do |c, v|
+        eval %Q{
+            def #{c}(string = nil)
+              result = ''
+              result << "\e[#{v}m" if Lucid::Term::ANSIColor.coloring?
+              if block_given?
+                result << yield
+              elsif string
+                result << string
+              elsif respond_to?(:to_str)
+                result << to_str
+              else
+                return result #only switch on
+              end
+              result << "\e[0m" if Lucid::Term::ANSIColor.coloring?
+              result
+            end
+        }
+      end
+
+      # Regular expression that is used to scan for ANSI-sequences while
+      # uncoloring strings.
+      COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+
+
+      def self.included(klass)
+        if version_is_greater_than_18? and klass == String
+          ATTRIBUTES.delete(:clear)
+          ATTRIBUTE_NAMES.delete(:clear)
+        end
+      end
+
+      # Returns an uncolored version of the string, that is all
+      # ANSI-sequences are stripped from the string.
+      def uncolored(string = nil) # :yields:
+        if block_given?
+          yield.gsub(COLORED_REGEXP, '')
+        elsif string
+          string.gsub(COLORED_REGEXP, '')
+        elsif respond_to?(:to_str)
+          to_str.gsub(COLORED_REGEXP, '')
+        else
+          ''
+        end
+      end
+
+      module_function
+
+      # Returns an array of all Lucid::Term::ANSIColor attributes as symbols.
+      def attributes
+        ATTRIBUTE_NAMES
+      end
+      extend self
+
+      private
+
+      def version_is_greater_than_18?
+        version = RUBY_VERSION.split('.')
+        version.map! &:to_i
+        version[0] >= 1 && version[1] > 8
+      end
+    end
+  end
+end