lucid 0.0.1 → 0.0.2

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Jeff Nyman
+Copyright (c) 2013 Jeff Nyman
 
 MIT License
 

data/README.md

@@ -1,6 +1,10 @@
 # Lucid
 
-Lucid is a Test Description Language (TDL) execution engine, similar to tools like Cucumber, Spinach, or Turnip, but without a name based on food.
+Lucid is a shiv around BDD tools. Currently the only such tool that Lucid intercepts calls to is Cucumber. The reason for this is that many of these BDD tools are highly opinionated in their structure. While most tools do have a way to force the structure to be your way, how this is done is not always consistent.
+
+By way of example, Cucumber expects features to live in a directory called features and step definitions to live in a directory called step_definitions that is under the features directory. When running a feature, all step definitions are loaded unless you explicitly require just the ones you want. If you structure your project differently from how Cucumber expects, then you have to require files explicitly.
+
+Lucid allows you to specify configuration options that are then passed to Cucumber.
 
 ## Installation
 
@@ -18,14 +22,12 @@ Or install it yourself as:
 
 ## Usage
 
-Instructions on usage will follow when I have an actual implementation.
+Lucid can be configured project by project through the use of a lucid.yml file that lives in the root of your project. This file will contain configurable options. These options will be indicated by specific declarations.
 
 ## Contributing
 
-You can contribute to the development of Lucid.
-
-1. Fork the project.
-2. Create your feature branch (`git checkout -b my-new-feature`).
-3. Commit your changes (`git commit -am 'Add some feature'`).
-4. Push to the branch (`git push origin my-new-feature`).
-5. Create new Pull Request.
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/bin/lucid

@@ -1,10 +1,15 @@
 #!/usr/bin/env ruby
+app_lib = File.expand_path('../lib', File.dirname(__FILE__))
+$LOAD_PATH.unshift(app_lib) unless $LOAD_PATH.include?(app_lib)
+
+require 'lucid/app'
 
 begin
-  require "lucid"
-rescue LoadError
-  require_relative "../lib/lucid"
+  Lucid::App.new.run
+rescue SystemExit
+  # noop
+rescue Exception => e
+  STDERR.puts("#{e.message} (#{e.class})")
+  STDERR.puts(e.backtrace.join("\n"))
+  Kernel.exit(1)
 end
-
-app = Lucid::CLI.new(ARGV)
-app.start

data/lib/lucid.rb

@@ -1,5 +1,4 @@
 require "lucid/version"
-require "lucid/cli"
 
 module Lucid
 end

data/lib/lucid/app.rb

