roger 0.0.1 → 0.10.0

data/lib/roger/extractor.rb

@@ -0,0 +1,95 @@
+require 'hpricot'
+require File.dirname(__FILE__) + '/resolver'
+
+module Roger
+  
+  # @deprecated Don't use the extractor anymore, use release.use(:mockup, options) processor and release.use(:url_relativizer, options) processor
+  class Extractor
+    
+    attr_reader :project, :target_path
+    
+    
+    # @param [Project] project Project object
+    # @param [String,Pathname] target_path Path to extract to
+    # @param [Hash] options Options hash
+    
+    # @option options [Array] :url_attributes The element attributes to parse and relativize
+    # @option options [Array] :url_relativize Wether or not we should relativize
+    # @option options [Array] :env ENV variable to pass to template renderer.
+    def initialize(project, target_path, options={})
+      @project = project
+      @target_path = Pathname.new(target_path)
+      @resolver = Resolver.new(self.target_path)
+      
+      
+      @options = {
+        :url_attributes => %w{src href action},
+        :url_relativize => true,
+        :env => {}
+      }
+      
+      @options.update(options) if options
+      
+      @options[:env].update("MOCKUP_PROJECT" => project)
+    end
+    
+    def run!
+      target_path = self.target_path
+      source_path = self.project.html_path
+      
+      
+      filter = "**/*.html"
+      raise ArgumentError, "Target #{target_path} already exists, please choose a new directory to extract into" if target_path.exist?
+      
+      mkdir_p(target_path)
+      target_path = target_path.realpath
+      
+      # Copy source to target first, we'll overwrite the templates later on.
+      cp_r(source_path.children, target_path)
+      
+      Dir.chdir(source_path) do
+        Dir.glob(filter).each do |file_path|
+          self.run_on_file!(file_path, @options[:env])
+        end
+      end           
+    end
+    
+    def run_on_file!(file_path, env = {})
+      source = self.extract_source_from_file(file_path, env)
+      File.open(target_path + file_path,"w"){|f| f.write(source) }
+    end
+    
+    # Runs the extractor on a single file and return processed source.
+    def extract_source_from_file(file_path, env = {})
+      source = Roger::Template.open(file_path, :partials_path => self.project.partial_path, :layouts_path => self.project.layouts_path).render(env.dup)
+
+      if @options[:url_relativize]
+        source = relativize_urls(source, file_path)
+      end
+      
+      source
+    end
+    
+    
+    protected
+    
+    def relativize_urls(source, file_path)
+      doc = Hpricot(source)
+      @options[:url_attributes].each do |attribute|
+        (doc/"*[@#{attribute}]").each do |tag|
+          converted_url = @resolver.url_to_relative_url(tag[attribute], file_path)
+              
+          case converted_url
+          when String
+            tag[attribute] = converted_url
+          when nil
+            puts "Could not resolve link #{tag[attribute]} in #{file_path}"
+          end
+        end
+      end
+      
+      doc.to_original_html      
+    end
+            
+  end
+end

data/lib/roger/generators/generator.rb

@@ -0,0 +1,23 @@
+class Roger::Generators::GeneratorGenerator < Roger::Generators::Base
+  
+  include Thor::Actions
+  
+  desc "Create your own generator for roger"
+  argument :name, :type => :string, :required => true, :desc => "Name of the new generator"
+  argument :path, :type => :string, :required => true, :desc => "Path to generate the new generator"
+  # class_option :template, :type => :string, :aliases => ["-t"], :desc => "Template to use, can be a path or a git repository remote, uses built in minimal as default"
+  
+  def self.source_root
+    File.dirname(__FILE__)
+  end
+
+  def create_lib_file
+    destination = "#{path}/#{name}_generator.rb"
+    template('templates/generator.tt', destination)
+    say "Add `require #{destination}` to your mockup file and run mockup generate #{name}."
+  end
+
+  
+end
+
+Roger::Generators::Base.register Roger::Generators::GeneratorGenerator

data/lib/roger/generators/new.rb

