Go to file
Kyoichiro Yamada a54593d7f3 fix lints: declaration of "err" shadows declaration at io.go:11 2017-04-15 23:47:29 +09:00
server fix lints: error strings should not be capitalized or end with punctuation or a newline 2017-04-15 23:47:29 +09:00
settings fix lints: declaration of "err" shadows declaration at io.go:11 2017-04-15 23:47:29 +09:00
watcher fix lints: error strings should not be capitalized or end with punctuation or a newline 2017-04-15 23:47:29 +09:00
.gitignore server assets ignored 2016-10-14 11:04:12 +02:00
.travis.yml allow fallback to watching by polling 2016-12-22 00:28:08 +01:00
LICENSE realize dev 2016-07-12 10:18:02 +02:00
README.md doc layout 2017-04-01 20:42:33 +02:00
lock.json go dep 2017-04-01 20:07:25 +02:00
manifest.json go dep 2017-04-01 20:07:25 +02:00
realize.go fix lints: declaration of "err" shadows declaration at realize.go:193 2017-04-15 23:47:29 +09:00

README.md

Realize

GoDoc TeamCity CodeBetter AUR Join the chat at https://gitter.im/tockins/realize Go Report Card

Logo

A Go build system with file watchers, output streams and live reload. Run, build and watch file changes with custom paths

Preview

Features

  • Highly customizable
  • Config your project Step by Step
  • Build, Install, Test, Fmt, Generate and Run at the same time
  • Live reload on file changes (re-build, re-install...)
  • Watch custom paths and specific file extensions
  • Watch by FsNotify or by polling
  • Support for multiple projects
  • Output streams and error logs (support for save on a file)
  • Web Panel (projects list, config settings, logs)

Wiki

Run this to get/install:

$ go get github.com/tockins/realize

Commands

  • Run

    From project/projects root execute:

    $ realize run
    

    It will create a realize.yaml file if it doesn't exist already, adds the working directory as project and run the pipeline.

    The Run command supports the following custom parameters:

    --path="realize/server"     -> Custom Path, if not specified takes the working directory name    
    --build                     -> Enable go build   
    --no-run                    -> Disable go run
    --no-install                -> Disable go install
    --no-config                 -> Ignore an existing config / skip the creation of a new one
    --server                    -> Enable the web server
    --legacy                    -> Enable legacy watch instead of Fsnotify watch
    --generate                  -> Enable go generate
    --test                      -> Enable go test
    

    Examples:

    $ realize run
    $ realize run --path="mypath"
    $ realize run --name="My Project" --build
    $ realize run --path="realize" --no-run --no-config
    $ realize run --path="/Users/alessio/go/src/github.com/tockins/realize-examples/coin/"
    

    If you want, you can specify additional arguments for your project.

    The additional arguments must go after the params

    Run can run a project from its working directory without make a config file (--no-config).

    $ realize run --path="/print/printer" --no-run yourParams --yourFlags // right
    $ realize run yourParams --yourFlags --path="/print/printer" --no-run // wrong
    
  • Add

    Add a project to an existing config file or create a new one without run the pipeline.

    "Add" supports the same parameters of the "Run" command.

    $ realize add
    
  • Init

    Like add, but with this command you can create a configuration step by step and customize each option.

    Init is the only command that supports a complete customization of all the options supported

    $ realize init
    
  • Remove

    Remove a project by its name

    $ realize remove --name="myname"
    
  • List

    Projects list in cli

    $ realize list
    
  • Color reference

    • Blue: outputs of the project
    • Red: errors
    • Magenta: times or changed files
    • Green: successfully completed action
  • Config sample

    For more examples check Realize Examples

       ```
       settings:
         legacy:                
           status: true           // legacy watch status
           interval: 10s          // polling interval
         resources:               // files names related to streams
           outputs: outputs.log   
           logs: logs.log         
           errors: errors.log
         server:                  
           status: true           // server status         
           open: false            // auto open in browser on start
           host: localhost        // server host  
           port: 5001             // server port
       projects:
       - name: realize    
         path: .                  // project path
         fmt: true                
         generate: false
         test: false
         bin: true
         build: false
         run: false
         params:                  // additional params
         - --myarg
         watcher:
           preview: false         // wached files preview
           paths:                 // paths to watch
           - /
           ignore_paths:          // paths to ignore
           - vendor
           exts:                  // exts to watch
           - .go
           scripts:               // custom commands after/before
           - type: after          // type after/before
             command: go run mycmd after  // command
             path: ""             //  run from a custom path or from the working dir
         streams:                 // enable/disable streams 
           cli_out: true
           file_out: false
           file_log: false
           file_err: false
    
      ```                      
    

    This is the configuration used for develop realize

      ```
      settings:
        resources:
          outputs: outputs.log
          logs: logs.log
          errors: errors.log
        server:
          status: false
          open: false
          host: localhost
          port: 5001
      projects:
      - name: realize
        path: /Users/alessio/go/src/github.com/tockins/realize
        fmt: true
        generate: false
        test: false
        bin: true
        build: false
        run: false
        watcher:
          preview: false
          paths:
          - /
          ignore_paths:
          - server/assets
          exts:
          - .go
          scripts:
          - type: before
            command: go-bindata -pkg="server" assets/...
            path: server
          - type: after
            command: go-bindata -pkg="server" assets/...
            path: server
        streams:
          cli_out: true
          file_out: false
          file_log: false
          file_err: false
      ```                    
    
Support us and suggest an improvement