grimen-packr 3.1.2

data/lib/packr/encoder.rb

@@ -0,0 +1,35 @@
+module Packr
+  class Encoder
+
+    def initialize(pattern = nil, encoder = nil, ignore = nil)
+      @parser = Parser.new(ignore)
+      @parser.put(pattern, "") if pattern
+      @encoder = encoder
+    end
+
+    def search(script)
+      words = Words.new
+      @parser.put_at(-1, lambda { |word, *args|
+        words.add(word)
+      })
+      @parser.exec(script)
+      words
+    end
+
+    def encode(script)
+      words = search(script)
+      words.sort!
+      index = 0
+      words.each do |word, key|
+        word.encoded = @encoder.call(index)
+        index += 1
+      end
+      @parser.put_at(-1, lambda { |word, *args|
+        words.get(word).encoded
+      })
+      @parser.exec(script)
+    end
+
+  end
+end
+

data/lib/packr/engine.rb

@@ -0,0 +1,20 @@
+module Packr
+  class Engine
+
+    def initialize
+      @minifier = Minifier.new
+      @shrinker = Shrinker.new
+      @privates = Privates.new
+      @base62   = Base62.new
+    end
+
+    def pack(script, options = {})
+      script = @minifier.minify(script)
+      script = @shrinker.shrink(script, options[:protect]) if options[:shrink_vars]
+      script = @privates.encode(script) if options[:private]
+      script = @base62.encode(script) if options[:base62]
+      script
+    end
+
+  end
+end

data/lib/packr/map.rb

@@ -0,0 +1,66 @@
+module Packr
+  # This is effectively a wrapper for Hash instances - we're including it
+  # to maintain similarity with the JavaScript version for easier maintainance.
+  class Map
+
+    def initialize(values = nil)
+      @values = {}
+      merge(values) unless values.nil?
+    end
+
+    def clear
+      @values.clear
+    end
+
+    def copy
+      self.class.new(@values)
+    end
+
+    def each
+      @values.each { |key, value| yield(value, key) }
+    end
+
+    def get(key)
+      @values[key.to_s]
+    end
+
+    def get_keys
+      @values.keys
+    end
+
+    def get_values
+      @values.values
+    end
+
+    def has?(key)
+      @values.has_key?(key.to_s)
+    end
+
+    def merge(*args)
+      args.each do |values|
+        values = values.get_values if values.is_a?(Map)
+        values.each { |key, value| put(key, value) }
+      end
+      self
+    end
+
+    def remove(key)
+      @values.delete(key.to_s)
+    end
+
+    def put(key, value = nil)
+      value ||= key
+      # Create the new entry (or overwrite the old entry).
+      @values[key.to_s] = value
+    end
+
+    def size
+      @values.length
+    end
+
+    def union(*values)
+      copy.merge(*values)
+    end
+
+  end
+end

data/lib/packr/minifier.rb

