path: root/emacs.scm

(define-module (emacs)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module (guix build-system emacs)
  #:use-module (gnu packages emacs)
  #:use-module (gnu packages emacs-xyz))

(define-public emacs-srv
  (let ((commit "714387d5a5cf34d8d8cd96bdb1f9cb8ded823ff7")
        (revision "1"))
    (package
      (name "emacs-srv")
      (version (string-append "0.0-" revision))
      (source
       (origin
         (method git-fetch)
         (uri (git-reference
               (url "https://github.com/legoscia/srv.el.git")
               (commit commit)))
         (sha256
          (base32
           "1a8pqhdi7m3lis5ad2f74s1sy8zpxlwvfsvd80lw746235x2v06z"))))
      (build-system emacs-build-system)
      (home-page "https://github.com/legoscia/srv.el")
      (synopsis "perform SRV DNS requests")
      (description
       "This code implements RFC 2782 (SRV records).  It was originally
written for jabber.el <http://emacs-jabber.sf.net>, but is now a
separate package.

It is used to look up hostname and port for a service at a specific
domain.  There might be multiple results, and the caller is supposed
to attempt to connect to each hostname+port in turn.  For example,
to find the XMPP client service for the domain gmail.com:

\(srv-lookup \"_xmpp-client._tcp.gmail.com\")
-> ((\"xmpp.l.google.com\" . 5222)
    (\"alt3.xmpp.l.google.com\" . 5222)
    (\"alt4.xmpp.l.google.com\" . 5222)
    (\"alt1.xmpp.l.google.com\" . 5222)
    (\"alt2.xmpp.l.google.com\" . 5222))
")
      (license #f))))

(define-public emacs-fsm
  (package
    (name "emacs-fsm")
    (version "0.2.1")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://elpa.gnu.org/packages/fsm-"
             version
             ".el"))
       (sha256
        (base32
         "1jyxyqdbfl8nv7c50q0sg3w5p7whp1sqgi7w921k5hfar4d11qqp"))))
    (build-system emacs-build-system)
    (home-page
     "http://elpa.gnu.org/packages/fsm.html")
    (synopsis "state machine library")
    (description "")
    (license license:gpl3+)))

(define-public emacs-hexrgb
  (package
    (name "emacs-hexrgb")
    (version "0")
    (source
     (origin
       (method url-fetch)
       (uri "https://www.emacswiki.org/emacs/download/hexrgb.el")
       (sha256
        (base32
         "18hb8brf7x92aidjfgczxangri6rkqq4x5d06lh41193f97rslm8"))))
    (build-system emacs-build-system)
    (home-page #f)
    (synopsis #f)
    (description #f)
    (license license:gpl2+)))

(define-public emacs-jabber
  (let ((commit "fff33826f42e040dad7ef64ea312d85215d3b0a1")
        (revision "1"))
    (package
      (name "emacs-jabber")
      (version (string-append "0.0-" revision))
      (source
       (origin
         (method git-fetch)
         (uri (git-reference
               (url "https://github.com/legoscia/emacs-jabber.git")
               (commit commit)))
         (sha256
          (base32
           "1fif38qhiaxskfmqin82n9334bzrkgd1h5ip1djcm571i670gj74"))))
      (build-system emacs-build-system)
      (propagated-inputs
       `(("emacs-fsm" ,emacs-fsm)
         ("emacs-srv" ,emacs-srv)
         ("emacs-hexrgb" ,emacs-hexrgb)))
      (home-page "unspecified")
      (synopsis "A Jabber client for Emacs.")
      (description "No description available.")
      (license #f))))

(define-public emacs-ibuffer-vc
  (package
    (name "emacs-ibuffer-vc")
    (version "20181225.2227")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/purcell/ibuffer-vc.git")
             (commit "64cb03887bcae6127e80f0d9342c33206e21d2d2")))
       (sha256
        (base32
         "1ayqa7l5ny7g01pb3917w2phnsdfw69scw3lk6bpa773pq00n2vi"))))
    (build-system emacs-build-system)
    (home-page
     "http://github.com/purcell/ibuffer-vc")
    (synopsis
     "Group ibuffer's list by VC project, or show VC status")
    (description
     "Adds functionality to ibuffer for grouping buffers by their parent
vc root directory, and for displaying and/or sorting by the vc
status of listed files.
")
    (license #f)))

(define-public emacs-powershell
  (let ((commit "c9a20e5a8b02dc5d7ccd2b1974eba28a9348ad5e")
        (revision "1"))
    (package
      (name "emacs-powershell")
      (version (string-append "0.0-" revision))
      (source
       (origin
         (method git-fetch)
         (uri (git-reference
               (url "https://github.com/jschaf/powershell.el.git")
               (commit commit)))
         (sha256
          (base32
           "1y8bph4133n4pcvsplni0ahg14ny27vl03jxf5lhhqkh06miqqsg"))))
      (build-system emacs-build-system)
      (home-page
       "http://github.com/jschaf/powershell.el")
      (synopsis "Mode for editing Powershell scripts")
      (description #f)
      (license #f))))

(define-public emacs-ssass-mode
  (package
    (name "emacs-ssass-mode")
    (version "0.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/AdamNiederer/ssass-mode.git")
             (commit "d17d2de381ffc96e62e77435fb7b387bf59aceec")))
       (sha256
        (base32
         "1vw2mzn8yczgyspgmv4f621d7h10qxa8hfzalb14bvwqn4h37spy"))))
    (build-system emacs-build-system)
    (home-page
     "http://github.com/AdamNiederer/ssass-mode")
    (synopsis "Edit Sass without a Turing Machine")
    (description
     "This mode is a clone of sass-mode which works in mmm-mode and doesn't
indent things as eagerly.  Syntax highlighting is provided with
`font-lock-mode'.

Exported names start with \"ssass-\"; private names start with
\"ssass--\".
")
    (license license:gpl3+)))

(define-public emacs-vue-html-mode
  (package
    (name "emacs-vue-html-mode")
    (version "20170225.2301")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/AdamNiederer/vue-html-mode.git")
             (commit "1e0aa0befd2fa958b70bdc88d9bab1a4eccf94fd")))
       (sha256
        (base32
         "0axzdq5kss3ng9a17xr5i96x1rr4p61sil5lx783xq4zrbamh7fw"))))
    (build-system emacs-build-system)
    (home-page
     "http://github.com/AdamNiederer/vue-html-mode")
    (synopsis
     "Major mode for editing Vue.js templates")
    (description "No description available.")
    (license license:gpl3+)))

(define-public emacs-vue-mode
  (package
    (name "emacs-vue-mode")
    (version "20170712.930")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/AdamNiederer/vue-mode.git")
             (commit "a680998d5e597e91be2e7e15e88bd83856a13c84")))
       (sha256
        (base32
         "1hmqwv4xdjmly1l4s1hkx1n28navnqy5nplas39pwywik2dlh2cs"))))
    (build-system emacs-build-system)
    (propagated-inputs
     `(("emacs-mmm-mode" ,emacs-mmm-mode)
       ("emacs-vue-html-mode" ,emacs-vue-html-mode)
       ("emacs-ssass-mode" ,emacs-ssass-mode)))
    (home-page "unspecified")
    (synopsis
     "Major mode for vue component based on web-mode and mmm-mode")
    (description "")
    (license license:gpl3+)))

(define-public emacs-mocha
  (package
    (name "emacs-mocha")
    (version "1.1")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://github.com/scottaj/mocha.el/archive/v" version ".tar.gz"))
       (sha256
        (base32
         "03c42p5rbrffzadd100pjilxjcfj7bdxn5flcswdhaymrf9lxirz"))))
    (build-system emacs-build-system)
    (propagated-inputs
     `(("emacs-js2-mode" ,emacs-js2-mode)
       ("emacs-f" ,emacs-f)))
    (home-page "http://github.com/scottaj/mocha.el")
    (synopsis "Run Mocha or Jasmine tests")
    (description
     "This mode provides the ability to run Mocha or Jasmine tests from within Emacs
")
    (license license:gpl3+)))

(define-public emacs-elm-mode
  (package
    (name "emacs-elm-mode")
    (version "0.20.3")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://github.com/jcollard/elm-mode/archive/v"
             version ".tar.gz"))
       (sha256
        (base32
         "0kkb53p2sa3nxhfsmk3r8qkvqsdhhg8raqfa14wf07037g4x01n0"))))
    (build-system emacs-build-system)
    (propagated-inputs
     `(("emacs-f" ,emacs-f)
       ("emacs-s" ,emacs-s)))
    (home-page
     "https://github.com/jcollard/elm-mode")
    (synopsis "Major mode for Elm")
    (description "")
    (license license:gpl3+)))

(define-public emacs-evil-goggles
  (let ((revision "1")
        (commit "90da624f368f4730a7ce8b3993f0d31baaea471d"))
    (package
      (name "emacs-evil-goggles")
      (version (string-append "0.0.0-" revision))
      (source
       (origin
         (method git-fetch)
         (uri (git-reference
               (url "https://github.com/edkolev/evil-goggles.git")
               (commit commit)))
         (sha256
          (base32
           "1j9jfial5cs555y7kcm6452xrwpqgxpidc289l7hdin4v9s9gqhm"))))
      (build-system emacs-build-system)
      (propagated-inputs `(("emacs-evil" ,emacs-evil)))
      (home-page
       "http://github.com/edkolev/evil-goggles")
      (synopsis "Add a visual hint to evil operations")
      (description
       "Add a visual hint to evil edit operations such as yank, delete,
paste, etc.

Usage:

 (evil-goggles-mode)
")
      (license license:gpl3+))))

(define-public emacs-elixir-mode
  (package
    (name "emacs-elixir-mode")
    (version "20190103.1736")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/elixir-lang/emacs-elixir")
             (commit "ad06579d6445c5954e8506eb1b314c7ed4a42f4b")))
       (sha256
        (base32
         "04gajw0m728ppmjq0ydinqimqxgx9m3awnwhz983cm53lcqv02pw"))))
    (build-system emacs-build-system)
    (propagated-inputs
     `(("emacs-pkg-info" ,emacs-pkg-info)))
    (home-page
     "https://github.com/elixir-lang/emacs-elixir")
    (synopsis "Major mode for editing Elixir files")
    (description
     " Provides font-locking, indentation and navigation support
 for the Elixir programming language.
")
    (license #f)))

(package
  (name "emacs-plantuml-mode")
  (version "20191102.2056")
  (source (origin
            (method git-fetch)
            (uri (git-reference
                  (url "https://github.com/skuro/plantuml-mode.git")
                  (commit "5889166b6cfe94a37532ea27fc8de13be2ebfd02")))
            (sha256
             (base32 "0yp41d2dmf3sx7qnl5x0zdjcr9y71b2wwc9m0q31v22xqn938ipc"))))
  (build-system emacs-build-system)
  (propagated-inputs (quasiquote (("emacs-dash" (unquote emacs-dash)))))
  (home-page "unspecified")
  (synopsis "Major mode for PlantUML")
  (description "No description available.") (license #f))

(define-public emacs-plantuml-mode
  (package
    (name "emacs-plantuml-mode")
    (version "1.4.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/skuro/plantuml-mode.git")
             (commit (string-append "v" version))))
       (sha256
        (base32
         "0yp41d2dmf3sx7qnl5x0zdjcr9y71b2wwc9m0q31v22xqn938ipc"))))
    (build-system emacs-build-system)
    (propagated-inputs `(("emacs-dash" ,emacs-dash)))
    (home-page "unspecified")
    (synopsis "Major mode for PlantUML")
    (description
     "A major mode fgor plantuml, see: http://plantuml.sourceforge.net/
Plantuml is an open-source tool in java that allows to quickly write :
    - sequence diagram,
    - use case diagram,
    - class diagram,
    - activity diagram,
    - component diagram,
    - state diagram
    - object diagram")
    (license #f)))

(define-public emacs-navigel
  (package
   (name "emacs-navigel")
   (version "20190828.449")
   (source
    (origin
     (method url-fetch)
     (uri (string-append
           "https://melpa.org/packages/navigel-"
           version
           ".el"))
     (sha256
      (base32
       "050gi4a4cz4bxjrdvs6jpymkk6glnbv3aw7pvibpbij8c0f3z69m"))))
   (build-system emacs-build-system)
   (propagated-inputs
    `(("emacs-tablist" ,emacs-tablist)))
   (home-page
    "https://gitlab.petton.fr/DamienCassou/navigel")
   (synopsis
    "Facilitate the creation of tabulated-list based UIs")
   (description
    "This library makes it simpler for Emacs Lisp developers to define
user-interfaces based on tablists (also known as tabulated-lists).
Overriding a few (CL) methods and calling `navigel-open' is all
that's required to get a nice UI to navigate your domain objects
\(e.g., files, music library, database).

Features include :

- pressing RET to open the entity at point in another buffer;
- pressing ^ to open the current entity's parent;
- marking entities for bulk operations (e.g., delete);
- `imenu' support for quick navigation;
")
   (license #f)))

(define-public emacs-kubernetes
  (package
   (name "emacs-kubernetes")
   (version "0.13.0")
   (source
    (origin
     (method url-fetch)
     (uri (string-append
           "https://github.com/chrisbarrett/kubernetes-el/archive/"
           version ".tar.gz"))
     (sha256
      (base32
       "03w4g5zsnda1f0xwylmdncadaq1wrlwhmpm17y0gr1jan4v6w97i"))))
   (build-system emacs-build-system)
   (propagated-inputs
    `(("emacs-dash" ,emacs-dash)
      ("emacs-evil" ,emacs-evil)
      ("emacs-magit" ,emacs-magit)
      ("emacs-magit-popup" ,emacs-magit-popup)))
   (home-page "unspecified")
   (synopsis "Magit-like porcelain for Kubernetes.")
   (description "")
   (license #f)))

(define-public emacs-kubel
  (package
   (name "emacs-kubel")
   (version "20200316.207")
   (source
    (origin
     (method git-fetch)
     (uri (git-reference
           (url "https://github.com/abrochard/kubel.git")
           (commit
            "db3a999c028ffeeeb49936e8b921c364bf8f437e")))
     (sha256
      (base32
       "1ai33jma22agrxww6dcgsh6dbv5h36gixgs0b6n1q4d5v7k6d9q3"))))
   (build-system emacs-build-system)
   (propagated-inputs
    `(("emacs-transient" ,emacs-transient)
      ("emacs-dash" ,emacs-dash)
      ("emacs-s" ,emacs-s)))
   (arguments
    '(#:include
      '("^[^/]+.el$"
        "^[^/]+.el.in$"
        "^dir$"
        "^[^/]+.info$"
        "^[^/]+.texi$"
        "^[^/]+.texinfo$"
        "^doc/dir$"
        "^doc/[^/]+.info$"
        "^doc/[^/]+.texi$"
        "^doc/[^/]+.texinfo$")
      #:exclude
      '("^.dir-locals.el$"
        "^test.el$"
        "^tests.el$"
        "^[^/]+-test.el$"
        "^[^/]+-tests.el$"
        "^kubel-evil.el$")))
   (home-page "https://github.com/abrochard/kubel")
   (synopsis
    "extension for controlling Kubernetes with limited permissions")
   (description
    "Emacs extension for controlling Kubernetes with limited permissions.e")
   (license #f)))

(define-public demo-it
  (package
    (name "emacs-demo-it")
    (version "0.0.0-1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/howardabrams/demo-it.git")
             (commit "9cfa5c3f92a0dca7eebb1f1a2011643c9b009d26")))
       (sha256
        (base32
         "1fcmrhm6h0j7jjw6kijrcacv628fy80ssxn6h5bilwmw0r4c7wm6"))))
    (build-system emacs-build-system)
    (home-page "unspecified")
    (synopsis "Create demonstrations")
    (description
     "  When making demonstrations of new products, technologies and other
  geekery, I love the versatility of using Emacs to demonstrate the
  trifecta of sprint reviews, including:

  - Presentations explaining the technologies
  - Source code ... correctly highlighted
  - Executing the code in Eshell ... or similar demonstration
  - Test a new feature

  However, I don't want to fat-finger, mentally burp, or even delay
  the gratification while I type, so I predefine each \"step\" as an
  Elisp function or keyboard macro, and then have =demo-it= execute
  each function when I hit either the SPACE key or the F12 key
  (advanced minor mode).

  Using the library is a four step process:

  1. Load the library in your own Elisp source code file
  2. Create a collection of functions that \"do things\".
  3. Create the ordered list of functions/steps with `demo-it-create'
  4. Start the demonstration with `demo-it-start'

  For instance:

      (require 'demo-it)   ;; Load this library of functions

      (defun dit-load-source-code ()
        \"Load some source code in a side window.\"
        (demo-it-presentation-advance)
        (demo-it-load-fancy-file \"example.py\" :line 5 12 :side))

      (defun dit-run-code ()
        \"Execute our source code in an Eshell buffer.\"
        ;; Close other windows and advance the presentation:
        (demo-it-presentation-return)
        (demo-it-start-shell)
        (demo-it-run-in-shell \"python example.py Snoopy\"))

      (demo-it-create :single-window :insert-slow :full-screen
                      (demo-it-title-screen \"example-title.org\")
                      (demo-it-presentation \"example.org\")
                       dit-load-source-code
                       dit-run-code
                      (demo-it-run-in-shell \"exit\" nil :instant))

      (demo-it-start)

  Each \"step\" is a series of Elisp functions that \"do things\".
  While this package has a collection of helping functions, the steps
  can use any Elisp command to show off a feature.

  I recommend installing these other Emacs packages:

  - https://github.com/takaxp/org-tree-slide
  - https://github.com/sabof/org-bullets
  - https://github.com/magnars/expand-region.el
  - https://github.com/Bruce-Connor/fancy-narrow

  See http://github.com/howardabrams/demo-it for more details and
  better examples.  You will want to walk through the source code
  for all the utility functions.
")
    (license #f)))

(define-public emacs-org-mime
  (package
   (name "emacs-org-mime")
   (version "0.1.6")
   (source
    (origin
     (method git-fetch)
     (uri ;; (git-reference
          ;;  (url "https://github.com/org-mime/org-mime.git")
          ;;  (commit "0.1.6"))
      (git-reference
       (url "https://github.com/czan/org-mime.git")
       (commit "562cb5a3f0e4af69d9495d0cd829bdd6a7fd77fa")))
     (sha256
      (base32
       "1dwk23265sigv9znaidi7qffz0mnmmc19vs8yv8zy6h7b6818622"))))
   (build-system emacs-build-system)
   (home-page "http://github.com/org-mime/org-mime")
   (synopsis
    "org html export for text/html MIME emails")
   (description #f)
   (license #f)))

(define-public emacs-csharp-mode
  (package
   (name "emacs-csharp-mode")
   (version "20191126.1928")
   (source
    (origin
     (method url-fetch)
     (uri (string-append
           "https://melpa.org/packages/csharp-mode-"
           version
           ".el"))
     (sha256
      (base32
       "1fiq9gd9288f1c3i0qw9rzzj8fh0csip817y2phla5gyjgmxk063"))))
   (build-system emacs-build-system)
   (home-page
    "https://github.com/josteink/csharp-mode")
   (synopsis "C# mode derived mode")
   (description
    "   This is a major mode for editing C# code.  It performs automatic
   indentation of C# syntax; font locking; and integration with
   imenu.el.

   csharp-mode requires CC Mode 5.30 or later.  It works with
   cc-mode 5.31.3, which is current at this time.

Features:

  - font-lock and indent of C# syntax including:
      all c# keywords and major syntax
      attributes that decorate methods, classes, fields, properties
      enum types
      #if/#endif  #region/#endregion
      instance initializers
      anonymous functions and methods
      verbatim literal strings (those that begin with @)
      generics

  - automagic code-doc generation when you type three slashes.

  - compatible with electric-pair-mode for intelligent insertion
    of matched braces, quotes, etc.

  - imenu integration - generates an index of namespaces, classes,
    interfaces, methods, and properties for easy navigation within
    the buffer.



Installation instructions
--------------------------------

Put csharp-mode.el somewhere in your load path, optionally byte-compile
it, and add the following to your .emacs file:

  (autoload 'csharp-mode \"csharp-mode\" \"Major mode for editing C# code.\" t)
  (setq auto-mode-alist\n     (append '((\"\\\\.cs$\" . csharp-mode)) auto-mode-alist))


Optionally, define and register a mode-hook function.  To do so, use
something like this in your .emacs file:

  (defun my-csharp-mode-fn ()
     \"function that runs when csharp-mode is initialized for a buffer.\"
     (turn-on-auto-revert-mode)
     (setq indent-tabs-mode nil)
     ...insert more code here...
     ...including any custom key bindings you might want ...
  )
  (add-hook  'csharp-mode-hook 'my-csharp-mode-fn t)


 General
 ----------------------------

 Mostly C# mode will \"just work.\"  Use `describe-mode' to see the
 default keybindings and the highlights of the mode.


 imenu integration
 -----------------------------

 This should just work.  For those who don't know what imenu is, it
 allows navigation to different points within the file from an
 \"Index\" menu, in the window's menubar.  csharp-mode computes the
 menu containing the namespaces, classes, methods, and so on, in the
 buffer.  This happens at the time the file is loaded; for large
 files it takes a bit of time to complete the scan.  If you don't
 want this capability, set `csharp-want-imenu' to nil.
")
   (license #f)))

(define-public emacs-omnisharp
  (package
   (name "emacs-omnisharp")
   (version "20191015.635")
   (source
    (origin
     (method url-fetch)
     (uri (string-append
           "https://melpa.org/packages/omnisharp-"
           version
           ".tar"))
     (sha256
      (base32
       "036cz5hjxg8bl0a54hidmjily5sax6y51iyyrabkqx015jrldiif"))))
   (build-system emacs-build-system)
   (propagated-inputs
    `(("emacs-flycheck" ,emacs-flycheck)
      ("emacs-dash" ,emacs-dash)
      ("emacs-auto-complete" ,emacs-auto-complete)
      ("emacs-popup" ,emacs-popup)
      ("emacs-csharp-mode" ,emacs-csharp-mode)
      ("emacs-s" ,emacs-s)
      ("emacs-f" ,emacs-f)))
   (home-page
    "https://github.com/Omnisharp/omnisharp-emacs")
   (synopsis
    "Omnicompletion (intellisense) and more for C#")
   (description
    "omnisharp-emacs is a port of the awesome OmniSharp server to the
Emacs text editor. It provides IDE-like features for editing files
in C# solutions in Emacs, provided by an OmniSharp server instance
that works in the background.

See the project home page for more information.
")
   (license #f)))

(define-public emacs-scala-mode
  (package
    (name "emacs-scala-mode")
    (version "20190929.1522")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/hvesalai/emacs-scala-mode.git")
             (commit
              "46bb948345f165ebffe6ff3116e36a3b8a3f219d")))
       (sha256
        (base32
         "1072lsin7dxadc0xyhy42wd0cw549axbbd4dy95wfmfcc1xbzjwv"))))
    (build-system emacs-build-system)
    (home-page
     "https://github.com/hvesalai/emacs-scala-mode")
    (synopsis "Major mode for editing Scala")
    (description "")
    (license #f)))

(define-public emacs-sbt-mode
  (package
    (name "emacs-sbt-mode")
    (version "20200106.753")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/hvesalai/emacs-sbt-mode.git")
               (commit
                 "633a315ad453cd963588c9b8fba02d9cf75296b4")))
        (sha256
          (base32
            "0ha2lyw42ir16b2d09y27q0rsdx6azcfv258frp1ja63mx0jiqic"))))
    (build-system emacs-build-system)
    (home-page
      "https://github.com/hvesalai/emacs-sbt-mode")
    (synopsis "Interactive support for sbt projects")
    (description "")
    (license #f)))

(define-public emacs-lsp-scala
  (package
    (name "emacs-lsp-scala")
    (version "20190604.1237")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/rossabaker/lsp-scala.git")
               (commit
                 "06f189aa5cafe93cecbdaa234bccd900def7bc68")))
        (sha256
          (base32
            "05l563j1wz01rqwd4r639i88ln3bkn0m4swvj3hs11d70brlw981"))))
    (build-system emacs-build-system)
    (propagated-inputs
      `(("emacs-lsp-mode" ,emacs-lsp-mode)
        ("emacs-sbt-mode" ,emacs-sbt-mode)))
    (home-page
      "https://github.com/rossabaker/lsp-scala")
    (synopsis "Scala support for lsp-mode")
    (description
      "This package defines an lsp-mode client for Scala.
")
    (license #f)))