@@ -0,0 +1,108 @@
+require "lucid/options"
+require "lucid/parser"
+
+module Lucid
+  
+  PROJECT_OPTIONS = 'lucid.yml'
+  
+  class App
+    def initialize(args=nil)
+      args ||= ARGV
+      @project_options = Lucid::PROJECT_OPTIONS
+      @options = Lucid::Options.parse(args)
+      
+      parser = Lucid::Parser.new(@options)
+      
+      @specs = parser.specs
+      #puts "[App.initialize] After calling parser for specs, I have: #{@specs.inspect}"
+      @tags = parser.tags
+      
+      @message = "No specs were found matching the pattern '#{@options[:pattern]}'." and return unless @specs
+      
+      @command = generate_command
+    end
+    
+    def run
+      puts @message and return if @message
+      @options[:print] ? puts(@command) : system("#{@command}\n\n")
+    end
+    
+  private
+  
+    def generate_command
+      specs = []
+      steps = []
+      
+      command = "#{@options[:command]} #{@options[:options]}"
+      
+      if @specs.any?
+        @specs.each do |file|
+          file_parts = split_spec(file)
+          specs << construct_spec_file(file_parts[:path], file_parts[:name], file_parts[:full_name])
+        end
+      else
+        # If there are no spec files explicitly identified, then all of them
+        # will be run. However, if non-standard locations for features or step
+        # definitions are being used, that information has to be passed along.
+        specs << @options[:spec_path] if @options[:non_standard_spec_path]
+        ##steps << @options[:step_path] if @options[:non_standard_step_path]
+      end
+      
+      need_root = nil
+      
+      specs.each do |spec|
+        start_path = spec[0..spec.index("/") - 1] unless spec.index("/").nil?
+        start_path = spec if spec.index("/").nil?
+        
+        if start_path != @options[:spec_path]
+          need_root = true
+        end
+      end
+      
+      specs << @options[:spec_path] if @options[:non_standard_spec_path] unless need_root.nil?
+      steps << @options[:step_path] if @options[:non_standard_step_path]
+      
+      requires = (@options[:requires] + steps).compact.uniq
+      
+      command += " -r #{requires.join(' -r ')}" if requires.any?
+      command += " #{specs.join(' ')}" if specs.any?
+      
+      return "#{command} #{@tags}".gsub('  ', ' ')
+    end
+    
+    def split_spec(file)
+      name = File.basename(file, '.feature')
+      
+      # The next bit gets rid of the file name and the actual path
+      # to the spec.
+      path = File.dirname(file).gsub(@options[:spec_path_regex], '')
+      
+      return {:path => path, :name => name, :full_name => file}
+    end
+    
+    def construct_spec_file(path, file, file_name)
+      #puts "[App.construct_spec_file] Path = #{path} || File = #{file} || File name = #{file_name}"
+      
+      construct = ""
+      
+      # If the file that is passed in matches the name of the specs path
+      # then the assumption is that the user specified the main specs path
+      # to be executed, such as with "lucid specs". If the information
+      # provided does not end with ".feature" then it is assumed that a
+      # full directory is being referenced.
+      if file == @options[:spec_path]
+        construct = "#{file}"
+      elsif file_name[-8, 8] == ".feature" #not file =~ /\.feature$/
+        construct = "#{file_name}".gsub('//', '/')
+      else
+        #construct = "#{@options[:spec_path]}/#{path}/#{file}.feature".gsub('//', '/')
+        construct = "#{file_name}".gsub('//', '/')
+      end
+      
+      #puts "[App.construct_spec_file] Construct = #{construct}"
+      
+      construct
+    end
+    
+  end
+end

data/lib/lucid/options.rb

