Class: Closure::Goog

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/closure/goog.rb

Overview

Scripts render with an instance named goog in the context.

Instance Method Summary collapse

Constructor Details

#initialize(env, sources, render_stack) ⇒ Goog

Returns a new instance of Goog.



22
23
24
25
26
27
28
 
# File 'lib/closure/goog.rb', line 22

def initialize(env, sources, render_stack)
  @sources = sources
  @env = env
  @render_stack = render_stack
  @dependencies = []
  @path = ''
end

Instance Method Details

#add_dependency(dependency, root = nil) ⇒ Object

You can add additional files to have their mtimes scanned. Perhaps you want to use a .yml file to define build options. Closure::Script calls this for every render so you don’t need to define compiler arguments in the same script that calls compile.

Parameters:

  • root (String) (defaults to: nil) —

    of file paths, optional



47
48
49
50
51
 
# File 'lib/closure/goog.rb', line 47

def add_dependency(dependency, root = nil)
  root ||= File.dirname(@render_stack.last)
  dependency = File.expand_path dependency, root
  @dependencies << dependency unless @dependencies.include? dependency
end

#base_js ⇒ String

The Google Closure base.js script. If you use this instead of a static link, you are free to relocate relative to the Google Closure library without updating every html fixture page.

Examples:

view_test.erb

<script src="<%= goog.base_js %>"></script>

Returns:

  • (String) 


174
175
176
 
# File 'lib/closure/goog.rb', line 174

def base_js
  @sources.base_js(@env)
end

#compile(args, root = nil) ⇒ Compilation

Compile javascript. Accepts every argument that compiler.jar supports. This method supports all compiler augmentations added by Closure Script. Path options are expanded relative to the script calling #compile.

  • ‘–ns namespace` expands in place to `–js filename` arguments which satisfy the namespace.

  • ‘–module name:*:dep` File count will be filled in automatically. The * is replaced with the count of files up to next –module or the end.

  • ‘–js_output_file file` is compared against sources modification times to determine if compilation is to be performed.

  • ‘–compilation_level` when not supplied, the scripts are loaded raw.

Examples:

myapp.js.erb

<% @response = goog.compile(%w{
  --js_output_file ../public/myapp.js
  --ns myapp.HelloWorld
  --compilation_level ADVANCED_OPTIMIZATIONS
}).to_response %>

Parameters:

  • args (Array<String>)
  • root (String) (defaults to: nil) —

    of file paths, optional

Returns:

  • (Compilation) 


88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/closure/goog.rb', line 88

def compile(args, root = nil)
  args = Array.new args # work on a copy
  root ||= File.dirname(@render_stack.last)
  Compiler::Util.expand_paths args, root
  mods = Compiler::Util.augment args, @sources, @env
  if Compiler::Util.arg_values(args, '--compilation_level').empty?
    # Raw mode
    comp = Compiler::Compilation.new @env
    if mods
      comp << Compiler::Util.module_path(@path)
      comp << Compiler::Util.module_info(mods)
      comp << Compiler::Util.module_uris_raw(mods, @sources)
    end
    js_counter = 0
    args_index = 0
    while args_index < args.length
      option, value = args[args_index, 2]
      if option == '--js'
        value = File.expand_path(value, root)
        script_tag = "<script src=#{(@path+src_for(value)).dump}></script>"
        comp << "document.write(#{script_tag.dump});\n"
        js_counter += 1
        # For modules, just the files for the first module
        break if mods and js_counter >= mods[0][:files].length
      end
      args_index = args_index + 2
    end
  else
    # Compiled mode
    module_output_path_prefix = Compiler::Util.arg_values(args, '--module_output_path_prefix').last
    if mods and !module_output_path_prefix
      # raise this before compilation so we don't write to a weird place
      raise "--module_output_path_prefix is required when using --module"
    end
    comp = Compiler.compile args, @dependencies, @env
    if mods
      refresh # compilation may add new files, module_uris_compiled uses src_for
      prefix =  File.expand_path module_output_path_prefix, root
      if comp.js_output_file
        File.open comp.js_output_file, 'w' do |f|
          f.write Compiler::Util.module_path @path
          f.write Compiler::Util.module_info mods
          f.write Compiler::Util.module_uris_compiled mods, @sources, prefix
        end
      else
        comp << Compiler::Util.module_path(@path)
        comp << Compiler::Util.module_info(mods)
        comp << Compiler::Util.module_uris_compiled(mods, @sources, prefix)
      end
      # Load the first module
      first_module_file = module_output_path_prefix + mods[0][:name] + '.js'
      first_module_file = File.expand_path first_module_file, root
      comp << '(function(){var e=document.createElement("script");e.type="text/javascript";e.src='
      comp << (@path + src_for(first_module_file)).dump
      comp << ";document.body.appendChild(e);})();\n"
    end
  end
  comp
