ymdp 0.1.3.2 → 0.1.4

data/VERSION

@@ -1 +1 @@
-0.1.3.2
+0.1.4

data/lib/ymdp.rb

@@ -18,7 +18,7 @@ Dir["#{dir}/*.rb"].each do |path|
   require File.expand_path(path)
 end
 
-["support", "configuration", "compiler"].each do |directory|
+["support", "configuration"].each do |directory|
   Dir["#{dir}/#{directory}/*.rb"].each do |path|
     require File.expand_path(path)
   end

data/lib/ymdp/commands/build.rb

@@ -0,0 +1,14 @@
+YMDP_ENV = "build"
+
+require 'compiler/options'
+require 'compiler/domains'
+
+YMDP::Compiler::Template::Base.base_path = BASE_PATH
+YMDP::Compiler::Template::Base.servers = SERVERS
+
+YMDP::Compiler::Domains.base_path = BASE_PATH
+YMDP::Compiler::Domains.servers = SERVERS
+
+@options = YMDP::Compiler::Options.parse
+YMDP::Compiler::Domains.new(@options).compile
+

data/lib/ymdp/compiler/base.rb

@@ -0,0 +1,206 @@
+# Compiles the source code for an individual domain.
+#
+# Usage:
+#
+#   @compiler = YMDP::Compiler::Base.new('staging', 'asdfh23rh2fas', :base_path => ".", :server => {
+#     "server" => "staging", "application_id" => "12345", "assets_id" => "abcdefg_1" })
+#
+# You can then compile the domain:
+#
+#   @compiler.build
+#
+module YMDP
+  module Compiler
+    class Base
+      attr_accessor :domain, :git_hash, :options, :base_path, :server
+  
+      # A TemplateCompiler instance covers a single domain, handling all the processing necessary to 
+      # convert the application source code into usable destination files ready for upload.
+      #
+      def initialize(domain, git_hash, options={})
+        @domain = domain
+        @git_hash = git_hash
+        @options = options
+        @base_path = options[:base_path]
+        @server = options[:server]
+        
+        raise ArgumentError.new("base_path is required") unless @base_path
+      end
+      
+      # Perform all the processing for a single domain.
+      #
+      # This is the main method on this object.
+      #
+      def process_all
+        create_directory("servers/#{domain}")
+        clean_domain
+        ["views", "assets"].each do |dir|
+          process_path("#{base_path}/app/#{dir}/")
+        end
+        process_all_translations
+        copy_images
+      end
+
+      # Do all the processing necessary to convert all the application source code from the given path
+      # into usable destination files ready for upload to the server:
+      #
+      # - create server directory if necessary,
+      # - for each file in the source path, build the file, and
+      # - copy the images from the source to the destination directory.
+      #
+      def process_path(path)
+        $stdout.puts "Processing #{path} for #{domain}"
+        process_all_files(path)
+      end
+  
+      # Process all code files (HTML and JavaScript) into usable, complete HTML files.
+      #
+      def process_all_files(path)
+        Dir["#{path}**/*"].each do |f|
+          build_file(f)
+        end    
+      end
+  
+      # Build this file if it's either:
+      #   - a view, but not a partial or layout, or
+      #   - a JavaScript file.
+      #
+      def build_file(file)
+        params = {
+          :file => file, 
+          :domain => domain, 
+          :git_hash => git_hash, 
+          :message => options[:message], 
+          :verbose => options[:verbose], 
+          :base_path => base_path,
+          :server => server
+        }
+        if build?(file)
+          if file =~ /(\.haml|\.erb)$/
+            YMDP::Compiler::Template::View.new(params).build
+          elsif file =~ /\.js$/
+            YMDP::Compiler::Template::JavaScript.new(params).build
+          end
+        end
+      end
+  
+      # Convert all YRB translation files from YRB ".pres" format into a single JSON file per language.
+      #
+      def process_all_translations
+        $stdout.puts "Processing ./app/assets/yrb/ for #{domain}"
+        YMDP::Base.supported_languages.each do |lang|
+          process_each_yrb(lang)
+        end
+      end
+  
+      # Convert the YRB translation files of a single language for this domain into a single JSON file.
+      #
+      def process_each_yrb(lang)
+        tmp_file = "#{TMP_DIR}/keys_#{lang}.pres"
+    
+        # Concatenate together all the YRB ".pres" files for this language into one file in the tmp dir.
+        #
+        F.concat_files("#{yrb_path}/#{lang}/*", tmp_file)
+    
+        yrb = YMDP::Compiler::Template::YRB.new(:file => tmp_file, :domain => domain)
+        yrb.build
+        yrb.validate if CONFIG.validate_json_assets?
+        
+        FileUtils.rm(tmp_file)
+      end
+  
+      # Creates a fresh destination directory structure for the code to be compiled into.
+      #
+      def clean_domain
+        dir = "#{servers_path}/#{domain}"
+        FileUtils.rm_rf("#{dir}/views")
+        FileUtils.rm_rf("#{dir}/assets/javascripts")
+        FileUtils.rm_rf("#{dir}/assets/stylesheets")
+        FileUtils.rm_rf("#{dir}/assets/yrb")
+        FileUtils.rm_rf("#{TMP_DIR}/")
+        FileUtils.mkdir_p(TMP_DIR)
+      end
+
+      # Format text in a standard way for output to the screen.
+      #
+      def log(text)
+        "#{Time.now.to_s} #{text}"
+      end
+  
+      # Convert a file's path from its source to its destination.
+      #
+      # The source directory is in the 'app' directory.
+      #
+      # The destination directory is made from the 'servers' root and the domain name.
+      #
+      # For example: 
+      #   - ./servers/staging
+      #   - ./servers/alpha
+      #
+      def destination(path)
+        destination = path.dup
+        destination.gsub!("#{base_path}/app", "#{servers_path}/#{domain}")
+      end
+  
+      # If this directory doesn't exist, create it and print that it's being created.
+      #
+      def create_directory(path)
+        dest = destination(path)
+    
+        unless File.exists?("#{base_path}/#{path}")
+          $stdout.puts "     create #{path}"
+          FileUtils.mkdir_p("#{base_path}/#{path}")
+        end
+      end
+  
+      # Images don't require any processing, just copy them over into this domain's assets directory.
+      #
+      def copy_images
+        if options[:verbose]
+          $stdout.puts log("Moving images into #{servers_path}/#{domain}/assets/images...")
+        end
+        FileUtils.rm_rf("#{servers_path}/#{domain}/assets/images")
+        FileUtils.mkdir_p("#{servers_path}/#{domain}/assets")
+        FileUtils.cp_r("#{images_path}/", "#{servers_path}/#{domain}/assets")
+      end
+  
+      # A filename beginning with an underscore is a partial.
+      #
+      def partial?(file)
+        file.split("/").last =~ /^_/
+      end
+  
+      # A file in the layouts directory is a layout.
+      #
+      def layout?(file)
+        file =~ /\/app\/views\/layouts\//
+      end
+  
+      # Build if it's not a partial and not a layout.
+      #
+      def build?(file)
+        !partial?(file) && !layout?(file)
+      end
+      
+      def app_path
+        "#{base_path}/app"
+      end
+      
+      def assets_path
+        "#{app_path}/assets"
+      end
+      
+      def yrb_path
+        "#{assets_path}/yrb"
+      end
+      
+      def images_path
+        "#{assets_path}/images"
+      end
+      
+      def servers_path
+        "#{app_path}/servers"
+      end
+    end
+  end
+end