@@ -0,0 +1,67 @@
+require 'shellwords'
+
+class Roger::Generators::NewGenerator < Thor::Group
+  
+  include Thor::Actions
+  
+  desc "Create a new HTML mockup based on an existing skeleton"
+  argument :path, :type => :string, :required => true, :desc => "Path to generate mockup into"
+  class_option :template, :type => :string, :aliases => ["-t"], :desc => "Template to use, can be a path or a git repository remote, uses built in minimal as default"
+  
+  attr_reader :source_paths
+  
+  def setup_variables    
+    self.destination_root = path
+    
+    @source_paths = []
+    
+    # Stuff to rm -rf later
+    @cleanup = []
+  end
+  
+  def validate_path_is_empty
+    if File.directory?(self.destination_root)
+      say "Directory #{self.destination_root} already exists, please only use this to create new mockups"
+      exit(1)
+    end
+  end
+  
+  def validate_template_path
+    if options[:template]
+      template = options[:template]
+    else
+      template = File.dirname(__FILE__) + "/../../../examples/default_template"
+    end
+    
+    if File.exist?(template)
+      say "Taking template from #{template}"
+      @source_paths << template
+    else
+      # Hack to create temp directory
+      t = Tempfile.new("htmlmockup-generate-new")
+      tmp_dir = Pathname.new(t.path)
+      t.close
+      t.unlink
+      
+      if run("git clone --depth=1 #{Shellwords.escape(template)} #{tmp_dir}")
+        say "Cloned template from #{template}"
+        run("rm -rf #{tmp_dir + ".git"}")
+        @source_paths << tmp_dir.to_s
+        @cleanup << tmp_dir.to_s
+      else
+        say "Template path #{template} doesn't seem to be a git remote or a local path"
+        exit(1)
+      end
+    end
+  rescue Exception => e
+    puts e
+    puts e.backtrace.join("\n")
+  end
+  
+  def create_mockup
+    directory(".", ".")
+  end
+  
+end
+
+Roger::Generators::Base.register Roger::Generators::NewGenerator

data/lib/roger/generators/templates/generator.tt

@@ -0,0 +1,13 @@
+class <%= name.capitalize %>Generator < Roger::Generators::Base
+  
+  include Thor::Actions
+  
+  desc "<%= name.capitalize %> generator helps you doing ... and ..."
+  argument :path, :type => :string, :required => true, :desc => "Path to generate the new generator"
+  
+  def create_stuff
+    # your stuff
+  end
+end
+
+Roger::Generators::Base.register <%= name.capitalize %>Generator

data/lib/roger/generators.rb

@@ -0,0 +1,23 @@
+require 'thor'
+require 'thor/group'
+
+module Roger
+  module Generators
+
+    class Base < Cli::Command
+      def self.register(sub)
+        name = sub.to_s.sub(/Generator$/, "").sub(/^.*Generators::/,"").downcase
+        usage = "#{name} #{sub.arguments.map{ |arg| arg.banner }.join(" ")}"
+        long_desc =  sub.desc || "Run #{name} generator"
+        
+        Cli::Generate.register sub, name, usage, long_desc
+        Cli::Generate.tasks[name].options = sub.class_options if sub.class_options
+      end
+    end
+
+  end
+end
+
+# Default generators
+require File.dirname(__FILE__) + "/generators/new"
+require File.dirname(__FILE__) + "/generators/generator"

data/lib/roger/mockupfile.rb

@@ -0,0 +1,63 @@
+module Roger
+  # Loader for mockupfile
+  class Mockupfile
+    
+    # This is the context for the mockupfile evaluation. It should be empty except for the
+    # #mockup method.
+    class Context
+      
+      def initialize(mockupfile)
+        @_mockupfile = mockupfile
+      end
+      
+      def mockup
+        @_mockupfile
+      end
+      
+      def binding
+        ::Kernel.binding
+      end
+      
+    end
+    
+    # @attr :path [Pathname] The path of the Mockupfile for this project
+    attr_accessor :path, :project
+        
+    def initialize(project)
+      @project = project
+      @path = Pathname.new(project.path + "Mockupfile")
+    end
+
+    # Actually load the mockupfile
+    def load
+      if File.exist?(@path) && !self.loaded?
+        @source = File.read(@path)
+        context = Context.new(self)
+        eval @source, context.binding, @path.to_s, 1
+        @loaded = true
+      end      
+    end
+    
+    # Wether or not the Mockupfile has been loaded
+    def loaded?
+      @loaded
+    end
+    
+    def release
+      if block_given?
+        yield(self.project.release)
+      end
+      self.project.release      
+    end
+    
+    def serve
+      if block_given?
+        yield(self.project.server)
+      end
+      self.project.server      
+    end
+    
+    alias :server :serve
+    
+  end
+end

