ymdp 0.1.1 → 0.1.3

data/Rakefile

@@ -20,6 +20,7 @@ begin
     gem.add_development_dependency "progressions-g", ">= 0"
     gem.add_development_dependency "bundler", ">= 0"
     gem.add_development_dependency "timer", ">= 0"
+    gem.add_development_dependency "serenity", ">= 0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.3

data/lib/ymdp/compiler/compiler.rb

@@ -0,0 +1,278 @@
+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"
+        }
+        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
+  
+    # 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 || Compiler::Options.parse
+        @domains = @options[:domain] || all_domains
+        @domains = @domains.to_a
+        @message = @options[:message]
+
+        commit
+      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
+        if options[:commit]
+          git.do_commit(@message)
+        end
+        @git_hash = git.get_hash(options[:branch])    
+      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
+      rescue StandardError => e
+        puts e.message
+        puts e.backtrace
+      end
+  
+      # Process source code for each domain in turn.
+      #
+      def process_domains
+        domains.each do |domain|
+          compiler = Compiler::Base.new(domain, git_hash, options)
+          
+          compiler.clean_domain
+  
+          ["views", "assets"].each do |dir|
+            compiler.process("#{BASE_PATH}/app/#{dir}/")
+          end
+        end
+    
+        if options[:rake]
+          system "rake #{options[:rake]}"
+        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
+
+    # Compiles the source code for an individual domain.
+    #
+    # Usage:
+    #
+    #   @compiler = Compiler::Base.new('staging', 'asdfh23rh2fas')
+    #
+    # You can then compile the domain:
+    #
+    #   @compiler.build
+    #
+    class Base
+      attr_accessor :domain, :git_hash, :options
+  
+      # 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
+      end
+
+      # Do all the processing necessary to convert the application source code 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)
+        puts "Processing #{path} for #{domain}"
+        create_directory("servers/#{domain}")
+        process_all_files(path)
+        process_all_translations
+        copy_images
+      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]
+        }
+        if build?(file)
+          if file =~ /(\.haml|\.erb)$/
+            YMDP::Template::View.new(params).build
+          elsif file =~ /\.js$/
+            YMDP::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
+        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.
+        #
+        Dir["#{BASE_PATH}/app/assets/yrb/#{lang}/*"].each do |path|
+          system "cat #{path} >> #{tmp_file}"
+        end
+    
+        yrb = YMDP::Template::YRB.new(:file => tmp_file, :domain => domain)
+        yrb.build
+        yrb.validate if CONFIG.validate_json_assets?
+        system "rm #{tmp_file}"
+      end
+  
+      # Creates a fresh destination directory structure for the code to be compiled into.
+      #
+      def clean_domain
+        dir = "#{YMDP_ROOT}/servers/#{domain}"
+        system "rm -rf #{dir}/views"
+        system "rm -rf #{dir}/assets/javascripts"
+        system "rm -rf #{dir}/assets/stylesheets"
+        system "rm -rf #{dir}/assets/yrb"
+        system "rm -rf #{TMP_DIR}/"
+        system "mkdir #{TMP_DIR}"
+      end
+
+      # Format text in a standard way for output to the screen.
+      #
+      def log(text)
+        "#{Time.now.to_s} #{text}"
+      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}")
+          puts "     create #{path}"
+          FileUtils.mkdir_p "#{BASE_PATH}/#{path}"
+        end
+      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!("#{YMDP_ROOT}/app", "#{YMDP_ROOT}/servers/#{domain}")
+      end
+  
+      # Images don't require any processing, just copy them over into this domain's assets directory.
+      #
+      def copy_images
+        if options[:verbose]
+          puts log("Moving images into #{YMDP_ROOT}/servers/#{domain}/assets/images...")
+        end
+        system "rm -rf #{YMDP_ROOT}/servers/#{domain}/assets/images"
+        system "cp -r #{YMDP_ROOT}/app/assets/images #{YMDP_ROOT}/servers/#{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
+    end
+  end
+end

data/lib/ymdp/compiler/template.rb

