packr 1.0.2 → 3.1.0

data/lib/packr/base62.rb

@@ -0,0 +1,150 @@
+class 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 @@
+class 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

data/lib/packr/constants.rb

@@ -0,0 +1,8 @@
+class Packr
+  
+  IGNORE  = RegexpGroup::IGNORE
+  REMOVE  = ""
+  SPACE   = " "
+  
+end
+

data/lib/packr/encoder.rb

@@ -0,0 +1,35 @@
+class 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/map.rb

@@ -0,0 +1,66 @@
+class 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 @@
+class Packr
+  class Minifier
+    
+    def self.conditional_comments
+      @@conditional_comments
+    end
+    
+    def initialize
+      @concat = 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)
+    
+    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
+