data/lib/ymdp/compiler/domains.rb

@@ -0,0 +1,103 @@
+require 'compiler/git_helper'
+require 'compiler/base'
+require 'compiler/template'
+
+# Covers all the domains and the actions that are taken on all domains at once.
+#
+# Usage:
+#
+# YMDP::Compiler::Domains.new(:message => "Commit message").compile
+#
+# Options are provided by command-line parsing from YMDP::Compiler::Options.
+#
+module YMDP
+  module Compiler
+    # Covers all the domains and the actions that are taken on all domains at once.
+    #
+    class Domains
+      attr_accessor :git, :git_hash, :message, :domains, :options
+  
+      def initialize(options=nil)
+        @options = options
+        @servers = @options[:servers]
+        @domains = @options[:domain] || all_domains
+        @domains = @domains.to_a
+        @message = @options[:message]
+
+        commit if @options[:commit]
+      end
+      
+      # Class Methods to handle global stuff like base path and server settings
+      
+      def self.base_path= base_path
+        @@base_path = base_path
+      end
+      
+      def self.base_path
+        @@base_path
+      end
+      
+      def self.servers= servers
+        @@servers = servers
+      end
+      
+      def self.servers
+        @@servers
+      end
+      
+      # Instance Methods to access global stuff like base path and server settings
+      
+      def servers
+        @@servers
+      end
+      
+      def base_path
+        @@base_path
+      end
+  
+      # Compile the source code for all domains into their usable destination files.
+      #
+      def compile
+        Timer.new(:title => "YMDP").time do
+          clean_tmp_dir do
+            process_domains
+          end
+        end
+      end
+  
+      # Returns all domains.
+      #
+      def all_domains
+        servers.servers.keys
+      end
+  
+      # Commit to git and store the hash of the commit.
+      #
+      def commit
+        @git = GitHelper.new
+        @git.do_commit(@message)
+        @git_hash = git.get_hash(options[:branch])    
+      end
+  
+      # Process source code for each domain in turn.
+      #
+      def process_domains
+        domains.each do |domain|
+          compiler = YMDP::Compiler::Base.new(domain, git_hash, options)
+          
+          compiler.process_all
+        end
+      end
+  
+      # Perform a block, starting with a clean 'tmp' directory and ending with one.
+      #
+      def clean_tmp_dir
+        system "rm -rf #{TMP_DIR}"
+        system "mkdir #{TMP_DIR}"
+        yield
+        system "rm -rf #{TMP_DIR}"
+        system "mkdir #{TMP_DIR}"
+      end
+    end
+  end
+end

