Download engine mode - download do código fonte engine mode

engine mode

Outro código-fonte

1.0.0

Baixar

`engine-mode`

engine-mode é um modo secundário global para Emacs. Ele permite que você defina facilmente mecanismos de pesquisa, vincule-os a atalhos de teclado e consulte-os no conforto do seu editor.

./doc/demo.gif

Por exemplo, suponha que queiramos pesquisar facilmente no GitHub:

(defengine github
  " https://github.com/search?ref=simplesearch&q=%s " )

Isso define um engine/search-github . Quando executado, ele pegará a região selecionada (ou solicitará entrada, se nenhuma região for selecionada) e pesquisará por ela no GitHub, exibindo os resultados em seu navegador padrão.

A macro defengine também pode receber uma combinação de teclas opcional, prefixada com engine/keymap-prefix (cujo padrão é Cx / ). Essa combinação de teclas será envolvida em uma chamada para kbd .

(defengine duckduckgo
  " https://duckduckgo.com/?q=%s "
  :keybinding " d " )

Cx / d agora está vinculado à nova função engine/search-duckduckgo ! Legal.

Se você gostaria de ver um vídeo sobre os porquês desse modo, confira a palestra que @hrs deu no EmacsNYC.

Instalação

engine-mode está disponível no MELPA.

Usando use-package :

( use-package engine-mode
  :ensure t

  :config
  (engine-mode t ))

Você também pode instalá-lo como qualquer outro arquivo elisp adicionando-o ao seu caminho de carregamento e habilitando-o globalmente:

( require 'engine-mode )
(engine-mode t )

Alterando seu navegador padrão

engine-mode usa a variável engine/browser-function para determinar qual navegador ele deve usar para abrir o URL que ele constrói. Para alterar o navegador padrão, redefina engine/browser-function . Por exemplo, para sempre usar o navegador eww integrado do Emacs:

( setq engine/browser-function 'eww-browse-url )

O padrão de engine/browser-function é browse-url-browser-function , que o Emacs usa globalmente para abrir links.

A implementação da variável browse-url-browser-function contém uma lista abrangente de possíveis funções do navegador. Você pode fazer isso pressionando Ch v browse-url-browser-function <RETURN> e seguindo o link para browse-url.el .

Alterando seu navegador por mecanismo

Para alterar o navegador apenas para um único mecanismo, use o argumento da palavra-chave :browser ao definir o mecanismo. Por exemplo, para usar eww apenas para os resultados de pesquisa do GitHub, tente:

(defengine github
  " https://github.com/search?ref=simplesearch&q=%s "
  :browser 'eww-browse-url )

Conforme mencionado, consulte a implementação da browse-url-browser-function para obter uma lista definitiva de navegadores.

Alterando o prefixo do mapa de teclado

O prefixo do mapa de teclado padrão para engine-mode é Cx / . Se quiser vincular o mapa de teclado a um prefixo adicional (digamos, Cc s ), você pode:

(engine/set-keymap-prefix ( kbd " C-c s " ))

Se você usar use-package , poderá conseguir o mesmo com:

 :bind-keymap ( " C-c s " . engine-mode-prefixed-map)

Documentos personalizados

defengine atribui a cada mecanismo uma docstring padrão razoável, mas você pode substituir isso caso a caso com o argumento da palavra-chave :docstring :

(defengine ctan
  " https://www.ctan.org/search/?x=1&PORTAL=on&phrase=%s "
  :docstring " Search the Comprehensive TeX Archive Network (ctan.org) " )

Modificando o termo de pesquisa antes de enviá-lo

Um mecanismo pode querer transformar um termo de pesquisa de alguma forma antes de interpolar o termo na URL. Talvez o termo devesse ter uma codificação diferente, ou ser maiúsculo diferente, ou, uh, ser passado pelo ROT13. Seja qual for o motivo, você pode aplicar uma transformação personalizada a um termo de pesquisa passando uma função para defengine por meio do argumento de palavra-chave :term-transformation-hook .

Por exemplo, para UPCASE todas as suas pesquisas DuckDuckGo:

(defengine duckduckgo
  " https://duckduckgo.com/?q=%s "
  :term-transformation-hook upcase)

Ou, para garantir que todas as suas consultas sejam codificadas como latin-1:

(defengine diec2
  " dlc.iec.cat/results.asp?txtEntrada=%s "
  :term-transformation-hook ( lambda ( term ) ( encode-coding-string term latin-1))
  :keybinding " c " )

Você também pode usar um :term-transformation-hook para fazer um mecanismo se comportar de maneira diferente quando recebe um argumento de prefixo (ou seja, digitar Cu antes de invocar o mecanismo).

Alguns mecanismos de pesquisa oferecem suporte à consulta de frases exatas, colocando a sequência de pesquisa entre aspas duplas. As transformações podem ser úteis neste caso para realizar uma pesquisa literal se o argumento universal estiver presente:

(defengine duckduckgo
  " https://duckduckgo.com/?q=%s "
  :term-transformation-hook ( lambda ( term ) ( if current-prefix-arg
                                          ( concat " " " term " " " )
                                        term ))
  :keybinding " d " )

Digitar Cx / d realizará uma pesquisa regular, mas digitar Cu Cx / d colocará sua consulta entre aspas antes de pesquisá-la. Isso é especialmente útil ao pesquisar o conteúdo da região.

Importando pesquisas de palavras-chave de outros navegadores

Como muitos navegadores salvam pesquisas de palavras-chave usando o mesmo formato do modo de mecanismo (ou seja, usando %s em uma URL para indicar um termo de pesquisa), não é muito difícil importá-las para o Emacs.

@sshaw escreveu um script para importar do Chrome no OS X. Obrigado por isso!

Comparação com `webjump`

O Emacs possui um pacote webjump integrado perfeitamente adorável que permite ao usuário definir um conjunto de URLs, interpolar termos de pesquisa neles e visitá-los no navegador.

Por que você pode usar engine-mode em vez de webjump ?

Você deseja vincular pesquisas específicas a atalhos de teclado. Como engine-mode define uma função para cada mecanismo, os atalhos de teclado no engine-mode podem ser associados diretamente a pesquisas específicas.
Você gostaria de associar as funções do navegador aos mecanismos caso a caso. Por exemplo, se você deseja realizar algumas pesquisas no Firefox e outras pesquisas no eww , isso é trivial no engine-mode .
Você gosta de algumas das pequenas conveniências da interface do usuário do engine-mode . Se você tiver uma região selecionada, por exemplo, engine-mode a usará como consulta de pesquisa, enquanto webjump a ignorará e oferecerá um prompt vazio.

Se você não está interessado nesses recursos, webjump é uma ótima escolha! Honestamente, o autor do engine-mode provavelmente não teria se incomodado em escrevê-lo se soubesse que webjump existia na época. ?

Exemplos de motores

(defengine amazon
  " https://www.amazon.com/s/ref=nb_sb_noss?url=search-alias%3Daps&field-keywords=%s " )

(defengine duckduckgo
  " https://duckduckgo.com/?q=%s "
  :keybinding " d " )

(defengine github
  " https://github.com/search?ref=simplesearch&q=%s " )

(defengine google
  " https://www.google.com/search?ie=utf-8&oe=utf-8&q=%s "
  :keybinding " g " )

(defengine google-images
  " https://www.google.com/images?hl=en&source=hp&biw=1440&bih=795&gbv=2&aq=f&aqi=&aql=&oq=&q=%s " )

(defengine google-maps
  " https://maps.google.com/maps?q=%s "
  :docstring " Mappin' it up. " )

(defengine project-gutenberg
  " https://www.gutenberg.org/ebooks/search/?query=%s " )

(defengine qwant
  " https://www.qwant.com/?q=%s " )

(defengine stack-overflow
  " https://stackoverflow.com/search?q=%s " )

(defengine twitter
  " https://twitter.com/search?q=%s " )

(defengine wikipedia
  " https://www.wikipedia.org/search-redirect.php?language=en&go=Go&search=%s "
  :keybinding " w "
  :docstring " Searchin' the wikis. " )

(defengine wiktionary
  " https://www.wikipedia.org/search-redirect.php?family=wiktionary&language=en&go=Go&search=%s " )

(defengine wolfram-alpha
  " https://www.wolframalpha.com/input/?i=%s " )

(defengine youtube
  " https://www.youtube.com/results?aq=f&oq=&search_query=%s " )