@@ -0,0 +1,80 @@
+module Packr
+  class Minifier
+
+    def self.conditional_comments
+      @@conditional_comments
+    end
+
+    def initialize
+      @concat = Packr::CONCAT.union(DATA)
+
+      def @concat.exec(script)
+        parsed = super(script)
+        while parsed != script
+          script = parsed
+          parsed = super(script)
+        end
+        parsed
+      end
+
+      @comments = DATA.union(COMMENTS)
+      @clean = DATA.union(CLEAN)
+      @whitespace = DATA.union(WHITESPACE)
+
+      @@conditional_comments = @comments.copy
+      @@conditional_comments.put_at(-1, " \\3")
+      @whitespace.remove_at(2) # conditional comments
+      @comments.remove_at(2)
+    end
+
+    def minify(script)
+      # packing with no additional options
+      script += "\n"
+      script = script.gsub(CONTINUE, "")
+      script = @comments.exec(script)
+      script = @clean.exec(script)
+      script = @whitespace.exec(script)
+      script = @concat.exec(script)
+      script
+    end
+
+    CONTINUE = /\\\r?\n/
+
+    CLEAN = Parser.new.
+      put("\\(\\s*([^;)]*)\\s*;\\s*([^;)]*)\\s*;\\s*([^;)]*)\\)", "(\\1;\\2;\\3)"). # for (;;) loops
+      put("throw[^};]+[};]", IGNORE). # a safari 1.3 bug
+      put(";+\\s*([};])", "\\1")
+
+    COMMENTS = Parser.new.
+      put(";;;[^\\n]*\\n", REMOVE).
+      put("(COMMENT1)\\n\\s*(REGEXP)?", "\n\\3").
+      put("(COMMENT2)\\s*(REGEXP)?", lambda do |*args|
+        match, comment, b, regexp = args[0..3]
+        if comment =~ /^\/\*@/ and comment =~ /@\*\/$/
+        #  comments = Minifier.conditional_comments.exec(comment)
+        else
+          comment = ""
+        end
+        comment + " " + (regexp || "")
+      end)
+
+    Packr::CONCAT = Parser.new.
+      put("(STRING1)\\+(STRING1)", lambda { |*args| args[1][0...-1] + args[3][1..-1] }).
+      put("(STRING2)\\+(STRING2)", lambda { |*args| args[1][0...-1] + args[3][1..-1] })
+
+    WHITESPACE = Parser.new.
+      put("/\\/\\/@[^\\n]*\\n", IGNORE).
+      put("@\\s+\\b", "@ "). # protect conditional comments
+      put("\\b\\s+@", " @").
+      put("(\\d)\\s+(\\.\\s*[a-z\\$_\\[(])", "\\1 \\2"). # http://dean.edwards.name/weblog/2007/04/packer3/#comment84066
+      put("([+-])\\s+([+-])", "\\1 \\2"). # c = a++ +b;
+      put("\\b\\s+\\$\\s+\\b", " $ "). # var $ in
+      put("\\$\\s+\\b", "$ "). # object$ in
+      put("\\b\\s+\\$", " $"). # return $object
+    # put("\\b\\s+#", " #").   # CSS
+      put("\\b\\s+\\b", SPACE).
+      put("\\s+", REMOVE)
+
+  end
+end
+

data/lib/packr/parser.rb