data/lib/ymdp/compiler/options.rb

@@ -0,0 +1,48 @@
+module YMDP
+  module Compiler
+    # Command-line options processor for Compiler module.
+    #
+    class Options
+      # Parse command line options into an options hash.
+      #
+      def self.parse
+        options = {
+          :commit => false,
+          :branch => "master",
+          :base_path => BASE_PATH,
+          :servers => SERVERS
+        }
+        OptionParser.new do |opts|
+          options[:commit] = false
+          options[:verbose] = CONFIG.verbose?
+          opts.banner = "Usage: build.rb [options]"
+
+          opts.on("-d", "--domain [domain]", "Force Domain") do |v|
+            options[:domain] = v
+          end
+          opts.on("-b", "--branch [branch]", "Current Branch") do |v|
+            options[:branch] = v
+          end
+          opts.on("-m", "--message [message]", "Commit Message") do |v|
+            options[:commit] = true
+            options[:message] = v
+          end
+          opts.on("-n", "--no-commit", "Don't Commit") do |v|
+            options[:commit] = false
+          end
+          opts.on("-v", "--verbose", "Verbose (show all file writes)") do |v|
+            options[:verbose] = true
+          end
+          opts.on("-r", "--rake [task]", "Execute Rake task") do |v|
+            options[:rake] = v
+          end
+          opts.on("-c", "--compress", "Compress JavaScript and CSS") do |v|
+            options[:compress] = v
+          end
+        end.parse!
+    
+        options
+      end    
+    end
+  end
+end

data/lib/ymdp/compiler/template.rb

@@ -7,379 +7,433 @@
 #
 # Usage:
 #
-#   YMDP::Template::View.new(params).build
-#   YMDP::Template::JavaScript.new(params).build
+#   YMDP::Compiler::Template::View.new(params).build
+#   YMDP::Compiler::Template::JavaScript.new(params).build
 #
-# See YMDP::Template::Base#initialize for details on params.
+# See YMDP::Compiler::Template::Base#initialize for details on params.
 #
 module YMDP
