module                                           (1)
  = declaration:moduledeclaration EOS
    LAYOUT
    imports:imports?
    LAYOUT
    toplevel:topLevelDeclarations?
    LAYOUT
    {
      return {
      	moduledeclaration: declaration,
        imports: imports,
        declarations: toplevel
      }
    }

moduledeclaration                               (2)
  = type:(type:("effect" / "port") __ { return type; })? "module" __ name:upperIds __ exposing:exposing
    {
      return {
        type: (type||"" + " module").trim(),
        name: name,
        exposing: exposing
      };
    }

// .. etc

  var watcher = chokidar.watch(['elm-package.json',                    (1)
                                'elm-stuff/exact-dependencies.json',
                                '**/*.elm'], {
    cwd: process.cwd(),
    persistent: true,
    ignoreInitial: false,
    followSymlinks: false,
    atomic: false
  });

  watcher.on("raw", function(event, file, details) {                   (2)
    var relFile = path.relative(process.cwd(), file);
    var sourceDirs = getSourceDirs(process.cwd());


    if(relFile === "elm-stuff/exact-dependencies.json") {
      if ( event === "modified") {
        parseAllPackageSources();                                      (3)
      }
      if (event === "deleted") {
        sendAstMsg({
          type: "packagesDeleted"
        });
      }
    }


    if (isSourceFile(sourceDirs, file) && event === "modified") {
      parseAndSend(file);                                              (4)
    }

    if (isSourceFile(sourceDirs, file) && event === "deleted") {
      sendAstMsg({
        file: file,
        type: "deleted"
      });
    }

    if (isSourceFile(sourceDirs, file) && event === "moved") {
      if (fileExists(file)) {
        parseAndSend(file);
      } else {
        sendAstMsg({
          file: file,
          type: "deleted"
        });
      }
    }
  });


  elmGlobals.watcher = watcher;
}

(behavior ::elm-parse-editor-on-change                               (1)
          :desc "Parse a connected elm editor on content change"
          :triggers #{:change}
          :debounce 200                                              (2)
          :reaction (fn [ed]
                      (object/raise ed :elm.parse.editor)))          (3)


(behavior ::elm-parse-editor                                         (4)
          :desc "Initiate parsing of the content/elm code of the given editor"
          :triggers #{:elm.parse.editor :focus :project-connected }
          :reaction (fn [ed]
                      (when (not (str-contains (-> @ed :info :path) "elm-stuff"))
                        (let [client (get-eval-client-if-connected ed :editor.elm.ast.parsetext)
                             path (-> @ed :info :path)]

                         (when (and client
                                  (= (pool/last-active) ed))

                           (clients/send client                     (5)
                                         :editor.elm.ast.parsetext
                                         {:code (editor/->val ed)}
                                         :only ed))))))

(behavior ::elm-parse-editor-result                                 (6)
          :desc "Handle parse results for a parsed editors content"
          :triggers #{:editor.elm.ast.parsetext.result}
          :reaction (fn [ed res]
                      (if-let [error (:error res)]
                        (do
                          (object/update! ed [:ast-status] assoc :status :error :error error)
                          (object/raise ed :elm.gutter.refresh))
                        (let [path (-> @ed :info :path)]
                          (object/update! ed [:ast-status] assoc :status :ok :error nil)

                          (elm-ast/upsert-ast! (-> (get-editor-client ed) deref :dir)  (7)
                                               {:file path
                                                :ast (:ast res)})
                          (object/raise ed :elm.gutter.exposeds.mark)))


                      (elm-ast/update-status-for-editor ed)))

encode : Route -> String
encode route =
    case route of
        Home ->
            "/"

        ArtistListingPage ->
            "/artists"

        NewArtistPage ->
            "/artists/new"

        ArtistDetailPage i ->
            "/artists/" ++ toString i

        AlbumDetailPage i ->
            "/albums/" ++ toString i

        NewArtistAlbumPage i ->
            "/artists/" ++ (toString i) ++ "/albums/new"

public int increment(int value) {
  return value++;
}

public int add (int x, int y) {
  return x + y;
}

increment : Int -> Int         (1)
increment value =
  value + 1


add : Int -> Int -> Int        (2)
add x y =
  x + y

myList : List String                      (1)
myList = ["First", "Second"]              (2)


-- List.head : List a -> Maybe.Maybe a    (3)


case List.head myList of                  (4)
  Nothing ->                              (5)
    "So you gave me an empty list!"

  Just val ->                             (6)
    val

-- returns "First"

myList = ["First", "Second", "Third"]

first = List.head myList
second = List.head (List.drop 1 myList)
tail = List.tail myList -- Just ["Second","Third"] : Maybe (List String)

-- Maybe.withDefault : a -> Maybe a -> a                                         (1)
Maybe.withDefault "No val" first -- -> "First"                                   (2)
Maybe.withDefault "No val" (List.head []) -- -> "No val"

-- Maybe.map : (a -> b) -> Maybe a -> Maybe b                                    (1)
Maybe.map String.toUpper first -- -> Just "FIRST"                                (2)
Maybe.map String.toUpper Nothing -- -> Nothing


