roger 0.0.1 → 0.10.0

data/lib/roger/release/finalizers/rsync.rb

@@ -0,0 +1,77 @@
+require 'shellwords'
+
+module Roger::Release::Finalizers
+  
+  # Finalizes the release by uploading your mockup with rsync to a remote server
+  # 
+  # @see RsyncFinalizer#initialize for options
+  #
+  class Rsync < Base
+  
+    # @param Hash options The options
+    #
+    # @option options String :rsync The Rsync command to run (default is "rsync")
+    # @option options String :remote_path The remote path to upload to
+    # @option options String :host The remote host to upload to
+    # @option options String :username The remote username to upload to
+    # @option options Boolean :ask Prompt the user before uploading (default is true)
+    def initialize(options = {})
+      @options = {
+        :rsync => "rsync",
+        :remote_path => "",
+        :host => "",
+        :username  => "",
+        :ask => true
+      }.update(options)
+    end
+  
+    def call(release, options = {})
+      options = @options.dup.update(options)
+    
+      # Validate options
+      validate_options!(release, options)
+      
+      if !options[:ask] || (prompt("Do you wish to upload to #{options[:host]}? Type y[es]: ")) =~ /\Ay(es)?\Z/
+        begin
+          `#{@options[:rsync]} --version`
+        rescue Errno::ENOENT
+          raise RuntimeError, "Could not find rsync in #{@options[:rsync].inspect}"
+        end
+        
+        local_path = release.build_path.to_s
+        remote_path = options[:remote_path]
+        
+        local_path += "/" unless local_path =~ /\/\Z/
+        remote_path += "/" unless remote_path =~ /\/\Z/
+        
+        release.log(self, "Starting upload of #{(release.build_path + "*")} to #{options[:host]}")
+      
+        command = "#{options[:rsync]} -az #{Shellwords.escape(local_path)} #{Shellwords.escape(options[:username])}@#{Shellwords.escape(options[:host])}:#{Shellwords.escape(remote_path)}"
+        
+        # Run r.js optimizer
+        output = `#{command}`
+        
+        # Check if r.js succeeded
+        unless $?.success?
+          raise RuntimeError, "Rsync failed.\noutput:\n #{output}"
+        end
+      end
+    end
+    
+    protected
+    
+    def validate_options!(release, options)
+      must_have_keys = [:remote_path, :host, :username]
+      if (options.keys & must_have_keys).size != must_have_keys.size
+        release.log(self, "You must specify these options: #{(must_have_keys - options.keys).inspect}")
+        raise "Missing keys: #{(must_have_keys - options.keys).inspect}"
+      end
+    end
+    
+    def prompt(question = 'Do you wish to continue?')
+      print(question)
+      return $stdin.gets.strip
+    end
+  
+  end
+end

data/lib/roger/release/finalizers/zip.rb

@@ -0,0 +1,42 @@
+module Roger::Release::Finalizers
+  
+  class Zip < Base
+    
+    attr_reader :release
+    
+    # @option options :prefix Prefix to put before the version (default = "html")
+    # @option options :zip The zip command
+    def call(release, options = {})
+      if options
+        options = @options.dup.update(options)
+      else
+        options = @options
+      end
+      
+      options = {
+        :zip => "zip",
+        :prefix => "html"
+      }.update(options)
+
+      name = [options[:prefix], release.scm.version].join("-") + ".zip"
+      release.log(self, "Finalizing release to #{release.target_path + name}")
+      
+      if File.exist?(release.target_path + name)
+        release.log(self, "Removing existing target #{release.target_path + name}")
+        FileUtils.rm_rf(release.target_path + name)
+      end
+      
+      begin
+        `#{options[:zip]} -v`
+      rescue Errno::ENOENT
+        raise RuntimeError, "Could not find zip in #{options[:zip].inspect}"
+      end
+
+      ::Dir.chdir(release.build_path) do
+        `#{options[:zip]} -r -9 "#{release.target_path + name}" ./*`
+      end
+    end
+    
+ 
+  end
+end

data/lib/roger/release/finalizers.rb