-  module Template
-    # Compiles a single file in a single domain, processing its Haml or ERB and turning
-    # it into usable destination files in the 'servers' directory.
-    #
-    class Base
-      # Usage:
-      # 
-      #   @template = YMDP::Template::Base.new(params)
-      #
-      # Arguments:
-      #
-      #   - verbose: boolean value, output verbose notices,
-      #   - domain: string, indicates which domain the template is compiling to,
-      #   - file: filename of the template in questions,
-      #   - hash: git hash of the latest commit,
-      #   - message: commit message of the latest commit.
-      #
-      def initialize(params)
-        @verbose = params[:verbose]
-        @domain = params[:domain]
-        @server = SERVERS[@domain]["server"]
-        @file = params[:file]
-        @assets_directory = "/om/assets/#{SERVERS[@domain]['assets_id']}"
-        @hash = params[:git_hash]
-        @message = params[:message]
+  module Compiler
+    module Template
+      # Compiles a single file in a single domain, processing its Haml or ERB and turning
+      # it into usable destination files in the 'servers' directory.
+      #
+      class Base
+        # Usage:
+        # 
+        #   @template = YMDP::Compiler::Template::Base.new(params)
+        #
+        # Arguments:
+        #
+        #   - verbose: boolean value, output verbose notices,
+        #   - domain: string, indicates which domain the template is compiling to,
+        #   - file: filename of the template in question,
+        #   - hash: git hash of the latest commit,
+        #   - message: commit message of the latest commit.
+        #
+        attr_accessor :domain, :server, :file, :assets_directory, :hash, :message
+        
+        def initialize(params)
+          @verbose = params[:verbose]
+          @domain = params[:domain]
+          
+          @file = params[:file]
+          @assets_directory = "/om/assets/#{servers[@domain]['assets_id']}"
+          @hash = params[:git_hash]
+          @message = params[:message]
     
-        set_content_variables
+          set_content_variables
     
-        @view = base_filename(@file.split("/").last)
-        Application.current_view = @view
-      end
+          @view = base_filename(@file.split("/").last)
+          Application.current_view = @view
+        end
+        
+        # Is the verbose setting on?
+        #
+        def verbose?
+          @verbose
+        end
   
-      # Parses the file 'content.yml' and adds each of its keys to the environment as
-      # an instance variable, so they will be available inside the template.
-      #
-      def set_content_variables
-        content = YAML.load_file("#{CONFIG_PATH}/content.yml")
-        content.each do |key, value|
-          attribute = "@#{key}"
-          instance_variable_set(attribute, value) unless instance_variable_defined?(attribute)
+        # Parses the file 'content.yml' and adds each of its keys to the environment as
+        # an instance variable, so they will be available inside the template.
+        #
+        def set_content_variables
+          content = YAML.load_file("#{CONFIG_PATH}/content.yml")
+          content.each do |key, value|
+            attribute = "@#{key}"
+            instance_variable_set(attribute, value) unless instance_variable_defined?(attribute)
+          end
         end
-      end
       
-      # If the filename begins with a _ it's a partial.
-      #
-      def partial?
-        @file =~ /#{BASE_PATH}\/app\/views\/_/
-      end
+        # If the filename begins with a _ it's a partial.
+        #
+        def partial?
+          @file =~ /#{base_path}\/app\/views\/_/
+        end
 
-      # Compile this view unless it is a partial.
-      #
-      def build
-        unless partial?
-          write_template(processed_template)
+        # Compile this view unless it is a partial.
+        #
+        def build
+          unless partial?
+            write_template(processed_template)
+          end
         end
-      end
   
-      # Returns the compiled template code after its Haml or ERB has been processed.
-      #
-      def processed_template
-        result = ""
-        File.open(@file) do |f|
-          template = f.read
-          if @file =~ /\.haml$/
-            result = process_haml(template, @file)
-          else
-            result = process_template(template)
+        # Returns the compiled template code after its Haml or ERB has been processed.
+        #
+        def processed_template
+          result = ""
+          File.open(@file) do |f|
+            template = f.read
+            if @file =~ /\.haml$/
+              result = process_haml(template, @file)
+            else
+              result = process_template(template)
+            end
           end
+          result
         end
