html_mockup 0.4.0 → 0.5.0

data/lib/html_mockup/release/processors/yuicompressor.rb

@@ -0,0 +1,53 @@
+# Use the ruby-yui-compressor gem.
+require 'yui/compressor'
+
+module HtmlMockup::Release::Processors
+  class Yuicompressor < Base
+    
+    # Compresses all JS and CSS files, it will keep all lines before
+    # 
+    #     /* -------------------------------------------------------------------------------- */
+    # 
+    # (80 dashes)
+    #
+    # @options options [Array] match Files to match, default to ["**/*.{css,js}"]
+    # @options options [Regexp] :delimiter An array of header delimiters. Defaults to the one above. The delimiter will be removed from the output.
+    # @options options [Array[Regexp]] :skip An array of file regular expressions to specifiy which files to skip. Defaults to [/javascripts\/vendor\/.\*.js\Z/, /_doc\/.*/]
+    def call(release, options={})
+      options = {
+        :match => ["**/*.{css,js}"],
+        :skip =>  [/javascripts\/vendor\/.*\.js\Z/, /_doc\/.*/],
+        :delimiter => Regexp.escape("/* -------------------------------------------------------------------------------- */")
+      }.update(options)
+      
+      compressor_options = {:line_break => 80}
+      css_compressor = YUI::CssCompressor.new(compressor_options) 
+      js_compressor = YUI::JavaScriptCompressor.new(compressor_options)
+      
+      # Add version numbers and minify the files
+      release.get_files(options[:match], options[:skip]).each do |f|
+        type = f[/\.(.+)$/,1]  
+      
+        data = File.read(f);
+        File.open(f,"w") do |fh| 
+          
+          # Extract header and store for later use
+          header = data[/\A(.+?)\n#{options[:delimiter]}\s*\n/m,1]
+          minified = [header]
+    
+          # Actual minification
+          release.log self,  "Minifying #{f}"
+          case type
+          when "css"
+            minified << css_compressor.compress(data)
+          when "js"
+            minified << js_compressor.compress(data)
+          end
+    
+          fh.write minified.join("\n")
+        end
+      end
+      
+    end
+  end
+end

data/lib/html_mockup/release/processors.rb

@@ -0,0 +1,11 @@
+module HtmlMockup::Release::Processors
+  class Base    
+    def call(release, options = {})
+      raise ArgumentError, "Implement in subclass"
+    end
+  end
+end
+
+require File.dirname(__FILE__) + "/finalizers/zip"
+require File.dirname(__FILE__) + "/finalizers/dir"
+

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

@@ -0,0 +1,101 @@
+require 'pathname'
+
+module HtmlMockup::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" --quiet 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" --quiet 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/html_mockup/release/scm.rb

@@ -0,0 +1,32 @@
+module HtmlMockup::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 HtmlMockup::Release::Scm The previous version
+    def previous
+      raise "Implement in subclass"      
+    end
+    
+  end
+end
+
+require File.dirname(__FILE__) + "/scm/git"

data/lib/html_mockup/release.rb

@@ -0,0 +1,312 @@
+require File.dirname(__FILE__) + "/cli"
+
+module HtmlMockup
+  class Release
+    
+    attr_reader :config, :project
+    
+    attr_reader :finalizers, :injections, :stack, :cleanups
+    
+    def self.default_stack
+      []
+    end    
+    
+    def self.default_finalizers
+      [[:dir, {}]]
+    end
+            
+    # @option config [Symbol] :scm The SCM to use (default = :git)
+    # @option config [String, Pathname] :target_path The path/directory to put the release into
+    # @option config [String, Pathname]:build_path Temporary path used to build the release
+    # @option config [Boolean] :cleanup_build Wether or not to remove the build_path after we're done (default = true)
+    def initialize(project, config = {})
+      defaults = {
+        :scm => :git,
+        :source_path  => Pathname.new(Dir.pwd) + "html",
+        :target_path => Pathname.new(Dir.pwd) + "releases",
+        :build_path => Pathname.new(Dir.pwd) + "build",
+        :cleanup_build => true
+      }
+      
+      @config = {}.update(defaults).update(config)
+      @project = project
+      @finalizers = []
+      @injections = []
+      @stack = []
+      @cleanups = []
+    end
+    
+    # Accessor for target_path
+    # The target_path is the path where the finalizers will put the release
+    #
+    # @return Pathname the target_path
+    def target_path
+      Pathname.new(self.config[:target_path])
+    end
+    
+    # Accessor for build_path
+    # The build_path is a temporary directory where the release will be built
+    #
+    # @return Pathname the build_path    
+    def build_path
+      Pathname.new(self.config[:build_path])      
+    end
+    
+    # Accessor for source_path
+    # The source path is the root of the mockup
+    #
+    # @return Pathanem the source_path
+    def source_path
+      Pathname.new(self.config[:source_path])
+    end
+    
+    # Get the current SCM object
+    def scm(force = false)
+      return @_scm if @_scm && !force
+      
+      case self.config[:scm]
+      when :git
+        @_scm = Release::Scm::Git.new(:path => self.source_path)
+      else
+        raise "Unknown SCM #{options[:scm].inspect}"
+      end
+    end
+    
+    # Inject variables into files with an optional filter
+    # 
+    # @examples
+    #   release.inject({"VERSION" => release.version, "DATE" => release.date}, :into => %w{_doc/toc.html})
+    #   release.inject({"CHANGELOG" => {:file => "", :filter => BlueCloth}}, :into => %w{_doc/changelog.html})  
+    def inject(variables, options)
+      @injections << [variables, options]
+    end
+    
+    # Use a certain pre-processor
+    #
+    # @examples
+    #   release.use :sprockets, sprockets_config
+    def use(processor, options = {})
+      @stack << [processor, options]
+    end
+    
+    # Write out the whole release into a directory, zip file or anything you can imagine
+    # #finalize can be called multiple times, it just will run all of them. 
+    #
+    # The default finalizer is :dir
+    #
+    # @param [Symbol, Proc] Finalizer to use
+    #
+    # @examples
+    #   release.finalize :zip
+    def finalize(finalizer, options = {})
+      @finalizers << [finalizer, options]
+    end
+    
+    # Files to clean up in the build directory just before finalization happens
+    #
+    # @param [String] Pattern to glob within build directory
+    #
+    # @examples
+    #   release.cleanup "**/.DS_Store"
+    def cleanup(pattern)
+      @cleanups << pattern
+    end
+    
+    # Generates a banner if a block is given, or returns the currently set banner.
+    # It automatically takes care of adding comment marks around the banner.
+    #
+    # The default banner looks like this:
+    #
+    # =======================
+    # = Version : v1.0.0    =
+    # = Date : 2012-06-20   =
+    # =======================
+    #
+    #
+    # @option options [:css,:js,:html,false] :comment Wether or not to comment the output and in what style. (default=js)
+    def banner(options = {}, &block)
+      options = {
+        :comment => :js
+      }.update(options)
+      
+      if block_given?
+        @_banner = yield.to_s
+      elsif !@_banner
+        banner = []
+        banner << "Version : #{self.scm.version}"
+        banner << "Date  : #{self.scm.date.strftime("%Y-%m-%d")}"
+
+        size = banner.inject(0){|mem,b| b.size > mem ? b.size : mem }
+        banner.map!{|b| "= #{b.ljust(size)} =" }
+        div = "=" * banner.first.size
+        banner.unshift(div)
+        banner << div
+        @_banner = banner.join("\n")
+      end
+      
+      if options[:comment]
+        self.comment(@_banner, :style => options[:comment])
+      else
+        @_banner
+      end
+    end
+    
+    # Actually perform the release
+    def run!
+      # Validate paths
+      validate_paths!
+      
+      # Extract valid mockup
+      extract!
+      
+      # Run stack
+      run_stack!
+            
+      # Run injections
+      run_injections!
+      
+      # Run cleanups
+      run_cleanups!
+      
+      # Run finalizers
+      run_finalizers!
+      
+      # Cleanup
+      cleanup! if self.config[:cleanup_build]
+      
+    end    
+    
+    def log(part, msg)
+      puts part.class.to_s + " : " + msg.to_s
+    end
+    
+    # @param [Array] globs an array of file path globs that will be globbed against the build_path
+    # @param [Array] excludes an array of regexps that will be excluded from the result
+    def get_files(globs, excludes = [])
+      files = globs.map{|g| Dir.glob(self.build_path + g) }.flatten
+      if excludes.any?
+        files.reject{|c| excludes.detect{|e| e.match(c) } }
+      else
+        files
+      end
+    end
+    
+    protected
+    
+    # ==============
+    # = The runway =
+    # ==============
+    
+    def validate_paths!
+      # Make sure the build_path is empty
+      raise ArgumentError, "Build path \"#{self.build_path}\" is not empty" if self.build_path.exist?
+        
+      # Make sure the target_path exists
+      raise ArgumentError, "Target path \"#{self.target_path}\" does not exist" if !self.target_path.exist?      
+    end
+    
+    def extract!
+      extractor = Extractor.new(self.project, self.build_path)
+      extractor.run!
+    end
+    
+    def run_stack!
+      @stack = self.class.default_stack.dup if @stack.empty?
+      @stack.each do |processor, options|
+        get_callable(processor, HtmlMockup::Release::Processors).call(self, options)
+      end
+    end
+        
+    def run_injections!
+      @injections.each do |injection|
+        Injector.new(injection[0], injection[1]).call(self)
+      end
+    end
+    
+    def run_finalizers!
+      @finalizers = self.class.default_finalizers.dup if @finalizers.empty?
+      @finalizers.each do |finalizer, options|
+        get_callable(finalizer, HtmlMockup::Release::Finalizers).call(self, options)
+      end
+    end
+    
+    def run_cleanups!
+      # 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(self.build_path.to_s) do
+        @cleanups.each do |pattern|
+          Dir.glob(pattern).each do |file|
+            path = File.join(self.build_path.to_s, file)
+            log(self, "Cleaning up \"#{path}\" in build")
+            rm(path)
+          end
+        end
+      end
+    end
+    
+    def cleanup!
+      log(self, "Cleaning up build path #{self.build_path}")
+      rm_rf(self.build_path)
+    end
+    
+    # Makes callable into a object that responds to call. 
+    #
+    # @param [#call, Symbol, Class] callable If callable already responds to #call will just return callable, a Symbol will be searched for in the scope parameter, a class will be instantiated (and checked if it will respond to #call)
+    # @param [Module] scope The scope in which to search callable in if it's a Symbol
+    def get_callable(callable, scope)
+      return callable if callable.respond_to?(:call)
+      
+      if callable.kind_of?(Symbol)
+        # TODO camelcase callable
+        callable = callable.to_s.capitalize.to_sym
+        if scope.constants.include?(callable)
+          c = scope.const_get(callable)
+          callable = c if c.is_a?(Class)
+        end
+      end
+      
+      if callable.kind_of?(Class)
+        callable = callable.new
+      end
+      
+      if callable.respond_to?(:call)
+        callable
+      else
+        raise ArgumentError, "Could not resolve #{callable.inspect}. Callable must be an object that responds to #call or a symbol that resolve to such an object or a class with a #call instance method."
+      end
+      
+    end
+    
+    # @param [String] string The string to comment
+    #
+    # @option options [:html, :css, :js] :style The comment style to use (default=:js, which is the same as :css)
+    # @option options [Boolean] :per_line Comment per line or make one block? (default=true)
+    def comment(string, options = {})
+      options = {
+        :style => :css,
+        :per_line => true
+      }.update(options)
+      
+      commenters = {
+        :html => Proc.new{|s| "<!-- #{s} -->" },
+        :css => Proc.new{|s| "/* #{s} */" },
+        :js => Proc.new{|s| "/* #{s} */" }                
+      }
+      
+      commenter = commenters[options[:style]] || commenters[:js]
+      
+      if options[:per_line]
+        string = string.split(/\r?\n/)
+        string.map{|s| commenter.call(s) }.join("\n")
+      else
+        commenter.call(s)
+      end
+    end
+  end
+end
+
+require File.dirname(__FILE__) + "/extractor"
+require File.dirname(__FILE__) + "/release/scm"
+require File.dirname(__FILE__) + "/release/injector"
+require File.dirname(__FILE__) + "/release/finalizers"
+require File.dirname(__FILE__) + "/release/processors"

data/lib/html_mockup/server.rb

@@ -6,17 +6,28 @@ require File.dirname(__FILE__) + "/rack/html_validator"
 
 module HtmlMockup
   class Server
-    attr_accessor :options,:server_options, :root, :partial_path
     
-    def initialize(root,partial_path,options={},server_options={})
+    attr_reader :options
+    
+    attr_accessor :html_path, :partial_path
+    
+    attr_accessor :port, :handler
+    
+    def initialize(html_path, partial_path, options={})
       @stack = ::Rack::Builder.new 
 
       @middleware = []
-      @root = root
+      @html_path = html_path
       @partial_path = partial_path
-      @options,@server_options = options,server_options
+      @options = {
+        :handler => nil, # Autodetect
+        :port => 9000
+      }.update(options)
+      
+      @port = @options[:port]
+      @handler = @options[:handler]
     end
-    
+        
     # Use the specified Rack middleware
     def use(middleware, *args, &block)
       @middleware << [middleware, args, block]
@@ -25,7 +36,7 @@ module HtmlMockup
     def handler
       if self.options[:handler]
         begin
-          @handler = ::Rack::Handler.get(self.options[:handler])
+          @handler = ::Rack::Handler.get(self.handler)
         rescue LoadError
         rescue NameError
         end
@@ -35,9 +46,9 @@ module HtmlMockup
       end
       @handler ||= detect_rack_handler
     end
-    
-    def run
-      self.handler.run self.application, @server_options do |server|
+        
+    def run!
+      self.handler.run self.application, self.server_options do |server|
         trap(:INT) do
           ## Use thins' hard #stop! if available, otherwise just #stop
           server.respond_to?(:stop!) ? server.stop! : server.stop
@@ -45,6 +56,7 @@ module HtmlMockup
         end
       end
     end
+    alias :run :run!
     
     def application
       return @app if @app
@@ -56,7 +68,7 @@ module HtmlMockup
       @middleware.each { |c,a,b| @stack.use(c, *a, &b) }
       
       @stack.use Rack::HtmlValidator if self.options["validate"]
-      @stack.run Rack::HtmlMockup.new(self.root, self.partial_path)
+      @stack.run Rack::HtmlMockup.new(self.html_path, self.partial_path)
       
       @app = @stack.to_app
     end
@@ -64,6 +76,14 @@ module HtmlMockup
     
     protected
     
+    # Generate server options for handler
+    def server_options
+      {
+        :Port => self.port
+      }
+    end
+    
+    
     # Sinatra's detect_rack_handler
     def detect_rack_handler
       servers = %w[mongrel thin webrick]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: html_mockup
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,27 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-27 00:00:00.000000000Z
+date: 2012-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &70245084497540 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 0.16.0
   type: :runtime
   prerelease: false
-  version_requirements: *70245084497540
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.16.0
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &70245084496900 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +37,12 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70245084496900
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: 
 email: flurin@digitpaint.nl
 executables:
@@ -48,8 +58,23 @@ files:
 - examples/partials/test.part.rhtml
 - examples/script/server
 - lib/html_mockup/cli.rb
+- lib/html_mockup/extractor.rb
+- lib/html_mockup/mockupfile.rb
+- lib/html_mockup/project.rb
 - lib/html_mockup/rack/html_mockup.rb
 - lib/html_mockup/rack/html_validator.rb
+- lib/html_mockup/rack/sleep.rb
+- lib/html_mockup/release.rb
+- lib/html_mockup/release/finalizers.rb
+- lib/html_mockup/release/finalizers/dir.rb
+- lib/html_mockup/release/finalizers/zip.rb
+- lib/html_mockup/release/injector.rb
+- lib/html_mockup/release/processors.rb
+- lib/html_mockup/release/processors/requirejs.rb
+- lib/html_mockup/release/processors/sass.rb
+- lib/html_mockup/release/processors/yuicompressor.rb
+- lib/html_mockup/release/scm.rb
+- lib/html_mockup/release/scm/git.rb
 - lib/html_mockup/server.rb
 - lib/html_mockup/template.rb
 - lib/html_mockup/w3c_validator.rb
@@ -66,6 +91,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1984595046850543499
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -74,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: HTML Mockup is a set of tools to create self-containing HTML mockups.