@@ -0,0 +1,21 @@
+module Packr
+  class Parser < RegexpGroup
+
+    def put(expression, replacement)
+      expression = DICTIONARY.exec(expression) if expression.is_a?(String)
+      super(expression, replacement)
+    end
+
+    # STRING1 requires backslashes to fix concat bug
+    DICTIONARY = RegexpGroup.new.
+      put(:OPERATOR,    /return|typeof|[\[(\^=,{}:;&|!*?]/.source).
+      put(:CONDITIONAL, /\/\*@\w*|\w*@\*\/|\/\/@\w*|@\w+/.source).
+      put(:COMMENT1,    /\/\/[^\n]*/.source).
+      put(:COMMENT2,    /\/\*[^*]*\*+([^\/][^*]*\*+)*\//.source).
+      put(:REGEXP,      /\/(\\[\/\\]|[^*\/])(\\.|[^\/\n\\])*\/[gim]*/.source).
+      put(:STRING1,     /\'(\\.|[^\'\\])*\'/.source).
+      put(:STRING2,     /"(\\.|[^"\\])*"/.source)
+
+  end
+end
+

data/lib/packr/privates.rb

@@ -0,0 +1,19 @@
+module Packr
+  class Privates < Encoder
+
+    IGNORE = {
+      :CONDITIONAL => Packr::IGNORE,
+      "(OPERATOR)(REGXEP)" => Packr::IGNORE
+    }
+
+    PATTERN = /\b_[\da-zA-Z$][\w$]*\b/
+
+    def initialize
+      super(PATTERN, lambda { |index|
+        "_" + Packr.encode62(index)
+      }, IGNORE)
+    end
+
+  end
+end
+

data/lib/packr/regexp_group.rb

@@ -0,0 +1,122 @@
+module Packr
+  class RegexpGroup < Collection
+
+    IGNORE          = "\\0"
+    BACK_REF        = /\\(\d+)/
+    ESCAPE_CHARS    = /\\./
+    ESCAPE_BRACKETS = /\(\?[:=!]|\[[^\]]+\]/
+    BRACKETS        = /\(/
+    LOOKUP          = /\\(\d+)/
+    LOOKUP_SIMPLE   = /^\\\d+$/
+
+    def initialize(values = nil, ignore_case = false)
+      super(values)
+      @ignore_case = !!ignore_case
+    end
+
+    def exec(string, override = nil)
+      string = string.to_s # type-safe
+      return string if @keys.empty?
+      override = 0 if override == IGNORE
+      string.gsub(Regexp.new(self.to_s, @ignore_case && Regexp::IGNORECASE)) do |match|
+        offset, i, result = 1, 0, match
+        arguments = [match] + $~.captures + [$~.begin(0), string]
+        # Loop through the items.
+        each do |item, key|
+          nxt = offset + item.length + 1
+          if arguments[offset] # do we have a result?
+            replacement = override.nil? ? item.replacement : override
+            case replacement
+            when Proc
+              result = replacement.call(*arguments[offset...nxt])
+            when Numeric
+              result = arguments[offset + replacement]
+            else
+              result = replacement
+            end
+          end
+          offset = nxt
+        end
+        result
+      end
+    end
+
+    def insert_at(index, expression, replacement)
+      expression = expression.is_a?(Regexp) ? expression.source : expression.to_s
+      super(index, expression, replacement)
+    end
+
+    def test(string)
+      exec(string) != string
+    end
+
+    def to_s
+      offset = 1
+      "(" + map { |item, key|
+        # Fix back references.
+        expression = item.to_s.gsub(BACK_REF) { |m| "\\" + (offset + $1.to_i) }
+        offset += item.length + 1
+        expression
+      }.join(")|(") + ")"
+    end
+
+    class Item
+      attr_accessor :expression, :length, :replacement
+
+      def initialize(expression, replacement = nil)
+        @expression = expression
+
+        if replacement.nil?
+          replacement = IGNORE
+        elsif replacement.respond_to?(:replacement)
+          replacement = replacement.replacement
+        elsif !replacement.is_a?(Proc)
+          replacement = replacement.to_s
+        end
+
+        # does the pattern use sub-expressions?
+        if replacement.is_a?(String) and replacement =~ LOOKUP
+          # a simple lookup? (e.g. "\2")
+          if replacement.gsub(/\n/, " ") =~ LOOKUP_SIMPLE
+            # store the index (used for fast retrieval of matched strings)
+            replacement = replacement[1..-1].to_i
+          else # a complicated lookup (e.g. "Hello \2 \1")
+            # build a function to do the lookup
+            # Improved version by Alexei Gorkov:
+            q = '"'
+            replacement_string = replacement.
+                gsub(/\\/, "\\\\").
+                gsub(/"/, "\\x22").
+                gsub(/\n/, "\\n").
+                gsub(/\r/, "\\r").
+                gsub(/\\(\d+)/, q + "+(args[\\1]||" + q+q + ")+" + q).
+                gsub(/(['"])\1\+(.*)\+\1\1$/, '\1')
+            replacement = lambda { |*args| eval(q + replacement_string + q) }
+
+            # My old crappy version:
+            # q = (replacement.gsub(/\\./, "") =~ /'/) ? '"' : "'"
+            # replacement = replacement.gsub(/\r/, "\\r").gsub(/\\(\d+)/,
+            #     q + "+(args[\\1]||" + q+q + ")+" + q)
+            # replacement_string = q + replacement.gsub(/(['"])\1\+(.*)\+\1\1$/, '\1') + q
+            # replacement = lambda { |*args| eval(replacement_string) }
+          end
+        end
+
+        @length = RegexpGroup.count(@expression)
+        @replacement = replacement
+      end
+
+      def to_s
+        @expression.respond_to?(:source) ? @expression.source : @expression.to_s
+      end
+    end
+
+    def self.count(expression)
+      # Count the number of sub-expressions in a Regexp/RegexpGroup::Item.
+      expression = expression.to_s.gsub(ESCAPE_CHARS, "").gsub(ESCAPE_BRACKETS, "")
+      expression.scan(BRACKETS).length
+    end
+
+  end
+end
+

data/lib/packr/shrinker.rb

@@ -0,0 +1,123 @@
+module Packr
+  class Shrinker
+
+    ENCODED_DATA = /~\^(\d+)\^~/
+    PREFIX = '@'
+    SHRUNK = /\@\d+\b/
+
+    def decode_data(script)
+      # put strings and regular expressions back
+      script.gsub(ENCODED_DATA) { |match| @strings[$1.to_i] }
+    end
+
+    def encode_data(script)
+      # encode strings and regular expressions
+      @strings = [] # encoded strings and regular expressions
+      DATA.exec(script, lambda { |match, *args|
+        operator, regexp = args[0].to_s, args[1].to_s
+        replacement = "~^#{@strings.length}^~"
+        unless regexp.empty?
+          replacement = operator + replacement
+          match = regexp
+        end
+        @strings << match
+        replacement
+      })
+    end
+
+    def shrink(script, protected_names = [])
+      script = encode_data(script)
+      protected_names ||= []
+      protected_names = protected_names.map { |s| s.to_s }
+
+      # identify blocks, particularly identify function blocks (which define scope)
+      __block         = /((catch|do|if|while|with|function)\b[^~{};]*(\(\s*[^{};]*\s*\))\s*)?(\{[^{}]*\})/
+      __brackets      = /\{[^{}]*\}|\[[^\[\]]*\]|\([^\(\)]*\)|~[^~]+~/
+      __encoded_block = /~#?(\d+)~/
+      __identifier    = /[a-zA-Z_$][\w\$]*/
+      __scoped        = /~#(\d+)~/
+      __var           = /\bvar\b/
+      __vars          = /\bvar\s+[\w$]+[^;#]*|\bfunction\s+[\w$]+/
+      __var_tidy      = /\b(var|function)\b|\sin\s+[^;]+/
+      __var_equal     = /\s*=[^,;]*/
+
+      blocks = [] # store program blocks (anything between braces {})
+      total = 0
+      # decoder for program blocks
+      decode_blocks = lambda do |script, encoded|
+        script = script.gsub(encoded) { |match| blocks[$1.to_i] } while script =~ encoded
+        script
+      end
+
+      # encoder for program blocks
+      encode_blocks = lambda do |match|
+        prefix, block_type, args, block = $1 || "", $2, $3, $4
+        if block_type == 'function'
+          # decode the function block (THIS IS THE IMPORTANT BIT)
+          # We are retrieving all sub-blocks and will re-parse them in light
+          # of newly shrunk variables
+          block = args + decode_blocks.call(block, __scoped)
+          prefix = prefix.gsub(__brackets, "")
+
+          # create the list of variable and argument names
+          args = args[1...-1]
+
+          if args != '_no_shrink_'
+            vars = block.scan(__vars).join(";").gsub(__var, ";var")
+            vars = vars.gsub(__brackets, "") while vars =~ __brackets
+            vars = vars.gsub(__var_tidy, "").gsub(__var_equal, "")
+          end
+          block = decode_blocks.call(block, __encoded_block)
+
+          # process each identifier
+          if args != '_no_shrink_'
+            count, short_id = 0, nil
+            ids = [args, vars].join(",").scan(__identifier)
+            processed = {}
+            ids.each do |id|
+              if !processed['#' + id] and !protected_names.include?(id)
+                processed['#' + id] = true
+                id = Packr.rescape(id)
+                # encode variable names
+                count += 1 while block =~ Regexp.new("#{PREFIX}#{count}\\b")
+                reg = Regexp.new("([^\\w$.])#{id}([^\\w$:])")
+                block = block.gsub(reg, "\\1#{PREFIX}#{count}\\2") while block =~ reg
+                reg = Regexp.new("([^{,\\w$.])#{id}:")
+                block = block.gsub(reg, "\\1#{PREFIX}#{count}:")
+                count += 1
+              end
+            end
+            total = [total, count].max
+          end
+          replacement = "#{prefix}~#{blocks.length}~"
+          blocks << block
+        else
+          replacement = "~##{blocks.length}~"
+          blocks << (prefix + block)
+        end
+        replacement
+      end
+
+      # encode blocks, as we encode we replace variable and argument names
+      script = script.gsub(__block, &encode_blocks) while script =~ __block
+
+      # put the blocks back
+      script = decode_blocks.call(script, __encoded_block)
+
+      short_id, count = nil, 0
+      shrunk = Encoder.new(SHRUNK, lambda { |object|
+        # find the next free short name
+        begin
+          short_id = Packr.encode52(count)
+          count += 1
+        end while script =~ Regexp.new("[^\\w$.]#{short_id}[^\\w$:]")
+        short_id
+      })
+      script = shrunk.encode(script)
+
+      decode_data(script)
+    end
+
+  end
+end
+