@@ -0,0 +1,314 @@
+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]
+    
+        set_content_variables
+    
+        @view = base_filename(@file.split("/").last)
+        Application.current_view = @view
+      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)
+        end
+      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)
+        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)
+          end
+        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
+  
+      # 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 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)
+        
+        # make the directory if it doesn't exist
+        FileUtils.mkdir_p(relative_directory)
+        
+        "#{relative_directory}/#{filename}"
+      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
+      
+      # 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)
+        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"
+        
+        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
+    end
+
+    class View < Base
+      include ActionView::Helpers::TagHelper
+  
+      begin
+        include ApplicationHelper
+      rescue NameError
+      end
+    
+      include YMDP::Base
+      include YMDP::AssetTagHelper
+      include YMDP::FormTagHelper
+      include YMDP::LinkTagHelper
+  
+      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 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 Haml.
+      #
+      def process_haml(template, filename=nil)
+        options = {}
+        if filename
+          options[:filename] = filename
+        end
+        Haml::Engine.new(template, options).render(self)
+      end
+  
+      def write_template(result)
+        write_template_with_layout(result)
+        YMDP::Validator::HTML.validate(destination_path) if CONFIG.validate_html?
+      end
+    end
+
+    class JavaScript < View
+      def compress_js(filename)
+        if compress_js_assets?
+          validate_filename = "#{filename}.min"
+          YMDP::Compressor::JavaScript.compress(filename)
+        end
+      end
+    
+      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) || result
+        write_template_without_layout(result)
+      end
+    end
+
+    class YRB < Base
+      def directory
+        directory = "#{BASE_PATH}/servers/#{@domain}/assets/yrb"
+        FileUtils.mkdir_p(directory)
+        directory
+      end
+  
+      def destination_path
+        filename = convert_filename(@file.split("/").last)
+        "#{directory}/#{filename}"
+      end  
+  
+      def to_json
+        processed_template
+      end
+  
+      def to_hash
+        JSON.parse(to_json)
+      end
+  
+      def to_yaml
+        h = {}
+        to_hash.each do |k,v|
+          k = k.downcase
+          h[k] = "#{v}"
+        end
+        h.to_yaml
+      end
+  
+      def processed_template
+        super.to_json
+      end
+  
+      def validate
+        YMDP::Validator::JSON.validate(destination_path)
+      end
+  
+      private
+  
+      def base_filename(filename)    
+        filename.gsub(/\.pres/, "")
+      end
+  
+      def convert_filename(filename)
+        "#{base_filename(filename)}.json"
+      end
+  
+      def process_template(template)
+        @hash = {}
+        lines = template.split("\n")
+        lines.each do |line|
+          unless line =~ /^[\s]*#/
+            line =~ /^([^\=]+)=(.+)/
+            key = $1
+            value = $2
+            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
+              @hash[key] = value
+            end
+          end
+        end
+        @hash
+      end
+  
+      def write_template(result)
+        puts destination_path if CONFIG.verbose?
+        write_template_without_layout(result)
+      end
+    end
+  end
+end

data/lib/ymdp/configuration/config.rb

@@ -0,0 +1,104 @@
+require 'serenity'
+
+module YMDP
+  module Configuration
+    class Base
+      attr_accessor :base
+      
+      def initialize(filename, base)
+        if File.exists?(filename)
+          @config = Serenity::Configuration.new(filename)
+          @base = base
+        else
+          file_not_found(filename)
+        end
+      end
+    
+      def [](key)
+        @config.get(base, key)
+      end
+    
+      def options(*args)
+        @config.get(base, *args)
+      end
+      
+      def each
+        options.each do |name, values|
+          yield name, values
+        end
+      end
+      
+      def file_not_found(filename)
+        puts
+        puts "Create #{filename} with the following command:\n\n  ./script/config" 
+        puts
+  
+        raise "File not found: #{filename}"  
+      end      
+    end
+    
+    class Servers < Base
+      def initialize
+        super("#{CONFIG_PATH}/servers.yml", "servers")
+      end
+      
+      def servers
+        options
+      end
+    end
+    
+    class Config < Base
+      def initialize
+        super("#{CONFIG_PATH}/config.yml", "config")
+      end
+      
+      def username
+        options("username")
+      end
+      
+      def password
+        options("password")
+      end
+      
+      def compress_embedded_js?
+        options("compress", "embedded_js")
+      end
+    
+      def compress_js_assets?
+        options("compress", "js_assets")
+      end
+    
+      def compress_css?
+        options("compress", "css")
+      end
+    
+      def validate_embedded_js?
+        options("validate", "embedded_js", YMDP_ENV)
+      end
+    
+      def validate_js_assets?
+        options("validate", "js_assets", YMDP_ENV)
+      end
+    
+      def validate_json_assets?
+        options("validate", "json_assets", YMDP_ENV)
+      end
+    
+      def validate_html?
+        options("validate", "html", YMDP_ENV)
+      end
+    
+      def obfuscate?
+        options("compress", "obfuscate")
+      end
+    
+      def verbose?
+        options("verbose")
+      end
+    
+      def growl?
+        options("growl")
+      end
+    end
+  end
+end

data/lib/ymdp/configuration/constants.rb

@@ -0,0 +1,5 @@
+YMDP_ROOT = BASE_PATH unless defined?(YMDP_ROOT)
+TMP_DIR = TMP_PATH unless defined?(TMP_DIR)
+
+CONFIG = YMDP::Configuration::Config.new
+SERVERS = YMDP::Configuration::Servers.new