it draws breath

velveteer · May 21, 2022 · e8d8dea · e8d8dea
commit e8d8dea
Show file tree

Hide file tree

Showing 17 changed files with 1,390 additions and 0 deletions.
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,2 @@
+dist-newstyle
+tags
diff --git a/.hlint.yaml b/.hlint.yaml
@@ -0,0 +1,49 @@
+# These are ignored for being annoying
+- ignore: { name: Redundant lambda }
+- ignore: { name: Redundant flip }
+- ignore: { name: Redundant if }
+- ignore: { name: Move brackets to avoid $ }
+- ignore: { name: Reduce duplication }
+- ignore: { name: Redundant <$> }
+- ignore: { name: Redundant fmap }
+
+# Losing variable names can be not-nice
+- ignore: { name: Eta reduce }
+- ignore: { name: Avoid lambda }
+
+# Humans know better
+- ignore: { name: Use camelCase }
+- ignore: { name: Use const }
+- ignore: { name: Use infix }
+- ignore: { name: Use section }
+- ignore: { name: Use if }
+- ignore: { name: Use notElem }
+- ignore: { name: Use fromMaybe }
+- ignore: { name: Use maybe }
+- ignore: { name: Use isJust }
+- ignore: { name: Use isNothing }
+- ignore: { name: Use list comprehension }
+- ignore: { name: Use fmap }
+- ignore: { name: Use foldl }
+- ignore: { name: Use unless }
+- ignore: { name: Use for }
+- ignore: { name: "Use :" }
+- ignore: { name: Use ++ }
+- ignore: { name: Use || }
+- ignore: { name: Use && }
+- ignore: { name: 'Use ?~' }
+- ignore: { name: Use <$> }
+- ignore: { name: Use <$ }
+- ignore: { name: Use <=< }
+
+# Some 'data' records will be extended with more fields later,
+# so they shouldn't be replaced with 'newtype' blindly
+- ignore: { name: Use newtype instead of data }
+
+# These extensions are probably fine but we don't need hlint
+# screaming about them.
+- ignore: { name: Use lambda-case }
+- ignore: { name: Use tuple-section }
+
+# Sometimes we like seeing how many args a constructor has
+- ignore: { name: Use record patterns }
diff --git a/.stylish-haskell.yaml b/.stylish-haskell.yaml
@@ -0,0 +1,237 @@
+# stylish-haskell configuration file
+# ==================================
+
+# The stylish-haskell tool is mainly configured by specifying steps. These steps
+# are a list, so they have an order, and one specific step may appear more than
+# once (if needed). Each file is processed by these steps in the given order.
+steps:
+  # Convert some ASCII sequences to their Unicode equivalents. This is disabled
+  # by default.
+  # - unicode_syntax:
+  #     # In order to make this work, we also need to insert the UnicodeSyntax
+  #     # language pragma. If this flag is set to true, we insert it when it's
+  #     # not already present. You may want to disable it if you configure
+  #     # language extensions using some other method than pragmas. Default:
+  #     # true.
+  #     add_language_pragma: true
+
+  # Align the right hand side of some elements.  This is quite conservative
+  # and only applies to statements where each element occupies a single
+  # line.
+  - simple_align:
+      cases: false
+      top_level_patterns: false
+      records: false
+
+  # Import cleanup
+  - imports:
+      # There are different ways we can align names and lists.
+      #
+      # - global: Align the import names and import list throughout the entire
+      #   file.
+      #
+      # - file: Like global, but don't add padding when there are no qualified
+      #   imports in the file.
+      #
+      # - group: Only align the imports per group (a group is formed by adjacent
+      #   import lines).
+      #
+      # - none: Do not perform any alignment.
+      #
+      # Default: global.
+      align: global
+
+      # The following options affect only import list alignment.
+      #
+      # List align has following options:
+      #
+      # - after_alias: Import list is aligned with end of import including
+      #   'as' and 'hiding' keywords.
+      #
+      #   > import qualified Data.List      as List (concat, foldl, foldr, head,
+      #   >                                          init, last, length)
+      #
+      # - with_alias: Import list is aligned with start of alias or hiding.
+      #
+      #   > import qualified Data.List      as List (concat, foldl, foldr, head,
+      #   >                                 init, last, length)
+      #
+      # - new_line: Import list starts always on new line.
+      #
+      #   > import qualified Data.List      as List
+      #   >     (concat, foldl, foldr, head, init, last, length)
+      #
+      # Default: after_alias
+      list_align: after_alias
+
+      # Right-pad the module names to align imports in a group:
+      #
+      # - true: a little more readable
+      #
+      #   > import qualified Data.List       as List (concat, foldl, foldr,
+      #   >                                           init, last, length)
+      #   > import qualified Data.List.Extra as List (concat, foldl, foldr,
+      #   >                                           init, last, length)
+      #
+      # - false: diff-safe
+      #
+      #   > import qualified Data.List as List (concat, foldl, foldr, init,
+      #   >                                     last, length)
+      #   > import qualified Data.List.Extra as List (concat, foldl, foldr,
+      #   >                                           init, last, length)
+      #
+      # Default: true
+      pad_module_names: false
+
+      # Long list align style takes effect when import is too long. This is
+      # determined by 'columns' setting.
+      #
+      # - inline: This option will put as much specs on same line as possible.
+      #
+      # - new_line: Import list will start on new line.
+      #
+      # - new_line_multiline: Import list will start on new line when it's
+      #   short enough to fit to single line. Otherwise it'll be multiline.
+      #
+      # - multiline: One line per import list entry.
+      #   Type with constructor list acts like single import.
+      #
+      #   > import qualified Data.Map as M
+      #   >     ( empty
+      #   >     , singleton
+      #   >     , ...
+      #   >     , delete
+      #   >     )
+      #
+      # Default: inline
+      long_list_align: multiline
+
+      # Align empty list (importing instances)
+      #
+      # Empty list align has following options
+      #
+      # - inherit: inherit list_align setting
+      #
+      # - right_after: () is right after the module name:
+      #
+      #   > import Vector.Instances ()
+      #
+      # Default: inherit
+      empty_list_align: inherit
+
+      # List padding determines indentation of import list on lines after import.
+      # This option affects 'long_list_align'.
+      #
+      # - <integer>: constant value
+      #
+      # - module_name: align under start of module name.
+      #   Useful for 'file' and 'group' align settings.
+      list_padding: 2
+
+      # Separate lists option affects formatting of import list for type
+      # or class. The only difference is single space between type and list
+      # of constructors, selectors and class functions.
+      #
+      # - true: There is single space between Foldable type and list of it's
+      #   functions.
+      #
+      #   > import Data.Foldable (Foldable (fold, foldl, foldMap))
+      #
+      # - false: There is no space between Foldable type and list of it's
+      #   functions.
+      #
+      #   > import Data.Foldable (Foldable(fold, foldl, foldMap))
+      #
+      # Default: true
+      separate_lists: false
+
+      # Space surround option affects formatting of import lists on a single
+      # line. The only difference is single space after the initial
+      # parenthesis and a single space before the terminal parenthesis.
+      #
+      # - true: There is single space associated with the enclosing
+      #   parenthesis.
+      #
+      #   > import Data.Foo ( foo )
+      #
+      # - false: There is no space associated with the enclosing parenthesis
+      #
+      #   > import Data.Foo (foo)
+      #
+      # Default: false
+      space_surround: false
+
+  # Language pragmas
+  - language_pragmas:
+      # We can generate different styles of language pragma lists.
+      #
+      # - vertical: Vertical-spaced language pragmas, one per line.
+      #
+      # - compact: A more compact style.
+      #
+      # - compact_line: Similar to compact, but wrap each line with
+      #   `{-#LANGUAGE #-}'.
+      #
+      # Default: vertical.
+      style: vertical
+
+      # Align affects alignment of closing pragma brackets.
+      #
+      # - true: Brackets are aligned in same column.
+      #
+      # - false: Brackets are not aligned together. There is only one space
+      #   between actual import and closing bracket.
+      #
+      # Default: true
+      align: false
+
+      # stylish-haskell can detect redundancy of some language pragmas. If this
+      # is set to true, it will remove those redundant pragmas. Default: true.
+      remove_redundant: true
+
+  # Replace tabs by spaces. This is disabled by default.
+  # - tabs:
+  #     # Number of spaces to use for each tab. Default: 8, as specified by the
+  #     # Haskell report.
+  #     spaces: 8
+
+  # Remove trailing whitespace
+  - trailing_whitespace: {}
+
+  # Squash multiple spaces between the left and right hand sides of some
+  # elements into single spaces. Basically, this undoes the effect of
+  # simple_align but is a bit less conservative.
+  # - squash: {}
+
+# A common setting is the number of columns (parts of) code will be wrapped
+# to. Different steps take this into account. Default: 80.
+columns: 120
+
+# By default, line endings are converted according to the OS. You can override
+# preferred format here.
+#
+# - native: Native newline format. CRLF on Windows, LF on other OSes.
+#
+# - lf: Convert to LF ("\n").
+#
+# - crlf: Convert to CRLF ("\r\n").
+#
+# Default: native.
+newline: native
+
+# Sometimes, language extensions are specified in a cabal file or from the
+# command line instead of using language pragmas in the file. stylish-haskell
+# needs to be aware of these, so it can parse the file correctly.
+#
+# No language extensions are enabled by default.
+language_extensions:
+  - FlexibleContexts
+  - OverloadedStrings
+  - LambdaCase
+  - DeriveGeneric
+  - DerivingStrategies
+  - GeneralizedNewtypeDeriving
+  - PatternSynonyms
+  - RecordWildCards
+  - TypeApplications
+  - ViewPatterns
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -0,0 +1,5 @@
+# Revision history for slacker
+
+## 0.1.0.0 -- YYYY-mm-dd
+
+* First version. Released on an unsuspecting world.
diff --git a/LICENSE b/LICENSE
@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright © 2022 Josh Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
@@ -0,0 +1,49 @@
+<h1 align="left">
+<img src="./logo.png" height=25 width=35 />
+slacker
+</h1>
+
+A Haskell library for working with the Slack API, particularly in [Socket Mode](https://api.slack.com/apis/connections/socket). It takes a little inspiration from Slack's own Bolt SDK family.
+
+This is a work-in-progress, notably it's missing comprehensive types for the large amount of objects from the Slack Events API, Web API, and Block Kit. The base framework for working with socket mode is available, but users currently have to deal with `Data.Aeson.Value` event payloads until more types with `Data.Aeson.FromJSON` instances are available. The roadmap should give some idea of what the finished state could look like.
+
+## Features
+
+* Supports concurrent socket connections
+* Handles Slack connection refreshes automatically
+* Structured logging
+* Graceful shutdown of socket mode
+* Format content using Block Kit
+* Basic support for Web API calls
+* Follows the latest Slack API conventions and avoids deprecated objects
+
+## Usage
+
+```haskell
+module Main where
+import Slacker
+
+main :: IO ()
+main = do
+  let cfg = defaultSlackConfig
+          & setApiToken "YOUR_API_TOKEN"
+          & setAppToken "YOUR_APP_TOKEN"
+  runSocketMode cfg handler
+
+handler :: SlackConfig -> SocketModeEvent -> IO ()
+handler cfg = \case
+  Event "app_mention" evt -> print evt
+  _ -> pure ()
+```
+
+See the example app for more.
+
+## Roadmap
+
+- [x] Socket Mode Daemon
+- [x] Post Messages via Web API
+- [ ] Interactive events in socket mode
+- [ ] Slash commands in socket mode
+- [ ] Implement More Event Types
+- [ ] Implement More Block Types
+- [ ] Hackage release
diff --git a/cabal.project b/cabal.project
@@ -0,0 +1,2 @@
+packages:
+  ./slacker.cabal