package ops

Linear Supertypes
RelPathStuff, Extensions, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ops
  2. RelPathStuff
  3. Extensions
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. sealed trait BasePath extends AnyRef

    A path which is either an absolute Path, a relative RelPath, or a ResourcePath with shared APIs and implementations.

    A path which is either an absolute Path, a relative RelPath, or a ResourcePath with shared APIs and implementations.

    Most of the filesystem-independent path-manipulation logic that lets you splice paths together or navigate in and out of paths lives in this interface

  2. trait BasePathImpl extends BasePath
  3. class Bytes extends AnyRef

    Trivial wrapper around Array[Byte] with sane equality and useful toString

  4. class Callable1[T1, R] extends (T1) ⇒ R

    Provides a.! b as an alternative to the a(b) syntax for calling a function with one argument

  5. class Callable2[T1, T2, R] extends (T1, T2) ⇒ R

    Provides a! b as an alternative to the (a(b, _) syntax for partially applying a function with two arguments

  6. case class Command[T](cmd: Vector[String], envArgs: Map[String, String], execute: (Path, Command[_]) ⇒ T) extends Dynamic with Product with Serializable

    A staged sub-process command that has yet to be executed.

  7. case class CommandResult(exitCode: Int, chunks: Seq[Either[Bytes, Bytes]]) extends Product with Serializable

    Contains the accumulated output for the invocation of a subprocess command.

    Contains the accumulated output for the invocation of a subprocess command.

    Apart from the exit code, the primary data-structure is a sequence of byte chunks, tagged with Left for stdout and Right for stderr. This is interleaved roughly in the order it was emitted by the subprocess, and reflects what a user would have see if the subprocess was run manually.

    Derived from that, is the aggregate out and err StreamValues, wrapping stdout/stderr respectively, and providing convenient access to the aggregate output of each stream, as bytes or strings or lines.

  8. trait CopyMove extends (Path, Path) ⇒ Unit
  9. trait Extensions extends AnyRef
  10. implicit class iterShow[T] extends AnyRef
    Definition Classes
    Extensions
  11. sealed trait FilePath extends BasePath

    Represents a value that is either an absolute Path or a relative RelPath, and can be constructed from a java.nio.file.Path or java.io.File

  12. sealed trait FileType extends AnyRef

    Simple enum with the possible filesystem objects a path can resolve to

  13. class FilterMapExt[+T, Repr] extends AnyRef

    Extends collections to give short aliases for the commonly used operations, so we can make it easy to use from the command line.

  14. class FilterMapExt2[+T] extends AnyRef

    Extends collections to give short aliases for the commonly used operations, so we can make it easy to use from the command line.

  15. class FilterMapExtGen[+T] extends AnyRef

    Extends collections to give short aliases for the commonly used operations, so we can make it easy to use from the command line.

  16. trait ImplicitOp[V] extends (Path) ⇒ V
  17. case class InteractiveShelloutException() extends Exception with Product with Serializable
  18. case class LsSeq(base: Path, listed: RelPath*) extends Seq[Path] with Product with Serializable

    A specialized Seq[Path] used to provide better a better pretty-printed experience

  19. class Path extends FilePath with BasePathImpl with Readable

    An absolute path on the filesystem.

    An absolute path on the filesystem. Note that the path is normalized and cannot contain any empty "", "." or ".." segments

  20. sealed trait PathConvertible[T] extends AnyRef
  21. class PermSet extends Set[PosixFilePermission]

    A set of permissions

  22. class Pipeable[T] extends AnyRef

    Lets you pipe values through functions

  23. trait Readable extends AnyRef

    A path that can be read from, either a Path or a ResourcePath.

    A path that can be read from, either a Path or a ResourcePath. Encapsulates the logic of how to read from it in various ways.

  24. class RegexContext extends AnyRef

    Lets you pattern match strings with interpolated glob-variables

  25. class RelPath extends FilePath with BasePathImpl

    An absolute path on the filesystem.

    An absolute path on the filesystem. Note that the path is normalized and cannot contain any empty or ".". Parent ".." segments can only occur at the left-end of the path, and are collapsed into a single number ups.

  26. trait RelPathStuff extends AnyRef
  27. implicit class RelPathStart extends AnyRef
    Definition Classes
    RelPathStuff
  28. implicit class RelPathStart2 extends AnyRef
    Definition Classes
    RelPathStuff
  29. case class ResourceNotFoundException(path: ResourcePath) extends Exception with Product with Serializable

    Thrown when you try to read from a resource that doesn't exist.

  30. class ResourcePath extends BasePathImpl with Readable

    Classloaders are tricky: http://stackoverflow.com/questions/12292926

  31. sealed trait ResourceRoot extends AnyRef

    Represents a possible root where classpath resources can be loaded from; either a ResourceRoot.ClassLoader or a ResourceRoot.Class.

    Represents a possible root where classpath resources can be loaded from; either a ResourceRoot.ClassLoader or a ResourceRoot.Class. Resources loaded from classloaders are always loaded via their absolute path, while resources loaded via classes are always loaded relatively.

  32. case class Shellable(s: Seq[String]) extends Product with Serializable

    An implicit wrapper defining the things that can be "interpolated" directly into a subprocess call.

  33. case class ShelloutException(result: CommandResult) extends Exception with Product with Serializable

    Thrown when a shellout command results in a non-zero exit code.

    Thrown when a shellout command results in a non-zero exit code.

    Doesn't contain any additional information apart from the CommandResult that is normally returned, but ensures that failures in subprocesses happen loudly and won't get ignored unless intentionally caught

  34. case class StreamValue(chunks: Seq[Bytes]) extends Product with Serializable

    Encapsulates one of the output streams from a subprocess and provides convenience methods for accessing it in a variety of forms

  35. trait StreamableOp1[T1, R, C <: Seq[R]] extends (T1) ⇒ C

    An Callable1 that returns a Seq[R], but can also do so lazily (Iterator[R]) via op.iter! arg.

    An Callable1 that returns a Seq[R], but can also do so lazily (Iterator[R]) via op.iter! arg. You can then use the iterator however you wish

  36. case class kill(signal: Int)(implicit wd: Path) extends (Int) ⇒ CommandResult with Product with Serializable

    Kills the given process with the given signal, e.g.

    Kills the given process with the given signal, e.g. kill(9)! pid

  37. case class stat(name: String, size: Long, mtime: FileTime, owner: UserPrincipal, permissions: PermSet, fileType: FileType) extends Product with Serializable

    The result from doing an system stat on a particular path.

    The result from doing an system stat on a particular path.

    Created via stat! filePath.

    If you want more information, use stat.full

Value Members

  1. val %: Command[Unit]

    Used to spawn a subprocess interactively; any output gets printed to the console and any input gets requested from the current console.

    Used to spawn a subprocess interactively; any output gets printed to the console and any input gets requested from the current console. Can be used to run interactive subprocesses like %vim, %python, %ssh "www.google.com" or %sbt.

  2. val %%: Command[CommandResult]

    Spawns a subprocess non-interactively, waiting for it to complete and collecting all output into a CommandResult which exposes it in a convenient form.

    Spawns a subprocess non-interactively, waiting for it to complete and collecting all output into a CommandResult which exposes it in a convenient form. Call via %%('whoami).out.trim or %%('git, 'commit, "-am", "Hello!").exitCode

  3. implicit def Callable1Implicit[T1, R](f: (T1) ⇒ R): Callable1[T1, R]
    Definition Classes
    Extensions
  4. implicit def FilterMapArraysImplicit[T](a: Array[T]): FilterMapExt[T, Array[T]]

    Lets you call FilterMapExt aliases on Arrays too

    Lets you call FilterMapExt aliases on Arrays too

    Definition Classes
    Extensions
  5. implicit def FilterMapExtImplicit[T, Repr](i: TraversableLike[T, Repr]): FilterMapExt[T, Repr]
    Definition Classes
    Extensions
  6. implicit def FilterMapGeneratorsImplicit[T](a: Generator[T]): FilterMapExtGen[T]
    Definition Classes
    Extensions
  7. implicit def FilterMapIteratorsImplicit[T](a: Iterator[T]): FilterMapExt2[T]
    Definition Classes
    Extensions
  8. implicit def PipeableImplicit[T](t: T): Pipeable[T]
    Definition Classes
    Extensions
  9. implicit def RegexContextMaker(s: StringContext): RegexContext
    Definition Classes
    Extensions
  10. implicit def SeqFactoryFunc[T, CC[X] <: Seq[X] with GenericTraversableTemplate[X, CC]](s: SeqFactory[CC]): (Seq[T]) ⇒ CC[T]

    Allows you to pipe sequences into other sequences to convert them, e.g.

    Allows you to pipe sequences into other sequences to convert them, e.g. Seq(1, 2, 3) |> Vector

    Definition Classes
    Extensions
  11. val empty: RelPath
    Definition Classes
    RelPathStuff
  12. implicit def fileData(p: Path): full

    Lets you treat any path as a file, letting you access any property you'd normally access through stat-ing it by stat-ing the file for you when necessary.

  13. val home: Path

    The user's home directory

  14. implicit val postfixOps: postfixOps
  15. lazy val pwd: Path

    The current working directory for this process.

  16. def resource(implicit resRoot: ResourceRoot = ...): ResourcePath
  17. val root: Path

    The root of the filesystem

  18. val up: RelPath
    Definition Classes
    RelPathStuff
  19. object /

    Extractor to let you easily pattern match on ops.Paths.

    Extractor to let you easily pattern match on ops.Paths. Lets you do

    @ val base/segment/filename = pwd
base: Path = Path(Vector("Users", "haoyi", "Dropbox (Personal)"))
segment: String = "Workspace"
filename: String = "Ammonite"

    To break apart a path and extract various pieces of it.

  20. object BasePath
  21. object Extensions extends Extensions
  22. object FilePath
  23. object FileType
  24. object ImplicitWd

    If you want to call subprocesses using % or %% and don't care what working directory they use, import this via

    If you want to call subprocesses using % or %% and don't care what working directory they use, import this via

    import ammonite.ops.ImplicitWd._

    To make them use the process's working directory for each subprocess

  25. object Internals
  26. object Path
  27. object PathConvertible
  28. object PathError
  29. object PermSet
  30. object Readable
  31. object RegexContext
  32. object RelPath extends RelPathStuff
  33. object ResourcePath
  34. object ResourceRoot
  35. object Shellable extends Serializable
  36. object Shellout

    Internal utilities to support spawning subprocesses

  37. object cp extends (Path, Path) ⇒ Unit with CopyMove

    Copies a file or folder from one place to another.

    Copies a file or folder from one place to another. Creates any necessary directories, and copies folders recursively.

  38. object exists extends (Path) ⇒ Boolean

    Checks if a file or folder exists at the given path.

  39. object ln extends (Path, Path) ⇒ Unit

    Creates a hardlink between two paths.

    Creates a hardlink between two paths. Use .s(src, dest) to create a symlink

  40. object ls extends StreamableOp1[Path, Path, LsSeq] with ImplicitOp[LsSeq]

    List the files and folders in a directory.

    List the files and folders in a directory. Can be called with .iter to return an iterator, or .rec to recursively list everything in subdirectories. .rec is a ls.Walker which means that apart from straight-forwardly listing everything, you can pass in a skip predicate to cause your recursion to skip certain files or folders.

  41. object mkdir extends (Path) ⇒ Unit

    Makes directories up to the specified path.

    Makes directories up to the specified path. Equivalent to mkdir -p in bash

  42. object mv extends (Path, Path) ⇒ Unit with Mover with CopyMove

    Moves a file or folder from one place to another.

    Moves a file or folder from one place to another.

    Creates any necessary directories

  43. object read extends (Readable) ⇒ String

    Reads a file into memory, either as a String, as (read.lines(...): Seq[String]), or as (read.bytes(...): Array[Byte]).

  44. object rm extends (Path) ⇒ Unit

    Roughly equivalent to bash's rm -rf.

    Roughly equivalent to bash's rm -rf. Deletes any files or folders in the target path, or does nothing if there aren't any

  45. object stat extends (Path) ⇒ stat with Serializable
  46. object tmp

    Alias for java.nio.file.Files.createTempFile and java.io.File.deleteOnExit.

    Alias for java.nio.file.Files.createTempFile and java.io.File.deleteOnExit. Pass in deleteOnExit = false if you want the temp file to stick around.

  47. object write extends (Path, Writable) ⇒ Unit

    Write some data to a file.

    Write some data to a file. This can be a String, an Array[Byte], or a Seq[String] which is treated as consecutive lines. By default, this fails if a file already exists at the target location. Use write.over or write.append if you want to over-write it or add to what's already there.

Deprecated Value Members

  1. lazy val cwd: Path
    Annotations
    @deprecated
    Deprecated

    (Since version 0.7.5) replaced by pwd

Inherited from RelPathStuff

Inherited from Extensions

Inherited from AnyRef

Inherited from Any

Ungrouped