front-compiler 1.0.6

data/lib/front_compiler/java_script/names_compactor.rb

@@ -0,0 +1,142 @@
+#
+# This module contains the names compactor functionality
+# 
+# This module is a part of the JavaScript class and taken out
+# just to keep the things simple
+# 
+# Copyright (C) Nikolay V. Nemshilov aka St.
+#
+class FrontCompiler
+  class JavaScript < FrontCompiler::SourceCode
+    module NamesCompactor
+      def compact_names!
+        string_safely do 
+          compact_names_of self
+        end
+      end
+      
+    protected
+      FUNCTION_START_RE = %r{
+          (\A|[^\da-z_\$])    # ensure this is not a weird method name
+          function(\s
+            ([a-z\d\$_]+)     # function name
+          )*\s*\(
+          ([a-z\d\\$\s_,]*)   # arguments list
+          \)\s*               # end of the function definition
+      }imx
+      def compact_names_of(src)
+        offset = 0
+        while pos = src.index(FUNCTION_START_RE, offset)
+          func_start = $&.dup
+          args_block = $4.dup
+          body_block = find_block("{}", pos + func_start.size, src)
+          
+          args, body = process_names(args_block, compact_names_of(body_block.dup))
+          func = func_start.gsub "(#{args_block})", "(#{args})"
+          
+          src[pos, func_start.size + body_block.size] = func + body
+          
+          offset = pos + func.size + body.size
+        end
+        
+        src
+      end
+      
+      # handles the names processing
+      def process_names(args, body)
+        args = args.dup  # <- duplicating the string case they will be parsed
+        body = body.dup
+        
+        # building the names replacement map
+        guess_names_map(body,
+          find_body_varnames(body).select{ |n| n.size > 1
+          }.concat(args.scan(/[\w\d_\$]+/im)
+          ).uniq.sort.select{ |n| n != '$super' } # <- escape the Prototype stuff
+        ).each do |name, replacement|
+          # replacing the names
+          [args, body].each do |str|
+            str.gsub!(/(\A|[^\w\d_\.\$])#{Regexp.escape(name)}(?![\w\d_\$]|\s*:)/) do
+              $1 + replacement
+            end
+            
+            # replacing the names in the short 'a ? b : c' conditions
+            str.gsub!(/([^\{,\s\w\d_\.\$]\s*)#{Regexp.escape(name)}(\s*?:)/) do
+              $1 + replacement + $2
+            end
+          end
+        end
+        
+        [args, body]
+      end
+      
+      # makes decisions about the names cutting down
+      def guess_names_map(body, names)
+        names_map = { }
+        used_renames = []
+        
+        @replacements ||= ('a'...'z').to_a.concat(('A'...'Z').to_a)
+        
+        names.each do |name|
+          [name[/[a-z]/i]||'a'].concat(@replacements).each do |rename|
+            if !used_renames.include?(rename) and !body.match(/[^\w\d_\.\$]#{rename}[^\w\d_\$]/)
+              names_map[name] = rename
+              used_renames << rename
+              break
+            end
+          end
+        end
+        
+        names_map
+      end
+      
+      # extracts localy defined varnames of the given function body block
+      def find_body_varnames(body)
+        # getting the body body
+        body = body[1, body.size-2]
+        
+        names = []
+        
+        # removing the internal functions
+        while pos = body.index(FUNCTION_START_RE)
+          func = $&.dup
+          
+          func_name = $3 ? $3.dup : ''
+          names << func_name unless func_name == ''
+          
+          body[pos+1, func.size-1+find_block("{}", pos+func.size, body).size] = ''
+        end
+        
+        # removing functions calls blocks
+        offset = 0
+        while pos = body.index(/[a-z0-9_]\(/i, offset)
+          pos += 1
+          block = find_block("()", pos, body)
+          body[pos, block.size] = '' unless body[0, pos].match(/(if|for|while|catch)\s*\Z/im)
+          
+          offset = pos + 1
+        end
+        
+        # getting the vars definitions
+        body.scan(/[\s\(:;=\{\[^$]+var\s(.*?)(;|$)/im) do |match|
+          line = $1.dup
+          
+          # removing arrays and objects definitions out of the line
+          ['[]', '{}'].each do |token|
+            while pos = line.index(token=='[]' ? /\[.*?\]/ : /\{.*?\}/)
+              line[pos, $&.size] = ''
+            end
+          end
+          
+          
+          # removing objects definitions
+          
+          names.concat(line.split(",").collect{ |token|
+              token[/[\w\d_\$]+/i]
+            }.compact)
+        end
+        
+        names
+      end
+    end
+  end
+end

data/lib/front_compiler/java_script/self_builder.rb

@@ -0,0 +1,137 @@
+#
+# This module contains the hashes compactor functionality
+# 
+# This module is a part of the JavaScript class and taken out
+# just to keep the things simple
+# 
+# Copyright (C) 2009 Nikolay V. Nemshilov aka St.
+#
+class FrontCompiler
+  class JavaScript < FrontCompiler::SourceCode
+    module SelfBuilder
+      def create_self_build
+        rehashed_version = process_hashes_in(self)
+        rehashed_version.size > self.size ? self : rehashed_version
+      end
+      
+    protected
+    
+      def process_hashes_in(string)
+        create_build_script *compact_hashes_in(string)
+      end
+      
+      def create_build_script(source, names_map)
+        "eval((function(s,d){"+
+          # building the postprocessing script
+          "for(var i=d.length-1;i>-1;i--)"+
+            "if(d[i])"+
+              "s=s.replace(new RegExp(i,'g'),d[i]);"+
+          "return s"+
+        "})("+
+          "\"#{source.gsub("\\", "\\\\\\\\").gsub("\n", '\\n').gsub('"', '\"').gsub('\\\'', '\\\\\\\\\'')}\","+
+          "\"#{names_map.join(',')}\".split(\",\")"+
+        "));"
+      end
+      
+      def compact_hashes_in(string)
+        string = string.dup
+        
+        names_map = guess_replacements_map(string, tokens_to_replace_in(string))
+        
+        names_map.each_with_index do |token, i|
+          string.gsub! token, "#{i}" if token != ''
+        end
+        
+        [string, names_map]
+      end
+      
+      def tokens_to_replace_in(string)
+        # grabbign the basic list of impact tokens
+        impact_tokens = get_impact_tokens(string, 
+          /(?![^a-z0-9_$])([a-z0-9_$]{#{MINUMUM_REPLACEABLE_TOKEN_SIZE},88})(?![a-z0-9_$])/i)
+        
+        # getting unprocessed sub-tokens list
+        string = string.dup
+        impact_tokens.each{ |token| string.gsub! token.split(':').first, '' }
+        
+        sub_impact_tokens = get_impact_tokens(string, /([A-Z][a-z]{#{MINUMUM_REPLACEABLE_TOKEN_SIZE-1},88})(?![a-z])/)
+        
+        
+        #
+        # NOTE: with the optimisation, the sub-tokens should be on the tokens list
+        #       after the basic tokens, so they were not affecting each other
+        #
+        
+        # the basic dictionary has some space for new tokens, adding some from the sub-tokens list
+        if impact_tokens.size < MAXIMUM_DICTIONARY_SIZE
+          sub_tokens = sub_impact_tokens[0, MAXIMUM_DICTIONARY_SIZE - impact_tokens.size]
+        else
+          # replacing the shortest basic tokens with longest sub-tokens
+          sub_tokens = []
+          while impact_tokens.last && sub_impact_tokens.first && impact_tokens.last.size < sub_impact_tokens.first.size
+            sub_tokens << sub_impact_tokens.shift
+            impact_tokens.pop
+          end
+        end
+        
+        impact_tokens.concat(sub_tokens)
+        
+        # grabbing the single tokens back
+        impact_tokens.collect{|line| line.split(':').first }
+      end
+      
+      #
+      # creates a list of impact-tokens (tokens multiplied to the number of their appearances)
+      #
+      def get_impact_tokens(string, regexp)
+        keys = {}
+        
+        # scanning through the string and calculating the number of appearances
+        string.scan(regexp).collect(&:last).each do |key|
+          keys[key] ||= 0
+          keys[key] +=  1
+        end
+        
+        # kicking of the tokens which appears less then twice
+        keys.reject!{|key,number| number < 2 }
+        
+        # creating the impact tokens
+        tokens = keys.collect do |token, number|
+          line = []
+          number.times{ line << token }
+          line.join(":")
+        end
+        
+        # sorting the tokens by impact
+        tokens.sort{|a,b| b.size <=> a.size}[0, MAXIMUM_DICTIONARY_SIZE]
+      end
+      
+      #
+      # Generic replacements quessing method
+      #
+      def guess_replacements_map(string, keys)
+        map = []
+        index = -1
+        keys.each do |old_name|
+          index += 1
+          
+          while string.match(/#{index}/)
+            map << ''
+            index+= 1
+          end
+          
+          map << old_name
+          
+          string = string.gsub old_name, "#{index}"
+        end
+        
+        map
+      end
+      
+    public
+    
+      MINUMUM_REPLACEABLE_TOKEN_SIZE = 3
+      MAXIMUM_DICTIONARY_SIZE        = 150
+    end
+  end 
+end

data/lib/front_compiler/java_script.rb

@@ -0,0 +1,53 @@
+#
+# This class represents a java-script source code
+#
+# Copyright (C) Nikolay V. Nemshilov aka St.
+#
+require "front_compiler/java_script/logic_compactor"
+require "front_compiler/java_script/names_compactor"
+require "front_compiler/java_script/self_builder"
+
+class FrontCompiler::JavaScript < FrontCompiler::SourceCode
+  include LogicCompactor, NamesCompactor, SelfBuilder
+  
+  def compact!
+    string_safely do 
+      remove_comments!.
+        compact_logic!.
+        compact_names!.
+        remove_empty_lines!.
+        remove_trailing_spaces!
+    end
+  end
+  
+  def remove_comments!
+    string_safely do 
+      gsub!(/\/\*.*?\*\//im, '')
+      gsub!(/\/\/.*?($)/, '\1')
+    end
+  end
+  
+  def remove_empty_lines!
+    string_safely do 
+      gsub!(/\n\s*\n/m, "\n")
+    end
+  end
+  
+  def remove_trailing_spaces!
+    string_safely do 
+      gsub!(/\s+/im, ' ') # cutting down all spaces to the minimum
+      gsub!(/\s*(=|\+|\-|<|>|\?|\|\||&&|\!|\{|\}|,|\)|\(|;|\]|\[|:|\*|\/)\s*/im, '\1')
+      gsub!(/;(\})/, '\1') # removing unnecessary semicolons
+      gsub!(/([^a-z\d_\$]typeof)\s+([a-z\d\$_]+)/im, '\1(\2)') # converting the typeof calls
+      strip!
+    end
+  end
+  
+protected
+  # extends the basic class to excape regular expressions as well
+  def string_safely(&block)
+    super [
+      /([\(=:]\s*)\/[^\*\/][^\n]*?[^\*\n\\](?!\\\/)\// # <- regexps
+    ], &block
+  end
+end

data/lib/front_compiler/source_code.rb

@@ -0,0 +1,105 @@
+#
+# That's all the source-codes base class
+#
+# Copyright (C) Nikolay V. Nemshilov aka St.
+#
+class FrontCompiler::SourceCode < String
+  def initialize(src)
+    super src
+  end
+  
+  # returns a fully compacted source
+  def compact!
+    remove_comments!.
+      remove_empty_lines!.
+      remove_trailing_spaces!
+  end
+  
+  # removes any comments
+  def remove_comments!
+    self
+  end
+  
+  # removes empty lines
+  def remove_empty_lines!
+    self
+  end
+  
+  # removes all the trailing spaces
+  def remove_trailing_spaces!
+    self
+  end
+  
+  # don't use alias here, it won't work with subclasses
+  def compact
+    compact!
+  end
+
+protected
+  # executes the given block, safely for the strings declared in the source-code
+  # can apply a list of additional regexps to escape
+  def string_safely(additional_regexps=[], &block)
+    if @in_string_safe_mode
+      yield
+      return self
+    end
+    
+    outtakes = []
+    
+    [/(\A|[^\\])('|")(\2)/,            # <- empty strings
+     /(\A|[^\\])('|").*?[^\\](\2)/     # <- usual strings
+    ].concat(additional_regexps).each do |regexp|
+      gsub! regexp do |match|
+        replacement = "rIgAxpOrStrEEng$$$#{outtakes.length}$$$riPlOcImEnt"
+        start = $1.dup
+        outtakes << { 
+          :replacement => replacement, 
+          :original    => match.to_s[start.size, match.to_s.size]
+        }
+        
+        start + replacement
+      end
+    end
+    @in_string_safe_mode = true
+    
+    yield block
+    
+    # bgingin the strings back
+    outtakes.reverse.each do |s|
+      gsub! s[:replacement], s[:original].gsub('\\','\\\\\\\\') # <- escapes reescaping
+    end
+    @in_string_safe_mode = false
+    
+    self
+  end
+  
+  # searches for a block in the code which starts at the given position
+  BLOCK_CHUNKS = {"()" => ["(",")"], "{}" => ["{","}"], "[]" => ["[","]"]}
+  def find_block(like, offset=0, stack=nil)
+    left, right = BLOCK_CHUNKS[like]
+    src = stack || self
+    start_pos = src.index(left, offset)
+    
+    # return an empty string if the left sign was not found or fount not at the beginning
+    return '' if start_pos.nil? or !src[offset, start_pos-offset].match(/\A\s*?\Z/im)
+    
+    start_pos += 1 # <- include the left sign to the block
+    block = src[offset, start_pos-offset]
+    
+    count = 0
+    (start_pos...src.size).each do |i|
+      char = src.slice(i,1)
+      
+      block << char
+      
+      if char == right and count == 0
+        break
+      else
+        count += 1 if char == left
+        count -= 1 if char == right
+      end
+    end
+    
+    block
+  end
+end

data/lib/front_compiler.rb

@@ -0,0 +1,59 @@
+#
+# FrontCompiler, the front unit of the library
+#
+# Copyright (C) Nikolay V. Nemshilov aka St.
+#
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))).uniq!
+
+class FrontCompiler
+  VERSION = "1.0.6"
+  
+  def initialize
+    @html_compactor = HTMLCompactor.new
+  end
+  
+  # compacts all the files out of the list
+  # and returns them as a single string
+  def compact_files(list)
+    list.collect do |file|
+      compact_file file
+    end.join("\n")
+  end
+  
+  # compacts the given file (path or a File object)
+  def compact_file(file)
+    file = File.open(file, 'r') if file.is_a?(String)
+    
+    case file.path.split('.').last.downcase
+      when 'js'   then compact_js   file.read
+      when 'css'  then compact_css  file.read
+      when 'html' then compact_html file.read
+      else                          file.read
+    end
+  end
+  
+  # compacts a JavaScript source code
+  def compact_js(source)
+    JavaScript.new(source).compact
+  end
+  
+  # compacts a CSS source code
+  def compact_css(source)
+    CssSource.new(source).compact
+  end
+  
+  # compacts a HTML code
+  def compact_html(source)
+    @html_compactor.minimize(source)
+  end
+  
+  # inlines the css-sourcecode in a javascript code
+  def inline_css(source)
+    CssSource.new(source).to_javascript
+  end
+end
+
+require "front_compiler/source_code"
+require "front_compiler/java_script"
+require "front_compiler/css_source"
+require "front_compiler/html_compactor"

data/lib/front_compiler_helper.rb

@@ -0,0 +1,45 @@
+#
+# The module provides some methods which can be used
+# in rails controller or something like that
+#
+# Generally this is just a facade for the FrontCompiler
+#
+# Copyright (C) Nikolay V. Nemshilov aka St.
+#
+
+module FrontCompilerHelper
+protected
+  def compact_files(list)
+    front_compiler.compact_files(list)
+  end
+  
+  def compact_file(file)
+    front_compiler.compact_file(file)
+  end
+  
+  def compact_js(source)
+    front_compiler.compact_js(source)
+  end
+  
+  def compact_css(source)
+    front_compiler.compact_css(source)
+  end
+  
+  def compact_html(source)
+    front_compiler.compact_html(source)
+  end
+  
+  def inline_css(source)
+    front_compiler.inline_css(source)
+  end
+  
+  def inline_css_file(file)
+    file = File.open(file) if file.is_a? String
+    inline_css file.read
+  end
+  
+private
+  def front_compiler
+    @front_compiler ||= FrontCompiler.new
+  end
+end

data/spec/lib/front_compiler/css_source/nested_styles_spec.rb.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__)+"/../../../spec_helper"
+
+describe FrontCompiler::CssSource::NestedStyles do 
+  def css(src)
+    FrontCompiler::CssSource.new(src)
+  end
+  
+  it "should convert nested constructions" do 
+    css(%{
+      div.stuff {
+        border: 1px solid #EEE;
+
+        div.name {
+          font-weight: bold;
+
+          div.id:before {
+            content: '#';
+          }
+        }
+        
+        div.name, div.text {
+          padding: 10pt;
+          
+          a.user,
+          a.delete {
+            background-position: left;
+            background-repeat: no-repeat;
+            background-image: url('user.png');
+          }
+          
+          a.delete {
+            background-image: url('delete.png');
+          }
+        }
+      }
+    }).should == %{
+      div.stuff {
+        border: 1px solid #EEE;
+      }
+
+        div.stuff div.name {
+          font-weight: bold;
+        }
+
+          div.stuff div.name div.id:before {
+            content: '#';
+          }
+        
+        div.stuff div.name, div.stuff div.text {
+          padding: 10pt;
+        }
+          
+          div.stuff div.name a.user, div.stuff div.text a.user,
+          div.stuff div.name a.delete, div.stuff div.text a.delete {
+            background-position: left;
+            background-repeat: no-repeat;
+            background-image: url('user.png');
+          }
+          
+          div.stuff div.name a.delete, div.stuff div.text a.delete {
+            background-image: url('delete.png');
+          }
+    }
+  end
+end