Esempio n. 1
0
// Creates a new source. Returns the source, if it has been
// loaded from cache or not, and an error.
func NewSource(dest, filename, base string) (*Source, bool, error) {
	src := cache.ReadData(dest+filename, new(Source)).(*Source)

	// Return the file from cache if possible
	if modified, err := cache.Modified(dest, filename); err != nil {
		return nil, false, err
	} else if !modified {
		return src, true, nil
	}

	// Reset the source info
	src.Provides = []string{}
	src.Requires = []string{}
	src.Base = (filename == base)
	src.Filename = filename

	// Open the file
	f, err := os.Open(filename)
	if err != nil {
		return nil, false, app.Error(err)
	}
	defer f.Close()

	r := bufio.NewReader(f)
	for {
		// Read it line by line
		line, _, err := r.ReadLine()
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, false, err
		}

		// Find the goog.provide() calls
		if strings.Contains(string(line), "goog.provide") {
			matchs := provideRe.FindSubmatch(line)
			if matchs != nil {
				src.Provides = append(src.Provides, string(matchs[1]))
				continue
			}
		}

		// Find the goog.require() calls
		if strings.Contains(string(line), "goog.require") {
			matchs := requiresRe.FindSubmatch(line)
			if matchs != nil {
				src.Requires = append(src.Requires, string(matchs[1]))
				continue
			}
		}
	}

	// Validates the base file
	if src.Base {
		if len(src.Provides) > 0 || len(src.Requires) > 0 {
			return nil, false,
				app.Errorf("base files should not provide or require namespaces: %s", filename)
		}
		src.Provides = append(src.Provides, "goog")
	}

	return src, false, nil
}
Esempio n. 2
0
// Compile all modified templates
func Compile() error {
	conf := config.Current()

	if conf.Soy == nil || conf.Soy.Root == "" {
		return nil
	}

	if err := os.MkdirAll(path.Join(conf.Build, "templates"), 0755); err != nil {
		return app.Error(err)
	}

	buildPrefix := filepath.Join(conf.Build, "templates")
	oldSoy, err := scan.Do(buildPrefix, ".js")
	if err != nil {
		return err
	}

	soy, err := scan.Do(conf.Soy.Root, ".soy")
	if err != nil {
		return err
	}

	indexed := map[string]bool{}
	for _, f := range soy {
		f = f[len(conf.Soy.Root):]
		indexed[f] = true
	}

	// Delete compiled templates no longer present in the sources
	for _, f := range oldSoy {
		compare := f[len(buildPrefix) : len(f)-3]
		if _, ok := indexed[compare]; !ok {
			if err := os.Remove(f); err != nil {
				return app.Error(err)
			}
		}
	}

	if len(soy) == 0 {
		return nil
	}

	for _, t := range soy {
		if modified, err := cache.Modified("compile", t); err != nil {
			return err
		} else if !modified {
			continue
		}

		prel, err := filepath.Rel(conf.Soy.Root, t)
		if err != nil {
			return app.Error(err)
		}

		out := path.Join(conf.Build, "templates", prel+".js")
		if err := os.MkdirAll(path.Dir(out), 0755); err != nil {
			return app.Error(err)
		}

		log.Println("Compiling template", t, "...")

		// Run the compiler command
		cmd := exec.Command(
			"java",
			"-jar", path.Join(conf.Soy.Compiler, "build", "SoyToJsSrcCompiler.jar"),
			"--outputPathFormat", out,
			"--shouldGenerateJsdoc",
			"--shouldProvideRequireSoyNamespaces",
			"--cssHandlingScheme", "goog",
			t)

		output, err := cmd.CombinedOutput()
		if err != nil {
			return app.Errorf("exec error with %s: %s\n%s", t, err, string(output))
		}

		log.Println("Done compiling template!")
	}

	return nil
}
Esempio n. 3
0
// Compiles the .gss files
func Compile() error {
	conf := config.Current()
	target := conf.Gss.CurTarget()

	// Output early if there's no GSS files.
	if conf.Gss == nil {
		if err := cleanRenamingMap(); err != nil {
			return err
		}

		return nil
	}

	// Check if the cached version is still ok
	modified := false
	for _, input := range conf.Gss.Inputs {
		if m, err := cache.Modified("compile", input.File); err != nil {
			return err
		} else if m {
			modified = true
			break
		}
	}

	if !modified {
		return nil
	}

	log.Println("Compiling GSS:", target.Name)

	if err := cleanRenamingMap(); err != nil {
		return err
	}

	// Prepare the list of non-standard functions.
	funcs := []string{}
	for _, f := range conf.Gss.Funcs {
		funcs = append(funcs, "--allowed-non-standard-function")
		funcs = append(funcs, f.Name)
	}

	// Prepare the renaming map args
	renaming := []string{}
	if target.Rename == "true" {
		renaming = []string{
			"--output-renaming-map-format", "CLOSURE_COMPILED",
			"--rename", "CLOSURE",
			"--output-renaming-map", path.Join(conf.Build, config.RENAMING_MAP_NAME),
		}
	}

	// Prepare the defines
	defines := []string{}
	for _, define := range target.Defines {
		defines = append(defines, "--define", define.Name)
	}

	// Prepare the inputs
	inputs := []string{}
	for _, input := range conf.Gss.Inputs {
		inputs = append(inputs, input.File)
	}

	// Prepare the command
	cmd := exec.Command(
		"java",
		"-jar", path.Join(conf.Gss.Compiler, "build", "closure-stylesheets.jar"),
		"--output-file", filepath.Join(conf.Build, config.CSS_NAME))
	cmd.Args = append(cmd.Args, funcs...)
	cmd.Args = append(cmd.Args, renaming...)
	cmd.Args = append(cmd.Args, inputs...)
	cmd.Args = append(cmd.Args, defines...)

	// Output the command if asked to
	if config.OutputCmd {
		fmt.Println("java", strings.Join(cmd.Args, " "))
	}

	// Run the compiler
	output, err := cmd.CombinedOutput()
	if err != nil {
		if len(output) != 0 {
			fmt.Println(string(output))
		}

		return app.Errorf("exec error: %s", err)
	}

	if len(output) > 0 {
		log.Println("Output from GSS compiler:\n", string(output))
	}

	log.Println("Done compiling GSS!")

	return nil
}