Merge pull request #852 from t9md/lazy-f

Better `f` as chimera of clever-f  and vim-seek.

CHANGELOG.md

@@ -1,8 +1,48 @@
+# 1.1.0: This release is all for better `f` by making it tunable
+- New: [Summary] Now `f` is **tunable**. #852.
+ - Inspired pure-vim's plugins: `clever-f`, `vim-seek`, `vim-sneak`.
+ - Highlighting find-char. It help you to pre-determine consequence of repeat by `;`, `,` and `.`.
+ - Aiming to get both benefit of two-char-find(`vim-seek`, `vim-sneak`) and one-char-find( vim's default ).
+ - Even after two-char-find was enabled, you can auto-confirm one-char input by specified timeout.
+ - Can reuse `f`, `F`, `t`, `T` as `repeat-find` like `clever-f`.
+- Config: [Detail] Following configuration option is available to **tune** `f`.
+ - `keymapSemicolonToConfirmFind`: default `false`.
+ - See explanation for `findByTwoChars`.
+ - `ignoreCaseForFind`: default `false`
+ - `useSmartcaseForFind`: default `false`
+ - `highlightFindChar`: default `true`
+ - Highlight find char, fadeout automatically( this auto-disappearing behavior/duration is not configurable ).
+ - Fadeout in 2 second when used as motion.
+ - Fadeout in 4 second when used as operator-target.
+ - `findByTwoChars`: default `false`
+ - When enabled, `f` accept TWO chars.
+ - Pros. Greatly reduces possible matches, avoid being stopped at earlier spot than where you aimed.
+ - Cons. Require explicit **confirmation** by `enter` for single char-input. You might mitigate frustration by.
+ - Confirm by `;`, easier to type and well blend to forwarding `repeat-find`( `;` ).
+ - Enable "keymap `;` to confirm `find` motion"( `keymapSemicolonToConfirmFind` ) configuration.
+ - e.g. `f a ;` to move to `a`( better than `f a enter`?). `f a ; ;` to move to 2nd `a`(well blended to default repeat-find(`;`)).
+ - Enable auto confirm by timeout( See. `findByTwoCharsAutoConfirmTimeout` )
+ - `findByTwoCharsAutoConfirmTimeout`: default `0`.
+ - "When `findByTwoChars` was enabled, automatically confirm single-char input on timeout( msec ).
+ - `0` means no timeout.
+ - `reuseFindForRepeatFind`: default `false`
+ - When `true` you can repeat last-find by `f` and `F`(also `t` and `T`).
+ - You still can use `,` and `;`.
+ - e.g. `f a f` move cursor to 2nd `a`.
+ - My configuration( I'm still in-eval phase, don't take this as recommendation ).
+ ```coffeescript
+ keymapSemicolonToConfirmFind: true
+ findByTwoChars: true
+ findByTwoCharsAutoConfirmTimeout: 500
+ reuseFindForRepeatFind: true
+ useSmartcaseForFind: true
+ ```
+
 # 1.0.0: New default `stayOn` all `true`.
 - Version: Decided to bump major version.
 - Breaking: Default config change/Renamed config name.
  - Summary:
- - Now all `stayOn` prefixed configuration have new default `true`.
+ - Now all `stayOn` prefixed configuration have new default `false`.
  - New default behavior is NOT compatible with pure-Vim.
  - Set all `stayOn` prefixed configuration to `false` to revert to previous behavior.
  - Some configuration parameter name is renamed to have `stayOn` prefix.

keymaps/vim-mode-plus.cson

@@ -105,7 +105,7 @@
  '-': 'vim-mode-plus:move-to-first-character-of-line-up'
  '+': 'vim-mode-plus:move-to-first-character-of-line-down'
  'enter': 'vim-mode-plus:move-to-first-character-of-line-down'
- 
+
  'g 0': 'vim-mode-plus:move-to-beginning-of-screen-line'
  'g ^': 'vim-mode-plus:move-to-first-character-of-screen-line'
  'g $': 'vim-mode-plus:move-to-last-character-of-screen-line'
@@ -282,7 +282,6 @@
  # 'g n': 'vim-mode-plus:move-to-next-number'
  # 'g N': 'vim-mode-plus:move-to-previous-number'
 
-
 # macOS only
 '.platform-darwin atom-text-editor.vim-mode-plus:not(.insert-mode)':
  'ctrl-s': 'vim-mode-plus:transform-string-by-select-list'
@@ -661,7 +660,7 @@
  'O': 'vim-mode-plus:reverse-selections'
  'D': 'vim-mode-plus:delete-to-last-character-of-line' # To avoid overridden by delete-line in visual-mode
 
-# Input mini editor e.g. mark, surround.
+# Input mini editor e.g. mark, surround, find, till.
 # -------------------------
 'atom-text-editor.vim-mode-plus-input':
  'ctrl-c': 'core:cancel'

lib/base.coffee

@@ -166,13 +166,11 @@ class Base
  selectList.show(@vimState, options)
 
  input: null
- focusInput: ({charsMax, hideCursor} = {}) ->
- @vimState.focusInput
- charsMax: charsMax
- hideCursor: hideCursor
- onConfirm: (@input) => @processOperation()
- onCancel: => @cancelOperation()
- onChange: (input) => @vimState.hover.set(input)
+ focusInput: (options = {}) ->
+ options.onConfirm ?= (@input) => @processOperation()
+ options.onCancel ?= => @cancelOperation()
+ options.onChange ?= (input) => @vimState.hover.set(input)
+ @vimState.focusInput(options)
 
  readChar: ->
  @vimState.readChar

lib/focus-input.js

@@ -1,20 +1,33 @@
-module.exports = function focusInput(vimState, {charsMax = 1, hideCursor, onChange, onCancel, onConfirm} = {}) {
- vimState.editorElement.classList.add("vim-mode-plus-input-focused")
- if (hideCursor) vimState.editorElement.classList.add("hide-cursor")
+module.exports = function focusInput(
+ vimState,
+ {charsMax = 1, autoConfirmTimeout, hideCursor, onChange, onCancel, onConfirm, purpose} = {}
+) {
+ const classListToAdd = ["vim-mode-plus-input-focused"]
+ if (hideCursor) classListToAdd.push("hide-cursor")
+ vimState.editorElement.classList.add(...classListToAdd)
 
  const editor = atom.workspace.buildTextEditor({mini: true})
 
  vimState.inputEditor = editor // set ref for test
  editor.element.classList.add("vim-mode-plus-input")
+ if (purpose) editor.element.classList.add(purpose)
  editor.element.setAttribute("mini", "")
 
- if (atom.inSpecMode()) atom.workspace.getElement().appendChild(editor.element) // I can skip jasmine.attachToDOM.
+ // So that I can skip jasmine.attachToDOM in test.
+ if (atom.inSpecMode()) atom.workspace.getElement().appendChild(editor.element)
  else vimState.editorElement.parentNode.appendChild(editor.element)
 
+ let autoConfirmTimeoutID
+ const clerAutoConfirmTimer = () => {
+ if (autoConfirmTimeoutID) clearTimeout(autoConfirmTimeoutID)
+ autoConfirmTimeoutID = null
+ }
+
  const unfocus = () => {
+ clerAutoConfirmTimer()
  vimState.editorElement.focus() // focus
  vimState.inputEditor = null // unset ref for test
- vimState.editorElement.classList.remove("vim-mode-plus-input-focused", "hide-cursor")
+ vimState.editorElement.classList.remove(...classListToAdd)
  editor.element.remove()
  editor.destroy()
  }
@@ -30,8 +43,23 @@ module.exports = function focusInput(vimState, {charsMax = 1, hideCursor, onChan
 
  vimState.onDidFailToPushToOperationStack(cancel)
 
- if (charsMax === 1) editor.onDidChange(() => confirm(editor.getText()))
- else if (onChange) editor.onDidChange(() => onChange(editor.getText()))
+ if (charsMax === 1) {
+ editor.onDidChange(() => confirm(editor.getText()))
+ } else {
+ editor.onDidChange(() => {
+ clerAutoConfirmTimer()
+
+ const text = editor.getText()
+ if (text.length >= charsMax) {
+ confirm(text)
+ } else {
+ if (onChange) onChange(text)
+ if (autoConfirmTimeout) {
+ autoConfirmTimeoutID = setTimeout(() => confirm(text), autoConfirmTimeout)
+ }
+ }
+ })
+ }
 
  atom.commands.add(editor.element, {
  "core:cancel": event => {

lib/highlight-find-manager.js

@@ -0,0 +1,63 @@
+const DecorationTypes = {
+ "pre-confirm": {
+ decorationProps: {
+ type: "highlight",
+ class: "vim-mode-plus-find-char pre-confirm",
+ },
+ },
+ "post-confirm": {
+ timeout: 2000,
+ decorationProps: {
+ type: "highlight",
+ class: "vim-mode-plus-find-char post-confirm",
+ },
+ },
+ "post-confirm-long": {
+ timeout: 4000,
+ decorationProps: {
+ type: "highlight",
+ class: "vim-mode-plus-find-char post-confirm-long",
+ },
+ },
+}
+
+module.exports = class HighlightFind {
+ constructor(vimState) {
+ this.vimState = vimState
+ vimState.onDidDestroy(() => this.destroy())
+
+ const {editor} = vimState
+ this.markerLayer = editor.addMarkerLayer()
+ this.decorationLayer = editor.decorateMarkerLayer(this.markerLayer, {})
+ }
+
+ destroy() {
+ this.decorationLayer.destroy()
+ this.markerLayer.destroy()
+ }
+
+ clearMarkers() {
+ this.markerLayer.clear()
+ }
+
+ highlightRanges(ranges, decorationType) {
+ if (this.clearMarkerTimeoutID) {
+ clearTimeout(this.clearMarkerTimeoutID)
+ this.clearMarkerTimeoutID = null
+ }
+
+ this.clearMarkers()
+ // We need to force update here to restart(re-trigger) keyframe animation.
+ this.vimState.editor.component.updateSync()
+
+ for (const range of ranges) {
+ this.markerLayer.markBufferRange(range)
+ }
+
+ const {timeout, decorationProps} = DecorationTypes[decorationType]
+ this.decorationLayer.setProperties(decorationProps)
+ if (timeout) {
+ this.clearMarkerTimeoutID = setTimeout(() => this.clearMarkers(), timeout)
+ }
+ }
+}

lib/motion-search.coffee

@@ -9,7 +9,7 @@ class SearchBase extends Motion
  jump: true
  backwards: false
  useRegexp: true
- configScope: null
+ caseSensitivityKind: null
  landingPoint: null # ['start' or 'end']
  defaultLandingPoint: 'start' # ['start' or 'end']
  relativeIndex: null
@@ -33,20 +33,6 @@ class SearchBase extends Motion
  else
  count
 
- getCaseSensitivity: ->
- if @getConfig("useSmartcaseFor#{@configScope}")
- 'smartcase'
- else if @getConfig("ignoreCaseFor#{@configScope}")
- 'insensitive'
- else
- 'sensitive'
-
- isCaseSensitive: (term) ->
- switch @getCaseSensitivity()
- when 'smartcase' then term.search('[A-Z]') isnt -1
- when 'insensitive' then false
- when 'sensitive' then true
-
  finish: ->
  if @isIncrementalSearch() and @getConfig('showHoverSearchCounter')
  @vimState.hoverSearchCounter.reset()
@@ -101,7 +87,7 @@ class SearchBase extends Motion
 # -------------------------
 class Search extends SearchBase
  @extend()
- configScope: "Search"
+ caseSensitivityKind: "Search"
  requireInput: true
 
  initialize: ->
@@ -206,7 +192,7 @@ class SearchBackwards extends Search
 # -------------------------
 class SearchCurrentWord extends SearchBase
  @extend()
- configScope: "SearchCurrentWord"
+ caseSensitivityKind: "SearchCurrentWord"
 
  moveCursor: (cursor) ->
  @input ?= (

lib/motion.coffee

@@ -116,6 +116,12 @@ class Motion extends Base
  state.stop()
  oldPosition = newPosition
 
+ isCaseSensitive: (term) ->
+ if @getConfig("useSmartcaseFor#{@caseSensitivityKind}")
+ term.search(/[A-Z]/) isnt -1
+ else
+ not @getConfig("ignoreCaseFor#{@caseSensitivityKind}")
+
 # Used as operator's target in visual-mode.
 class CurrentSelection extends Motion
  @extend(false)
@@ -890,14 +896,43 @@ class Find extends Motion
  inclusive: true
  offset: 0
  requireInput: true
+ caseSensitivityKind: "Find"
 
  initialize: ->
  super
- @focusInput() unless @isComplete()
+
+ @repeatIfNecessary()
+ return if @isComplete()
+
+ if @getConfig("findByTwoChars")
+ options =
+ charsMax: 2
+ autoConfirmTimeout: @getConfig("findByTwoCharsAutoConfirmTimeout")
+ onChange: (char) => @highlightTextInCursorRows(char, "pre-confirm")
+ onCancel: =>
+ @vimState.highlightFind.clearMarkers()
+ @cancelOperation()
+
+ options ?= {}
+ options.purpose = "find"
+
+ @focusInput(options)
+
+ repeatIfNecessary: ->
+ if @getConfig("reuseFindForRepeatFind")
+ if @vimState.operationStack.getLastCommandName() in ["Find", "FindBackwards", "Till", "TillBackwards"]
+ @input = @vimState.globalState.get("currentFind").input
+ @repeated = true
 
  isBackwards: ->
  @backwards
 
+ execute: ->
+ super
+ decorationType = "post-confirm"
+ decorationType += "-long" if @isAsTargetExceptSelect()
+ @highlightTextInCursorRows(@input, decorationType)
+
  getPoint: (fromPoint) ->
  {start, end} = @editor.bufferRangeForBufferRow(fromPoint.row)
 
@@ -911,15 +946,27 @@ class Find extends Motion
  method = 'scanInBufferRange'
 
  points = []
- @editor[method] ///#{_.escapeRegExp(@input)}///g, scanRange, ({range}) ->
- points.push(range.start)
+ @editor[method] @getRegex(@input), scanRange, ({range}) -> points.push(range.start)
+
  points[@getCount(-1)]?.translate([0, offset])
 
+ highlightTextInCursorRows: (text, decorationType) ->
+ return unless @getConfig("highlightFindChar")
+ ranges = []
+ for cursor in @editor.getCursors()
+ scanRange = cursor.getCurrentLineBufferRange()
+ @editor.scanInBufferRange(@getRegex(text), scanRange, ({range}) -> ranges.push(range))
+ @vimState.highlightFind.highlightRanges(ranges, decorationType)
+
  moveCursor: (cursor) ->
  point = @getPoint(cursor.getBufferPosition())
  @setBufferPositionSafely(cursor, point)
  @globalState.set('currentFind', this) unless @repeated
 
+ getRegex: (term) ->
+ modifiers = if @isCaseSensitive(term) then 'g' else 'gi'
+ new RegExp(_.escapeRegExp(term), modifiers)
+
 # keymap: F
 class FindBackwards extends Find
  @extend()

lib/operation-stack.js

@@ -38,6 +38,10 @@ module.exports = class OperationStack {
  return handler // DONT REMOVE
  }
 
+ getLastCommandName() {
+ return this.lastCommandName
+ }
+
  reset() {
  this.resetCount()
  this.stack = []
@@ -222,7 +226,10 @@ module.exports = class OperationStack {
  }
 
  finish(operation) {
- if (operation && operation.recordable) this.recordedOperation = operation
+ if (operation) {
+ if (operation.recordable) this.recordedOperation = operation
+ this.lastCommandName = operation.name
+ }
 
  this.vimState.emitDidFinishOperation()
  if (operation && operation.isOperator()) operation.resetState()