data/lib/roger/project.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + "/release"
+require File.dirname(__FILE__) + "/server"
+require File.dirname(__FILE__) + "/mockupfile"
+
+module Roger
+  # Loader for mockupfile and project dependencies
+  class Project
+    
+    # @attr :path [Pathname] The project path
+    # @attr :html_path [Pathname] The path of the HTML mockup
+    # @attr :partial_path [Pathname] The path for the partials for this mockup
+    # @attr :mockupfile [Mockupfile] The Mockupfile for this project
+    attr_accessor :path, :html_path, :partial_path, :layouts_path, :mockupfile
+    
+    attr_accessor :shell
+    
+    attr_accessor :options
+    
+    def initialize(path, options={})
+      @path = Pathname.new(path)
+      
+      @options = {
+        :html_path => @path + "html",
+        :partial_path => @path + "partials",
+        :layouts_path => @path + "layouts"
+      }
+      
+      # Clumsy string to symbol key conversion
+      options.each{|k,v| @options[k.is_a?(String) ? k.to_sym : k] = v }
+      
+      self.html_path = @options[:html_path]
+      self.partial_path = @options[:partials_path] || @options[:partial_path] || self.html_path + "../partials/"
+      self.layouts_path = @options[:layouts_path]
+      self.shell = @options[:shell]
+      
+      load_mockup!
+    end
+    
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+    
+    def server
+      options = @options[:server] || {}
+      @server ||= Server.new(self, options)
+    end
+    
+    def release
+      options = @options[:release] || {}      
+      @release ||= Release.new(self, options)
+    end
+    
+    def html_path=(p)
+      @html_path = self.realpath_or_path(p)
+    end
+    
+    def partial_path=(p)
+      @partial_path = self.single_or_multiple_paths(p)
+    end
+    alias :partials_path :partial_path
+    alias :partials_path= :partial_path=
+    
+    def layouts_path=(p)
+      @layouts_path = self.single_or_multiple_paths(p)
+    end
+    
+    protected
+
+    def load_mockup!
+      @mockupfile = Mockupfile.new(self)
+      @mockupfile.load      
+    end
+
+    def single_or_multiple_paths(p)
+      if p.kind_of?(Array)
+        p.map{|tp| self.realpath_or_path(tp) }
+      else
+        self.realpath_or_path(p)
+      end
+    end
+    
+    def realpath_or_path(path)
+      path = Pathname.new(path)
+      if path.exist?
+        path.realpath
+      else
+        path
+      end      
+    end
+    
+  end
+end

data/lib/roger/rack/html_validator.rb

@@ -0,0 +1,26 @@
+require 'rack/request'
+require 'rack/response'
+
+module Roger
+  module Rack
+    class HtmlValidator
+      def initialize(app)
+        @app = app
+      end
+      
+      def call(env)
+        resp = @app.call(env)
+        if resp[1]["Content-Type"].to_s.include?("html")
+          str = ""
+          resp[2].each{|c| str << c}
+          validator = W3CValidator.new(str)
+          validator.validate!
+          if !validator.valid
+            env["rack.errors"].puts "Validation failed on #{env["PATH_INFO"]}: (errors: #{validator.errors}, warnings: #{validator.warnings})"
+          end
+        end
+        resp
+      end    
+    end
+  end
+end

data/lib/roger/rack/roger.rb

@@ -0,0 +1,52 @@
+require 'rack/request'
+require 'rack/response'
+require 'rack/file'
+
+require File.dirname(__FILE__) + '/../resolver'
+
+module Roger
+  module Rack
+    
+    class Roger
+      
+      attr_reader :project
+      
+      def initialize(project)
+        @project = project
+        @docroot = project.html_path
+        
+        @resolver = Resolver.new(@docroot)
+        @file_server = ::Rack::File.new(@docroot)
+      end
+
+      def call(env)
+        url = env["PATH_INFO"]
+        env["MOCKUP_PROJECT"] = project
+        
+        if template_path = @resolver.url_to_path(url)
+          env["rack.errors"].puts "Rendering template #{template_path.inspect} (#{url.inspect})"
+          # begin
+            templ = ::Roger::Template.open(template_path, :partials_path => @project.partials_path, :layouts_path => @project.layouts_path)
+            mime = ::Rack::Mime.mime_type(File.extname(template_path), 'text/html')
+            resp = ::Rack::Response.new do |res|
+              res.headers["Content-Type"] = mime if mime
+              res.status = 200
+              res.write templ.render(env)
+            end
+            resp.finish
+          # rescue StandardError => e
+          #   env["rack.errors"].puts "#{e.message}\n #{e.backtrace.join("\n")}\n\n"
+          #   resp = ::Rack::Response.new do |res|
+          #     res.status = 500
+          #     res.write "An error occurred"
+          #   end
+          #   resp.finish
+          # end
+        else
+          env["rack.errors"].puts "Invoking file handler for #{url.inspect}"
+          @file_server.call(env)
+        end
+      end    
+    end
+  end
+end

data/lib/roger/rack/sleep.rb

@@ -0,0 +1,21 @@
+module Roger
+  module Rack
+    # Listens to the "sleep" parameter and sleeps the amount of seconds specified by the parameter. There is however a maximum of 5 seconds.
+    class Sleep
+  
+      def initialize(app)
+        @app = app
+      end
+  
+      def call(env)
+        r = ::Rack::Request.new(env)
+        if r.params["sleep"]
+          sleeptime = [r.params["sleep"].to_i, 5].min
+          sleep sleeptime
+        end
+        @app.call(env)
+      end
+  
+    end
+  end
+end