-        result
-      end
       
-      # Implemented in child classes, this defines what must be done to process a template.
-      #
-      def process_template(template)
-        raise "Define in child"
-      end
+        # Implemented in child classes, this defines what must be done to process a template.
+        #
+        def process_template(template)
+          raise "Define in child"
+        end
   
-      # Produces the destination path of this template, in the servers directory for
-      # the given domain.
-      #
-      # For example:
-      #
-      #   source: app/views/authorize.html.haml
-      #   destination: servers/staging/views/authorize.html.haml
-      #
-      def destination_path
-        # just the file, with no directory
-        filename = File.basename(@file)
+        # Produces the destination path of this template, in the servers directory for
+        # the given domain.
+        #
+        # For example:
+        #
+        #   source: app/views/authorize.html.haml
+        #   destination: servers/staging/views/authorize.html.haml
+        #
+        def destination_path
+          # just the file, with no directory
+          filename = File.basename(@file)
         
-        # just the filename, with no extension
-        filename = convert_filename(filename)
+          # just the filename, with no extension
+          filename = convert_filename(filename)
         
-        # just the directory, with no file 
-        directory = File.dirname(@file)
+          # just the directory, with no file 
+          directory = File.dirname(@file)
         
-        # replace the app directory with the server directory
-        relative_directory = directory.gsub!("#{BASE_PATH}/app", server_path)
+          # replace the app directory with the server directory
+          relative_directory = directory.gsub!("#{base_path}/app", server_path)
         
-        # make the directory if it doesn't exist
-        FileUtils.mkdir_p(relative_directory)
+          # make the directory if it doesn't exist
+          FileUtils.mkdir_p(relative_directory)
         
-        "#{relative_directory}/#{filename}"
-      end
+          "#{relative_directory}/#{filename}"
+        end
       
-      # Path to the servers directory for the current domain:
-      #
-      # - "./servers/staging"
-      # - "./servers/alpha"
-      #
-      def server_path
-        "#{SERVERS_PATH}/#{@domain}"
-      end
+        # Path to the servers directory for the current domain:
+        #
+        # - "./servers/staging"
+        # - "./servers/alpha"
+        #
+        def server_path
+          "#{servers_path}/#{@domain}"
+        end
   
-      # Outputs a message if @verbose is on.
-      #
-      def verbose(message)
-        $stdout.puts(message) if @verbose
-      end
+        # Outputs a message if @verbose is on.
+        #
+        def verbose(message)
+          $stdout.puts(message) if @verbose
+        end
       
-      # Writes the input string to the destination file without adding any layout.
-      #
-      def write_template_without_layout(result)
-        path = destination_path
+        # Writes the input string to the destination file without adding any layout.
+        #
+        def write_template_without_layout(result)
+          path = destination_path
     
-        File.open(path, "w") do |f|
-          f.write(result)
+          File.open(path, "w") do |f|
+            f.write(result)
+          end
+          verbose "Finished writing #{path}.\n"
         end
-        verbose "Finished writing #{path}.\n"
-      end
   
-      def write_template_with_layout(result)
-        @content = result
-        application_layout = "#{BASE_PATH}\/app\/views\/layouts\/application.html"
-        haml_layout = application_layout + ".haml"
-        erb_layout = application_layout + ".erb"
+        # Writes the input string to the destination file, passing it through the
+        # application template.
+        #
+        # The application layout can be either Haml or ERB.
+        #
+        def write_template_with_layout(result)
+          @content = result
+          application_layout = "#{base_path}\/app\/views\/layouts\/application.html"
+          haml_layout = application_layout + ".haml"
+          erb_layout = application_layout + ".erb"
         
-        if File.exists?(haml_layout)
-          layout = File.open(haml_layout) do |f|
-            template = f.read
-            process_haml(template, haml_layout)
-          end
-        elsif File.exists?(erb_layout)
-          layout = File.open(erb_layout) do |f|
-            template = f.read
-            process_template(erb_layout)
+          if File.exists?(haml_layout)
+            layout = File.open(haml_layout) do |f|
+              template = f.read
+              process_haml(template, haml_layout)
+            end
+          elsif File.exists?(erb_layout)
+            layout = File.open(erb_layout) do |f|
+              template = f.read
+              process_template(erb_layout)
+            end
           end
