RubyGems - cukecooker - Versions diffs - 0.1 - Mend

cukecooker 0.1

Files changed (3) hide show

data/README.rdoc ADDED Viewed

@@ -0,0 +1,24 @@
+== Cukecooker
+Cukecooker aids you in writing Cucumber scenarios.
+It generates an HTML with your project's step definitions and lets you
+use them to write scenarios in a comfortable way, with autocomplete
+and text inputs for group matches.
+=== Usage
+In your project root, which should contain a features folder, run this
+in a terminal:
+  cukecooker
+Or:
+  cukecooker path/to/your/project
+If everything went well you should see
+  Done! Now open cukecooker-project.html in a browser.
+Go ahead, try it!

data/bin/cukecooker ADDED Viewed

@@ -0,0 +1,581 @@
+StepRegex = %r(\s*(?:When|Given|Then).*/\^(.+)\$\/\s*do(\s*\|.*\|)?)
+steps = ""
+# Checks that dir exists and is a directory
+def check_dir(dir)
+  unless File.exists?(dir)
+    puts "Error: #{dir} does not exist"
+    exit
+  end
+  unless File.directory?(dir)
+    puts "Error: #{dir} is not a directory"
+    exit
+  end
+end
+# Get command line directory or default to current
+dir = ARGV[0] || "."
+dir = File.expand_path(dir)
+check_dir dir
+# Asume project name is the name of the given directory.
+# If it's src, go one level up
+name = File.basename dir
+if name == 'src'
+  name = File.basename File.dirname(dir)
+end
+dir = "#{dir}/features/step_definitions"
+check_dir dir
+step_files = Dir["#{dir}/**/*.rb"]
+step_files.each do |step_file|
+  lines = File.readlines step_file
+  lines.each do |line|
+    next unless match = StepRegex.match(line)
+    regexp = match[1]
+    next if regexp.empty?
+    steps << "," unless steps.empty?
+    if match[2]
+      parameters = match[2].strip[1 ... -1].split(',').map!{|x| "'#{x.strip.gsub('_', ' ')}'"}.join(',') if match[2]
+      steps << "[/^#{regexp}$/, [#{parameters}]]"
+    else
+      steps << "[/^#{regexp}$/]"
+    end
+  end
+end
+if steps.empty?
+  puts "Error: no step definitions found in #{dir}/features/step_definitions"
+  puts "  Be sure to run cukecooker in a directory which contains a features/step_definitions directory"
+  puts "  or give cukecooker the path to that directory."
+  exit
+end
+OrRegexp = '/\(\?\:.*?\|.*?\)/'
+OptionalRegexp = '/.\?/'
+OptionalWithParenRegexp = '/\(\?\:.*?\)\?/'
+CaptureRegepx = '/\(.+?\)/'
+CaptureWithQuotesRegepx = '/"\(.+?\)"/'
+RegexpRegexp = '/\\\\\//'
+File.open("cukecooker-#{name}.html", "w") do |file|
+file.write <<EOF
+<html>
+<head>
+<title>cukecooker - #{name}</title>
+<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js" type="text/javascript"></script>
+<script type="text/javascript">
+// The original step definitions, extracted from the step definition files.
+// Each element in the array is an array whose first element is the regular expression
+// and the next element is an (optional) array containing the parameters given in the do block.
+originalSteps = [#{steps}];
+// The expanded steps (splitted by ors or optional regexps).
+// Each element in the array is a hash with the following properties:
+//   regexp: the regular expression to deal with
+//   params: an array of parameters that were given in the do block
+//   regexpReplaced: the regular expression with groups replaced with params
+steps = [];
+// The index of the selected step.
+selectedStepIndex = 0;
+// The indices of the li's that are shown.
+liIndices = [];
+// The selected step once the user pressed enter.
+buildingStep = null;
+// The current action entered by the user
+currentAction = "Given ";
+// The last action entered by the user
+lastAction = '';
+// Is the current action different than the last action?
+lastActionChanged = false;
+// The text that was in #stepMatch before a keyup event was fired
+lastStepMatchText = '';
+// Is the user creating the first step in the scenario?
+firstStepInScenario = true;
+allLiIndices = [];
+// HACK: keyup event if fired twice... why? :'-(
+justBuiltAStep = false;
+$(function() {
+  $steps = $("#steps");
+  $stepBuilder = $("#stepBuilder");
+  $scenario = $("#scenario");
+  $stepMatch = $("#stepMatch");
+  $stepMatch_static = $("#stepMatch_static");
+  $explanationStep = $("#explanationStep");
+  $explanationStepBuilder = $("#explanationStepBuilder");
+  // Push all elements into array
+  function pushAll(array, elements) {
+    for(var i = 0; i < elements.length; i++)
+      array.push(elements[i]);
+  }
+  // Split the regexp into their expansions.
+  // For example:
+  //   "(?:a|b) c"        --> ["a c", "b c"]
+  //   "(?:a )?b"         --> ["a b", "b"]
+  //   "(?:a )?(?:b|c) d" --> ["a b d", "a c d", "b d", "c d"]
+  function splitRegexp(regexp) {
+    var results = [];
+    // Find an OR expression
+    var match = regexp.match(#{OrRegexp});
+    if (match) {
+      match = match[0];
+      var idx = regexp.indexOf(match);
+      // Remove (?: ... )
+      match = match.substring(3, match.length - 1);
+      var pieces = match.split("\|");
+      for(var i = 0; i < pieces.length; i++) {
+        var before = regexp.substring(0, idx);
+        var after = regexp.substring(idx + match.length + 4);
+        var newRegexp = before + pieces[i] + after;
+        pushAll(results, splitRegexp(newRegexp));
+      }
+      return results;
+    }
+    // Find optional expression with parenthesis
+    match = regexp.match(#{OptionalWithParenRegexp});
+    if (match) {
+      match = match[0];
+      var idx = regexp.indexOf(match);
+      var before = regexp.substring(0, idx);
+      var after = regexp.substring(idx + match.length);
+      // This is without the surrounding (?: ... )?
+      var middle = match.substring(3, match.length - 2);
+      var regexpWithout = before + after;
+      var regexpWith = before + middle + after;
+      pushAll(results, splitRegexp(regexpWithout));
+      pushAll(results, splitRegexp(regexpWith));
+      return results;
+    }
+    // Find optional expression without parenthesis
+    match = regexp.match(#{OptionalRegexp});
+    if (match) {
+      match = match[0];
+      var idx = regexp.indexOf(match);
+      var before = regexp.substring(0, idx);
+      var after = regexp.substring(idx + match.length);
+      // This is without the ?
+      var middle = match.substring(0, match.length - 1);
+      var regexpWithout = before + after;
+      var regexpWith = before + middle + after;
+      pushAll(results, splitRegexp(regexpWithout));
+      pushAll(results, splitRegexp(regexpWith));
+      return results;
+    }
+    // Replace \/ with /
+    while(regexp.indexOf("\\\\/") >= 0) {
+      regexp = regexp.replace(#{RegexpRegexp}, "/");
+    }
+    return [regexp];
+  }
+  // Processes each group in the step regexp with the given callback. The callback
+  // receives the index of the matched group and must return a replacement
+  // for it.
+  function processGroups(step, callback) {
+    paramIdx = 0;
+    regexp = step.regexp;
+    while(true) {
+      m = regexp.match(#{CaptureRegepx});
+      if (!m) break;
+      m = m[0];
+      idx = regexp.indexOf(m);
+      regexp = regexp.substring(0, idx) + callback(paramIdx) + regexp.substring(idx + m.length);
+      paramIdx++;
+    }
+    return regexp;
+  }
+  // Transforms 'foo "(...)" bar' into 'foo (...) bar'
+  function removeQuotedGroups(step) {
+    regexp = step.regexp;
+    while(true) {
+      m = regexp.match(#{CaptureWithQuotesRegepx});
+      if (!m) break;
+      m = m[0];
+      idx = regexp.indexOf(m);
+      regexp = regexp.substring(0, idx) + m.substring(1, m.length -1) + regexp.substring(idx + m.length);
+    }
+    return regexp;
+  }
+  // Appends the step just built to the scenario div.
+  function appendToScenario() {
+      replacement = processGroups(buildingStep, function(idx) {
+        return '<span class="param">' + $("#p" + idx).val() + '</span>';
+      });
+      replacement = "<strong>" + currentAction + "</strong>" + replacement;
+      if (currentAction == "And ") {
+        replacement = "&nbsp;&nbsp;" + replacement;
+      } else if (lastActionChanged && !firstStepInScenario) {
+        replacement = "<br/>" + replacement;
+      }
+      regexp = buildingStep.regexp;
+      if (regexp[regexp.length - 1] == ':') {
+        if (currentAction == "And ") {
+          replacement += '<br/>&nbsp;&nbsp;"""<br/>&nbsp;&nbsp;TODO: text or table goes here&nbsp;&nbsp;<br/>&nbsp;&nbsp;"""';
+        } else {
+          replacement += '<br/>"""<br/>TODO: text or table goes here<br/>"""';
+        }
+      }
+      firstStepInScenario = false;
+      justBuiltAStep = true;
+      $scenario.append(replacement + "<br/>");
+  }
+  // Prepares the page for building steps (input texts for parameters)
+  function prepareBuildStep() {
+    buildingStep = steps[currentLiIndex()];
+    // Set the current action and see if it changed from the last one
+    if (lastAction == currentAction && currentAction != "And ") {
+      currentAction = "And ";
+      lastActionChanged = false;
+    } else {
+      lastActionChanged = true;
+    }
+    lastAction = currentAction;
+    groupsCount = 0;
+    processGroups(buildingStep, function(idx) {
+      groupsCount++;
+      return '';
+    });
+    if (groupsCount == 0) {
+      appendToScenario();
+      searchAgain();
+    } else {
+      $explanationStep.hide();
+      $explanationStepBuilder.show();
+      $stepMatch.attr('readonly', 'readonly');
+      $stepMatch.val(currentAction + buildingStep.regexpReplaced);
+      $steps.hide();
+      $stepBuilder.show();
+      regexpWithoutQuotes = removeQuotedGroups(buildingStep);
+      originalRegexp = buildingStep.regexp;
+      buildingStep.regexp = regexpWithoutQuotes;
+      html = '<table><tr><td><nobr><strong>' + currentAction + "</strong>";
+      html += processGroups(buildingStep, function(idx) {
+        return '</nobr></td><td width="100"><input type="text" id="p' + idx + '" class="complete"></td><td><nobr>';
+      });
+      html += '</td></tr><tr align="center"><td>';
+      for(var i = 0; i < groupsCount; i++) {
+        html += '</td><td class="param">' + buildingStep.params[i] + "</td><td>";
+      }
+      html += "</td></tr></table>";
+      $stepBuilder.html(html);
+      $("#p0").focus();
+      buildingStep.regexp = originalRegexp;
+    }
+  }
+  // Resets everything except the scenario div to search a new step.
+  function searchAgain() {
+    selectedStepIndex = 0;
+    liIndices = allLiIndices;
+    $explanationStep.show();
+    $explanationStepBuilder.hide();
+    $stepMatch.attr('readonly', '');
+    $steps.show();
+    $stepBuilder.hide();
+    $stepsLi.show();
+    $stepsLi.removeClass("selected");
+    stepLi(0).addClass("selected");
+    $stepMatch.val("");
+    $stepMatch.focus();
+    $steps.scrollTop(0);
+  }
+  // Returns the index of the currently selected <li>
+  function currentLiIndex() {
+    return liIndices[selectedStepIndex];
+  }
+  // Returns the selected <li> as a jQuery object
+  function currentLi() {
+    return $($stepsLi[currentLiIndex()]);
+  }
+  // Returns a step <li> as a jQuery object
+  function stepLi(idx) {
+    return $($stepsLi[idx]);
+  }
+  // Split original steps and create the steps array
+  for(var i = 0; i < originalSteps.length; i++) {
+    originalStep = originalSteps[i];
+    step = originalStep[0].toString();
+    // Remove /^ and $/
+    s = step.substring(2, step.length - 2);
+    splits = splitRegexp(s);
+    for(var j = 0; j < splits.length; j++) {
+      split = splits[j];
+      newStep = {}
+      newStep.regexp = split
+      newStep.params = originalStep.length == 1 ? [] : originalStep[1]
+      newStep.regexpReplaced = processGroups(newStep, function(idx) {
+        return newStep.params[idx];
+      });
+      steps.push(newStep);
+      allLiIndices.push(allLiIndices.length);
+    }
+  }
+  liIndices = allLiIndices;
+  // Sort steps according to regexps, alphabetically
+  steps.sort(function(a, b) {
+    x = a.regexp.toLowerCase();
+    y = b.regexp.toLowerCase();
+    return x < y ? -1 : (x > y ? 1 : 0);
+  });
+  // Write the steps in the <li>s
+  for(var i = 0; i < steps.length; i++) {
+    step = steps[i];
+    replacement = processGroups(step, function(idx) {
+      return '<span class="param">' + step.params[idx] + '</span>';
+    });
+    $steps.append("<li>" + replacement + "</li>");
+  }
+  $stepsLi = $steps.find("li");
+  // Highlight the first selected step
+  stepLi(0).addClass("selected");
+  // Focus the text input to write the match
+  $stepMatch.focus();
+  // When pressing a key in the step match input, filter the steps
+  $stepMatch.keyup(function(ev) {
+    if (justBuiltAStep) {
+      justBuiltAStep = false;
+      return;
+    }
+    text = $stepMatch.val();
+    // If the text didn't change and it's not enter, do nothing
+    if (text == lastStepMatchText && ev.keyCode != 13)
+      return true;
+    // These are the arrow keys, home, end, etc. We can ignore them.
+    if (ev.keyCode >= 33 && ev.keyCode <= 40) {
+      return true;
+    }
+    lastStepMatchText = text;
+    // If the user pressed enter, selected the step
+    if (ev.keyCode == 13) {
+      prepareBuildStep();
+      return false;
+    }
+    // Unselect the current step
+    currentLi().removeClass("selected");
+    // See if we the text starts with an action and remove it
+    foundMatch = false;
+    if (text.match(/^when /i)) {
+      text = text.substring(5);
+      currentAction = "When ";
+    }
+    if (text.match(/^then /i)) {
+      text = text.substring(5);
+      currentAction = "Then ";
+    }
+    if (text.match(/^given /i)) {
+      text = text.substring(6);
+      currentAction = "Given ";
+    }
+    if (text.match(/^and /i)) {
+      text = text.substring(4);
+      currentAction = "And ";
+    }
+    // Do the filtering
+    text = eval("/^" + text + "/i");
+    liIndices = [];
+    selectedStepIndex = -1;
+    for(var i = 0; i < steps.length; i++) {
+      step = steps[i];
+      $stepLi = stepLi(i);
+      if (step.regexpReplaced.match(text)) {
+        $stepLi.show();
+        if (selectedStepIndex == -1) {
+          $stepLi.addClass("selected");
+          selectedStepIndex = 0;
+        }
+        liIndices.push(i);
+      } else {
+        $stepLi.hide();
+      }
+    }
+  });
+  // When pressing up or down on the stepMatch input,
+  // change the selected step
+  $stepMatch.keydown(function(ev) {
+    if (selectedStepIndex == -1) return;
+    // Up, Down, PageUp or PageDown
+    if (ev.keyCode == 38 || ev.keyCode == 40 || ev.keyCode == 33 || ev.keyCode == 34) {
+      currentLi().removeClass("selected");
+      var increment = 0;
+      switch(ev.keyCode) {
+      case 33: increment = -10; break;
+      case 34: increment =  10; break;
+      case 38: increment = -1; break;
+      case 40: increment =  1; break;
+      }
+      selectedStepIndex += increment;
+      if (selectedStepIndex < 0) selectedStepIndex = 0;
+      if (selectedStepIndex > liIndices.length - 1) selectedStepIndex = liIndices.length - 1;
+      current = currentLi();
+      current.addClass("selected");
+      $steps.scrollTop(0);
+      $steps.scrollTop(current.position().top - 90);
+      return false;
+    }
+    return true;
+  });
+  // When hovering an <li>, highglight it
+  $stepsLi.mouseenter(function(ev) {
+    currentLi().removeClass("selected");
+    selectedStepIndex = $stepsLi.index(this);
+    currentLi().addClass("selected");
+  });
+  // When clicking an <li>, build it
+  $stepsLi.click(function(ev) {
+    selectedStepIndex = $stepsLi.index(this);
+    prepareBuildStep();
+  });
+  // When pressing enter or tab in the step building inputs, go
+  // to the next one or write to scenario if it's the last one
+  $(".complete").live("keyup", function(ev) {
+    // When pressing ESC, go back to search
+    if (ev.keyCode == 27) {
+      searchAgain();
+      return false;
+    }
+    // Enter
+    if (ev.keyCode == 13) {
+      $this = $(this);
+      value = $this.val();
+      if (value == '')
+        return false;
+      id = $this.attr("id").substring(1);
+      id = parseInt(id) + 1;
+      $next = $("#p" + id);
+      if ($next.length > 0) {
+        $next.focus();
+      } else {
+        appendToScenario();
+        searchAgain();
+      }
+      return false;
+    }
+    return true;
+  });
+  // Clear the scenario
+  $("#clear").click(function() {
+    $scenario.html("");
+    searchAgain();
+    firstStepInScenario = true;
+    currentAction = "Given ";
+  });
+});
+</script>
+<style>
+body { font-family: "Helvetica Neue",Arial,Helvetica,sans-serif; font-size:85%; height:80% }
+table { font-size:100%; }
+ul { list-style-type:none; margin:0px; padding:0px;}
+li { padding: 4px; cursor: pointer;}
+h3 { padding: 0px; margin:0px; }
+#steps, #stepBuilder { height: 40%; position: relative; overflow: auto; border: 1px solid black; background-color: #DFDFEF; margin-top: 20px;}
+#scenarioContainer { margin-top:20px; border: 1px solid black; padding:10px; background-color: #EFEF99; }
+#scenario { font-size: 105%; padding-left: 20px; margin-top: 10px;}
+#container { min-height: 100%; position: relative; }
+#separator { height: 5%; }
+#logo { position: absolute; bottom: 0px; right: 4px; height: 20px; width: 100%; text-align: right; font-weight:bold;}
+.param { font-weight: bold; color: blue;}
+.selected { background-color: #BBE; padding:4px;}
+.complete { width:100%; }
+</style>
+</head>
+<body>
+<div id="container">
+  <h3 id="explanationStep">
+  Write a step as you would write it in cucumber (including given, when, then, and) and press enter when you have selected one.
+  </h3>
+  <h3 id="explanationStepBuilder" style="display:none">
+  Now fill in the fields for the step (press tab or enter to change between fields, or escape to search another step).
+  </h3>
+  <input type="text" id="stepMatch" size="100" />
+  <ul id="steps">
+  </ul>
+  <div id="stepBuilder" style="display:none">
+  </div>
+  <div id="scenarioContainer">
+    <h3>Scenario <a href="javascript:void(0)" id="clear" style="margin-left:10px">clear</a></h3>
+    <div id="scenario">
+    </div>
+  </div>
+</div>
+<div id="separator">
+</div>
+<div id="logo">
+#{name} - cukecooker :)
+</div>
+</body>
+</html>
+EOF
+end
+puts "Done! Now open cukecooker-#{name}.html in a browser."

metadata ADDED Viewed

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: cukecooker
+version: !ruby/object:Gem::Version
+  hash: 9
+  prerelease: false
+  segments:
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors:
+- Ary Borenszweig
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2010-12-08 00:00:00 -03:00
+default_executable:
+dependencies: []
+description:
+email: aborenszweig@manas.com.ar
+executables:
+- cukecooker
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- bin/cukecooker
+- README.rdoc
+has_rdoc: true
+homepage: https://github.com/asterite/cukecooker
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- .
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      hash: 3
+      segments:
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      hash: 3
+      segments:
+      - 0
+      version: "0"
+requirements: []
+rubyforge_project:
+rubygems_version: 1.3.7
+signing_key:
+specification_version: 3
+summary: Write cucumber scenarios with aid
+test_files: []