grimen-packr 3.1.2

data/History.txt

@@ -0,0 +1,20 @@
+=== 3.1.1 / 2011-07-19
+
+* Remove dependency on Hoe
+
+=== 3.1.0 / 2009-02-22
+
+* Project is now a gem, not a Rails plugin
+* Improved local variable compression
+* Private field obfuscation
+* Changed variable protection, protected variables must be supplied
+  as options to Packr#pack.
+
+=== 1.0.2 / 2007-12-13
+
+* Added variable protection, protecting $super for use with Prototype
+
+=== 1.0.0 / 2007-12-04
+
+* Initial release, compatible with Packer 3.0
+

data/README.rdoc

@@ -0,0 +1,108 @@
+= PackR
+
+* http://github.com/jcoglan/packr
+* http://dean.edwards.name/packer/
+* http://base2.googlecode.com
+
+
+== Description
+
+PackR is a Ruby version of Dean Edwards' JavaScript compressor.
+
+
+== Features
+
+* Whitespace and comment removal
+* Compression of local variable names
+* Compression and obfuscation of 'private' (_underscored) identifiers
+* Base-62 encoding
+
+
+== Synopsis
+
+To call from within a Ruby program:
+
+  require 'packr'
+  
+  code = File.read('my_script.js')
+  compressed = Packr.pack(code)
+  File.open('my_script.min.js', 'wb') { |f| f.write(compressed) }
+
+This method takes a number of options to control compression, for example:
+
+  compressed = Packr.pack(code, :shrink_vars => true, :base62 => true)
+
+The full list of available options is:
+
+* <tt>:shrink_vars</tt> -- set to +true+ to compress local variable names
+* <tt>:private</tt> -- set to +true+ to obfuscate 'private' identifiers, i.e.
+  names beginning with a single underscore
+* <tt>:base62</tt> -- encode the program using base 62
+* <tt>:protect</tt> -- an array of variable names to protect from compression, e.g.
+
+  compressed = Packr.pack(code, :shrink_vars => true,
+                                :protect => %w[$super self])
+
+To call from the command line (use <tt>packr --help</tt> to see available
+options):
+
+  packr my_script.js > my_script.min.js
+
+
+== Notes
+
+This program is not a JavaScript parser, and rewrites your files using regular
+expressions. Be sure to include semicolons and braces everywhere they are
+required so that your program will work correctly when packed down to a single
+line.
+
+By far the most efficient way to serve JavaScript over the web is to use PackR
+with the --shrink-vars flag, combined with gzip compression. If you don't have
+access to your server config to set up mod_deflate, you can generate gzip files
+using (on Unix-like systems):
+
+  packr -s my-file.js | gzip > my-file.js.gz
+  
+You can then get Apache to serve the files by putting this in your .htaccess
+file:
+
+  AddEncoding gzip .gz
+  RewriteCond %{HTTP:Accept-encoding} gzip
+  RewriteCond %{HTTP_USER_AGENT} !Safari
+  RewriteCond %{REQUEST_FILENAME}.gz -f
+  RewriteRule ^(.*)$ $1.gz [QSA,L]
+
+If you really cannot serve gzip files, use the --base62 option to further
+compress your code. This mode is at its best when compressing large files with
+many repeated tokens.
+
+The --private option can be used to stop other programs calling private methods
+in your code by renaming anything beginning with a single underscore. Beware
+that you should not use this if the generated file contains 'private' methods
+that need to be accessible by other files. Also know that all the files that
+access any particular private method must be compressed together so they all get
+the same rewritten name for the private method.
+
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2004-2011 Dean Edwards, James Coglan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the 'Software'), to deal in
+the Software without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/packr

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'oyster'
+require File.expand_path('../../lib/packr', __FILE__)
+
+spec = Oyster.spec do
+  name    "packr -- JavaScript code compressor based on Dean Edwards' Packer"
+  
+  synopsis <<-EOS
+  packr [OPTIONS] INPUT_FILES > OUTPUT_FILE
+  cat INPUT_FILES | packr [OPTIONS] > OUTPUT_FILE
+  EOS
+  
+  description <<-EOS
+  PackR is a program for compressing JavaScript programs. It can remove
+  whitespace and comments, compress local variable names, compress/obfuscate
+  private identifiers, and encode the program in base-62.
+  
+  When invoked from the command line, it concatenates all the code in
+  INPUT_FILES (or from standard input) and compresses the code using the given
+  options, printing the result to standard output. You can pipe this output into
+  another file to save it.
+  EOS
+  
+  flag    :'shrink-vars',   :default => true,
+  :desc => 'Shrink local variable names inside functions'
+  
+  flag    :private,         :default => false,
+  :desc => 'Obfuscate private identifiers, i.e. names beginning with a single underscore'
+  
+  flag    :base62,          :default => false,
+  :desc => 'Encode the program using base 62'
+  
+  array   :protect,         :default => [],
+  :desc => 'List of variable names to protect from compression when using --shrink-vars'
+  
+  notes <<-EOS
+  This program is not a JavaScript parser, and rewrites your files using regular
+  expressions. Be sure to include semicolons and braces everywhere they are
+  required so that your program will work correctly when packed down to a single
+  line.
+  
+  By far the most efficient way to serve JavaScript over the web is to use PackR
+  with the --shrink-vars flag, combined with gzip compression. If you don't have
+  access to your server config to set up mod_deflate, you can generate gzip
+  files using (on Unix-like systems):
+  
+    packr -s my-file.js | gzip > my-file.js.gz
+    
+  You can then get Apache to serve the files by putting this in your .htaccess
+  file:
+  
+    AddEncoding gzip .gz
+    RewriteCond %{HTTP:Accept-encoding} gzip
+    RewriteCond %{HTTP_USER_AGENT} !Safari
+    RewriteCond %{REQUEST_FILENAME}.gz -f
+    RewriteRule ^(.*)$ $1.gz [QSA,L]
+  
+  If you really cannot serve gzip files, use the --base62 option to further
+  compress your code. This mode is at its best when compressing large files with
+  many repeated tokens.
+  
+  The --private option can be used to stop other programs calling private
+  methods in your code by renaming anything beginning with a single underscore.
+  Beware that you should not use this if the generated file contains 'private'
+  methods that need to be accessible by other files. Also know that all the
+  files that access any particular private method must be compressed together so
+  they all get the same rewritten name for the private method.
+  EOS
+  
+  author <<-EOS
+  Original JavaScript version by Dean Edwards, Ruby port by James Coglan <jcoglan@googlemail.com>
+  EOS
+  
+  copyright <<-EOS
+  Copyright (c) 2004-2011 Dean Edwards, James Coglan. This program is free
+  software, distributed under the MIT license.
+  EOS
+end
+
+begin
+  opts = spec.parse
+  
+  inputs = opts[:unclaimed]
+  code = inputs.empty? ?
+      $stdin.read :
+      inputs.map { |f| File.read(f) }.join("\n")
+  
+  $stdout.puts Packr.pack(code,
+    :shrink_vars => !!opts[:'shrink-vars'],
+    :protect     => opts[:protect],
+    :private     => !!opts[:private],
+    :base62      => !!opts[:base62])
+  
+rescue Oyster::HelpRendered
+end