-- Maybe.map2 (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c                     (3)
Maybe.map2 (\a b -> a ++ ", " b) first second -- -> Just "First, Second"         (4)
Maybe.map2 (\a b -> a ++ ", " b) first Nothing -- -> Nothing
Maybe.map2 (++) first second -- -> Just "First, Second"                          (5)

-- Maybe.andThen Maybe.Maybe a -> (a -> Maybe b) -> Maybe b                      (1)
Maybe.andThen tail List.head  -- -> Just "Second"                                (2)
tail `Maybe.andThen` List.head -- -> Just "Second"                               (3)

tail
  `Maybe.andThen` List.head
  `Maybe.andThen` (\s -> Just (String.toUpper s))   -- -> Just "SECOND"          (4)


Just []
  `Maybe.andThen` List.head
  `Maybe.andThen` (\s -> Just (String.toUpper s))   -- -> Nothing                (5)

type Perhaps a = Absolutely a | NotSoMuch

type alias Model =                     (1)
  { allModules : List Modul
  , filteredModules : List Modul
  , searchStr : String
  , selected : Maybe Modul
  }


type alias Modul =                     (2)
  { name : String
  , file : String
  , packageName : String
  , version : String
  }

type Action                                             (1)
  = NoOp
  | Filter String
  | Prev
  | Next
  | Select
  | ClickSelect String
  | Close
  | Refresh (List Modul)


update : Action -> Model -> ( Model, Effects Action )  (2)
update action model =
  case action of
    NoOp ->                                            (3)
      ( model, Effects.none )

    Filter str ->                                      (4)
      let
        filtered =
          filterModules str model.allModules

        sel =
          List.head filtered
      in
        ( { model
            | searchStr = str
            , filteredModules = filtered
            , selected = sel
          }
        , Effects.none
        )

    Prev ->                                           (5)
      ( { model | selected = prevModule model }
      , notifyChangeSelection
      )

    Next ->
      ( { model | selected = nextModule model }
      , notifyChangeSelection
      )

    Select ->                                         (6)
      case model.selected of
        Nothing ->
          ( model, Effects.none )

        Just x ->
          ( model
          , notifySelect x.file
          )

    ClickSelect file ->                               (7)
      ( model
      , notifySelect file
      )

    Close ->                                          (8)
      ( model, notifyClose )

    Refresh modules ->                                (9)
      ( Model modules modules "" (List.head modules)
      , Effects.none
      )

view : Signal.Address Action -> Model -> Html                                     (1)
view address model =
  div
    [ class "filter-list" ]                                                       (2)
    [ searchInputView address model
    , ul
        []
        (List.map (\m -> itemView address m model) model.filteredModules)         (3)
    ]


searchInputView : Signal.Address Action -> Model -> Html                          (4)
searchInputView address model =
  let
    options =
      { preventDefault = True, stopPropagation = False }

    keyActions =
      Dict.fromList [ ( 38, Prev ), ( 40, Next ), ( 13, Select ), ( 27, Close ) ] (5)

    dec =
      (Json.customDecoder                                                         (6)
        keyCode
        (\k ->
          if Dict.member k keyActions then
            Ok k
          else
            Err "not handling that key"
        )
      )

    handleKeydown k =                                                             (7)
      Maybe.withDefault NoOp (Dict.get k keyActions) |> Signal.message address
  in
    input                                                                         (8)
      [ value model.searchStr
      , class "search"
      , type' "text"
      , placeholder "search"
      , on "input" targetValue (\str -> Signal.message address (Filter str))
      , onWithOptions "keydown" options dec handleKeydown
      ]
      []


itemView : Signal.Address Action -> Modul -> Model -> Html
itemView address mod model =                                                     (9)
  let
    pipeM =                                                                      (10)
      flip Maybe.andThen

    itemClass =                                                                  (11)
      model.selected
        |> pipeM
            (\sel ->
              if (sel == mod) then
                Just "selected"
              else
                Nothing
            )
        |> Maybe.withDefault ""
  in
    li
      [ class itemClass
      , onClick address (ClickSelect mod.file)
      ]
      [ p [] [ text mod.name ]
      , p [ class "binding" ] [ text (mod.packageName ++ " - " ++ mod.version) ]
      ]

-- Inbound

modzSignal : Signal Action                     (1)
modzSignal =
  Signal.map Refresh modzPort


port modzPort : Signal (List Modul)            (2)



-- Outbound

selectMailbox : Signal.Mailbox String          (3)
selectMailbox =
  Signal.mailbox ""


port select : Signal String                    (4)
port select =
  selectMailbox.signal


changeSelectionMailbox : Signal.Mailbox ()     (5)
changeSelectionMailbox =
  Signal.mailbox ()


port changeSelection : Signal ()               (6)
port changeSelection =
  changeSelectionMailbox.signal


closeMailbox : Signal.Mailbox ()
closeMailbox =
  Signal.mailbox ()


port close : Signal ()
port close =
  closeMailbox.signal

app : StartApp.App Model                       (1)
app =
  StartApp.start
    { init = init
    , update = update
    , view = view
    , inputs = [ modzSignal ]                  (2)
    }


main : Signal Html                             (3)
main =
  app.html


port tasks : Signal (Task.Task Never ())       (4)
port tasks =
  app.tasks

(defn- resolve-module-file [project-path pck-json package module version]                   (1)
  (->> pck-json
       :source-directories
       (map #(files/join project-path
                         "elm-stuff/packages"
                         package
                         version
                         %
                         (str (s/replace module "." files/separator) ".elm")))
       (some #(if (files/exists? %) % nil))))


(defn- get-exposed-modules [project-path {:keys [package exact]}]                          (2)
  (let [pck-json (u/parse-json-file (files/join project-path
                                                "elm-stuff/packages"
                                                package exact
                                                "elm-package.json"))]
    (->> pck-json
         :exposed-modules
         (map (fn [x]
                {:name x
                 :packageName package
                 :version exact
                 :file (resolve-module-file project-path pck-json package x exact)})))))


(defn- get-package-modules [project-path]                                                 (3)
  (->> (u/get-project-deps project-path)
       (filter :exact)
       (mapcat (partial get-exposed-modules project-path))
       (sort-by :name)))


(defn- deduce-module-name [root-path elm-file-path]                                       (4)
  (-> elm-file-path
      (s/replace root-path "")
      (s/replace ".elm" "")
      (s/replace #"^/" "")
      (s/replace files/separator ".")))


(defn- get-project-modules [project-path]                                                 (5)
  (let [pck-json (u/parse-json-file (files/join project-path "elm-package.json"))]
    (->> (:source-directories pck-json)
         (mapcat (fn [dir]
                   (if (= dir ".")
                     (->> (files/ls project-path) ;; fixme: no nesting allowed to avoid elm-stuff etc
                          (filter #(= (files/ext %) "elm"))
                          (map (fn [x]
                                 {:name (deduce-module-name "" x)
                                  :file (files/join project-path x)})))
                     (->> (files/filter-walk #(= (files/ext %) "elm") (files/join project-path dir))
                          (map (fn [x]
                                 {:name (deduce-module-name (files/join project-path dir) x)
                                  :file x}))))))
         (map (fn [m]
                (assoc m :packageName (files/basename project-path) :version (:version pck-json))))
         (sort-by :name))))



(defn get-all-modules [project-path]                                                      (6)
  (concat
    (get-project-modules project-path)
    (get-package-modules project-path)))

(defui wrapper [this]                                             (1)
   [:div {:id "elm-module-browser"} "Retrieving modules..."])


(object/object* ::modulebrowser                                   (2)
                :tags #{:elm.modulebrowser}
                :label "Elm module browser"
                :order 2
                :init (fn [this]
                        (wrapper this)))

(def module-bar (object/create ::modulebrowser))                  (3)

(sidebar/add-item sidebar/rightbar module-bar)                    (4)

(behavior ::clear!                                              (1)
          :triggers #{:clear!}
          :reaction (fn [this]
                      (cmd/exec! :close-sidebar)))

(behavior ::focus!                                              (2)
          :triggers #{:focus!}
          :reaction (fn [this]
                      (let [input (dom/$ "#elm-module-browser input")]
                        (.focus input))))

(behavior ::ensure-visible                                      (3)
          :triggers #{:ensure-visible}
          :reaction (fn [this]
                      (sidebar-cmd/ensure-visible this)))

(behavior ::show-project-modules                                (4)
          :triggers #{:show-project-modules}
          :reaction (fn [this prj-path]
                      (let [modules (get-all-modules prj-path)
                            el (dom/$ "#elm-module-browser")
                            mod-browser (.embed js/Elm js/Elm.ModuleBrowser el (clj->js {:modzPort []}))] (5)

                        (.send (.-modzPort (.-ports mod-browser)) (clj->js modules))   (6)

                        ;; set up port subscriptions

                        (.subscribe (.-changeSelection (.-ports mod-browser))          (7)
                                    (fn []
                                      (object/raise this :ensure-visible)))

                        (.subscribe (.-select (.-ports mod-browser))
                                    (fn [file]
                                      (cmd/exec! :open-path file)
                                      (object/raise this :clear!)))

                        (.subscribe (.-close (.-ports mod-browser))
                                    (fn []
                                      (object/raise this :clear!)))


                        (object/raise this :focus!))))



(behavior ::list-modules                                     (8)
          :triggers #{:editor.elm.list-modules}
          :reaction (fn [ed]
                      (when-let [prj-path (u/project-path (-> @ed :info :path))]
                        (do
                          (object/raise sidebar/rightbar :toggle module-bar)
                          (object/raise module-bar :show-project-modules prj-path)))))


(cmd/command {:command :show-modulebrowser                  (9)
              :desc "Elm: Show module-browser"
              :exec (fn []
                      (when-let [ed (pool/last-active)]
                        (object/raise ed :editor.elm.list-modules)))})

bootstrapDB :: Sql.Connection -> IO ()
bootstrapDB conn = do
  createSchema conn
  populateSampleData conn


createSchema :: Sql.Connection -> IO ()
createSchema conn = do
  executeDB "PRAGMA foreign_keys = ON"
  executeDB "create table artist (id integer primary key asc, name varchar2(255))"
  executeDB "create table track (id integer primary key asc, name varchar2(255), duration integer)"
  executeDB "create table album (id integer primary key asc, artist_id integer, name varchar2(255), FOREIGN KEY(artist_id) references artist(id))"
  executeDB "create table album_track (track_no integer, album_id, track_id, primary key(track_no, album_id, track_id), foreign key(album_id) references album(id), foreign key(track_id) references track(id))"

  where
    executeDB = Sql.execute_ conn


-- definition of sample data omitted for brevity

populateSampleData :: Sql.Connection -> IO ()
populateSampleData conn = do
  mapM_ insertArtist artists
  mapM_ insertTrack tracks
  mapM_ insertAlbum albums
  mapM_ insertAlbumTrack albumTracks

  where
    insertArtist a = Sql.execute conn "insert into artist (id, name) values (?, ?)" a
    insertTrack t = Sql.execute conn "insert into track (id, name, duration) values (?, ?, ?)" t
    insertAlbum a = Sql.execute conn "insert into album (id, artist_id, name) values (?, ?, ?)" a
    insertAlbumTrack at = Sql.execute conn "insert into album_track (track_no, album_id, track_id) values (?, ?, ?)" at

type Route                      (1)
  = Home
  -- ...
  | AlbumDetailPage Int
  | NewArtistAlbumPage Int
  | EmptyRoute


routeParsers =                 (2)
  [ static Home "/"
  -- ...
  , dyn1 AlbumDetailPage "/albums/" int ""
  , dyn1 NewArtistAlbumPage "/artists/" int "/albums/new"
  ]

encode route =                 (3)
  case route of
    Home -> "/"
    -- ...
    AlbumDetailPage   i   -> "/albums/" ++ toString i
    NewArtistAlbumPage i  -> "/artists/" ++ (toString i) ++ "/albums/new"
    EmptyRoute -> ""

type alias AlbumRequest a =    (1)
  { a | name : String
      , artistId : Int
      , tracks : List Track
  }

type alias Album =             (2)
  { id : Int
  , name : String
  , artistId : Int
  , tracks : List Track
  }

type alias Track =             (3)
  { name : String
  , duration : Int
  }


getAlbumsByArtist : Int -> (Maybe (List Album) -> a) -> Effects a               (4)
getAlbumsByArtist artistId action =
  Http.get albumsDecoder (baseUrl ++ "/albums?artistId=" ++ toString artistId)
    |> Task.toMaybe
    |> Task.map action
    |> Effects.task

createAlbum : AlbumRequest a -> (Maybe Album -> b) -> Effects.Effects b         (5)
createAlbum album action =
  Http.send Http.defaultSettings
        { verb = "POST"
        , url = baseUrl ++ "/albums"
        , body = Http.string (encodeAlbum album)
        , headers = [("Content-Type", "application/json")]
        }
    |> Http.fromJson albumDecoder
    |> Task.toMaybe
    |> Task.map action
    |> Effects.task

-- other functions left out for brevity. Check out the sample code or have a look at episode 2 for inspiration



-- Decoders/encoders for albums/tracks                                         (6)

albumsDecoder : JsonD.Decoder (List Album)
albumsDecoder =
  JsonD.list albumDecoder


albumDecoder : JsonD.Decoder Album
albumDecoder =
  JsonD.object4 Album
    ("albumId" := JsonD.int)
    ("albumName" := JsonD.string)
    ("albumArtistId" := JsonD.int)
    ("albumTracks" := JsonD.list trackDecoder)


trackDecoder : JsonD.Decoder Track
trackDecoder =
  JsonD.object2 Track
    ("trackName" := JsonD.string)
    ("trackDuration" := JsonD.int)


encodeAlbum : AlbumRequest a -> String
encodeAlbum album =
  JsonE.encode 0 <|
    JsonE.object
      [ ("albumName", JsonE.string album.name)
      , ("albumArtistId", JsonE.int album.artistId)
      , ("albumTracks", JsonE.list <| List.map encodeTrack album.tracks)
      ]


encodeTrack : Track -> JsonE.Value
encodeTrack track =
    JsonE.object
      [ ("trackName", JsonE.string track.name)
      , ("trackDuration", JsonE.int track.duration)
      ]

type alias Model =
  WithRoute
    Routes.Route
    { --....
    , albumDetailModel : AlbumDetail.Model
    }


type Action
  = NoOp
  -- ...
  | AlbumDetailAction AlbumDetail.Action
  | RouterAction (TransitRouter.Action Routes.Route)


initialModel =
  { transitRouter = TransitRouter.empty Routes.EmptyRoute
  -- ...
  , albumDetailModel = AlbumDetail.init
  }


mountRoute prevRoute route model =
  case route of
    -- ...

    AlbumDetailPage albumId ->         (1)
      let
        (model', effects) =
          AlbumDetail.update (AlbumDetail.GetAlbum albumId) AlbumDetail.init
      in
        ( { model | albumDetailModel = model' }
        , Effects.map AlbumDetailAction effects)


    NewArtistAlbumPage artistId ->     (2)
      let
        (model', effects) =
          AlbumDetail.update (AlbumDetail.ShowAlbum Nothing) (AlbumDetail.initForArtist artistId)
      in
        ( { model | albumDetailModel = model' }
        , Effects.map AlbumDetailAction effects)

    -- ...


update action model =
  case action of
    -- ..

    AlbumDetailAction act ->           (3)
      let
        ( model', effects ) =
          AlbumDetail.update act model.albumDetailModel
      in
        ( { model | albumDetailModel = model' }
        , Effects.map AlbumDetailAction effects
        )

    -- ..

type alias Model = WithRoute Routes.Route                                (1)
  { homeModel : Home.Model
  , artistListingModel : ArtistListing.Model
  , artistDetailModel : ArtistDetail.Model
  }


type Action =
    NoOp
  | HomeAction Home.Action
  | ArtistListingAction ArtistListing.Action
  | ArtistDetailAction ArtistDetail.Action
  | RouterAction (TransitRouter.Action Routes.Route)                    (2)


initialModel : Model
initialModel =
  { transitRouter = TransitRouter.empty Routes.EmptyRoute               (3)
  , homeModel = Home.init
  , artistListingModel = ArtistListing.init
  , artistDetailModel = ArtistDetail.init
  }


actions : Signal Action
actions =
  Signal.map RouterAction TransitRouter.actions                         (4)


mountRoute : Route -> Route -> Model -> (Model, Effects Action)
mountRoute prevRoute route model =                                      (5)
  case route of

    Home ->
      (model, Effects.none)

    ArtistListingPage ->                                                (6)
      (model, Effects.map ArtistListingAction (ServerApi.getArtists ArtistListing.HandleArtistsRetrieved))

    ArtistDetailPage artistId ->
      (model, Effects.map ArtistDetailAction (ServerApi.getArtist artistId ArtistDetail.ShowArtist))

    NewArtistPage ->
      ({ model | artistDetailModel = ArtistDetail.init } , Effects.none)

    EmptyRoute ->
      (model, Effects.none)


routerConfig : TransitRouter.Config Routes.Route Action Model
routerConfig =                                                          (7)
  { mountRoute = mountRoute
  , getDurations = \_ _ _ -> (50, 200)
  , actionWrapper = RouterAction
  , routeDecoder = Routes.decode
  }


init : String -> (Model, Effects Action)
init path =                                                             (8)
  TransitRouter.init routerConfig path initialModel

update : Action -> Model -> (Model, Effects Action)
update action model =
  case action of

    NoOp ->
      (model, Effects.none)

    HomeAction homeAction ->
      let (model', effects) = Home.update homeAction model.homeModel
      in ( { model | homeModel = model' }
         , Effects.map HomeAction effects )

    ArtistListingAction act ->                                                       (1)
      let (model', effects) = ArtistListing.update act model.artistListingModel
      in ( { model | artistListingModel = model' }
         , Effects.map ArtistListingAction effects )

    ArtistDetailAction act ->                                                        (2)
      let (model', effects) = ArtistDetail.update act model.artistDetailModel
      in ( { model | artistDetailModel = model' }
         , Effects.map ArtistDetailAction effects )

    RouterAction routeAction ->                                                      (3)
      TransitRouter.update routerConfig routeAction model

menu : Signal.Address Action -> Model -> Html
menu address model =                                                       (1)
  header [class "navbar navbar-default"] [
    div [class "container"] [
        div [class "navbar-header"] [
          div [ class "navbar-brand" ] [
            a (linkAttrs Home) [ text "Albums galore" ]
          ]
        ]
      , ul [class "nav navbar-nav"] [
          li [] [a (linkAttrs ArtistListingPage) [ text "Artists" ]]       (2)
      ]
    ]
  ]



contentView : Signal.Address Action -> Model -> Html
contentView address model =                                                (3)
  case (TransitRouter.getRoute model) of
    Home ->
      Home.view (Signal.forwardTo address HomeAction) model.homeModel

    ArtistListingPage ->                                                   (4)
      ArtistListing.view (Signal.forwardTo address ArtistListingAction) model.artistListingModel

    ArtistDetailPage i ->
      ArtistDetail.view (Signal.forwardTo address ArtistDetailAction) model.artistDetailModel

    NewArtistPage  ->
      ArtistDetail.view (Signal.forwardTo address ArtistDetailAction) model.artistDetailModel

    EmptyRoute ->
      text "Empty WHAT ?"


view : Signal.Address Action -> Model -> Html
view address model =
  div [class "container-fluid"] [
      menu address model
    , div [ class "content"
          , style (TransitStyle.fadeSlideLeft 100 (getTransition model))]  (5)
          [contentView address model]
  ]

artistRow : Signal.Address Action -> Artist -> Html
artistRow address artist =
  tr [] [
     td [] [text artist.name]
    ,td [] [button [ Routes.clickAttr <| Routes.ArtistDetailPage artist.id ] [text "Edit"]]  (1)
    ,td [] [button [ onClick address (DeleteArtist (.id artist))] [ text "Delete!" ]]
  ]


view : Signal.Address Action -> Model -> Html
view address model =
  div [] [
      h1 [] [text "Artists" ]
    , button [
            class "pull-right btn btn-default"
          , Routes.clickAttr Routes.NewArtistPage                                            (2)
        ]
        [text "New Artist"]
    , table [class "table table-striped"] [
          thead [] [
            tr [] [
               th [] [text "Name"]
              ,th [] []
              ,th [] []
          ]
        ]
        , tbody [] (List.map (artistRow address) model.artists)
    ]
  ]

  -- ... inside update function

  HandleSaved maybeArtist ->
      case maybeArtist of
        Just artist ->
          ({ model | id = Just artist.id
                   , name = artist.name }
            , Effects.map (\_ -> NoOp) (Routes.redirect Routes.ArtistListingPage)   (1)
          )

        Nothing ->
          Debug.crash "Save failed... we're not handling it..."

app : StartApp.App Model
app =
  StartApp.start
    { init = init initialPath                  (1)
    , update = update
    , view = view
    , inputs = [actions]                       (2)
    }


main : Signal Html
main =
  app.html


port tasks : Signal (Task.Task Never ())
port tasks =
  app.tasks


port initialPath : String                      (3)

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Albums</title>
    <link rel="stylesheet" href="assets/css/bootstrap.min.css">
  </head>
  <body>
    <script type="text/javascript" src="main.js"></script>                 (1)
    <script type="text/javascript" src="/_reactor/debug.js"></script>      (2)

    <script type="text/javascript">
      var main = Elm.fullscreen(Elm.Main, {initialPath: "/"});             (3)
    </script>

  </body>
</html>

  build-depends:
    -- ...
    ,  wai-cors
    -- ...

;....

import Network.Wai.Middleware.Cors

;....

albumCors :: Middleware
albumCors = cors $ const (Just albumResourcePolicy)                             (1)


albumResourcePolicy :: CorsResourcePolicy                                       (2)
albumResourcePolicy =
    CorsResourcePolicy
        { corsOrigins = Nothing -- gives you /*
        , corsMethods = ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTION"]
        , corsRequestHeaders = simpleHeaders -- adds "Content-Type" to defaults
        , corsExposedHeaders = Nothing
        , corsMaxAge = Nothing
        , corsVaryOrigin = False
        , corsRequireOrigin = False
        , corsIgnoreFailures = False
        }


main :: IO ()
main = do
  run 8081 $ albumCors $ app                                                    (3)

  build-depends:
    -- ...
    , sqlite-simple
    -- ...

{-# LANGUAGE OverloadedStrings #-}
module Main where


import qualified Storage as S                              (1)
import qualified Api as A                                  (2)
import Network.Wai
import Network.Wai.Handler.Warp
import Servant
import Network.Wai.Middleware.Cors
import Control.Exception (bracket)
import Database.SQLite.Simple as Sql


app :: Sql.Connection -> Application
app conn = serve A.api (A.artistsServer conn)              (3)


testConnect :: IO Sql.Connection
testConnect = Sql.open ":memory:"                          (4)


withTestConnection :: (Sql.Connection -> IO a) -> IO a
withTestConnection cb =                                    (5)
  withConn $ \conn -> cb conn
  where
    withConn = bracket testConnect Sql.close               (6)

{-
  ...
  cors stuff omitted, already covered
-}


main :: IO ()
main = do
  withTestConnection $ \conn ->  do
    S.bootstrapDB conn                                     (7)
    run 8081 $ albumCors $ app conn                        (8)

{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE DataKinds     #-}

module Api where

import qualified Model as M                           (1)
import qualified Storage as S
import Data.Aeson
import Control.Monad.IO.Class     (MonadIO, liftIO)
import Control.Monad.Trans.Either
import Servant
import Database.SQLite.Simple as Sql


instance ToJSON M.Artist
instance FromJSON M.Artist


type ArtistAPI =                                       (2)
       Get '[JSON] [M.Artist]
  :<|> ReqBody '[JSON] M.Artist :> Post '[JSON] M.Artist
  :<|> Capture "artistId" Int :> Get '[JSON] M.Artist
  :<|> Capture "artistId" Int :> ReqBody '[JSON] M.Artist :> Put '[JSON] M.Artist
  :<|> Capture "artistId" Int :> Delete '[] ()

-- '

artistsServer :: Sql.Connection -> Server ArtistAPI    (3)
artistsServer conn =
  getArtists :<|> postArtist :<|> getArtist :<|>  updateArtist :<|> deleteArtist

  where
    getArtists                   = liftIO $ S.findArtists conn     (4)
    getArtist artistId           = liftIOMaybeToEither err404 $ S.artistById conn artistId
    postArtist artist            = liftIO $ S.newArtist conn artist
    updateArtist artistId artist = liftIO $ S.updateArtist conn artist artistId
    deleteArtist artistId        = liftIO $ S.deleteArtist conn artistId


liftIOMaybeToEither ::  (MonadIO m) => a -> IO (Maybe b) -> EitherT a m b
liftIOMaybeToEither err x = do                         (5)
    m <- liftIO x
    case m of
      Nothing -> left err
      Just x -> right x


type API = "artists" :> ArtistAPI


api :: Proxy API
api = Proxy

{-# LANGUAGE DeriveGeneric #-}

module Model where

import GHC.Generics

data Artist = Artist                (1)
  { artistId :: Maybe Int           (2)
  , artistName :: String            (3)
  } deriving (Eq, Show, Generic)

{-# LANGUAGE OverloadedStrings #-}
module Storage where


import qualified Model as M
import qualified Data.Text as Txt


import Database.SQLite.Simple as Sql
import Database.SQLite.Simple.Types as SqlTypes


instance Sql.FromRow M.Artist where                         (1)
  fromRow = M.Artist <$> Sql.field <*> Sql.field



artistById :: Sql.Connection -> Int -> IO (Maybe M.Artist)  (2)
artistById conn idParam =
  findById conn "artist" idParam :: IO (Maybe M.Artist)


findArtists :: Sql.Connection -> IO [M.Artist]
findArtists conn =
  Sql.query_ conn "select * from artist" :: IO [M.Artist]


newArtist :: Sql.Connection -> M.Artist -> IO M.Artist
newArtist conn artist = do
  Sql.execute conn "insert into artist (name) values (?) " (Sql.Only $ M.artistName artist)
  rawId <- lastInsertRowId conn
  let updArtist = artist { M.artistId = Just (fromIntegral rawId) }  (3)
  return updArtist


-- Really we should check whether the artist exists here
updateArtist :: Sql.Connection -> M.Artist -> Int -> IO M.Artist
updateArtist conn artist idParam = do
  Sql.executeNamed conn "update artist set name = :name where id = :id" params
  return artist { M.artistId = Just idParam }                        (4)
  where
    params = [":id" := (idParam :: Int), ":name" := ((M.artistName artist) :: String)]


deleteArtist :: Sql.Connection -> Int -> IO ()
deleteArtist conn idParam =
  Sql.execute conn "delete from artist where id = ?" (Sql.Only idParam)


findById :: (FromRow a) => Sql.Connection -> String -> Int -> IO (Maybe a)
findById conn table idParam = do
  rows <- Sql.queryNamed conn (createFindByIdQuery table) [":id" := (idParam :: Int)]
  let result = case (length rows) of
                  0 -> Nothing
                  _ -> Just $ head rows      (5)

  return result


createFindByIdQuery :: String -> SqlTypes.Query
createFindByIdQuery table =
  SqlTypes.Query $ Txt.pack $ "SELECT * from " ++ table ++ " where id = :id"   (6)

-- ... boostrap function left out, check the source repo for details

(defn parse-json-file [json-file]
  (when (files/exists? json-file)
    (-> (->> (files/open-sync json-file)
             :content
             (.parse js/JSON))
        (js->clj :keywordize-keys true))))


(defn remove-pkg [path pkg]
  (let [pkg-file (files/join path "elm-package.json")]
    (-> (u/parse-json-file pkg-file)
        (update-in [:dependencies] (fn [deps]
                                     (-> (into {}
                                               (map (fn [[k v]]
                                                      [(u/nskw->name k) v]) deps))
                                         (dissoc pkg))))
        u/pretty-json
        ((partial files/save pkg-file)))))

(def dagreD3 (js/require (files/join u/elm-plugin-dir "node_modules/dagre-d3")))
(def d3 (js/require (files/join u/elm-plugin-dir "node_modules/d3")))


defn create-graph [data]                                                         (1)
  (let [g (.setGraph (new dagreD3.graphlib.Graph)  #js {})]
    (doseq [x (:nodes data)]
      (.setNode g (dep-id x) (node-label x)))
    (doseq [x (:edges data)]
      (.setEdge g (:a x) (:b x) #js {:label (:label x)
                                     :style (when (:transitive x)
                                              "stroke-dasharray: 5, 5;")}))
    g))



(behavior ::on-render                                                           (2)
          :desc "Elm render dependencies"
          :triggers #{:elm.graph.render}
          :reaction (fn [this]
                      (let [svg (.select d3 "svg")
                            g (.select svg "g")
                            renderer (.render dagreD3)]
                        (renderer g (create-graph (:data @this)))
                        (init-zoom svg g)
                        (resize-graph this svg))))

name:                albums
version:             0.1.0.0
synopsis:            Albums rest backend
license:             MIT
license-file:        LICENSE
author:              rundis
maintainer:          mrundberget@hotmail.com
category:            Web
build-type:          Simple
cabal-version:       >=1.10

executable albums
  main-is:             Main.hs              (1)
  build-depends:
      base >= 4.7 && < 5
    , either
    , aeson >= 0.8                          (2)
    , servant                               (3)
    , servant-server
    , wai
    , warp
  hs-source-dirs:      src                  (4)
  default-language:    Haskell2010

data Artist = Artist
  { artistId :: Int
  , name :: String
  } deriving (Eq, Show, Generic)

instance ToJSON Artist                                       (1)

type ArtistAPI =                                             (2)
       Get '[JSON] [Artist]                                  (3)
  :<|> Capture "artistId" Int :> Get '[JSON] Artist          (4)


artistsServer :: Server ArtistAPI
artistsServer = getArtists :<|> artistOperations             (5)

  where getArtists :: EitherT ServantErr IO [Artist]
        getArtists = return artists                          (6)

        artistOperations artistId =
          viewArtist

          where viewArtist :: EitherT ServantErr IO Artist
                viewArtist = artistById artistId             (7)

artistById :: Int -> EitherT ServantErr IO Artist
artistById idParam =
  case a of
    Nothing -> left (err404 {errBody = "No artist with given id exists"})  (1)
    Just b -> return b                                                     (2)
  where
    a = find ((== idParam) . artistId) artists                             (3)

type API = "artists" :> ArtistAPI    (1)


api :: Proxy API
api = Proxy                          (2)


app :: Application
app = serve api artistsServer        (3)


main :: IO ()
main = run 8081 app                  (4)

{
    "version": "1.0.0",
    "summary": "The frontend for the Albums CRUD sample app",
    "repository": "https://github.com/rundis/albums.git",
    "license": "MIT",
    "source-directories": [
        "."                                                      (1)
    ],
    "exposed-modules": [],
    "dependencies": {                                            (2)
        "elm-lang/core": "3.0.0 <= v < 4.0.0",
        "evancz/elm-effects": "2.0.1 <= v < 3.0.0",
        "evancz/elm-html": "4.0.2 <= v < 5.0.0",
        "evancz/elm-http": "3.0.0 <= v < 4.0.0",
        "evancz/start-app": "2.0.2 <= v < 3.0.0"
    },
    "elm-version": "0.16.0 <= v < 0.17.0"
}

type alias Artist =                                     (1)
  { id : Int
  , name : String
  }

type alias Model =                                      (2)
  { artists : List Artist}


type Action = ArtistRetrieved (Maybe (List Artist))     (3)

init : (Model, Effects Action)
init =                                                  (1)
  ( Model []
    , getArtists
  )


update : Action -> Model -> (Model, Effects Action)
update action model =                                  (2)
  case action of
    ArtistRetrieved xs ->
      ( {model | artists = (Maybe.withDefault [] xs) }
      , Effects.none
      )


getArtists : Effects.Effects Action
getArtists =                                           (3)
  Http.get artists "http://localhost:8081/artists"
    |> Task.toMaybe
    |> Task.map ArtistRetrieved
    |> Effects.task


artist : Json.Decoder Artist
artist =                                               (4)
  Json.object2 Artist
    ("artistId" := Json.int)
    ("name" := Json.string)


artists : Json.Decoder (List Artist)
artists =                                              (5)
  Json.list artist

artistRow : Artist -> Html
artistRow artist =                                     (1)
  tr [] [
     td [] [text (toString artist.id)]
    ,td [] [text artist.name]
  ]

view : Signal.Address Action -> Model -> Html
view address model =                                  (2)
  div [class "container-fluid"] [
        h1 [] [text "Artists" ]
      , table [class "table table-striped"] [
          thead [] [
            tr [] [
               th [] [text "Id"]
              ,th [] [text "Name"]
          ]
        ]
      , tbody [] (List.map artistRow model.artists)
    ]
  ]

app : StartApp.App Model
app =                                          (1)
  StartApp.start
    { init = init
    , update = update
    , view = view
    , inputs = []
    }



main : Signal Html
main =                                         (2)
  app.html



port tasks : Signal (Task.Task Never ())
port tasks =                                   (3)
  app.tasks

type alias Tile               (1)
  { id: Int
  , threatCount: Maybe Int    (2)
  , isRevealed: Bool
  , isMine: Bool}

type GameStatus = IN_PROGRESS | SAFE | DEAD

type alias Game =             (3)
  { status: GameStatus        (4)
  , rows: Int
  , cols: Int
  , tiles: List Tile}

export function createUI(channel) {                                            (1)
  const Tile = createComponent((tile) => {                                     (2)
    if (tile.get('isRevealed')) {
      return div({className: 'tile' + (tile.get('isMine') ? ' mine' : '')},
                 tile.get('threatCount') > 0 ? tile.get('threatCount') : '');
    }
    return div({
      className: 'tile',
      onClick: function () {
        channel.emit('reveal', tile.get('id'));                                (3)
      }
    }, div({className: 'lid'}, ''));
  });

  const Row = createComponent((tiles) => {
    return div({className: 'row'}, tiles.map(Tile).toJS());
  });

  const Board = createComponent((game) => {
    return div({
      className: 'board'
    }, partition(game.get('cols'), game.get('tiles')).map(Row).toJS());
  });

  const UndoButton = createComponent(() => {                                  (4)
    return button({
      onClick: channel.emit.bind(channel, 'undo')
    }, 'Undo');
  });

  const Game = createComponent((game) => {
    return div({}, [Board(game), UndoButton()]);
  });

  return (data, container) => {                                               (5)
    render(Game(data), container);
  };
}

threatCount : Maybe Int -> List Html
threatCount count =
  case count of
    Nothing -> []
    Just t  -> [text (if t > 0 then toString t else "")]


tileView : Signal.Address Action -> Game.Tile -> Html                               (1)
tileView address tile =
  if tile.isRevealed then
    div [class ("tile" ++ (if tile.isMine then " mine" else ""))]
        <| threatCount tile.threatCount

  else
    div [class "tile", onClick address (RevealTile tile.id)]                        (2)
        [div [class "lid"] []]                                                      (3)


rowView : Signal.Address Action -> List Game.Tile -> Html
rowView address tiles =
  div [class "row"] (List.map (tileView address) tiles)


statusView: Game -> Html
statusView game =
  let
    (status, c) = case game.status of
                    SAFE          -> (" -  You won", "status-won")
                    DEAD          -> (" - You lost", "status-lost")
                    IN_PROGRESS   -> ("", "")
  in
    span [class c] [text status]


view : Signal.Address Action -> Game -> Html                                       (4)
view address game =
  let
    rows = Utils.partitionByN game.cols game.tiles
  in
    div [id "main"] [
      h1 [] [text "Minesweeper", statusView game],
      div [class "board"] (List.map (rowView address) rows),
      div [] [button [class "button", onClick address NewGame] [text "New game"]]
    ]

const channel = new EventEmitter();
const renderMinesweeper = createUI(channel);
let game = createGame({cols: 16, rows: 16, mines: 48});
let history = List([game]);

function render() {                                                         (1)
  renderMinesweeper(game, document.getElementById('board'));
}

channel.on('undo', () => {                                                  (2)
  if (history.size > 1) {
    history = history.pop();
    game = history.last();
    render();
  }
});

channel.on('reveal', (tile) => {                                            (3)
  if (isGameOver(game)) { return; }

  const newGame = revealTile(game, tile);

  if (newGame !== game) {
    history = history.push(newGame);
    game = newGame;
  }

  render();

  if (isGameOver(game)) {
    // Wait for the final render to complete before alerting the user
    setTimeout(() => { alert('GAME OVER!'); }, 50);
  }
});

(defn- dispatch
  [c]
  (cond (nil? c)                        parse-eof
        (identical? c *delimiter*)      reader/ignore
        (reader/whitespace? c)          parse-whitespace
        (identical? c \^)               parse-meta
        (identical? c \#)               parse-sharp
        (identical? c \()               parse-list
        (identical? c \[)               parse-vector
        (identical? c \{)               parse-map
        (identical? c \})               parse-unmatched
        (identical? c \])               parse-unmatched
        (identical? c \))               parse-unmatched
        (identical? c \~)               parse-unquote
        (identical? c \')               parse-quote
        (identical? c \`)               parse-syntax-quote
        (identical? c \;)               parse-comment
        (identical? c \@)               parse-deref
        (identical? c \")               parse-string
        (identical? c \:)               parse-keyword
        :else                           parse-token))

(defn raise [zloc]                               (1)
  (if-let [containing (z/up zloc)]
    (z/replace containing (z/node zloc))         (2)
    zloc))                                       (3)

(ns foo-bar
  (:require [rewrite-clj.zip :as z]
            [rewrite-clj.paredit :as pe])

(-> (z/of-string "(dynamic-wind in (lambda () body) out)")    (1)
    (pe/find-by-pos {:row 1 :col 29})                         (2)
    pe/raise                                                  (3)
    pe/raise
    z/root-string)                                            (4)

(defn paredit-cmd [ed f]
  (let [pos (editor/->cursor ed)
        form (u/get-top-level-form ed)                                         (1)
        zloc (positioned-zip pos form)]                                        (2)
    (when zloc
      (editor/replace ed (:start form) (:end form) (-> zloc f z/root-string))  (3)
      (editor/move-cursor ed pos)                                              (4)
      (format-keep-pos ed))))                                                  (5)

(behavior ::raise!                                                   (1)
          :triggers #{:parembrace.raise!}
          :reaction (fn [ed]
                      (paredit-cmd ed pe/raise)))



(cmd/command {:command :parembrace.raise                             (2)
              :desc "Parembrace: Raise"
              :exec (fn []
                      (when-let [ed (pool/last-active)]
                        (object/raise ed :parembrace.raise!)))})

(defproject clj-light-refactor "0.1.5"
  :dependencies [[org.clojure/clojure "1.5.1"]
                 [quiescent "0.1.4"]])               (1)

[:app :lt.objs.plugins/load-js ["react.min.js"                       (1)
                                "clj-light-refactor_compiled.js"]]

  :user {:plugins [[cider/cider-nrepl "0.9.0-SNAPSHOT"]]}}

(behavior ::list-ns
          :triggers #{:list-ns}
          :reaction (fn [ed]
                      (object/raise ed
                                    :eval.custom                                 (1)
                                    (mw/create-op {:op "ns-list"})               (2)
                                    {:result-type :refactor.list-ns-res          (3)
                                     :verbatim true})))


(behavior ::list-ns-res
          :triggers #{:editor.eval.clj.result.refactor.list-ns-res}              (4)
          :reaction (fn [ed res]
                      (let [[ok? ret] (mw/extract-result res                     (5)
                                                         :singles
                                                         [:ns-list :results])]
                        (if-not ok?
                          (object/raise ed
                                        :editor.exception
                                        (:err ret)
                                        {:line (-> ret :meta :line)})

                          (do
                            (object/raise sidebar/rightbar :toggle ns-bar)       (6)
                            (object/raise ns-bar
                                          :update-ns-list!                       (7)
                                          (->> (:ns-list ret)
                                               (maybe-exclude (:exclusions @ns-bar))
                                               (map #(hash-map :name %)))))))))

 [:editor.clj "ctrl-alt-n" :show-nsbrowser]

(ns acme.core
  (:require [clojure.data.json :as json]
            [clj-time.coerce :as c]))


(extend-type org.joda.time.DateTime           (1)
  json/JSONWriter
  (-write [date out]
    (json/-write (c/to-string date) out)))    (2)

(ns acme.util.date
  (:require [clj-time.core :as t]
            [clj-time.format :as f]
            [clj-time.coerce :as c]))


(def iso-date-pattern (re-pattern "^\\d{4}-\\d{2}-\\d{2}.*"))


(defn date? [date-str]                                                         (1)
  (when (and date-str (string? date-str))
    (re-matches iso-date-pattern date-str)))


(defn json->datetime [json-str]
  (when (date? json-str)
    (if-let [res (c/from-string json-str)]                                     (2)
      res
      nil))) ;; you should probably throw an exception or something here !

(defn datetimeify [m]
  (let [f (fn [[k v]]
            (if (date? v)
              [k (json->datetime v)]                                           (3)
              [k v]))]
    (clojure.walk/postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))

(defn wrap-date [handler]                                     (1)
  (fn [req]
    (handler (update-in req [:params] (datetimeify %)))))


def app (-> routes
            auth/wrap-auth
            wrap-date                                         (2)
            wrap-keyword-params
            wrap-json-params
            wrap-datasource
            wrap-params
            wrap-config))

(ns acme-catalog.core
  (:require [compojure.core :refer [defroutes ANY]]
            [ring.middleware.params :refer [wrap-params]]
            [ring.middleware.keyword-params :refer [wrap-keyword-params]]
            [ring.middleware.json :refer [wrap-json-params]]
            [clojure.java.io :as io]
            [buddy.auth.backends.token :refer [jws-backend]]
            [buddy.auth.middleware :refer [wrap-authentication]]
            [buddy.core.keys :as ks]
            [acme-catalog.resources :as r]))

(defroutes app-routes
  (ANY "/products" [] r/products)
  (ANY "/products/:id" [id] (r/product id)))


(def auth-backend (jws-backend {:secret (ks/public-key (io/resource "auth_pubkey.pem"))  (1)
                                :token-name "Acme-Token"}))

(def app
  (-> app-routes
      (wrap-authentication auth-backend)                                                 (2)
      wrap-keyword-params
      wrap-json-params))