rememberyou / emacs-ideas Goto Github PK

Description

The project is to create a new GNU Emacs package that will sort a buffer
depending on the programming language used. The ultimate goal is that a user
will be able to add a hook to the created mode in different languages
(preferably non-procedural), wishing to be sorted according to their functions,
classes, imports, etc.

The issue with the current sorting functions is that the user has to select the
corresponding regions himself, and these sortings do not always work according
to the formatting of the function documentation and the intermediate lines.

Functions

This package will include the following functions [0/7]:

• psort-count-not-sorted-classes: gets the number of classes that need to be
  sorted. Defaults to 0.

• psort-count-not-sorted-functions: gets the number of functions that need to be
  sorted. Defaults to 0.

• psort-count-not-sorted-imports: gets the number of imports that need to be
  sorted. Defaults to 0.

• psort-highlight-not-sorted: allows using a background color, things that need to
  be sorted. Defaults to nil.

• psort-mode: launch of the mode. Defaults to nil.

• psort-get-sorted-language: get the name of the buffer language being sorted
  (e.g. Python, Java, Lisp, etc.). Defaults to nil.

• psort-sort-buffer: sort the buffer according to the user
  configuration. Defaults to nil.

Variables

This package will include the following variables [0/8]:

• psort-highlight-color: background color for detecting things to sort with
  hightlight-not-sorted. Defaults to "red".

• psort-not-sorting-functions: a list of special functions that should not be
  sorted as the constructors (e.g. init.py in python).

• psort-sort-method: defined the method used to sort (e.g. alphabetically, by
  length, etc). Defaults to "alphabetically".

• psort-sort-with-classes: make it possible to know whether sorting should be
  done by considering classes or not (practical if several classes are defined
  in a file). Defaults to t.

• psort-sort-with-imports: make it possible to know whether sorting should be
  done by considering imports or not. Defaults to t.

• psort-sorting-time: Time of last sorting. Defauls to 0.

• psort-verbose: if t, display text each time the psort-sort-buffer is
  called. Display example : "Sorted functions: 5". Defaults to t.

• psort-verbose-format: formatting verbose bode. Useful if you prefer to
  display the time it took to sort the functions, or display a different message
  than the one initially provided.

Things to Implement [0/2]

• Use imenu with completing-read replacement that sorts candidates by length.
• Improve imenu's quality widly depending on the major mode.

Some people on #emacs and Reddit, talked about how cool it could be to create a tinder mode for GNU Emacs.

For the API, we could take a look at this link: https://gist.github.com/rtt/10403467

Description

A package to be able to manage React.js with TypeScript.

Functions

Almost the same that can offer rjsx-mode.

Variables

Almost the same that can offer rjsx-mode.

Things to Implement

Almost the same that can offer rjsx-mode.

Description

This package aims to simplify the process of taking an image and hosting it on a remote service like postImage. Therefore, based on a single function, the user can either make a screenshot of his current buffer, or host a particular image. Similar to webpaste to host its code.

Things to Implement [0/2]

• Use imagemagick to take the screenshots, already built-in with GNU Emacs.
• Allow you to host your image on other services with curl.

Useful links

https://www.emacswiki.org/emacs/ScreenShot
https://superuser.com/questions/777184/upload-image-to-postimage-org-using-curl

Description

emacs-gradle-mode is not maintained anymore. It would be cool to fork this repository or/and start something from scratch by taking inspiration to this package.

One missing feature is the fact that emacs-gradle-mode can't identifying and reporting on patterns of misuse or deprecations in Gradle scripts (SEE: more here)

Functions

All of what gradle and gradle-lint-plugin can provide.

Variables

All of what gradle and gradle-lint-plugin can provide.

Description

Very often I have TODO keywords inside my code base. I make a heavy usage of magit-todos to show me what TODOs do I have across my code. However, I would love to have those items directly integrated to Org Agenda.

Maybe, I could be more diligent and instead of writing TODOs in my code-base I could be capturing it with a proper org template. However, I have several coworkers that do not use Emacs and they create some TODOs and FIXMEs in the code.

Things to Implement [0/2]

I was thinking about a *-minor-mode that when enabled would look for TODO itens inside a project.

• It could work integrated with projectile
• It might be very cool to change the status of the TODO item in the code base when the status change inside the Org Agenda.

Description

This package aims to add some functionality for this idea box to GNU Emacs. We would be able to add ideas in markdown, list them, edit them and comment on them; as well as being able to provide links to local info files and links to (built-in) source code, and possibly example config code. All from our familiar environment.

Do you know hugo for emacs blogging?
I'd like a help hand if possible to set up a blog using hugo, emacs and github or gitlab.
I can set up it up only to my localhost, but I am failing to set up hugo to work with my github/gitlab account.
Here are the steps I have taken:
Of course, I have to uncomment the lines in my
init.el