data/lib/packr.rb

@@ -0,0 +1,55 @@
+module Packr
+
+  autoload :Map,         'packr/map'
+  autoload :Collection,  'packr/collection'
+  autoload :RegexpGroup, 'packr/regexp_group'
+  autoload :Encoder,     'packr/encoder'
+  autoload :Parser,      'packr/parser'
+  autoload :Minifier,    'packr/minifier'
+  autoload :Privates,    'packr/privates'
+  autoload :Shrinker,    'packr/shrinker'
+  autoload :Words,       'packr/words'
+  autoload :Base62,      'packr/base62'
+  autoload :Engine,      'packr/engine'
+
+  IGNORE = RegexpGroup::IGNORE
+  REMOVE = ""
+  SPACE = " "
+
+  DATA = Parser.new.
+    put("STRING1", IGNORE).
+    put('STRING2', IGNORE).
+    put("CONDITIONAL", IGNORE). # conditional comments
+    put("(OPERATOR)\\s*(REGEXP)", "\\1\\2")
+
+  def self.encode62(c)
+    (c < 62 ? '' : encode62((c / 62.0).to_i)) +
+        ((c = c % 62) > 35 ? (c+29).chr : c.to_s(36))
+  end
+
+  def self.encode52(c)
+    # Base52 encoding (a-Z)
+    encode = lambda do |d|
+      (d < 52 ? '' : encode.call((d / 52.0).to_i)) +
+          ((d = d % 52) > 25 ? (d + 39).chr : (d + 97).chr)
+    end
+    encoded = encode.call(c.to_i)
+    encoded = encoded[1..-1] + '0' if encoded =~ /^(do|if|in)$/
+    encoded
+  end
+
+  def self.rescape(string)
+    string.gsub(/([\/()\[\]{}|*+-.,^$?\\])/) { |m| "\\#{$1}" }
+  end
+
+  def self.pack(script, options = {})
+    @packr ||= Packr::Engine.new
+    @packr.pack(script, options)
+  end
+
+  def self.new
+    Packr::Engine.new
+  end
+
+end
+

