front-compiler 1.0.6

data/spec/lib/front_compiler/css_source_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__)+"/../../spec_helper"
+
+describe FrontCompiler::CssSource do
+  def css(src)
+    FrontCompiler::CssSource.new(src)
+  end
+  
+  it "should remove comments" do 
+    css(%{
+      /* some styleshit here */
+      html, body { 
+        font-size: 9pt;
+      }
+      /* some more styleshit */
+      p {
+        padding: 10pt;
+        background: url("/*/*/image.png");
+      }
+
+      a:after {
+        content: '/* */';
+      }
+    }).remove_comments!.should == %{
+      
+      html, body { 
+        font-size: 9pt;
+      }
+      
+      p {
+        padding: 10pt;
+        background: url("/*/*/image.png");
+      }
+
+      a:after {
+        content: '/* */';
+      }
+    }
+  end
+  
+  it "should remove all the empty lines out of the code" do 
+    css(%{
+      html, body {
+        font-weight: bold;
+
+
+        color: red;
+      }
+
+
+      label {
+
+
+
+        display: block;
+      }
+
+    }).remove_empty_lines!.should == %{
+      html, body {
+        font-weight: bold;
+        color: red;
+      }
+      label {
+        display: block;
+      }
+    }
+  end
+  
+  it "should remove all the trailing spaces out of the code" do 
+    css(%{ 
+      html, body { 
+        cusor :    pointer;
+        color: red;
+      }
+
+
+      div     > p  ~  label:after { 
+            content: '           ';
+        text-decoration: underline;
+      }
+
+      form p label { 
+        display: block;
+      }
+    }).remove_trailing_spaces!.should == ""\
+    "html,body{cusor:pointer;color:red}div>p~label:after{"\
+    "content:'           ';text-decoration:underline}"\
+    "form p label{display:block}"
+  end
+  
+  it "should apply all the minimizations to the code" do 
+    css(%{ 
+      /* some comment */
+      div           ,
+      p {         padding: 10pt; }
+    }).compact!.should == %{div,p{padding:10pt}}
+  end
+  
+  it "should convert the stylesheet into a embedded javascript code" do 
+    css(%{ 
+      /* some comment */
+      div           ,
+      p {         padding: 10pt; 
+        background: url('something');
+        content: "something";
+     }
+    }).to_javascript.should == 
+      'document.write("<style type=\\"text/css\\">'+
+        'div,p{padding:10pt;background:url(\'something\');content:\"something\"}'+
+      '</style>");'
+  end
+end

data/spec/lib/front_compiler/html_compactor_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__)+"/../../spec_helper"
+
+describe FrontCompiler::HTMLCompactor do
+  before :all do 
+    @c = FrontCompiler::HTMLCompactor.new
+  end
+  
+  it "should remove all the comments out of the code" do 
+    @c.remove_comments(%{ 
+      <ul><!-- main menu -->
+        <li><!-- main label -->
+          Main</li>
+      </ul>
+    }).should == %{ 
+      <ul>
+        <li>
+          Main</li>
+      </ul>
+    }
+  end
+  
+  it "should remove all the trailing spaces out of the code" do 
+    @c.remove_trailing_spaces(%{ 
+      <ul     class="bla">
+         <li>
+           <a href=""       id="main">     Home </a>
+         </li>
+      </ul>
+    }).should == %{<ul class="bla"><li><a href="" id="main">Home</a></li></ul>}
+  end
+  
+  it "should apply all the compactings" do 
+    @c.minimize(%{ <!-- some comment -->
+      <ul     class="bla">
+         <li>  <!-- some another comment -->
+           <a href=""       id="main">     Home </a>
+         </li>
+      </ul>
+    }).should == %{<ul class="bla"><li><a href="" id="main">Home</a></li></ul>}
+  end
+end

data/spec/lib/front_compiler/java_script/logic_compactor_spec.rb

