Get rid of action chains

[rejeep]

Is it possible with a decent implementation?

[tkf]

How about something like this?

When I type <M-x> "linum-mode"

My suggestion is to make it possible to take any number of TPYING argument by When I type step. Also, do what When I press does when the TYPING is surrounded by <>. This is backward compatible so it won't break any test.

[rejeep]

This might work in a few cases, but you'll still have issues for more complex situations, such as calling this function:

(defun enter ()
  (interactive)
  (read-string "enter: "))

You would need to:

• Press M-x
• Type enter
• Press RET
• Type whatever
• Press RET

The only rock solid solution I can come up with is to use two functions that are used in every step definition. One function for "type or press" steps and one function for all others.

So if a "type or press" function is called we always add to the action chain (without executing it).

And if a "non type or press" function is called and the previous step call was a:

• "type and press", execute the action chain
• "non type and press", execute the current step and do nothing with the chain

This solution sucks and requires changes in Ecukes or every third party library that uses Ecukes has to use these functions all over the place.

[tkf]

Can't you simulate that steps with a step definition like this?:

(When "I start an action chain")
(loop for t in types ; '("<M-x>" "\"enter\"" "<RET>" "\"whatever\"" "<RET>")
      do (let ((type (substring t 1 (1- (length t))))
               (bracket (substring t 0 1)))
           (cond
            ((equal bracket "\"") (And "Type %s" type)
             (equal bracket "<") (And "Press %s" type)))))
(And "I execute the action chain")

[rejeep]

Not sure if I understand. The "whatever" in types is project specific, so the user still have to take action, right?

Another idea is to add before/after hooks in Ecukes for when a step runs. That way Espuds could check what the previous step was.

[tkf]

Step definition I was talking about is quite general. Here is more specific definition.

(When "^I type \\(.*\\)$"  ; (regexp can be improved)
  (lambda (types)
    (When "I start an action chain")
    (loop for t in (SPLIT-TYPES types)
          do (let ((type (substring t 1 (1- (length t))))
                   (bracket (substring t 0 1)))
               (cond
                ((equal bracket "\"") (OLD-I-TYPE-STEP type)
                 (equal bracket "<") (And "I press %s" type)))))
    (And "I execute the action chain")))

Note that if you want to make it backward compatible (i.e., don't execute anything after I start an action chain step), you need extra code here. But I omit that part for simplicity.

SPLIT-TYPES is a function that can split a string in parts where each part is enclosed by "" or <>. Example:

(SPLIT-TYPES "<M-x> \"enter\" <RET> \"whatever\" <RET>")
;; => '("<M-x>" "\"enter\"" "<RET>" "\"whatever\"" "<RET>")

Then, this step should be equivalent to your example:

I type <M-x> "enter" <RET> "whatever" <RET>

[rejeep]

Ahh, I see. Yeah, that might work. So instead of having multiple steps, you merge them into one. Great idea.

[magnars]

I'm gonna give this a big old +1 👍

[tkf]

Grad that I was talking about completely stupid idea :)

I just notice that using <> might not be good idea since you need to pass <> to edmacro-parse-keys for cases like "<M-return>". Probably choosing other bracket/quote would be better.