@@ -0,0 +1,19 @@
+module Roger::Release::Finalizers
+  class Base    
+    
+    def initialize(options = {})
+      @options = {}
+      @options.update(options) if options
+    end
+    
+    def call(release, options = {})
+      raise ArgumentError, "Implement in subclass"
+    end
+  end
+end
+
+require File.dirname(__FILE__) + "/finalizers/zip"
+require File.dirname(__FILE__) + "/finalizers/dir"
+require File.dirname(__FILE__) + "/finalizers/rsync"
+require File.dirname(__FILE__) + "/finalizers/git_branch"
+

data/lib/roger/release/injector.rb

@@ -0,0 +1,99 @@
+require 'tilt'
+module Roger
+  
+  # Inject VERSION / DATE (i.e. in TOC)
+  # r.inject({"VERSION" => release.version, "DATE" => release.date}, :into => %w{_doc/toc.html})
+  
+  # Inject CHANGELOG
+  # r.inject({"CHANGELOG" => {:file => "", :filter => BlueCloth}}, :into => %w{_doc/changelog.html})  
+  
+  class Release::Injector
+    
+    # @example Simple variable injection (replaces [VARIABLE] into all .css files)
+    #     {"[VARIABLE]" => "replacement"}, :into => %w{**/*.css}
+    #
+    # @example Regex variable injection (replaces all matches into test.js files)
+    #     {/\/\*\s*\[BANNER\]\s*\*\// => "replacement"}, :into => %w{javacripts/test.js}    
+    #
+    # @example Simple variable injection with filtering (replaces [VARIABLE] with :content run through the markdown processor into all .html files)
+    #     {"[VARIABLE]" => {:content => "# header one", :processor => "md"}, :into => %w{**/*.html}
+    #    
+    # @example Full file injection (replaces all matches of [CHANGELOG] with the contents of "CHANGELOG.md" into _doc/changelog.html)
+    #
+    #     {"CHANGELOG" => {:file => "CHANGELOG.md"}}, :into => %w{_doc/changelog.html}
+    #
+    # @example Full file injection with filtering (replaces all matches of [CHANGELOG] with the contents of "CHANGELOG" which ran through Markdown compresser into _doc/changelog.html)
+    #
+    #     {"CHANGELOG" => {:file => "CHANGELOG", :processor => "md"}}, :into => %w{_doc/changelog.html}
+    #
+    # Processors are based on Tilt (https://github.com/rtomayko/tilt). 
+    # Currently supported/tested processors are:
+    #
+    # * 'md' for Markdown (bluecloth)
+    #
+    # Injection files are relative to the :source_path
+    # 
+    # @param [Hash] variables Variables to inject. See example for more info
+    # @option options [Array] :into An array of file globs relative to the build_path
+    def initialize(variables, options)      
+      @variables = variables
+      @options = options
+    end
+    
+    def call(release, options = {})
+      @options.update(options)
+      files = release.get_files(@options[:into])
+      
+      files.each do |f|
+        c = File.read(f)
+        injected_vars = []
+        @variables.each do |variable, injection|
+          if c.gsub!(variable, get_content(injection, release))
+            injected_vars << variable
+          end
+        end
+        release.log(self, "Injected variables #{injected_vars.inspect} into #{f}") if injected_vars.size > 0
+        File.open(f,"w") { |fh| fh.write c }
+      end
+      
+    end
+    
+    def get_content(injection, release)
+      case injection
+      when String
+        injection
+      when Hash
+        get_complex_injection(injection, release)
+      else
+        if injection.respond_to?(:to_s)
+          injection.to_s
+        else
+          raise ArgumentError, "Woah, what's this? #{injection.inspect}"
+        end
+      end
+    end
+    
+    def get_complex_injection(injection, release)
+      
+      if injection[:file]
+        content = File.read(release.source_path + injection[:file])
+      else
+        content = injection[:content]
+      end
+      
+      raise ArgumentError, "No :content or :file specified" if !content
+
+      if injection[:processor]
+        if tmpl = Tilt[injection[:processor]]
+          (tmpl.new{ content }).render
+        else
+          raise ArgumentError, "Unknown processor #{injection[:processor]}"
+        end
+      else
+        content
+      end
+      
+    end
+    
+  end
+end

data/lib/roger/release/processors/mockup.rb