@@ -0,0 +1,148 @@
+require "lucid/version"
+require 'optparse'
+require 'yaml'
+
+module Lucid
+  class Options
+    def self.parse(args)
+      default_options = self.get_options(:default)
+      project_options = self.get_options(:project)
+      combine_options = default_options.merge(project_options)
+      
+      option_parser = OptionParser.new do |opts|
+        opts.banner = ["Lucid: Test Description Language Execution Engine",
+                       "Usage: lucid [options] PATTERN", ""].join("\n")
+        
+        opts.separator ''
+        
+        opts.on('-p', '--print', "Echo the Lucid command instead of executing it.") do
+          combine_options[:print] = true
+        end
+        
+        opts.on('-o', '--options OPTIONS', "Options to pass to the tool.") do |options|
+          combine_options[:options] = options
+        end
+        
+        opts.on('-t', '--tags TAGS', "Tags to include or exclude.") do |tags|
+          combine_options[:tags] = tags
+        end
+        
+        opts.on('-v', '--version', "Display Lucid version information.") do
+          puts Lucid::VERSION
+          Kernel.exit(0)
+        end
+        
+        opts.on('-h', '--help', "Display help on how to use Lucid.") do
+          puts opts
+          Kernel.exit(0)
+        end
+      end
+      
+      option_parser.parse!(args)
+      
+      # This statement is necessary to get the spec execution pattern from
+      # the command line. This will not be a switch and so it will be the
+      # only actual command line argument.
+      combine_options[:pattern] = args.first if args.any?
+      
+      return self.establish(combine_options)
+    end
+    
+  private
+  
+    def self.get_options(type = :default)
+      if type == :project
+        project_options = {}
+        
+        if File.exist?(Lucid::PROJECT_OPTIONS)
+          yaml_options = YAML.load_file(Lucid::PROJECT_OPTIONS)
+          
+          ['command', 'options', 'spec_path', 'step_path', 'requires', 'shared', 'spec_path_regex'].each do |key|
+            begin
+              project_options[key.to_sym] = yaml_options[key] if yaml_options.has_key?(key)
+            rescue NoMethodError
+              # noop
+            end
+          end
+        end
+        
+        project_options
+      else
+        {
+          :command         => 'cucumber',     # :cuke_command
+          :options         => nil,            # :cucumber
+          :spec_path       => 'features',     # :feature_path
+          :step_path       => 'features/step_definitions',
+          :requires        => [],
+          :shared          => 'true',         # value was 'shared'
+          :print           => false,
+          :tags            => nil,
+          :spec_path_regex => nil,
+          :step_path_regex => nil,
+          :pattern         => nil
+        }
+      end
+      
+    end
+    
+    def self.establish(options)
+      defaults = self.get_options(:default)
+      
+      current_set = options.dup  # tmp_options
+      
+      current_set[:spec_path] = current_set[:spec_path].gsub(/\\/, '/')
+      current_set[:spec_path] = current_set[:spec_path].sub(/\/$/, '')
+      
+      current_set[:step_path] = current_set[:step_path].gsub(/\\/, '/')
+      current_set[:step_path] = current_set[:step_path].sub(/\/$/, '')
+      
+      unless current_set[:pattern].nil?
+        current_set[:pattern] = current_set[:pattern].gsub(/\\/, '/')
+        current_set[:pattern] = current_set[:pattern].sub(/\/$/, '')
+      end
+      
+      # Establish that the spec path and the step path are not the standard
+      # values that Cucumber would expect by default.
+      current_set[:non_standard_spec_path] = current_set[:spec_path] != defaults[:spec_path]
+      current_set[:non_standard_step_path] = current_set[:step_path] != defaults[:step_path]
+      
+      # Create a regular expression from the spec path and the step path.
+      # This is done so that Lucid can look at the paths dynamically, mainly
+      # when dealing with shared steps.
+      current_set[:spec_path_regex] = Regexp.new(current_set[:spec_path].gsub('/', '\/')) unless current_set[:spec_path_regex]
+      current_set[:step_path_regex] = Regexp.new(current_set[:step_path].gsub('/', '\/')) unless current_set[:step_path_regex]
+      
+      # If the values are set to nil, the following commands make sure to
+      # revert to the defaults.
+      current_set[:spec_path] ||= defaults[:spec_path]
+      current_set[:step_path] ||= defaults[:step_path]
+      current_set[:requires] ||= defaults[:requires]
+      current_set[:command] ||= defaults[:command]
+      
+      # The shared setting has to be something that Lucid can use.
+      shared = current_set[:shared].nil? ? 'true' : current_set[:shared].to_s.strip
+      shared = 'true' if shared.strip == ''
+      
+      # Here the shared value is established based on a few likely usage
+      # patterns for it. Note that if one of these usage patterns is not
+      # used, then shared will be kept at whatever setting it has.
+      if ['shared', 'yes', ''].include?(shared.downcase)
+        shared == true
+      elsif ['false', 'no'].include?(shared.downcase)
+        shared == false
+      end
+      
+      current_set[:shared] = shared
+      
+      # The pattern that was specified must be handled to make sure it is
+      # something that can be worked with.
+      unless current_set[:pattern].nil?
+        current_set[:pattern] = current_set[:pattern].strip
+        current_set[:pattern] = nil unless current_set[:pattern] && !current_set[:pattern].empty?
+      end
+      
+      return current_set
+    end
+    
+  end # class: Options
+end # module: Lucid

data/lib/lucid/parser.rb

