lucid 0.0.4 → 0.0.5

data/lib/lucid/load_path.rb

@@ -0,0 +1,13 @@
+module Lucid
+  module LoadPath
+    def add_dirs(*dirs)
+      dirs.each do |dir|
+        $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+      end
+    end
+
+    module_function :add_dirs
+  end
+end
+
+Lucid::LoadPath.add_dirs('lib')

data/lib/lucid/parser.rb

@@ -1,126 +1,2 @@
-module Lucid
-  class Parser
-    
-    def initialize(options)
-      @options = options
-    end
-    
-    def specs
-      return [] if @options[:pattern].nil?
-      
-      set_of_specs = gather_specs_by_glob
-      
-      return set_of_specs.any? ? set_of_specs : nil
-    end
-    
-    def tags
-      tags = {
-        :or  => [],
-        :and => [],
-        :not => []
-      }
-      
-      return '' if @options[:tags].nil?
-      
-      @options[:tags].split(',').each do |tag|
-        # Tags that are numeric can be ranged.
-        if tag =~ /^(~)?([0-9]+)-([0-9]+)$/
-          x = $2.to_i
-          y = $3.to_i
-          exclude = $1
-          
-          # Make sure numeric tags are in numerical order.
-          if x > y
-            hold_x = x.dup
-            x = y.dup
-            y = hold_x.dup
-          end
-          
-          (x..y).each do |capture|
-            if exclude
-              tags[:not] << "#{capture}"
-            else
-              tags[:or] << "#{capture}"
-            end
-          end
-        else
-          if tag =~ /^~(.+)/
-            tags[:not] << $1
-          elsif tag =~ /^\+(.+)/
-            tags[:and] << $1
-          else
-            tags[:or] << tag
-          end
-        end
-      end # each
-      
-      [:and, :or, :not].each { |type| tags[type].uniq! }
-      
-      intersection = tags[:or] & tags[:not]
-      tags[:or] -= intersection
-      tags[:not] -= intersection
-      
-      intersection = tags[:and] & tags[:not]
-      tags[:and] -= intersection
-      tags[:not] -= intersection
-      
-      tags[:or].each_with_index { |tag, i| tags[:or][i] = "@#{tag}" }
-      tags[:and].each_with_index { |tag, i| tags[:and][i] = "@#{tag}" }
-      tags[:not].each_with_index { |tag, i| tags[:not][i] = "~@#{tag}" }
-      
-      tag_builder = ''
-      tag_builder += "-t #{tags[:or].join(',')} " if tags[:or].any?
-      tag_builder += "-t #{tags[:and].join(' -t ')} " if tags[:and].any?
-      tag_builder += "-t #{tags[:not].join(' -t ')}" if tags[:not].any?
-      
-      tag_builder.gsub!('@@', '@')
-      tag_builder
-    end # method: tags
-    
-  private
-  
-    def gather_specs_by_glob
-      only = []
-      except = []
-      specs_to_include = []
-      specs_to_exclude = []
-      
-      pattern = @options[:pattern].dup
-      
-      # Determine if some specs were indicated to be excluded
-      # and mark those separately. This also handles when only
-      # specific specs are to be executed.
-      pattern.split(',').each do |f|
-        if f[0].chr == '~'
-          except << f[1..f.length]
-        else
-          only << f
-        end
-      end
-      
-      # If there are exceptions, then all specs should be
-      # gathered by default. Unless, that is, the command
-      # indicates that only certain specs should be run.
-      pattern = '**/*' if except.any?
-      pattern = nil if only.any?
-      
-      if only.any?
-        only.each do |f|
-          #specs_to_include += Dir.glob("#{@options[:spec_path]}/#{f}.feature")
-          specs_to_include += Dir.glob("#{f}")
-        end
-      else
-        specs_to_include += Dir.glob("#{@options[:spec_path]}/#{pattern}.feature")
-      end
-      
-      if except.any?
-        except.each do |f|
-          specs_to_exclude = Dir.glob("#{@options[:spec_path]}/#{f}.feature")
-        end
-      end
-      
-      (specs_to_include - specs_to_exclude).uniq
-    end
-    
-  end # class: Parser
-end # module: Lucid
+require 'lucid/platform'
+require 'lucid/ast'

data/lib/lucid/platform.rb

@@ -0,0 +1,27 @@
+require 'rbconfig'
+
+module Lucid
+  unless defined?(Lucid::VERSION)
+    VERSION       = '0.0.5'
+    BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/lucid')
+    LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+    JRUBY         = defined?(JRUBY_VERSION)
+    IRONRUBY      = defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
+    WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+    OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
+    WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
+    RAILS         = defined?(Rails)
+    RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    RUBY_2_0      = RUBY_VERSION =~ /^2\.0/
+    RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
+
+    class << self
+      attr_accessor :use_full_backtrace
+
+      def file_mode(m, encoding="UTF-8")
+        "#{m}:#{encoding}"
+      end
+    end
+    self.use_full_backtrace = false
+  end
+end