• TODO Ox-hugo

  Hugo is better than org2blog
  https://gohugo.io/getting-started/quick-start/
  https://zzamboni.org/post/my-emacs-configuration-with-commentary/

  How to set up hugo:
  apt install hugo
  then:
  cd /org/ and issue
  hugo new site blog
  cd /org/blog
  git init
  Then add a theme:
  cd /org/blog/themes/
  git submodule add https://github.com/budparr/gohugo-theme-ananke.git ananke
  cd ..
  echo 'theme = "ananke"' >> config.toml
  hugo new posts/my-first-post.md
  Edit the my-first-post.md
  cd /org/blog
  then start the server
  hugo server -D
  open it in:
  http://localhost:1313/
  in emacs it is "org-hugo"
  M-x org-hugo

hash-plus BEGIN_SRC emacs-lisp

;; (use-package ox-hugo
;; :ensure t
;; :after ox)

;; (require 'ox-hugo)
;; (require 'org-hugo-auto-export-mode)

;; (use-package org-capture
;; :ensure nil
;; :config
;; (defun org-hugo-new-subtree-post-capture-template ()
;; ;; "Returns org-capture' template string for new Hugo post. ;; ;; See org-capture-templates' for more information."

;; (let* ((title (read-from-minibuffer "Post Title: ")) ;Prompt to enter the post title
;; (fname (org-hugo-slug title)))
;; (mapconcat #'identity
;; (,(concat "* TODO " title) ;; ":PROPERTIES:" ;; ,(concat ":EXPORT_HUGO_BUNDLE: " fname) ;; ":EXPORT_FILE_NAME: index" ;; ":END:" ;; "%?\n") ;Place the cursor here finally ;; "\n"))) ;; (add-to-list 'org-capture-templates ;; '("o" ;org-capture' binding + o
;; "Post"
;; entry
;; ;; It is assumed that below file is present in `org-directory'
;; ;; and that it has an "Ideas" heading. It can even be a
;; ;; symlink pointing to the actual location of all-posts.org!
;; (file+datetree (concat org-directory "~/blog/content/posts/my-post.org")
;; "* TODO %^{Description} %^g\n%?\nAdded: %U")
;; (function org-hugo-new-subtree-post-capture-template))))

hash-plus END_SRC

Description

I find ansi-term slow compared to other terminator emulators. The idea is to optimize it with some modifications.

Things to Implement [0/1]

• Use FFI and libtsm.

Useful Links

http://www.reddit.com/r/vim/comments/30btwx/neovim_now_has_a_full_terminal_emulator_mode_i/
https://github.com/akermu/emacs-libvterm

Description

Some Emacs package use native components, written in C, C++ or any other language, that require building on the user's computer. Such packages include irony-mode, mu4e, pdf-tools, intero and a lot more. The common approach is to use a shell script or ad-hoc elisp to install the dependencies using the adequate method for the running OS and try to produce a binary. This is horrible.

The envisioned library would provide a standard way for packages to expose their native component's dependencies and build system and would handle building and rebuilding

Things to Implement [0/5]

• Some basic abstraction over common build systems, at the very least autotools and cmake.

• Some basic abstraction over package management, supporting both the "old school method" (apt-get install) and the Nix/Guix "shell" approach (where the package manager creates a shell with the required packages available)

• Some basic abstraction over common dependencies. Eg, Debian's libexpat-dev = Arch's libexpat = nix's expat. Runtime dependencies must be distinguished from compilation deps. Having a stupid database of name equivalences is no big deal and makes things a lot easier for everyone.
  (the general rule that ∀x Debian = libX-dev, Arch=libX, Nix=X can be a good start)

• Updates support: store the built version and compare with the library's version.

• Support for generating binaries and Emacs native modules.

Interface for package writers

It could look like this:

(require 'whatever-name-you-want-to-give-the-lib)

(declare-native-component your-package-name
  :type 'program
  :build 'cmake
  :lang 'c++ ; must accept a symbol or a list, determines the binding language for deps.
  :src "server" ; a subdirectory or your-package-name's root dir
  :build-deps '(compiler poppler png zlib)) ;; May be either a list of an alist of (language . deps), so the correct bindings are installed for each language.

From that, the library would create the build environment for the current OS and build the components. Options for installing the components should probably be provided, with reasonable defaults (= just take this binary and put it in your-package-name/bin or /lib

Support for including a simple test could help automate validation of the configuration in all supported OSs and build systems.

Prior art

Packages with a native component:

• https://github.com/Sarcasm/irony-mode
• https://github.com/politza/pdf-tools (uses a complex shell script)
• https://github.com/djcb/mu (no support at all for building from Emacs, usually used as an OS package)
• https://github.com/commercialhaskell/intero (the best implementation, but very specific)

Package managers with support for building:

• Borg has good support for building packages, both the elisp part and external modules. It provides a good abstraction over build systems and OS so all specifics are handled through plugins, eg my own nix-shell support plugin. Build configuration is in the user's .gitmodules, an example can be seen here. But the level of abstraction is so high that setups are not really reusable.

Description

Integrate the fzy fuzzy finder.

Functions

As a user, I would like to integrate fzy with dired. For example, a simple fuzzy search in the current directory using dired, should return the corresponding results.

Variables

Free to your imagination.

Useful Links

fzy-locate