end

#deps_js ⇒ String

This is where base.js looks to find deps.js by default. You will always be served a Closure Script generated deps.js from this location. Very old Library versions may get confused by the forward caching query string; either update your base.js, install a deps_response Script where it’s looking, or manually set CLOSURE_BASE_PATH.

Returns:

  • (String) 


184
185
186
 
# File 'lib/closure/goog.rb', line 184

def deps_js
  @sources.deps_js(@env)
end

#deps_response ⇒ Rack::Response

You can serve a deps.js from anywhere you want to drop a script.

Examples:

something.js.erb

<% @response = goog.deps_response %>

Returns:

  • (Rack::Response) 


192
193
194
 
# File 'lib/closure/goog.rb', line 192

def deps_response
  @sources.deps_response(File.dirname(Rack::Utils.unescape(@env["PATH_INFO"])), @env)
end

#each ⇒ Object

Advanced Scripts may need to know where all the sources are. This has potential for a source browser, editor, and more.

Examples:

goog.each {|directory, path| ... }


200
201
202
203
204
 
# File 'lib/closure/goog.rb', line 200

def each
  @sources.each do |directory, path|
    yield directory, path
  end
end

#files_for(namespace, filenames = nil) ⇒ Array

Calculate files needed to satisfy a namespace. This will be especially useful for module generation. If you pass the filenames returned from last run, additional files (if any) will be appended to satisfy the new namespace.

Examples:

cal_file_list.erb

<%= goog.files_for %w{myapp.Calendar} %>

Returns:

  • (Array) 


164
165
166
 
# File 'lib/closure/goog.rb', line 164

def files_for(namespace, filenames=nil)
  @sources.files_for(namespace, filenames, @env)
end

#path=(p) ⇒ Object

Specify an explicit host or path for loading scripts. e.g. ‘//example.com’ or ‘/proxy/path’ You may also include a protocol and path if necessary. e.g. ‘example.com:8080/proxy/path’ attr_reader :path



35
36
37
38
39
40
 
# File 'lib/closure/goog.rb', line 35

def path= p
  @path = p if p.start_with?('/')
  @path = p if p.start_with?('http://')
  @path = p if p.start_with?('https://')
  raise 'goog.path not valid' unless @path == p
end

#refresh ⇒ Object

If your Script changes any javascript sources then call this. This is a lazy refresh, you may call it repeatedly.



55
56
57
 
# File 'lib/closure/goog.rb', line 55

def refresh
  @sources.invalidate @env
end

#soy_to_js(args, root = nil) ⇒ Object

Convert soy templates to javascript. Accepts all arguments that SoyToJsSrcCompiler.jar support plus it expands filename globs. All source filenames are relative to the script calling #soy_to_js.

Parameters:

  • args (Array<String>)
  • root (String) (defaults to: nil) —

    of file paths, optional



64
65
66
67
68
 
# File 'lib/closure/goog.rb', line 64

def soy_to_js(args, root = nil)
  root ||= File.dirname(@render_stack.last)
  Templates::compile(args, root)
  refresh
end

#src_for(filename) ⇒ String

Calculate the deps src for a filename.

Parameters:

  • filename (String)

Returns:

  • (String) —

    http path info with forward caching query.



151
152
153
154
 
# File 'lib/closure/goog.rb', line 151

def src_for(filename)
  filename = File.expand_path filename
  @sources.src_for(filename, @env)
end