data/lib/lucid/rspec/allow_doubles.rb

@@ -0,0 +1,20 @@
+require 'rspec/core'
+
+# This file allows you to use all of RSpec's mocking frameworks. This
+# essentially allows you to create test doubles which are used to
+# stand in place of a production object during execution.
+
+RSpec.configuration.configure_mock_framework
+Domain(RSpec::Core::MockFrameworkAdapter)
+
+Before do
+  RSpec::Mocks::setup(self)
+end
+
+After do
+  begin
+    RSpec::Mocks::verify
+  ensure
+    RSpec::Mocks::teardown
+  end
+end

data/lib/lucid/rspec/disallow_options.rb

@@ -0,0 +1,27 @@
+require 'optparse'
+
+module Spec #:nodoc:
+  module Runner #:nodoc:
+    # Lucid uses OptionParser in order to parse any command line options.
+    # If RSpec is being used in any way with Lucid, then what will happen
+    # is that RSpec's option parser will kick in and try to parse ARGV.
+    # Since the command line arguments will be specific to Lucid, RSpec
+    # will not know what to do with them and will fail. So what this bit
+    # of logic is doing is making sure that the option parser for RSpec
+    # will not be operative.
+    class OptionParser < ::OptionParser #:nodoc:
+      MODDED_RSPEC = Object.new
+      def MODDED_RSPEC.method_missing(m, *args); self; end
+
+      def self.method_added(m)
+        unless @__modding_rspec
+          @__modding_rspec = true
+          define_method(m) do |*a|
+            MODDED_RSPEC
+          end
+          @__modding_rspec = false
+        end
+      end
+    end
+  end
+end

data/lib/lucid/runtime.rb