@@ -0,0 +1,363 @@
+require File.dirname(__FILE__)+"/../../../spec_helper"
+
+describe FrontCompiler::JavaScript::LogicCompactor do
+  def compact(src)
+    FrontCompiler::JavaScript.new(src).compact_logic!
+  end
+  
+  it "should have the compact_logic method" do 
+    FrontCompiler::JavaScript.new('').should respond_to(:compact_logic!)
+  end
+  
+  it "should convert multi-lined if/else short constructions" do 
+    compact(%{
+      var a = b ?
+        c : d;
+      var a = b
+        ? c : d;
+      var a = b ?
+        c :
+        d;
+      var a = b
+        ? c
+        : d;
+    }).should == %{
+      var a = b ? c : d;
+      var a = b ? c : d;
+      var a = b ? c : d;
+      var a = b ? c : d;
+    }
+  end
+  
+  it "should convert multi-lined assignments" do 
+    compact(%{ 
+      var a =
+        b + c;
+      var a = b -
+        c;
+      var a = b
+        % c;
+    }).should == %{ 
+      var a = b + c;
+      var a = b - c;
+      var a = b % c;
+    }
+  end
+  
+  it "should convert mutli-lined method-calls chain" do 
+    compact(%{
+      var a = b
+        .c()
+        .d();
+    }).should == %{
+      var a = b.c().d();
+    }
+  end
+  
+  it "should convert multi-lined method calls" do 
+    compact(%{
+      var a = b(
+        c,
+        d
+      );
+      var a = b(
+        c, d
+      );
+    }).should == %{
+      var a = b(c, d);
+      var a = b(c, d);
+    }
+  end
+  
+  it "should convert multi-lined logical expressions" do 
+    compact(%{
+      if (a
+          && b ||
+          c)
+        var d = e
+          | f &
+          g;
+    }).should == %{
+      if (a && b || c)
+        var d = e | f & g;
+    }
+  end
+  
+  it "should not touch multilined logic constructions" do 
+    compact(%{
+      if (something) {
+        bla;
+        foo;
+      }
+      for (var k in o) {
+        bla; foo;
+      }
+      while (something) { bla; foo; }
+    }).should == %{
+      if (something) {
+        bla;
+        foo;
+      }
+      for (var k in o) {
+        bla; foo;
+      }
+      while (something) { bla; foo; }
+    }
+  end
+  
+  it "should not break try/catch/finally constructions" do 
+    compact(%{
+      try { bla; bla
+      }
+      catch(e) {
+        bla; bla; bla
+      }
+      finally { 
+        bla; bla; bla
+      }
+    }).should == %{
+      try { bla; bla
+      }
+      catch(e) {
+        bla; bla; bla
+      }
+      finally { 
+        bla; bla; bla
+      }
+    }
+  end
+  
+  it "should convert simple multilined constructions" do 
+    compact(%{
+      if (something) {
+        foo;
+      } else { foo }
+      for (var k in o) { foo; }
+      do {
+        something;
+      } while(needed)
+      while (something()) { foo }
+    }).should == %{
+      if (something) 
+        foo;
+       else  foo; 
+      for (var k in o)  foo; 
+      do 
+        something;
+       while(needed)
+      while (something())  foo; 
+    }
+  end
+  
+  it "should keep internal multilined constructions safe" do 
+    compact(%{
+      if (something) {
+        for (var i=0; i<something.length; i++) {
+          var boo = something[i];
+          var foo = boo % i;
+        }
+      }
+    }).should == %{
+      if (something) 
+        for (var i=0; i<something.length; i++) {
+          var boo = something[i];
+          var foo = boo % i;
+        }
+      
+    }
+  end
+  
+  it "should handle nested constructions" do 
+    compact(%{
+      if (something) {
+        for (var k in o) {
+          while(something) {
+            var o[k] = something;
+          }
+        }
+      } else {
+        while (something) {
+          for (var k in o) {
+            something = o[k];
+          }
+        }
+      }
+    }).should == %{
+      if (something) 
+        for (var k in o) 
+          while(something) 
+            var o[k] = something;
+          
+        
+       else 
+        while (something) 
+          for (var k in o) 
+            something = o[k];
+          
+        
+      
+    }
+  end
+  
+  it "should keep doubleifs alive" do 
+    compact(%{
+      if (something) {
+        if (something_else) {
+          bla; bla;
+        }
+      }
+    }).should == %{
+      if (something) {
+        if (something_else) {
+          bla; bla;
+        }
+      }
+    }
+  end
+  
+  it "should remove semicolons after functions which before the 'else' keyword" do 
+    compact(%{
+      if (something) {
+        function() {
+        };
+      } else {
+        something;
+      }
+    }).should == %{
+      if (something) 
+        function() {
+        }
+       else 
+        something;
+      
+    }
+  end
+  
+  it "should calculate try/catch constructions as code lines" do 
+    compact(%{
+      if (something) {
+        try {something} catch(MyException e) {}
+        try {another} finally {}
+      } else {
+        do_nothing;
+      }
+    }).should == %{
+      if (something) {
+        try {something} catch(MyException e) {}
+        try {another} finally {}
+      } else 
+        do_nothing;
+      
+    }
+  end
+  
+  it "should whatch if/else conditions intersections" do 
+    compact(%{
+      if (something) {
+        for (something) {
+          if (something) {
+            return something;
+          }
+        }
+      } else {
+        return null;
+      }
+    }).should == %{
+      if (something) {
+        for (something) 
+          if (something) 
+            return something;
+          
+        
+      } else 
+        return null;
+      
+    }
+  end
+  
+  it "should calculate number of constructions correctly in such case" do 
+    compact(%{
+      if (a) {
+        for (k in a) {
+          if (a)
+            t;
+        }
+
+        if (a) {
+          each;
+        }
+      }
+    }).should == %{
+      if (a) {
+        for (k in a) 
+          if (a)
+            t;
+        
+
+        if (a) 
+          each;
+        
+      }
+    }
+  end
+  
+  it "should fix missed semicolons before return|function|if|while|do" do
+    %w(return function if while do try).each do |command|
+      compact(%{
+        var a = 2
+        #{command};
+        var b = 4;
+        #{command};
+      }).should == %{
+        var a = 2;
+        #{command};
+        var b = 4;
+        #{command};
+      }
+    end
+  end
+  
+  it "should fix temporary lambdas calls" do
+    %w(return function if while do try).each do |command|
+      compact(%{
+        var c = (function() {
+
+        })(1,2,3,4)
+        #{command} (c)
+      }).should == %(
+        var c = (function() {
+
+        })(1,2,3,4);
+        #{command} (c)
+      )
+    end
+    
+  end
+  
+  it "should not break weird else if constructions" do
+    compact(%{
+      if(somethind) {
+      } else
+      if (another) {
+      }
+    }).should == %{
+      if(somethind) {
+      } else
+      if (another) {
+      }
+    }
+  end
+  
+  it "should not put missed semicolons in fron of opened lists" do
+    compact(%{
+      var flips = [
+        function() {},
+        function() {}
+      ];
+    }).should == %{
+      var flips = [
+        function() {}, function() {}
+      ];
+    }
+  end
+end