+        
+          write_template_without_layout(layout)
+        end
+  
+        # Write this processed template to its destination file.
+        #
+        # Overwrite in child class to define whether the class uses a template or not.
+        #
+        def write_template(result)
+          write_template_with_layout(result)
         end
         
-        write_template_without_layout(layout)
+        def servers_path
+          "#{base_path}/servers"
+        end
+
+
+
+
+      
+      # Class Methods to handle global stuff like base path and server settings
+      
+      def self.base_path= base_path
+        @@base_path = base_path
+      end
+      
+      def self.base_path
+        @@base_path
+      end
+      
+      def self.servers= servers
+        @@servers = servers
+      end
+      
+      def self.servers
+        @@servers
+      end
+      
+      # Instance Methods to access global stuff like base path and server settings
+      
+      def servers
+        @@servers
+      end
+      
+      def base_path
+        @@base_path
       end
   
-      # Write this processed template to its destination file.
-      #
-      # Overwrite in child class to define whether the class uses a template or not.
-      #
-      def write_template(result)
-        write_template_with_layout(result)
+
+        
       end
-    end
 
-    class View < Base
-      # TODO: Refactor this.  Right now it includes all the YMDP::Base and other helper files
-      # into the same namespace where we're processing the templates.  It does this so it can
-      # send its 'binding' into the ERB or Haml template and the template will be able to 
-      # process methods like "render :partial => 'sidebar'" and so on. 
-      #
-      # All the methods which are meant to be run from inside a view need to be refactored into
-      # their own class, which can be sent into the template as a binding.
-      # 
-      include ActionView::Helpers::TagHelper
+      class View < Base
+        # TODO: Refactor this.  Right now it includes all the YMDP::Base and other helper files
+        # into the same namespace where we're processing the templates.  It does this so it can
+        # send its 'binding' into the ERB or Haml template and the template will be able to 
+        # process methods like "render :partial => 'sidebar'" and so on. 
+        #
+        # All the methods which are meant to be run from inside a view need to be refactored into
+        # their own class, which can be sent into the template as a binding.
+        # 
+        include ActionView::Helpers::TagHelper
   
-      begin
-        include ApplicationHelper
-      rescue NameError
-      end
+        begin
+          include ApplicationHelper
+        rescue NameError
+        end
     
-      include YMDP::Base
-      include YMDP::AssetTagHelper
-      include YMDP::FormTagHelper
-      include YMDP::LinkTagHelper
+        include YMDP::Base
+        include YMDP::AssetTagHelper
+        include YMDP::FormTagHelper
+        include YMDP::LinkTagHelper
   
-      attr_accessor :output_buffer
+        attr_accessor :output_buffer
       
-      # Filename without its extension:
-      #
-      # - "authorize.html.haml" becomes "authorize"
-      #
-      def base_filename(filename)
-        filename.gsub(/(\.html|\.erb|\.haml)/, "")
-      end
+        # Filename without its extension:
+        #
+        # - "authorize.html.haml" becomes "authorize"
+        #
+        def base_filename(filename)
+          filename.gsub(/(\.html|\.erb|\.haml)/, "")
+        end
 
-      # Filename without its extension:
-      #
-      # - "authorize.html.haml" becomes "authorize"
-      #
-      def convert_filename(filename)
-        base_filename(filename)
-      end
+        # Filename without its extension:
+        #
+        # - "authorize.html.haml" becomes "authorize"
+        #
+        def convert_filename(filename)
+          base_filename(filename)
+        end
   
-      # Process this template with ERB.
-      #
-      def process_template(template)
-        ERB.new(template, 0, "%<>").result(binding)
-      end
+        # Process this template with ERB.
+        #
+        def process_template(template)
+          ERB.new(template, 0, "%<>").result(binding)
+        end
   