@@ -0,0 +1,142 @@
+module Lucid
+  class Parser
+    
+    def initialize(options)
+      @options = options
+    end
+    
+    def specs
+      #puts "[Parser.specs] Is @options[:pattern] nil? #{@options[:pattern].nil?}"
+      return [] if @options[:pattern].nil?
+      
+      set_of_specs = gather_specs_by_glob
+      
+      #puts "[Parser.specs] Were there any specs? #{set_of_specs.any?}"
+      
+      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
+      
+      #puts "[Parser.gather_specs_by_glob] The pattern is: #{pattern}"
+      
+      # 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?
+      
+      #puts "[Parser.gather_specs_by_glob] Is the pattern after only/except nil?: #{pattern.nil?}"
+      #puts "[Parser.gather_specs_by_glob] The @options[:spec_path] is: #{@options[:spec_path]}"      
+      
+      if only.any?
+        only.each do |f|
+          #puts "[Parser.gather_specs_by_glob] There is an only and it is: #{f}"
+          
+          #specs_to_include += Dir.glob("#{@options[:spec_path]}/#{f}.feature")
+          specs_to_include += Dir.glob("#{f}")
+        end
+      else
+        #puts "[Parser.gather_specs_by_glob] There is no only so pattern is: #{pattern}"
+        specs_to_include += Dir.glob("#{@options[:spec_path]}/#{pattern}.feature")
+      end
+      
+      puts "[Parser.gather_specs_by_glob] After checking only, specs_to_include is: #{specs_to_include}"
+      
+      if except.any?
+        except.each do |f|
+          #puts "[Parser.gather_specs_by_glob] There is an except and it is: #{f}"
+          specs_to_exclude = Dir.glob("#{@options[:spec_path]}/#{f}.feature")
+        end
+      end
+      
+      #puts "[Parser.gather_specs_by_glob] Returning #{specs_to_include - specs_to_exclude}"
+      
+      (specs_to_include - specs_to_exclude).uniq
+    end
+    
+  end # class: Parser
+end # module: Lucid

data/lib/lucid/version.rb

@@ -1,3 +1,3 @@
 module Lucid
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lucid.gemspec

@@ -8,9 +8,12 @@ Gem::Specification.new do |gem|
   gem.version       = Lucid::VERSION
   gem.authors       = ["Jeff Nyman"]
   gem.email         = ["jeffnyman@gmail.com"]
-  gem.description   = %q{Test Description Language Execution Engine}
-  gem.summary       = %q{Test Description Language Execution Engine}
+  gem.license       = "MIT"
+  gem.description   = %q{Execution Wrapper for Cucumber}
+  gem.summary       = %q{Execution Wrapper for Cucumber}
   gem.homepage      = "https://github.com/jnyman/lucid"
+  
+  gem.required_ruby_version = '>= 1.9.2'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/lucid.yml

@@ -0,0 +1,8 @@
+# Lucid Projects File
+command: bundle exec cucumber
+options: -p lucid
+spec_path: specs
+step_path: specs/steps
+requires:
+  - specs/lucid
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lucid
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-19 00:00:00.000000000 Z
+date: 2013-02-26 00:00:00.000000000 Z
 dependencies: []
-description: Test Description Language Execution Engine
+description: Execution Wrapper for Cucumber
 email:
 - jeffnyman@gmail.com
 executables:
@@ -26,11 +26,15 @@ files:
 - Rakefile
 - bin/lucid
 - lib/lucid.rb
-- lib/lucid/cli.rb
+- lib/lucid/app.rb
+- lib/lucid/options.rb
+- lib/lucid/parser.rb
 - lib/lucid/version.rb
 - lucid.gemspec
+- lucid.yml
 homepage: https://github.com/jnyman/lucid
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -40,7 +44,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -52,5 +56,6 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Test Description Language Execution Engine
+summary: Execution Wrapper for Cucumber
 test_files: []
+has_rdoc: 

data/lib/lucid/cli.rb

@@ -1,13 +0,0 @@
-module Lucid
-  class CLI
-    
-    def initialize(args = ARV)
-      @args = args
-    end
-    
-    def start
-      
-    end
-    
-  end # class CLI
-end # module Lucid