data/lib/roger/release/cleaner.rb

@@ -0,0 +1,47 @@
+module Roger
+  class Release::Cleaner
+    def initialize(pattern)
+      @pattern = pattern
+    end
+    
+    def call(release, options = {})
+      # We switch to the build path and append the globbed files for safety, so even if you manage to sneak in a
+      # pattern like "/**/*" it won't do you any good as it will be reappended to the path
+      Dir.chdir(release.build_path.to_s) do
+        Dir.glob(@pattern).each do |file|
+          path = File.join(release.build_path.to_s, file)
+          if is_inside_build_path(release.build_path, path)
+            release.log(self, "Cleaning up \"#{path}\" in build")
+            rm_rf(path)
+          else
+            release.log(self, "FAILED cleaning up \"#{path}\" in build")
+          end
+        end
+      end
+    end
+
+    protected
+
+    def is_inside_build_path(build_path, path)     
+      
+      begin 
+        build_path = Pathname.new(build_path).realpath.to_s
+        path = Pathname.new(path)
+        if(path.absolute?)
+          path = path.realpath.to_s
+        else
+          path = Pathname.new(File.join(build_path.to_s, path)).realpath.to_s
+        end
+      rescue Errno::ENOENT
+        # Real path does not exist
+        return false
+      end
+      
+      if path[build_path]
+        return true
+      else
+        raise RuntimeError, "Cleaning pattern is not inside build directory"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fileutils'
+
+module Roger::Release::Finalizers
+  
+  # Finalizes the release into a directory in target_path
+  # 
+  # The directory name will have the format PREFIX-VERSION
+  #  
+  class Dir < Base    
+    # @option options :prefix Prefix to put before the version (default = "html")
+    def call(release, options = {})
+      if options
+        options = @options.dup.update(options)
+      else
+        options = @options
+      end
+
+      name = [(options[:prefix] || "html"), release.scm.version].join("-")      
+      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
+      
+      FileUtils.cp_r release.build_path, release.target_path + name
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# Finalizes the release into a specific branch of a repository and pushes it
+#
+class GitBranch < Roger::Release::Finalizers::Base
+ 
+  # @param Hash options The options
+  #
+  # @option options String :remote The remote repository (default is the origin of the current repository)
+  # @option options String :branch The remote branch (default is "gh-pages")
+  # @option options Boolean :cleanup Cleanup temp dir afterwards (default is true)  
+  # @option options Boolean :push Push to remote (default is true)    
+  def initialize(options={})
+    @options = {
+      :remote => nil,
+      :branch => "gh-pages",
+      :cleanup => true,
+      :push => true
+    }
+  end
+  
+  
+  def call(release, options = {})
+    options = @options.dup.update(options)  
+    git_dir = find_git_dir(release.project.path)
+    
+    # 0. Get remote
+    unless remote = (options[:remote] || `git --git-dir=#{git_dir} config --get remote.origin.url`).strip
+      raise "No remote found for origin"
+    end
+    
+    e_remote = Shellwords.escape(remote)
+    e_branch = Shellwords.escape(options[:branch])
+
+    tmp_dir = Pathname.new(Dir.mktmpdir)
+    clone_dir = tmp_dir + "clone"
+    
+    # Check if remote already has branch
+    if `git ls-remote --heads #{e_remote} refs/heads/#{e_branch}` == ""
+      release.log(self, "Creating empty branch")
+      # Branch does not exist yet
+      FileUtils.mkdir(clone_dir)
+      Dir.chdir(clone_dir) do
+        `git init`
+        `git remote add origin #{e_remote}`
+        `git checkout -b #{e_branch}`
+      end
+    else
+      release.log(self, "Cloning existing repo")
+      # 1. Clone into different directory      
+      `git clone #{e_remote} --branch #{e_branch} --single-branch #{clone_dir}`
+    end
+    
+    release.log(self, "Working git magic in #{clone_dir}")
+    Dir.chdir(clone_dir) do
+      # 3. Copy changes
+      FileUtils.rm_rf("*")
+      FileUtils.cp_r release.build_path.to_s + "/.", clone_dir.to_s
+      
+      # 4. Add all files
+      `git add .`
+    
+      # 5. Commit
+      `git commit -a -m "Release #{release.scm.version}"`
+
+      # 6. Git push
+      if options[:push]
+        `git push origin #{e_branch}`
+      end
+    end
+    
+    if options[:cleanup]
+      FileUtils.rm_rf(tmp_dir)
+    end
+    
+  end
+  
+  protected
+  
+  # Find the git dir
+  # TODO this is just a copy from release/scm/git.rb 
+  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