-      # Process this template with Haml.
-      #
-      def process_haml(template, filename=nil)
-        options = {}
-        if filename
-          options[:filename] = filename
+        # Process this template with Haml.
+        #
+        def process_haml(template, filename=nil)
+          options = {}
+          if filename
+            options[:filename] = filename
+          end
+          Haml::Engine.new(template, options).render(self)
         end
-        Haml::Engine.new(template, options).render(self)
-      end
   
-      # Write this template with the application layout applied.
-      #
-      # Validate the resulting HTML file if that option is turned on.
-      #
-      def write_template(result)
-        write_template_with_layout(result)
-        YMDP::Validator::HTML.validate(destination_path) if CONFIG.validate_html?
+        # Write this template with the application layout applied.
+        #
+        # Validate the resulting HTML file if that option is turned on.
+        #
+        def write_template(result)
+          write_template_with_layout(result)
+          YMDP::Validator::HTML.validate(destination_path) if CONFIG.validate_html?
+        end
       end
-    end
 
-    # Process templates for JavaScript files.
-    # 
-    # JavaScript files support ERB tags.
-    #
-    class JavaScript < View
-      # Write the processed template without any layout.
-      #
-      # Run the JavaScript compressor on the file if that option is turned on.
-      #
-      def write_template(result)
-        filename = @file.split("/").last
-        tmp_filename = "./tmp/#{filename}"
-        save_to_file(result, tmp_filename)
-        result = YMDP::Compressor::JavaScript.compress(tmp_filename) if CONFIG.compress_embedded_js?
-        write_template_without_layout(result)
+      # Process templates for JavaScript files.
+      # 
+      # JavaScript files support ERB tags.
+      #
+      class JavaScript < View
+        # Write the processed template without any layout.
+        #
+        # Run the JavaScript compressor on the file if that option is turned on.
+        #
+        def write_template(result)
+          filename = @file.split("/").last
+          tmp_filename = "./tmp/#{filename}"
+          save_to_file(result, tmp_filename)
+          result = YMDP::Compressor::JavaScript.compress(tmp_filename) if CONFIG.compress_embedded_js?
+          write_template_without_layout(result)
+        end
       end
-    end
 
-    # Process Yahoo! Resource Bundle format translation files.
-    #
-    # Convert them to a hash and write the hash to a JSON file.
-    #
-    # Each language can have as many YRB translation files (with an extension of ".pres")
-    # as necessary.  The files are concatenated together and translated into a single JSON file
-    # for each language.
-    #
-    class YRB < Base
-      # Base directory for translations for this domain.
+      # Process Yahoo! Resource Bundle format translation files.
       #
-      def directory
-        directory = "#{BASE_PATH}/servers/#{@domain}/assets/yrb"
-        FileUtils.mkdir_p(directory)
-        directory
-      end
-  
-      # The destination of the compiled JSON file.
+      # Convert them to a hash and write the hash to a JSON file.
       #
-      def destination_path
-        filename = convert_filename(@file.split("/").last)
-        "#{directory}/#{filename}"
-      end  
-  
-      # JSON values of the compiled translations.
+      # Each language can have as many YRB translation files (with an extension of ".pres")
+      # as necessary.  The files are concatenated together and translated into a single JSON file
+      # for each language.
       #
-      def to_json
-        processed_template
-      end
+      class YRB < Base
+        # Base directory for translations for this domain.
+        #
+        def directory
+          directory = "#{base_path}/servers/#{@domain}/assets/yrb"
+          FileUtils.mkdir_p(directory)
+          directory
+        end
   
-      # Turn it back into a hash.
-      #
-      def to_hash
-        JSON.parse(to_json)
-      end
+        # The destination of the compiled JSON file.
+        #
+        def destination_path
+          filename = convert_filename(@file.split("/").last)
+          "#{directory}/#{filename}"
+        end  
   
-      # Convert the hash to Yaml if you should want to do that.
-      #
-      def to_yaml
-        h = {}
-        to_hash.each do |k,v|
-          k = k.downcase
-          h[k] = "#{v}"
+        # JSON values of the compiled translations.
+        #
+        def to_json
+          processed_template
         end
-        h.to_yaml
-      end
   
