some ivy-kill-ring to complete M-y?

Helm has a convenient feature: the ability to display a list of kill ring entries (most recent kills). I miss this feature, but still prefer ivy. Thank you for your work!

[abo-abo]

You mean helm-show-kill-ring? Here is something similar, but Ivy doesn't currently work well with multi-line candidates:

(defun ivy-show-kill-ring ()
  (interactive)
  (ivy-read "kill-ring: " (helm-kill-ring-candidates)
            :action 'insert))

Making multi-line selection work better might take some time.

I will try this and the other solutions from http://emacswiki.org/emacs/BrowseKillRing

[EDIT] This snippet actually worked without extra package.

(defun yank-browse (string)
      "Browse the `kill-ring' to choose which entry to yank."
      (interactive
       (minibuffer-with-setup-hook #'minibuffer-completion-help
         (let* ((kills (delete-dups (append kill-ring-yank-pointer kill-ring nil)))
                (entries
                 (mapcar (lambda (string)
                           (let ((pos 0))
                             ;; FIXME: Maybe we should start by removing
                             ;; all properties.
                             (setq string (copy-sequence string))
                             (while (string-match "\n" string pos)
                               ;; FIXME: Maybe completion--insert-strings should
                               ;; do that for us.
                               (put-text-property
                                (match-beginning 0) (match-end 0)
                                'display (eval-when-compile
                                           (propertize "\\n" 'face 'escape-glyph))
                                string)
                               (setq pos (match-end 0)))
                             ;; FIXME: We may use the window-width of the
                             ;; wrong window.
                             (when (>= (* 3 (string-width string))
                                       (* 2 (window-width)))
                               (let ((half (- (/ (window-width) 3) 1)))
                                 ;; FIXME: We're using char-counts rather than
                                 ;; width-count.
                                 (put-text-property
                                  half (- (length string) half)
                                  'display (eval-when-compile
                                             (propertize "……" 'face 'escape-glyph))
                                  string)))
                             string))
                         kills))
                (table (lambda (string pred action)
                         (cond
                          ((eq action 'metadata)
                           '(metadata (category . kill-ring)))
                          (t
                           (complete-with-action action entries string pred))))))
           ;; FIXME: We should return the entry from the kill-ring rather than
           ;; the entry from the completion-table.
           ;; FIXME: substring completion doesn't work well because it only matches
           ;; subtrings before the first \n.
           ;; FIXME: completion--insert-strings assumes that boundaries of
           ;; candidates are obvious enough, but with kill-ring entries this is not
           ;; true, so we'd probably want to display them with «...» around them.
           (list (completing-read "Yank: " table nil t)))))
      (setq this-command 'yank)
      (insert-for-yank string))

Here is how it is rendered:

I inserted the highlighted item then called the function again.

It suits for me: I prefer totally avoid to install the heavy Helm.

Thank you for your answer.

[abo-abo]

I've added a new command counsel-yank-pop. It's more-or-less functional now, some improvements may come in the future.

[Pitometsu]

Here much more interesting, interactive and emacs-way solution http://www.namazu.org/~tsuchiya/elisp/yank-pop-summary.el

Could counsel-yank-pop work this way?