data/spec/lib/front_compiler/java_script/names_compactor_spec.rb

@@ -0,0 +1,219 @@
+require File.dirname(__FILE__)+"/../../../spec_helper"
+
+describe FrontCompiler::JavaScript::NamesCompactor do
+  def compact(src)
+    FrontCompiler::JavaScript.new(src).compact_names!
+  end
+  
+  it "should have the compact_logic method" do 
+    FrontCompiler::JavaScript.new('').should respond_to(:compact_names!)
+  end
+  
+  it "should not touch any local variables" do 
+    compact(%{
+      var something = funny;
+    }).should == %{
+      var something = funny;
+    }
+  end
+  
+  it "should handle simple cases" do 
+    compact(%{
+      function(something, another) {
+        var more = something / another;
+        another = more * something;
+        something = another - more;
+      }
+      function (something, another) {
+        var more = something / another;
+      }
+      function asdf(something, another) {
+        var more = something / another;
+      }
+    }).should == %{
+      function(s, a) {
+        var m = s / a;
+        a = m * s;
+        s = a - m;
+      }
+      function (s, a) {
+        var m = s / a;
+      }
+      function asdf(s, a) {
+        var m = s / a;
+      }
+    }
+  end
+  
+  it "should catch up local function names" do 
+    compact(%{
+      function() {
+        function boo() {
+        };
+        var foo = function() {};
+        var moo = function (  ) {};
+
+        boo(foo(moo());
+      }
+    }).should == %{
+      function() {
+        function b() {
+        };
+        var f = function() {};
+        var m = function (  ) {};
+
+        b(f(m());
+      }
+    }
+  end
+  
+  it "should catch up several vars in a line" do 
+    compact(%{
+      function() {
+        var boo = {}, foo = [], moo = new String;
+        foo.push(moo);
+        boo[moo] = foo;
+      }
+    }).should == %{
+      function() {
+        var b = {}, f = [], m = new String;
+        f.push(m);
+        b[m] = f;
+      }
+    }
+  end
+  
+  it "should keep safe the logical constructions and external variables" do 
+    compact(%{
+      function(something) {
+        try {
+          if (something) {
+            for (var key in something) {
+              var object = something[key];
+            }
+          } else if (limit) {
+            for (var i=0; i < limit; i++) {
+              var object = limit + i;
+            }
+          } else {
+            while (running) {
+              var object = running;
+            }
+          }
+        } catch(MyException e) {
+          handle(e);
+        }
+      }
+    }).should == %{
+      function(s) {
+        try {
+          if (s) {
+            for (var k in s) {
+              var o = s[k];
+            }
+          } else if (limit) {
+            for (var i=0; i < limit; i++) {
+              var o = limit + i;
+            }
+          } else {
+            while (running) {
+              var o = running;
+            }
+          }
+        } catch(MyException e) {
+          handle(e);
+        }
+      }
+    }
+  end
+  
+  it "should keep safe the objects members calls" do 
+    compact(%{
+      function(something) {
+        var object = something.important ? 
+          something.important(something.more()) : nil;
+      }
+    }).should == %{
+      function(s) {
+        var o = s.important ? 
+          s.important(s.more()) : nil;
+      }
+    }
+  end
+  
+  it "should resolve similar names issues" do 
+    compact(%{
+      function(aaron, abba, alisa) {
+        var ann = aaron * abba + alisa;
+      }
+    }).should == %{
+      function(a, b, c) {
+        var d = a * b + c;
+      }
+    }
+  end
+  
+  it "should handle a nested functions construction" do 
+    compact(%{
+      function(boo) {
+        function moo() {
+          function foo() {
+            var moo = boo * 2;
+            boo(moo);
+          }
+        }
+        var foo = moo(boo);
+      }
+    }).should == %{
+      function(b) {
+        function c() {
+          function f() {
+            var m = b * 2;
+            b(m);
+          }
+        }
+        var a = c(b);
+      }
+    }
+  end
+  
+  it "should not break object keys definitions" do 
+    compact(%{
+      function(foo, boo) {
+        var moo = {foo: foo, boo  : boo};
+        moo = foo ? boo : [foo, boo];
+        boo = { mooboo: moo + boo }
+      }
+    }).should == %{
+      function(f, b) {
+        var m = {foo: f, boo  : b};
+        m = f ? b : [f, b];
+        b = { mooboo: m + b }
+      }
+    }
+  end
+  
+  it "should not break similar external variables" do 
+    compact(%{
+      function(foo, boo) {
+        var moo = foo_boo;
+      }
+    }).should == %{
+      function(f, b) {
+        var m = foo_boo;
+      }
+    }
+  end
+  
+  it "should handle the case when there are two slashes but no regular expression" do
+    compact(%{
+      function(i) {
+        var y = (cell.y/3).floor() * 3 + (i/3).floor();
+      }
+    }).should == %{
+      function(a) {
+        var y = (cell.y/3).floor() * 3 + (a/3).floor();
+      }
+    }
+  end
+end