darcsweb - gen/PathPure.hs

{-# OPTIONS_GHC -w #-}
module PathPure where
import qualified Data.Bits
import qualified Data.Char

import qualified Prelude

string_is_empty :: Prelude.String -> Prelude.Bool
string_is_empty s =
  case s of {
   ([]) -> Prelude.True;
   (:) _ _ -> Prelude.False}

remove_slashes :: Prelude.String -> Prelude.String
remove_slashes s =
  case s of {
   ([]) -> "";
   (:) c rest ->
    case ((Prelude.==) :: Prelude.Char -> Prelude.Char -> Prelude.Bool) c '/' of {
     Prelude.True -> remove_slashes rest;
     Prelude.False -> (:) c (remove_slashes rest)}}

starts_with_dot :: Prelude.String -> Prelude.Bool
starts_with_dot s =
  case s of {
   ([]) -> Prelude.False;
   (:) c _ ->
    ((Prelude.==) :: Prelude.Char -> Prelude.Char -> Prelude.Bool) c '.'}

last_char :: Prelude.String -> Prelude.Maybe Prelude.Char
last_char s =
  case s of {
   ([]) -> Prelude.Nothing;
   (:) c rest ->
    case rest of {
     ([]) -> Prelude.Just c;
     (:) _ _ -> last_char rest}}

split_path_aux :: Prelude.String -> Prelude.String -> ([]) Prelude.String
split_path_aux acc s =
  case s of {
   ([]) -> (:) acc ([]);
   (:) c rest ->
    case ((Prelude.==) :: Prelude.Char -> Prelude.Char -> Prelude.Bool) c '/' of {
     Prelude.True -> (:) acc (split_path_aux "" rest);
     Prelude.False -> split_path_aux ((Prelude.++) acc ((:) c "")) rest}}

split_path :: Prelude.String -> ([]) Prelude.String
split_path s =
  case s of {
   ([]) -> ([]);
   (:) _ _ -> split_path_aux "" s}

filter_nonempty :: (([]) Prelude.String) -> ([]) Prelude.String
filter_nonempty l =
  case l of {
   ([]) -> ([]);
   (:) x xs ->
    case string_is_empty x of {
     Prelude.True -> filter_nonempty xs;
     Prelude.False -> (:) x (filter_nonempty xs)}}

all_true :: (Prelude.String -> Prelude.Bool) -> (([]) Prelude.String) ->
            Prelude.Bool
all_true f l =
  case l of {
   ([]) -> Prelude.True;
   (:) x xs -> (Prelude.&&) (f x) (all_true f xs)}

is_safe_segment :: Prelude.String -> Prelude.Bool
is_safe_segment seg =
  let {name = remove_slashes seg} in
  (Prelude.&&)
    ((Prelude.&&)
      ((Prelude.&&)
        ((Prelude.&&)
          ((Prelude.&&) (Prelude.not (string_is_empty name))
            (Prelude.not
              (((Prelude.==) :: Prelude.String -> Prelude.String -> Prelude.Bool)
                name "..")))
          (Prelude.not
            (((Prelude.==) :: Prelude.String -> Prelude.String -> Prelude.Bool)
              name ".")))
        (Prelude.not
          (((Prelude.==) :: Prelude.String -> Prelude.String -> Prelude.Bool)
            name "_darcs")))
      (Prelude.not
        (((Prelude.==) :: Prelude.String -> Prelude.String -> Prelude.Bool)
          name ".git")))
    (Prelude.not (starts_with_dot name))

is_safe_sub_path :: Prelude.String -> Prelude.Bool
is_safe_sub_path sub =
  let {segments = filter_nonempty (split_path sub)} in
  case segments of {
   ([]) -> Prelude.False;
   (:) _ _ -> all_true is_safe_segment segments}

add_trailing_slash :: Prelude.String -> Prelude.String
add_trailing_slash s =
  case s of {
   ([]) -> "/";
   (:) _ _ ->
    case last_char s of {
     Prelude.Just c ->
      case ((Prelude.==) :: Prelude.Char -> Prelude.Char -> Prelude.Bool) c
             '/' of {
       Prelude.True -> s;
       Prelude.False -> (Prelude.++) s "/"};
     Prelude.Nothing -> "/"}}