@@ -0,0 +1,200 @@
+require 'fileutils'
+require 'multi_json'
+require 'gherkin/rubify'
+require 'gherkin/i18n'
+require 'lucid/configuration'
+require 'lucid/load_path'
+require 'lucid/interface_methods'
+require 'lucid/formatter/duration'
+require 'lucid/runtime/interface_io'
+require 'lucid/runtime/specs_loader'
+require 'lucid/runtime/results'
+require 'lucid/runtime/orchestrator'
+
+module Lucid
+  class Runtime
+    attr_reader :results
+
+    include Formatter::Duration
+    include Runtime::InterfaceIO
+
+    def initialize(configuration = Configuration.default)
+      require 'lucid/core_ext/disable_autorunners'
+      @current_scenario = nil
+      @configuration = Configuration.parse(configuration)
+      @orchestrator = Orchestrator.new(self, @configuration)
+      @results = Results.new(@configuration)
+    end
+
+    # Allows you to take an existing runtime and change it's configuration
+    def configure(new_configuration)
+      @configuration = Configuration.parse(new_configuration)
+      @orchestrator.configure(@configuration)
+      @results.configure(@configuration)
+    end
+
+    def load_code_language(language)
+      @orchestrator.load_code_language(language)
+    end
+
+    def run
+      load_execution_context
+      fire_after_configuration_hook
+
+      tdl_walker = @configuration.establish_tdl_walker(self)
+      self.visitor = tdl_walker # Ugly circular dependency, but needed to support Domain#puts
+
+      tdl_walker.visit_features(specs)
+    end
+
+    def features_paths
+      @configuration.spec_source
+    end
+
+    def step_visited(step) #:nodoc:
+      @results.step_visited(step)
+    end
+
+    def scenarios(status = nil)
+      @results.scenarios(status)
+    end
+
+    def steps(status = nil)
+      @results.steps(status)
+    end
+
+    def step_match(step_name, name_to_report=nil) #:nodoc:
+      @orchestrator.step_match(step_name, name_to_report)
+    end
+
+    def unmatched_step_definitions
+      @orchestrator.unmatched_step_definitions
+    end
+
+    def matcher_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+      @orchestrator.matcher_text(Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg_class)
+    end
+
+    def with_hooks(scenario, skip_hooks=false)
+      around(scenario, skip_hooks) do
+        before_and_after(scenario, skip_hooks) do
+          yield scenario
+        end
+      end
+    end
+
+    def around(scenario, skip_hooks=false, &block) #:nodoc:
+      if skip_hooks
+        yield
+        return
+      end
+
+      @orchestrator.around(scenario, block)
+    end
+
+    def before_and_after(scenario, skip_hooks=false) #:nodoc:
+      before(scenario) unless skip_hooks
+      yield scenario
+      after(scenario) unless skip_hooks
+      @results.scenario_visited(scenario)
+    end
+
+    def before(scenario) #:nodoc:
+      return if @configuration.dry_run? || @current_scenario
+      @current_scenario = scenario
+      @orchestrator.fire_hook(:before, scenario)
+    end
+
+    def after(scenario) #:nodoc:
+      @current_scenario = nil
+      return if @configuration.dry_run?
+      @orchestrator.fire_hook(:after, scenario)
+    end
+
+    def after_step #:nodoc:
+      return if @configuration.dry_run?
+      @orchestrator.fire_hook(:execute_after_step, @current_scenario)
+    end
+
+    def unknown_programming_language?
+      @orchestrator.unknown_programming_language?
+    end
+
+    def write_stepdefs_json
+      if(@configuration.testdefs)
+        stepdefs = []
+        @orchestrator.step_definitions.sort{|a,b| a.to_hash['source'] <=> a.to_hash['source']}.each do |stepdef|
+          stepdef_hash = stepdef.to_hash
+          steps = []
+          features.each do |feature|
+            feature.feature_elements.each do |feature_element|
+              feature_element.raw_steps.each do |step|
+                args = stepdef.arguments_from(step.name)
+                if(args)
+                  steps << {
+                    'name' => step.name,
+                    'args' => args.map do |arg|
+                      {
+                        'offset' => arg.offset,
+                        'val' => arg.val
+                      }
+                    end
+                  }
+                end
+              end
+            end
+          end
+          stepdef_hash['file_colon_line'] = stepdef.file_colon_line
+          stepdef_hash['steps'] = steps.uniq.sort {|a,b| a['name'] <=> b['name']}
+          stepdefs << stepdef_hash
+        end
+        if !File.directory?(@configuration.testdefs)
+          FileUtils.mkdir_p(@configuration.testdefs)
+        end
+        File.open(File.join(@configuration.testdefs, 'testdefs.json'), 'w') do |io|
+          io.write(MultiJson.dump(stepdefs, :pretty => true))
+        end
+      end
+    end
+
+    # Returns AST::DocString for +string_without_triple_quotes+.
+    def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
+      AST::DocString.new(string_without_triple_quotes,content_type)
+    end
+
+  private
+
+    def fire_after_configuration_hook #:nodoc
+      @orchestrator.fire_hook(:after_configuration, @configuration)
+    end
+
+    # The specs is used to begin loading the executable specs. This is as
+    # opposed to loading the execution context (code files), which was
+    # already handled. A SpecsLoader instance is created and this is what
+    # makes sure that a spec file can be turned into a code construct
+    # (a SpecFile instance) which in turn can be broken down into an AST.
+    def specs
+      @loader ||= Runtime::SpecsLoader.new(
+        @configuration.spec_files,
+        @configuration.filters,
+        @configuration.tag_expression)
+      @loader.specs
+    end
+
+    # Loading the execution context means getting all of the loadable files
+    # in the spec repository. Loadable files means any code language type
+    # files. These files are sent to an orchestrator instance that will be
+    # responsible for loading them. The loading of these files provides the
+    # execution context for Lucid as it runs executable specs.
+    def load_execution_context
+      files = @configuration.library_context + @configuration.definition_context
+      log.info("Runtime Load Execution Context: #{files}")
+      @orchestrator.load_files(files)
+    end
+
+    def log
+      Lucid.logger
+    end
+  end
+
+end

data/lib/lucid/runtime/facade.rb

@@ -0,0 +1,60 @@
+require 'forwardable'
+
+module Lucid
+  class Runtime
+    # This is what a programming language will consider to be a runtime.
+    #
+    # It's a thin class that directs the handul of methods needed by the
+    # programming languages to the right place.
+    class Facade
+      extend Forwardable
+
+      def initialize(orchestrator, interface)
+        @orchestrator, @interface = orchestrator, interface
+      end
+
+      def_delegators :@interface,
+        :embed,
+        :ask,
+        :puts,
+        :features_paths,
+        :step_match
+
+      def_delegators :@orchestrator,
+        :invoke_steps,
+        :invoke,
+        :load_code_language
+
+      # Returns a Lucid::AST::Table for +text_or_table+, which can either
+      # be a String:
+      #
+      #   table(%{
+      #     | account | description | amount |
+      #     | INT-100 | Taxi        | 114    |
+      #     | CUC-101 | Peeler      | 22     |
+      #   })
+      #
+      # or a 2D Array:
+      #
+      #   table([
+      #     %w{ account description amount },
+      #     %w{ INT-100 Taxi        114    },
+      #     %w{ CUC-101 Peeler      22     }
+      #   ])
+      #
+      def table(text_or_table, file=nil, line_offset=0)
+        if Array === text_or_table
+          AST::Table.new(text_or_table)
+        else
+          AST::Table.parse(text_or_table, file, line_offset)
+        end
+      end
+
+      # Returns AST::DocString for +string_without_triple_quotes+.
+      #
+      def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
+        AST::DocString.new(string_without_triple_quotes,content_type)
+      end
+    end
+  end
+end