@@ -0,0 +1,93 @@
+module Roger::Release::Processors
+  class Mockup < Base
+    
+    attr_accessor :project
+    
+    def initialize(options={})
+      @options = {
+        :env => {},
+        :match => ["**/*.{html,md,html.erb}"],
+        :skip => [/\Astylesheets/, /\Ajavascripts/]
+      }
+      
+      @options.update(options) if options            
+    end
+
+    def call(release, options={})
+      self.project = release.project
+      
+      options = {}.update(@options).update(options)
+      
+      options[:env].update("MOCKUP_PROJECT" => project)
+      
+      release.log(self, "Processing mockup files")
+      
+      release.log(self, "  Matching: #{options[:match].inspect}", true)      
+      release.log(self, "  Skiping : #{options[:skip].inspect}", true)            
+      release.log(self, "  Env     : #{options[:env].inspect}", true)
+      release.log(self, "  Files   :", true)
+      
+      release.get_files(options[:match], options[:skip]).each do |file_path|
+        release.log(self, "    Extract: #{file_path}", true)
+        self.run_on_file!(file_path, options[:env])
+      end
+    end
+    
+    
+    def run_on_file!(file_path, env = {})
+      template = Roger::Template.open(file_path, :partials_path => self.project.partial_path, :layouts_path => self.project.layouts_path)
+      
+      # Clean up source file
+      FileUtils.rm(file_path)
+      
+      # Write out new file
+      File.open(self.target_path(file_path, template),"w"){|f| f.write(template.render(env.dup)) }
+    end
+    
+    # Runs the extractor on a single file and return processed source.
+    def extract_source_from_file(file_path, env = {})
+      Roger::Template.open(file_path, :partials_path => self.project.partial_path, :layouts_path => self.project.layouts_path).render(env.dup)
+    end    
+    
+    protected
+    
+    def target_path(path, template)
+      # 1. If we have a double extension we rip of the template it's own extension and be done with it
+      parts = File.basename(path.to_s).split(".")
+      dir = Pathname.new(File.dirname(path.to_s))
+      
+      # 2. Try to figure out the extension based on the template's mime-type
+      mime_types = {
+        "text/html" => "html",
+        "text/css"  => "css",
+        "application/javascript" => "js",
+        "text/xml" => "xml",
+        "application/xml" => "xml",
+        "text/csv" => "csv",
+        "application/json" => "json"
+      }
+      extension = mime_types[template.template.class.default_mime_type]
+      
+      # Always return .html directly as it will cause too much trouble otherwise
+      if parts.last == "html"
+        return path
+      end
+      
+      if parts.size > 2
+        # Strip extension
+        dir + parts[0..-2].join(".")
+      else
+        return path if extension.nil?
+        
+        if parts.size > 1
+          # Strip extension and replace with extension
+          dir + (parts[0..-2] << extension).join(".")
+        else
+          # Let's just add the extension
+          dir + (parts << extension).join(".")
+        end
+      end
+    end    
+    
+  end
+end

data/lib/roger/release/processors/url_relativizer.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '../../../resolver'
+
+module Roger::Release::Processors
+  class UrlRelativizer < Base
+    
+    def initialize(options={})
+      @options = {
+        :url_attributes => %w{src href action},
+        :match => ["**/*.html"],
+        :skip => []
+      }
+      
+      @options.update(options) if options            
+    end
+
+    def call(release, options={})
+      options = {}.update(@options).update(options)
+      
+      release.log(self, "Relativizing all URLS in #{options[:match].inspect} files in attributes #{options[:url_attributes].inspect}, skipping #{options[:skip].any? ? options[:skip].inspect : "none" }")
+      
+      @resolver = Roger::Resolver.new(release.build_path)
+     release.get_files(options[:match], options[:skip]).each do |file_path|
+        release.debug(self, "Relativizing URLS in #{file_path}") do
+          orig_source = File.read(file_path)
+          File.open(file_path,"w") do |f| 
+            doc = Hpricot(orig_source)
+            options[:url_attributes].each do |attribute|
+              (doc/"*[@#{attribute}]").each do |tag|
+                converted_url = @resolver.url_to_relative_url(tag[attribute], file_path)
+                release.debug(self, "Converting '#{tag[attribute]}' to '#{converted_url}'")
+                case converted_url
+                when String
+                  tag[attribute] = converted_url
+                when nil
+                  release.log(self, "Could not resolve link #{tag[attribute]} in #{file_path}")
+                end
+              end
+            end
+            f.write(doc.to_original_html) 
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roger/release/processors.rb