data/lib/packr/base62.rb

@@ -0,0 +1,150 @@
+module Packr
+  class Base62 < Encoder
+
+    WORDS    = /\b[\da-zA-Z]\b|\w{2,}/
+
+    ENCODE10 = "String"
+    ENCODE36 = "function(c){return c.toString(36)}"
+    ENCODE62 = "function(c){return(c<62?'':e(parseInt(c/62)))+((c=c%62)>35?String.fromCharCode(c+29):c.toString(36))}"
+
+    UNPACK = lambda do |p,a,c,k,e,r|
+      "eval(function(p,a,c,k,e,r){e=#{e};if('0'.replace(0,e)==0){while(c--)r[e(c)]=k[c];" +
+          "k=[function(e){return r[e]||e}];e=function(){return'#{r}'};c=1};while(c--)if(k[c])p=p." +
+          "replace(new RegExp('\\\\b'+e(c)+'\\\\b','g'),k[c]);return p}('#{p}',#{a},#{c},'#{k}'.split('|'),0,{}))"
+    end
+
+    def encode(script)
+      words = search(script)
+      words.sort!
+
+      encoded = Collection.new # a dictionary of base62 -> base10
+      words.size.times { |i| encoded.put(Packr.encode62(i), i) }
+
+      replacement = lambda { |word| words.get(word).replacement }
+
+      index = 0
+      words.each do |word, key|
+        if encoded.has?(word)
+          word.index = encoded.get(word)
+          def word.to_s; ""; end
+        else
+          index += 1 while words.has?(Packr.encode62(index))
+          word.index = index
+          index += 1
+          if word.count == 1
+            def word.to_s; ""; end
+          end
+        end
+        word.replacement = Packr.encode62(word.index)
+        if word.replacement.length == word.to_s.length
+          def word.to_s; ""; end
+        end
+      end
+
+      # sort by encoding
+      words.sort! { |word1, word2| word1.index - word2.index }
+
+      # trim unencoded words
+      words = words.slice(0, get_key_words(words).split("|").length)
+
+      script = script.gsub(get_pattern(words), &replacement)
+
+      # build the packed script
+
+      p = escape(script)
+      a = "[]"
+      c = get_count(words)
+      k = get_key_words(words)
+      e = get_encoder(words)
+      d = get_decoder(words)
+
+      # the whole thing
+      UNPACK.call(p,a,c,k,e,d)
+    end
+
+    def search(script)
+      words = Words.new
+      script.scan(WORDS).each { |word| words.add(word) }
+      words
+    end
+
+    def escape(script)
+      # Single quotes wrap the final string so escape them.
+      # Also, escape new lines (required by conditional comments).
+      script.gsub(/([\\'])/) { |match| "\\#{$1}" }.gsub(/[\r\n]+/, "\\n")
+    end
+
+    def get_count(words)
+      size = words.size
+      size.zero? ? 1 : size
+    end
+
+    def get_decoder(words)
+      # returns a pattern used for fast decoding of the packed script
+      trim = RegexpGroup.new.
+        put("(\\d)(\\|\\d)+\\|(\\d)", "\\1-\\3").
+        put("([a-z])(\\|[a-z])+\\|([a-z])", "\\1-\\3").
+        put("([A-Z])(\\|[A-Z])+\\|([A-Z])", "\\1-\\3").
+        put("\\|", "")
+
+      pattern = trim.exec(words.map { |word, key|
+        word.to_s.empty? ? "" : word.replacement
+      }[0...62].join("|"))
+
+      return "^$" if pattern.empty?
+
+      pattern = "[#{pattern}]"
+
+      size = words.size
+      if size > 62
+        pattern = "(#{pattern}|"
+        c = Packr.encode62(size)[0].chr
+        if c > "9"
+          pattern += "[\\\\d"
+          if c >= "a"
+            pattern += "a"
+            if c >= "z"
+              pattern += "-z"
+              if c >= "A"
+                pattern += "A"
+                pattern += "-#{c}" if c > "A"
+              end
+            elsif c == "b"
+              pattern += "-#{c}"
+            end
+          end
+          pattern += "]"
+        elsif c == "9"
+          pattern += "\\\\d"
+        elsif c == "2"
+          pattern += "[12]"
+        elsif c == "1"
+          pattern += "1"
+        else
+          pattern += "[1-#{c}]"
+        end
+
+        pattern += "\\\\w)"
+      end
+      pattern
+    end
+
+    def get_encoder(words)
+      c = words.size
+      self.class.const_get("ENCODE#{c > 10 ? (c > 36 ? 62 : 36) : 10}")
+    end
+
+    def get_key_words(words)
+      words.map { |word, key| word.to_s }.join("|").gsub(/\|+$/, "")
+    end
+
+    def get_pattern(words)
+      words = words.map { |word, key| word.to_s }.join("|").gsub(/\|{2,}/, "|").gsub(/^\|+|\|+$/, "")
+      words = "\\x0" if words == ""
+      string = "\\b(#{words})\\b"
+      %r{#{string}}
+    end
+
+  end
+end
+

data/lib/packr/collection.rb

@@ -0,0 +1,147 @@
+module Packr
+  # A Map that is more array-like (accessible by index).
+  class Collection < Map
+
+    attr_reader :values
+    attr_writer :keys
+
+    def initialize(values = nil)
+      @keys = []
+      super(values)
+    end
+
+    def add(key, item = nil)
+      # Duplicates not allowed using add().
+      # But you can still overwrite entries using put().
+      return if has?(key)
+      put(key, item)
+    end
+
+    def clear
+      super
+      @keys.clear
+    end
+
+    def copy
+      copy = super
+      copy.keys = @keys.dup
+      copy
+    end
+
+    def each
+      @keys.each { |key| yield(get(key), key) }
+    end
+
+    def get_at(index)
+      index += @keys.length if index < 0 # starting from the end
+      key = @keys[index]
+      key.nil? ? nil : @values[key.to_s]
+    end
+
+    def get_keys
+      @keys.dup
+    end
+
+    def index_of(key)
+      @keys.index(key.to_s)
+    end
+
+    def insert_at(index, key, item = nil)
+      return if @keys[index].nil?
+      @keys.insert(index, key.to_s)
+      @values[key.to_s] = nil # placeholder
+      put(key, item)
+    end
+
+    def item(key_or_index)
+      __send__(key_or_index.is_a?(Numeric) ? :get_at : :get, key_or_index)
+    end
+
+    def map
+      @keys.map { |key| yield(get(key), key) }
+    end
+
+    def merge(*args)
+      args.each do |values|
+        values.is_a?(Collection) ?
+            values.each { |item, key| put(key, item) } :
+            super(values)
+      end
+      self
+    end
+
+    # TODO update this method
+    def put(key, item = nil)
+      item ||= key
+      @keys << key.to_s unless has?(key.to_s)
+      begin; klass = self.class::Item; rescue; end
+      item = self.class.create(key, item) if klass and !item.is_a?(klass)
+      @values[key.to_s] = item
+      self
+    end
+
+    def put_at(index, item = nil)
+      key = @keys[index]
+      return if key.nil?
+      put(key, item)
+    end
+
+    def remove(key)
+      if has?(key)
+        @keys.delete(key.to_s)
+        @values.delete(key.to_s)
+      end
+    end
+
+    def remove_at(index)
+      key = @keys.delete_at(index)
+      @values.delete(key)
+    end
+
+    def reverse!
+      @keys.reverse!
+      self
+    end
+
+    def size
+      @keys.length
+    end
+
+    def slice(start, fin)
+      sliced = copy
+      if start
+        keys, removed = @keys, @keys
+        sliced.keys = @keys[start...fin]
+        if sliced.size.nonzero?
+          removed = removed[0...start]
+          removed = removed + keys[fin..-1] if fin
+        end
+        removed.each do |remov|
+          sliced.values.delete(remov)
+        end
+      end
+      sliced
+    end
+
+    def sort!(&compare)
+      if block_given?
+        @keys.sort! do |key1, key2|
+          compare.call(@values[key1], @values[key2], key1, key2)
+        end
+      else
+        @keys.sort!
+      end
+      self
+    end
+
+    def to_s
+      "(#{@keys.join(',')})"
+    end
+
+    def self.create(key, item)
+      begin; klass = self::Item; rescue; end
+      klass ? klass.new(key, item) : item
+    end
+
+  end
+end