-      # This function is the file which is written to the destination--in this
-      # case, the JSON file.
-      #
-      def processed_template
-        super.to_json
-      end
+        # Turn it back into a hash.
+        #
+        def to_hash
+          JSON.parse(to_json)
+        end
   
-      # Validate the JSON file.
-      #
-      def validate
-        YMDP::Validator::JSON.validate(destination_path)
-      end
+        # Convert the hash to Yaml if you should want to do that.
+        #
+        def to_yaml
+          h = {}
+          to_hash.each do |k,v|
+            k = k.downcase
+            h[k] = "#{v}"
+          end
+          h.to_yaml
+        end
+  
+        # This function is the file which is written to the destination--in this
+        # case, the JSON file.
+        #
+        def processed_template
+          super.to_json
+        end
+  
+        # Validate the JSON file.
+        #
+        def validate
+          YMDP::Validator::JSON.validate(destination_path)
+        end
   
-      private
+        private
       
-      # Strip off the ".pres" extension from original YRB files.
-      #
-      def base_filename(filename)    
-        filename.gsub(/\.pres/, "")
-      end
+        # Strip off the ".pres" extension from original YRB files.
+        #
+        def base_filename(filename)    
+          filename.gsub(/\.pres/, "")
+        end
   
-      # Take the base filename and add the ".json" extension.
-      #
-      def convert_filename(filename)
-        "#{base_filename(filename)}.json"
-      end
+        # Take the base filename and add the ".json" extension.
+        #
+        def convert_filename(filename)
+          "#{base_filename(filename)}.json"
+        end
       
-      # Is this line a valid comment in YRB?
-      def comment?(line)
-        line =~ /^[\s]*#/
-      end
+        # Is this line a valid comment in YRB?
+        def comment?(line)
+          line =~ /^[\s]*#/
+        end
       
-      # Is this line valid YRB syntax?
-      #
-      def key_and_value_from_line(line)
-        if line =~ /^([^\=]+)=(.+)/
-          return $1, $2.strip
-        else
-          return nil, nil
+        # Is this line valid YRB syntax?
+        #
+        def key_and_value_from_line(line)
+          if line =~ /^([^\=]+)=(.+)/
+            return $1, $2.strip
+          else
+            return nil, nil
+          end
         end
-      end
   
-      # Parse YRB and add it to a hash.  Raise an error if the key already exists in the hash.
-      #
-      def process_template(template)
-        @hash = {}
-        lines = template.split("\n")
-        lines.each do |line|
-          unless comment?(line)
-            key, value = key_and_value_from_line(line)
-            unless key.blank?
-              if @hash.has_key?(key)
-                puts
-                puts "Duplicate value in #{destination_path}"
-                puts "  #{key}=#{@hash[key]}"
-                puts "  #{key}=#{value}"
-                puts
-                if @hash[key] == value
-                  puts "  Values are the same but duplicate values still should not exist!"
+        # Parse YRB and add it to a hash.  Raise an error if the key already exists in the hash.
+        #
+        def process_template(template)
+          @hash = {}
+          lines = template.split("\n")
+          lines.each do |line|
+            unless comment?(line)
+              key, value = key_and_value_from_line(line)
+              unless key.blank?
+                if @hash.has_key?(key)
                   puts
+                  puts "Duplicate value in #{destination_path}"
+                  puts "  #{key}=#{@hash[key]}"
+                  puts "  #{key}=#{value}"
+                  puts
+                  if @hash[key] == value
+                    puts "  Values are the same but duplicate values still should not exist!"
+                    puts
+                  end
+                  raise "Duplicate key error"
                 end
-                raise "Duplicate key error"
+                @hash[key] = value
               end
-              @hash[key] = value
             end
           end
+          @hash
         end
-        @hash
-      end
   
-      # Write JSON file to its destination.
-      #
-      def write_template(result)
-        puts destination_path if CONFIG.verbose?
-        write_template_without_layout(result)
+        # Write JSON file to its destination.
+        #
+        def write_template(result)
+          puts destination_path if CONFIG.verbose?
+          write_template_without_layout(result)
+        end
       end
     end
   end
-end
+end