@@ -0,0 +1,17 @@
+module Roger::Release::Processors
+  class Base
+    
+    def initialize(options = {})
+      @options = {}
+      @options.update(options) if options
+    end
+  
+    
+    def call(release, options = {})
+      raise ArgumentError, "Implement in subclass"
+    end
+  end
+end
+
+require File.dirname(__FILE__) + "/processors/mockup"
+require File.dirname(__FILE__) + "/processors/url_relativizer"

data/lib/roger/release/scm/git.rb

@@ -0,0 +1,101 @@
+require 'pathname'
+
+module Roger::Release::Scm
+  class Git < Base
+    
+    # @option config [String] :ref Ref to use for current tag
+    # @option config [String, Pathname] :path Path to working dir
+    def initialize(config={})
+      super(config)
+      @config[:ref] ||= "HEAD"
+    end
+        
+    # Version is either:
+    # - the tagged version number (first "v" will be stripped) or
+    # - the return value of "git describe --tags HEAD"
+    # - the short SHA1 if there hasn't been a previous tag
+    def version
+      get_scm_data if @_version.nil?
+      @_version
+    end
+    
+    # Date will be Time.now if it can't be determined from GIT repository
+    def date
+      get_scm_data if @_date.nil?
+      @_date
+    end
+  
+    def previous
+      self.class.new(@config.dup.update(:ref => get_previous_tag_name))
+    end
+    
+    protected
+    
+    def get_previous_tag_name
+      # Get list of SHA1 that have a ref
+      begin
+        sha1s = `git --git-dir=#{git_dir} log --pretty='%H' --simplify-by-decoration`.split("\n")
+        tags = []
+        while tags.size < 2 && sha1s.any?
+          sha1 = sha1s.shift
+          tag = `git --git-dir=#{git_dir} describe --tags --exact-match #{sha1} 2>/dev/null`.strip
+          tags << tag if !tag.empty?
+        end
+        tags.last
+      rescue
+        raise "Could not get previous tag"
+      end      
+    end
+    
+    def git_dir
+      @git_dir ||= find_git_dir(@config[:path])
+    end
+
+    # Some hackery to determine if we're on a tagged version or not
+    def get_scm_data(ref = @config[:ref])
+      @_version = ""
+      @_date = Time.now
+      begin
+        if File.exist?(git_dir)
+          @_version = `git --git-dir=#{git_dir} describe --tags #{ref} 2>&1`
+          
+          if $?.to_i > 0
+            # HEAD is not a tagged verison, get the short SHA1 instead            
+            @_version = `git --git-dir=#{git_dir} show #{ref} --format=format:"%h" -s 2>&1` 
+          else
+            # HEAD is a tagged version, if version is prefixed with "v" it will be stripped off
+            @_version.gsub!(/^v/,"")
+          end
+          @_version.strip!
+    
+          # Get the date in epoch time
+          date = `git --git-dir=#{git_dir} show #{ref} --format=format:"%ct" -s 2>&1`
+          if date =~ /\d+/
+            @_date = Time.at(date.to_i)
+          else
+            @_date = Time.now
+          end
+    
+        end
+      rescue RuntimeError => e
+      end
+
+    end
+    
+    # Find the git dir
+    def find_git_dir(path)
+      path = Pathname.new(path).realpath
+      while path.parent != path && !(path + ".git").directory?
+        path = path.parent
+      end
+      
+      path = path + ".git"
+      
+      raise "Could not find suitable .git dir in #{path}" if !path.directory?
+
+      path
+    end
+    
+  end
+end
+

data/lib/roger/release/scm.rb

@@ -0,0 +1,32 @@
+module Roger::Release::Scm
+  class Base
+    
+    attr_reader :config
+    
+    def initialize(config={})
+      @config = config
+    end
+    
+    # Returns the release version string from the SCM
+    #
+    # @return String The current version string
+    def version
+      raise "Implement in subclass"
+    end
+    
+    # Returns the release version date from the SCM
+    def date
+      raise "Implement in subclass"      
+    end
+    
+    # Returns a Release::Scm object with the previous version's data
+    #
+    # @return Roger::Release::Scm The previous version
+    def previous
+      raise "Implement in subclass"      
+    end
+    
+  end
+end
+
+require File.dirname(__FILE__) + "/scm/git"