jqueryplugingen 0.1.2 → 0.1.3

data/History.txt

@@ -1,9 +1,21 @@
+== 0.1.3 2009-06-08
+
+* Add rake tasks for build/dist plugins:
+	* Add clean rake task
+	* Replace Makefile
+	* Delegate build tasks to gem rakefiles rather than generate
+	* Add to task folder to generation and then in Rakefile scan that folder for custom tasks
+
+== 0.1.2 2009-06-07
+
+* Be able to download jquery tmbundles into Textmate:
+	* Add rake task for tmbundle loading from gem or from svn latest
+
 == 0.1.1 2009-06-06
 
 * Be able to download jquery files into library:
   * jQuery core, ui and themes with rake
 	* Add option to install different versions of libraries
-	* Add rake task for tmbundle loading from gem or from svn latest
 
 == 0.1.0 2009-05-30
 

data/Manifest.txt

@@ -162,14 +162,19 @@ bundles/JavaScript.tmbundle/info.plist
 jQuery-Plugin-Generator.tmproj
 lib/jqp/cli.rb
 lib/jquery_plugin_gen.rb
+lib/jquery_plugin_gen/compiletask.rb
 lib/jquery_plugin_gen/generator.rb
 lib/jquery_plugin_gen/quick_template.rb
+lib/jquery_plugin_gen/support/build.rake
 lib/jquery_plugin_gen/support/bundles.rake
 lib/jquery_plugin_gen/support/jquery.rake
+lib/jquery_plugin_gen/support/package.rake
 lib/jquery_plugin_gen/tasks.rb
+lib/packer/Pack.pm
+lib/packer/ParseMaster.pm
+lib/packer/jsPacker.pl
 lib/templates/History.txt.erb
 lib/templates/README.txt.erb
-lib/templates/Makefile.erb
 lib/templates/Rakefile.erb
 lib/templates/example.html.erb
 lib/templates/src/plugin.js.erb

data/README.rdoc

@@ -10,11 +10,14 @@ Generate the structure of jquery plugins easily. Manage library dependencies suc
 == FEATURES/PROBLEMS:
 
 * be able to use the produced code on linux and windows (need jqp.bat)
+* bundle up jsspec
+* include qunit
 * add acceptance test
 * add hoe-type features for updating plugins to jquery plugin page (as rake tasks)
-* be able to bundle library dependencies
-* be able to switch  between local and remote libraries in actual html pages
+* be able to bundle/package library dependencies
+* be able to switch  between local and remote libraries in actual html pages (perhaps this is the release bundle)
 * be able to generate new modules and update html pages (as rake task or generator)
+* nice to remove option -p for project "jpq myplugin"
 
 == SYNOPSIS:
 

data/lib/jquery_plugin_gen/compiletask.rb

@@ -0,0 +1,166 @@
+#!/usr/bin/env ruby
+
+# Define a compile task libarary to aid in the definition of
+# redistributable package files of javascript/jquery plugins.
+
+require 'rake'
+require 'rake/tasklib'
+require 'fileutils'
+
+module Rake
+
+  # Create a compiling task that will build the project into
+  # distributable files (e.g a single and a packed js file with compression).
+  #
+  # The CompileTask will create the following targets:
+  #
+  # [<b>:compile</b>]
+  #   Create all the requested package files.
+  #
+  # [<b>:clobber_compile</b>]
+  #   Delete all the package files.  This target is automatically
+  #   added to the main clobber target.
+  #
+  # [<b>:recompile</b>]
+  #   Rebuild the package files from scratch, even if they are not out
+  #   of date.
+  #
+  # Example:
+  #
+  #   JqueryPluginGen::CompileTask.new('query.plugin') do |p|
+  #     p.js_files.include("src/**/*.js")
+  #     p.css_files.include("src/css/**/*.css")
+  #     p.image_files.include("src/images/**/*.*")
+  #     p.js_dir = "src"
+  #     p.images_dir = "images"
+  #     p.css_dir = "css"
+  #     p.package_files.include("README.txt", "HISTORY.txt")
+  #     p.package_dir = "build"
+  #   end
+  #
+     
+  class CompileTask < TaskLib
+
+    # Name of the plugin files (don't add .js, eg 'jquery.mywidget').
+    attr_accessor :name
+
+    # Directory used to store the package files (default is 'images').
+    attr_accessor :images_dir
+
+    # Directory used to store the package files (default is 'css').
+    attr_accessor :css_dir
+
+    # Directory used to store the package files (default is 'build').
+    attr_accessor :package_dir
+
+    # True if the single js file is compiled using SED (default is true).
+    attr_accessor :need_sed
+
+    # True if the single js file is compressed using PACKER (default is true).
+    attr_accessor :need_packer
+
+    # List of files to be included in the package.
+    attr_accessor :package_files
+
+    # List of files to be included in the package.
+    attr_accessor :js_files
+
+    # List of files to be included in the package.
+    attr_accessor :css_files
+
+    # List of files to be included in the package.
+    attr_accessor :image_files
+
+    # Create a Compile Task
+    def initialize(name)
+      init(name)
+      yield self if block_given?
+      define unless name.nil?
+    end
+
+    # Initialization that bypasses the "yield self" and "define" step.
+    def init(name)
+      @name = name
+      @package_files = Rake::FileList["README.txt", "HISTORY.txt"]
+      @package_dir = 'build'
+      @need_sed = true
+      @need_packer = true
+      @images_dir = 'images'
+      @css_dir = 'css'
+      @js_dir = 'src'
+      @js_files = Rake::FileList.new
+      @js_files.include("#{@js_dir}/**/*.js")
+      @image_files = Rake::FileList.new
+      @image_files.include("#{@js_dir}/#{@image_dir}/**/*.*")
+      @css_files = Rake::FileList.new
+      @css_files.include("#{@js_dir}/#{@css_dir}/**/*.css")     
+    end
+
+    # Create the tasks defined by this task library.
+    def define
+      fail "Name required (or :noversion)" if @name.nil?
+      @name = nil if :noname == @name
+      
+
+      desc "Build all the packages"
+      task :compile => :pack do
+        [images_dir, css_dir].each { |dir| mkdir_p("#{package_dir_path}/#{dir}") }
+        FileUtils.cp(image_files, package_images_path)
+        FileUtils.cp(css_files, package_css_path)
+        FileUtils.cp(package_files, package_dir_path)
+     end
+      
+      desc "Force a rebuild of the package files"
+      task :recompile => [:clobber_compile, :compile]
+      
+      desc "Remove compile products" 
+      task :clobber_compile do
+        FileUtils.rm_r(package_dir_path) rescue nil
+      end
+      
+      desc "Merge js files into one"
+      task :merge do
+        `#{sed_command}`
+      end
+      
+      desc "Compress js files to min"
+      task :pack => :merge do
+        `#{packer_command}`
+      end
+
+      task :clobber => [:clobber_compile]
+
+      self
+    end
+      
+    def package_dir_path
+      "#{package_dir}"
+    end
+    
+    def package_css_path
+      "#{package_dir_path}/#{css_dir}"
+    end
+    
+    def package_images_path
+      "#{package_dir_path}/#{images_dir}"
+    end
+    
+    def package_js
+      "#{package_dir_path}/#{name}.js"
+    end
+
+    def packed_js
+      "#{package_dir_path}/#{name}.min.js"
+    end
+    
+    def sed_command
+      "sed -e '1 s/^\xEF\xBB\xBF//' #{js_files} > #{package_js}"
+    end
+    
+    def packer_command
+      "perl -I #{File.dirname(__FILE__)}/../packer #{File.dirname(__FILE__)}/../packer/jsPacker.pl -i #{package_js} -o #{packed_js} -e62"
+    end
+
+  end
+
+end

data/lib/jquery_plugin_gen/generator.rb

@@ -3,10 +3,8 @@ require 'fileutils'
 module JqueryPluginGen
   class Generator
        
-    X = 'FI' + 'X' 
-
     def self.base_dirs
-      %w(src lib test dist src/images src/css test/data)
+      %w(src lib test src/images src/css test/data tasks)
     end
        
     def self.execute(args)
@@ -35,7 +33,6 @@ module JqueryPluginGen
 
        details = args
         files = {
-          "Makefile" => QuickTemplate.erb('Makefile', details),
           "History.txt" => QuickTemplate.erb('History.txt', details),
           "README.txt" => QuickTemplate.erb('README.txt', details),
           "src/#{file_name}.js" => QuickTemplate.erb('src/plugin.js', details),

data/lib/jquery_plugin_gen/support/build.rake

@@ -0,0 +1,13 @@
+begin
+  %w[rake/clean].each { |f| require f }
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  %w[rake/clean].each { |f| require f }
+end
+
+CLEAN.include %w( build )
+
+require 'jquery_plugin_gen/compiletask'
+
+desc "Compile tasks"
+Rake::CompileTask.new('jquery.plugin')

data/lib/jquery_plugin_gen/support/package.rake

@@ -0,0 +1,13 @@
+begin
+  %w[rake/packagetask].each { |f| require f }
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  %w[rake/packagetask].each { |f| require f }
+end
+
+desc "Package"
+Rake::PackageTask.new("#{PLUGIN}", "#{VERSION}") do |p|
+  p.need_tar = true
+  p.need_zip = true
+  p.package_files.include("build/**/*.*")
+end

data/lib/jquery_plugin_gen/tasks.rb

@@ -2,4 +2,4 @@
 
 # import the rake tasks for use when having created a plugin
 
-Dir.glob(File.join(File.dirname(__FILE__), '**/*.rake')).each { |r| import r }
+Dir.glob(File.join(File.dirname(__FILE__), '**/*.rake')).each { |t| import t rescue nil}

data/lib/jquery_plugin_gen.rb

@@ -5,5 +5,5 @@ require 'jquery_plugin_gen/quick_template'
 require 'jquery_plugin_gen/generator'
 
 module JqueryPluginGen
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

data/lib/packer/Pack.pm

@@ -0,0 +1,467 @@
+#Pack (July 2005)
+#  Based on "Pack.js" by Dean Edwards <http://dean.edwards.name/>
+#  Ported to Perl by Rob Seiler, ELR Software Pty Ltd <http://www.elr.com.au>
+#  Copyright 2005. License <http://creativecommons.org/licenses/LGPL/2.1/>
+
+package Pack;
+use strict;
+use Data::Dumper;
+
+use ParseMaster;
+
+# Package wide variable declarations
+use vars qw/$VERSION $PM_VERSION
+            $_X_encodePrivate $_JSunpack $_JSdecode %baseLookup
+            $_X_encode10 $_X_encode36 $_X_encode62 $_X_encode95
+            $_JSencode10 $_JSencode36 $_JSencode62 $_JSencode95
+            @_X_parsers
+            $_X_script $_X_encoding $_X_fastDecode $_X_specialChars
+           /;
+$VERSION    = '024';
+$PM_VERSION = $ParseMaster::VERSION;
+
+# Package wide constants
+my $X_IGNORE  = q{$1};
+my $X_ENCODE  = q/\x24encode\(\x24count\)/;  # NB: requires g modifier
+my $PERL      = 'perl';     # Flag to indicate whether we need to use one of our "internal" Perl encoding functions
+my $JSCRIPT   = 'jscript';  # or embed a pre-build JScript encoding function
+########################################
+
+##################
+sub pack($$$$) { # require 4 arguments
+##################
+#print Dumper(@_);
+  ($_X_script, $_X_encoding, $_X_fastDecode, $_X_specialChars) = @_;
+  # validate parameters (sort of!)
+  $_X_script  .= "\n";
+  $_X_encoding = ($_X_encoding > 95) ? 95 : $_X_encoding;
+
+  @_X_parsers = (); # Reset parsers
+
+####################
+  sub _X_pack($) { # require 1 argument
+####################
+  # apply all parsing routines
+    my $X_script = shift;
+    for (my $i = 0; $i<scalar(@_X_parsers); $i++) {
+      my $X_parse = $_X_parsers[$i];
+       $X_script = &$X_parse($X_script);
+    }
+    return $X_script;
+  };
+
+######################
+  sub _X_addParser { #
+######################
+  # keep a list of parsing functions, they'll be executed all at once
+    my $X_parser = shift;
+    push (@_X_parsers,$X_parser);
+  }
+
+#############################
+  sub _X_basicCompression { #
+#############################
+    # zero encoding - just removal of white space and comments
+    my $X_script = shift;
+    my $parser = ParseMaster->new();
+    # make safe
+    $parser->escapeChar("\\");
+    # protect strings
+    $parser->add(q/'[^'\n\r]*'/, $X_IGNORE);
+    $parser->add(q/"[^"\n\r]*"/, $X_IGNORE);
+    # remove comments
+    $parser->add(q/\/\/[^\n\r]*[\n\r]/);
+    $parser->add(q/\/\*[^*]*\*+([^\/][^*]*\*+)*\//);
+    # protect regular expressions
+    $parser->add(q/\s+(\/[^\/\n\r\*][^\/\n\r]*\/g?i?)/, q{$2}); # IGNORE
+    $parser->add(q/[^\w\x24\/'"*)\?:]\/[^\/\n\r\*][^\/\n\r]*\/g?i?/, $X_IGNORE);
+    # remove: ;;; doSomething();
+    $parser->add(q/;;[^\n\r]+[\n\r]/) if ($_X_specialChars);
+    # remove redundant semi-colons
+    $parser->add(q/;+\s*([};])/, q{$2});
+    # remove white-space
+    $parser->add(q/(\b|\x24)\s+(\b|\x24)/, q{$2 $3});
+    $parser->add(q/([+\-])\s+([+\-])/, q{$2 $3});
+    $parser->add(q/\s+/, '');
+    # done
+    return $parser->exec($X_script);
+  }
+
+###############################
+  sub _X_encodeSpecialChars { #
+###############################
+    my $X_script = shift;
+    my $parser = ParseMaster->new();
+    # replace: $name -> n, $$name -> $$na
+    $parser->add(q/((\x24+)([a-zA-Z\x24_]+))(\d*)/,
+      sub {
+        my $X_offset   = pop;
+        my @X_match    = @_;
+        my $X_length   = length($X_match[$X_offset+2]);
+        my $lengthnext = length($X_match[$X_offset+3]);
+        my $X_start = $X_length - ((($X_length - $lengthnext) > 0) ? ($X_length - $lengthnext) : 0);
+        my $str = $X_match[$X_offset+1];
+        $str = substr($str,$X_start,$X_length) . $X_match[$X_offset+4];
+        return "$str";
+      });
+     # replace: _name -> _0, double-underscore (__name) is ignored
+     my $X_regexp = q/\b_[A-Za-z\d]\w*/;
+     # build the word list
+     my %X_keywords = &_X_analyze($X_script, $X_regexp, $_X_encodePrivate);
+#print Dumper(%X_keywords);
+     # quick ref
+     my $X_encoded = \$X_keywords{X_encoded}; # eg _private1 => '_0',_private2 => '_1';
+#print Dumper($X_encoded);
+     $parser->add($X_regexp, sub {my $X_offset = pop; my @X_match = @_; return ${$X_encoded}->{$X_match[$X_offset]};});
+
+     return $parser->exec($X_script);
+  };
+
+###########################
+  sub _X_encodeKeywords { #
+###########################
+    my $X_script = shift;
+    # escape high-ascii values already in the script (i.e. in strings)
+    if ($_X_encoding > 62) {$X_script = &_X_escape95($X_script)};
+    # create the parser
+    my $parser = ParseMaster->new();
+    my $X_encode = &_X_getEncoder($_X_encoding,$PERL);
+    # for high-ascii, don't encode single character low-ascii
+    my $X_regexp = ($_X_encoding > 62) ? q/\w\w+/ : q/\w+/;
+    # build the word list
+    my %X_keywords = &_X_analyze($X_script, $X_regexp, $X_encode);
+#print Dumper(%X_keywords);
+    my $X_encoded = \$X_keywords{X_encoded}; # eg alert => 2, function => 10 etc
+    # encode
+    $parser->add($X_regexp, sub {my $X_offset = pop; my @X_match = @_; return ${$X_encoded}->{$X_match[$X_offset]};});
+    # if encoded, wrap the script in a decoding function
+
+    return $X_script && _X_bootStrap(\$parser->exec($X_script), \%X_keywords);
+  }
+
+####################
+  sub _X_analyze { #
+####################
+#print Dumper(@_);
+    my ($X_script, $X_regexp, $X_encode) = @_;
+    # analyse
+    # retreive all words in the script
+    my @X_all = $X_script =~ m/$X_regexp/g; # Save all captures in a list context
+    my %XX_sorted    = ();  # list of words sorted by frequency
+    my %XX_encoded   = ();  # dictionary of word->encoding
+    my %XX_protected = ();  # instances of "protected" words
+    if (@X_all) {
+      my @X_unsorted  = (); # same list, not sorted
+      my %X_protected = (); # "protected" words (dictionary of word->"word")
+      my %X_values    = (); # dictionary of charCode->encoding (eg. 256->ff)
+      my %X_count     = (); # word->count
+      my $i = scalar(@X_all); my $j = 0; my $X_word = '';
+      # count the occurrences - used for sorting later
+      do {
+        $X_word = '$' . $X_all[--$i];
+        if (!exists($X_count{$X_word})) {
+          $X_count{$X_word}   = [0,$i]; # Store both the usage count and original array position (ie a secondary sort key)
+          $X_unsorted[$j]   = $X_word;
+          # make a dictionary of all of the protected words in this script
+          #   these are words that might be mistaken for encoding
+          $X_values{$j}     = &$X_encode($j);
+          my $v           = '$'.$X_values{$j};
+          $X_protected{$v}  = $j++;
+        }
+        # increment the word counter
+        $X_count{$X_word}[0]++;
+      } while ($i);
+#print Dumper (%X_values);
+#print Dumper (@X_unsorted);
+#print Dumper (%X_protected);
+      # prepare to sort the word list, first we must protect
+      #  words that are also used as codes. we assign them a code
+      #  equivalent to the word itself.
+      # e.g. if "do" falls within our encoding range
+      #       then we store keywords["do"] = "do";
+      # this avoids problems when decoding
+       $i = scalar(@X_unsorted);
+      do {
+        $X_word = $X_unsorted[--$i];
+        if (exists($X_protected{$X_word})) {
+          $XX_sorted{$X_protected{$X_word}} = substr($X_word,1);
+          $XX_protected{$X_protected{$X_word}} = 1; # true
+          $X_count{$X_word}[0] = 0;
+        }
+      } while ($i);
+#print Dumper (%XX_protected);
+#print Dumper (%XX_sorted);
+#print Dumper (%X_count);
+      # sort the words by frequency
+      # Sort with count a primary key and original array order as secondary key - which is apparently the default in javascript!
+      @X_unsorted = sort ({($X_count{$b}[0] - $X_count{$a}[0]) or ($X_count{$b}[1] <=> $X_count{$a}[1])} @X_unsorted);
+#print Dumper (@X_unsorted) . "\n";
+
+      $j = 0;
+      # because there are "protected" words in the list
+      # we must add the sorted words around them
+      do {
+        if (!exists($XX_sorted{$i})) {$XX_sorted{$i} = substr($X_unsorted[$j++],1)}
+        $XX_encoded{$XX_sorted{$i}} = $X_values{$i};
+      } while (++$i < scalar(@X_unsorted));
+    }
+#print Dumper(X_sorted => \%XX_sorted, X_encoded => \%XX_encoded, X_protected => \%XX_protected);
+    return (X_sorted => \%XX_sorted, X_encoded => \%XX_encoded, X_protected => \%XX_protected);
+  }
+
+######################
+  sub _X_bootStrap { #
+######################
+    # build the boot function used for loading and decoding
+    my ($X_packed, $X_keywords) = @_; # Reference arguments!
+#print Dumper ($X_keywords) . "\n";
+
+    # $packed: the packed script - dereference and escape
+    $X_packed = "'" . &_X_escape($$X_packed) ."'";
+
+    my %sorted    = %{$$X_keywords{X_sorted}};    # Dereference to local variables
+    my %protected = %{$$X_keywords{X_protected}}; # for simplicity
+
+    my @sorted    = ();
+    foreach my $key (keys %sorted) {$sorted[$key] = $sorted{$key}}; # Convert hash to a standard list
+
+    # ascii: base for encoding
+    my $X_ascii = ((scalar(@sorted) > $_X_encoding) ? $_X_encoding : scalar(@sorted)) || 1;
+
+    # count: number of (unique {RS}) words contained in the script
+    my $X_count = scalar(@sorted); # Use $X_count for assigning $X_ascii
+
+    # keywords: list of words contained in the script
+    foreach my $i (keys %protected) {$sorted[$i] = ''}; # Blank out protected words
+#print Dumper(@sorted) . "\n";
+
+    # convert from a string to an array - prepare keywords as a JScript string->array {RS}
+    $X_keywords = "'" . join('|',@sorted) . "'.split('|')";
+
+    # encode: encoding function (used for decoding the script)
+    my $X_encode = $_X_encoding > 62 ? $_JSencode95 : &_X_getEncoder($X_ascii,$JSCRIPT); # This is a JScript function (as a string)
+       $X_encode =~ s/_encoding/\x24ascii/g; $X_encode =~ s/arguments\.callee/\x24encode/g;
+    my $X_inline = '$count' . ($X_ascii > 10 ? '.toString($ascii)' : '');
+
+    # decode: code snippet to speed up decoding
+    my $X_decode = '';
+    if ($_X_fastDecode) {
+      # create the decoder
+      $X_decode = &_X_getFunctionBody($_JSdecode); # ie from the Javascript literal function
+      if ($_X_encoding > 62) {$X_decode =~ s/\\\\w/[\\xa1-\\xff]/g}
+      # perform the encoding inline for lower ascii values
+      elsif ($X_ascii < 36) {$X_decode =~ s/$X_ENCODE/$X_inline/g}
+      # special case: when $X_count==0 there ar no keywords. i want to keep
+      # the basic shape of the unpacking funcion so i'll frig the code...
+      if (!$X_count) {$X_decode =~ s/(\x24count)\s*=\s*1/$1=0/}
+    }
+
+    # boot function
+    my $X_unpack = $_JSunpack;
+    if ($_X_fastDecode) {
+      # insert the decoder
+      $X_unpack =~ s/\{/\{$X_decode;/;
+    }
+    $X_unpack =~ s/"/'/g;
+    if ($_X_encoding > 62) { # high-ascii
+      # get rid of the word-boundaries for regexp matches
+      $X_unpack =~ s/'\\\\b'\s*\+|\+\s*'\\\\b'//g; # Not checked! {RS}
+    }
+    if ($X_ascii > 36 || $_X_encoding > 62 || $_X_fastDecode) {
+    # insert the encode function
+    $X_unpack =~ s/\{/\{\$encode=$X_encode;/;
+    } else {
+      # perform the encoding inline
+      $X_unpack =~ s/$X_ENCODE/$X_inline/;
+    }
+
+    # arguments   {RS} Do this before using &pack because &pack changes the pack parameters (eg $fastDecode) in Perl!!
+    my $X_params = "$X_packed,$X_ascii,$X_count,$X_keywords"; # Interpolate to comma separated string
+    if ($_X_fastDecode) {
+      # insert placeholders for the decoder
+      $X_params .= ',0,{}';
+    }
+
+    # pack the boot function too
+    $X_unpack = &pack($X_unpack,0,0,1);
+
+    # the whole thing
+    return "eval(" . $X_unpack . "(" . $X_params . "))\n";
+  };
+
+#######################
+  sub _X_getEncoder { #
+#######################
+  # mmm.. ..which one do i need ?? ({RS} Perl or JScript ??)
+    my ($X_ascii,$language) = @_;
+    my $perl_encoder    = ($X_ascii > 10) ? ($X_ascii > 36) ? ($X_ascii > 62) ? $_X_encode95 : $_X_encode62 : $_X_encode36 : $_X_encode10;
+    my $jscript_encoder = ($X_ascii > 10) ? ($X_ascii > 36) ? ($X_ascii > 62) ? $_JSencode95 : $_JSencode62 : $_JSencode36 : $_JSencode10;
+    return ($language eq $JSCRIPT) ? $jscript_encoder : $perl_encoder;
+  };
+
+#############################
+# Perl versions of encoders #
+#############################
+  # base10 zero encoding - characters: 0123456789
+  $_X_encode10 = sub {return &_encodeBase(shift,10)};
+  # base36               - characters: 0123456789abcdefghijklmnopqrstuvwxyz
+  $_X_encode36 = sub {return &_encodeBase(shift,36)};
+  # base62               - characters: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
+  $_X_encode62 = sub {return &_encodeBase(shift,62)};
+  # high-ascii values    - characters: ����������������������������������������������������������������������������������������������
+  $_X_encode95 = sub {return &_encodeBase(shift,95)};
+  # Lookup character sets for baseN encoding
+     $baseLookup{10} = [(0..9)[0..9]];                    # base 10
+     $baseLookup{36} = [(0..9,'a'..'z')[0..35]];          # base 36
+     $baseLookup{62} = [(0..9,'a'..'z','A'..'Z')[0..61]]; # base 62
+     $baseLookup{95} = (); for (my $i=0; $i<95; $i++) {$baseLookup{95}[$i] = chr($i+161)}; # base95 (high ascii)
+#print Dumper(%baseLookup);
+#####################
+  sub _encodeBase { #
+#####################
+  # Generic base conversion function using defined lookup arrays (perl version only)
+    my ($X_charCode, $base) = @_;
+    my $X_encoded = '';
+    # Do we know this encoding?
+    if (exists ($baseLookup{$base})) {
+      if ($X_charCode == 0) {$X_encoded = $baseLookup{$base}[0]}
+      while($X_charCode > 0) {
+        $X_encoded  = $baseLookup{$base}[$X_charCode % $base] . $X_encoded;
+        $X_charCode = int($X_charCode / $base);
+      }
+    }
+    else {$X_encoded = "$X_charCode"} # default is to return unchanged (ie as for base 10) if no baselookup is available
+    return $X_encoded;
+  };
+
+#############################
+  $_X_encodePrivate = sub { #
+#############################
+  # special _chars
+    my $X_charCode = shift;
+    return '_' . $X_charCode;
+  };
+
+############################
+  sub _X_escape($script) { #
+############################
+  # protect characters used by the parser
+    my $X_script = shift;
+    $X_script =~ s/([\\'])/\\$1/g;
+    return $X_script;
+  };
+
+#####################
+  sub _X_escape95 { #
+#####################
+  # protect high-ascii characters already in the script
+    my $X_script = shift;
+    $X_script =~ s/([\xa1-\xff])/sprintf("\\x%1x",ord($1))/eg;
+    return $X_script;
+  };
+
+############################
+  sub _X_getFunctionBody { #
+############################
+  # extract the body of a function (ie between opening/closing {}) - consistent with Dean Edwards approach
+    my $X_function = shift;
+    $X_function =~ m/^.*\{(.*)\}*$/sg; # Multiline, global (greedy)
+    my $start = index($X_function,'{');
+    my $end   = rindex($X_function,'}');
+    $X_function = substr($X_function,($start+1),($end-1-$start));
+    return $X_function;
+  };
+
+######################
+  sub _X_globalize { #
+######################
+  # set the global flag on a RegExp (you have to create a new one) !!! Unused in perl version
+    # my $X_regexp = shift;
+  };
+
+  # build the parsing routine
+  &_X_addParser(\&_X_basicCompression);
+  &_X_addParser(\&_X_encodeSpecialChars) if ($_X_specialChars);
+  &_X_addParser(\&_X_encodeKeywords)     if ($_X_encoding);
+
+  # go!
+  return &_X_pack($_X_script);
+}
+
+########################
+# Javascript Literals  #
+########################
+
+# JScript function "_unpack" - from DeanEdwards pack.js (NB: No ";" after final "}")
+($_JSunpack) = <<'END_JSCRIPT_UNPACK';
+/* unpacking function - this is the boot strap function   */
+/* data extracted from this packing routine is passed to  */
+/* this function when decoded in the target               */
+function($packed, $ascii, $count, $keywords, $encode, $decode) {
+  while ($count--)
+    if ($keywords[$count])
+     $packed = $packed.replace(new RegExp('\\b' + $encode($count) + '\\b', 'g'), $keywords[$count]);
+  /* RS_Debug = $packed; */  /* {RS} !!!!!!!!! */
+  return $packed;
+}
+END_JSCRIPT_UNPACK
+
+# JScript function "_decode" - from DeanEdwards pack.js
+($_JSdecode) = <<'END_JSCRIPT_DECODE';
+  /* code-snippet inserted into the unpacker to speed up decoding */
+  function() {
+    /* does the browser support String.replace where the */
+    /*  replacement value is a function? */
+    if (!''.replace(/^/, String)) {
+      /* decode all the values we need */
+          while ($count--) $decode[$encode($count)] = $keywords[$count] || $encode($count);
+          /* global replacement function */
+          $keywords = [function($encoded){return $decode[$encoded]}];
+          /* generic match */
+          $encode = function(){return'\\w+'};
+          /* reset the loop counter -  we are now doing a global replace */
+          $count = 1;
+      }
+  };
+END_JSCRIPT_DECODE
+
+# JScript versions of encoders
+($_JSencode10) = <<'END_JSCRIPT_ENCODE10';
+  /* zero encoding */
+  /* characters: 0123456789 */
+  function($charCode) {
+    return $charCode;
+  };
+END_JSCRIPT_ENCODE10
+
+($_JSencode36) = <<'END_JSCRIPT_ENCODE36';
+  /* inherent base36 support */
+  /* characters: 0123456789abcdefghijklmnopqrstuvwxyz */
+  function($charCode) {
+    return $charCode.toString(36);
+  };
+END_JSCRIPT_ENCODE36
+
+($_JSencode62) = <<'END_JSCRIPT_ENCODE62';
+  /* hitch a ride on base36 and add the upper case alpha characters */
+  /* characters: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ */
+  function($charCode) {
+    return ($charCode < _encoding ? '' : arguments.callee(parseInt($charCode / _encoding))) +
+    (($charCode = $charCode % _encoding) > 35 ? String.fromCharCode($charCode + 29) : $charCode.toString(36));
+   };
+END_JSCRIPT_ENCODE62
+
+($_JSencode95) = <<'END_JSCRIPT_ENCODE95';
+ /* use high-ascii values */
+ /* characters: ���������������������������������������������������������������������������������������������� */
+ function($charCode) {
+   return ($charCode < _encoding ? '' : arguments.callee($charCode / _encoding)) +
+     String.fromCharCode($charCode % _encoding + 161);
+ };
+END_JSCRIPT_ENCODE95
+
+###########
+# END     #
+###########
+1; # Pack #
+###########

data/lib/packer/ParseMaster.pm

@@ -0,0 +1,207 @@
+#ParseMaster (July 25 2005)
+#  Based on "ParseMaster.js" by Dean Edwards <http://dean.edwards.name/>
+#  Ported to Perl by Rob Seiler, ELR Software Pty Ltd <http://www.elr.com.au>
+#  Copyright 2005. License <http://creativecommons.org/licenses/LGPL/2.1/>
+
+package ParseMaster;
+use strict;
+use Data::Dumper;
+
+# Package wide variable declarations
+use vars qw/$VERSION
+            @_X_escaped @_X_patterns
+           /;
+
+$VERSION    = '017';
+
+# constants
+my $X_EXPRESSION  = 0;
+my $X_REPLACEMENT = 1;
+my $X_LENGTH      = 2;
+
+# re's used to determine nesting levels
+my $X_GROUPS      = qr/\(/o;                # NB: Requires g modifier!
+my $X_SUB_REPLACE = qr/\$\d/o;
+my $X_INDEXED     = qr/^\$\d+$/o;
+my $XX_ESCAPE     = qr/\\./o;               # NB: Requires g modifier!
+my $XX_DELETED    = qr/\001[^\001]*\001/o;  # NB: Requires g modifier!
+my $DIGIT         = qr/[^\D]/o;             # Yep - this is a digit - contains no non-digits
+
+# Constructor
+sub new {
+  my $class = shift;
+  my $self  = {};
+  @_X_escaped  = ();  # Re-initialize global for each instance
+  @_X_patterns = ();  # Re-initialize global for each instance
+  # Instance variables - access by similarly named set/get functions
+  $self->{_ignoreCase_} = 0;
+  $self->{_escapeChar_} = '';
+  bless ($self, $class);
+  return $self;
+}
+
+sub ignoreCase {
+  my ($self, $value) = @_;
+  if (defined($value)) {
+    $self->{_ignoreCase_} = $value;
+  }
+  return $self->{_ignoreCase_};
+}
+
+sub escapeChar{
+  my ($self, $value) = @_;
+  if (defined($value)) {
+    $self->{_escapeChar_} = $value;
+  }
+  return $self->{_escapeChar_};
+}
+
+#######################
+# Public Parsemaster functions
+
+my $X_DELETE = sub(@$) {
+  my $X_offset = pop;
+  my @X_match = @_;
+  return (chr(001) . $X_match[$X_offset] . chr(001));
+}; # NB semicolon required for closure!
+
+# create and add a new pattern to the patterns collection
+sub add {
+  my ($self, $expression, $X_replacement) = @_;
+  if (!$X_replacement) {$X_replacement = $X_DELETE};
+
+  # count the number of sub-expressions
+  my $temp = &_X_internalEscape($expression);
+  my $length  = 1; # Always at least one because each pattern is itself a sub-expression
+     $length += $temp =~ s/$X_GROUPS//g; # One way to count the left capturing parentheses in the regexp string
+
+  # does the pattern deal with sub-expressions?
+  if ((ref($X_replacement) ne "CODE") && ($X_replacement =~ m/$X_SUB_REPLACE/)) {
+    if ($X_replacement =~ m/$X_INDEXED/) { # a simple lookup? (eg "$2")
+      # store the index (used for fast retrieval of matched strings)
+      $X_replacement = substr($X_replacement,1) - 1;
+    }
+    else { # a complicated lookup (eg "Hello $2 $1")
+      my $i = $length;
+      while ($i) { # Had difficulty getting Perl to do Dean's splitting and joining of strings containing $'s
+        my $str = '$a[$o+' . ($i-1) . ']'; # eg $a[$o+1]
+        $X_replacement =~ s/\$$i/$str/;      # eg $2 $3 -> $a[$o+1] $a[$o+2]
+        $i--;
+      }
+      # build a function to do the lookup - returns interpolated string of array lookups
+      $X_replacement = eval('sub {my $o=pop; my @a=@_; return "' . $X_replacement . '"};');
+    }
+  }
+  else {}
+  # pass the modified arguments
+  &_X_add($expression || q/^$/, $X_replacement, $length);
+}
+
+# execute the global replacement
+sub exec {
+#print Dumper(@_X_patterns);
+  my ($self, $X_string) = @_;
+  my $escChar    = $self->escapeChar();
+  my $ignoreCase = $self->ignoreCase();
+  my ($regexp,$captures) = &_getPatterns();  # Concatenated and parenthesized regexp eg '(regex1)|(regex2)|(regex3)' etc
+  $X_string = &_X_escape($X_string, $escChar);
+  if ($ignoreCase) {$X_string =~ s/$regexp/{&_X_replacement(&_matchVars($captures,\$X_string))}/gie} # Pass $X_String as a
+    else           {$X_string =~ s/$regexp/{&_X_replacement(&_matchVars($captures,\$X_string))}/ge}  # reference for speed
+
+  $X_string = &_X_unescape($X_string, $escChar);
+  $X_string =~ s/$XX_DELETED//g;
+  return $X_string;
+}
+
+sub _X_add {
+  push (@_X_patterns, [@_]); # Save each argument set as is into an array of arrays
+}
+
+# this is the global replace function (it's quite complicated)
+sub _X_replacement {
+  my (@arguments) = @_;
+#print Dumper (@arguments);
+  if ($arguments[0] le '') {return ''}
+  # Dereference last index (source String) here - faster than in _matchVars (maybe not needed at all?)
+  $arguments[$#arguments] = ${$arguments[$#arguments]};
+  my $i = 1;
+  # loop through the patterns
+  for (my $j=0; $j<scalar(@_X_patterns); $j++) { # Loop through global all @_X_patterns
+    my @X_pattern = @{$_X_patterns[$j]};
+    # do we have a result? NB: "if ($arguments[$i])" as in Dean's Javascript is false for the value 0!!!
+    if ((defined $arguments[$i]) && ($arguments[$i] gt '')) {
+      my $X_replacement = $X_pattern[$X_REPLACEMENT];
+      # switch on type of $replacement
+      if (ref($X_replacement) eq "CODE") {     # function
+        return &$X_replacement(@arguments,$i);
+      }
+      elsif ($X_replacement =~ m/$DIGIT/) {    # number (contains no non-digits)
+        return $arguments[$X_replacement + $i];
+      }
+      else { # default
+        return $X_replacement;                 # default
+      }
+    } # skip over references to sub-expressions
+    else {$i += $X_pattern[$X_LENGTH]}
+  }
+}
+
+#######################
+# Private functions
+#######################
+
+# encode escaped characters
+sub _X_escape {
+  my ($X_string, $X_escapeChar) = @_;
+  if ($X_escapeChar) {
+    my $re = '\\'.$X_escapeChar.'(.)';
+    $X_string =~ s/$re/{push(@_X_escaped,$1); $X_escapeChar}/ge;
+  }
+  return $X_string;
+}
+
+# decode escaped characters
+sub _X_unescape {
+  my ($X_string, $X_escapeChar) = @_;
+  if ($X_escapeChar) { # We'll only do this if there is an $X_escapeChar!
+    my $re = '\\'.$X_escapeChar;
+    $X_string =~ s/$re/{$X_escapeChar . (shift(@_X_escaped))}/ge; # Don't use Dean Edwards as below 'or' here - because zero will return ''!
+  # $X_string =~ s/$re/{$X_escapeChar . (shift(@_X_escaped) || '')}/ge;
+  }
+  return $X_string;
+}
+
+sub _X_internalEscape {
+  my ($string) = shift;
+  $string =~ s/$XX_ESCAPE//g;
+  return $string;
+}
+
+# Builds an array of match variables to (approximately) emulate that available in Javascript String.replace()
+sub _matchVars {
+  my ($m,$sref) = @_;
+  my @args = (1..$m);                # establish the number potential memory variables
+  my @mv = map {eval("\$$_")} @args; # matchvarv[1..m] = the memory variables $1 .. $m
+  unshift (@mv, $&);                 # matchvar[0]     = the substring that matched
+  push    (@mv, length($`));         # matchvar[m+1]   =  offset within the source string where the match occurred (= length of prematch string)
+  push    (@mv, $sref);              # matchvar[m+2]   = reference to full source string (dereference in caller if/when needed)
+#print Dumper (@mv);
+  return @mv;
+}
+
+sub _getPatterns {
+  my @Patterns = ();
+  my $lcp = 0;
+  for (my $i=0; $i<scalar(@_X_patterns); $i++) {       # Loop through global all @_patterns
+    push (@Patterns, $_X_patterns[$i][$X_EXPRESSION]); # accumulate the expressions
+    $lcp += $_X_patterns[$i][$X_LENGTH];               # sum the left capturing parenthesis counts
+  }
+  my $str = "(" . join(')|(',@Patterns). ")";          # enclose each pattern in () separated by "|"
+  return ($str, $lcp);
+}
+
+##################
+# END            #
+##################
+1; # ParseMaster #
+##################

data/lib/packer/jsPacker.pl

@@ -0,0 +1,163 @@
+#!perl
+#jsPacker (July 2005)
+#
+use strict;
+use Pack;
+use vars qw($PROGNAME $VERSION
+            $opt_h $opt_q $opt_v $opt_i $opt_o $opt_e $opt_f $opt_s);
+use Getopt::Std;
+
+$PROGNAME    = $0;
+$VERSION     = '1.00b';
+
+my $Description = 'A JavaScript Compressor/Obfuscator';
+my $Version    = "v$VERSION\[p$Pack::VERSION-pm$Pack::PM_VERSION\]";
+
+# "English" versions of settings
+my %ENCODINGS = (0=>'None', 10=>'Decimal', 36=>'Normal', 62=>'Normal', 95=>'High-ascii');
+my %SETTINGS  = (0=>'No', 1=>'Yes');
+
+exit(0) if &main();
+exit(1);
+
+################
+# Sub-routines #
+################
+# Main program
+sub main {
+  # Get command line options
+  &getopts('hqvfsi:o:e:');
+  $opt_h ||= 0;   # $opt_h shows usage and exits
+  $opt_q ||= 0;   # $opt_q sets quiet mode (no stdout output)
+  $opt_v ||= 0;   # $opt_v shows version and exits
+  $opt_i ||= '';  # $opt_i is input file. Required!
+  $opt_o ||= '';  # $opt_o is output file. If not set, use standard output
+  $opt_e ||= 0;   # $opt_e encoding level (0,10,36,62,95)
+  $opt_f ||= 0;   # $opt_f use fast decoding
+  $opt_s ||= 0;   # $opt_x use special characters
+
+  # Display help or version if requested
+  if ($opt_h) {&usage("help")}
+  if ($opt_v) {&usage("version")}
+
+  # Constrain encoding level, fastdecoding and specialcharacters to allowed limits
+  $opt_e = ($opt_e > 0) ? ($opt_e > 10) ? ($opt_e > 36) ? ($opt_e > 62) ? 95 : 62 : 36 : 10 : 0;
+  $opt_f = ($opt_f) ? 1 : 0;
+  $opt_s = ($opt_s) ? 1 : 0;
+
+  # Do the job if an input file is specified
+  if ($opt_i) {
+    # Read the source script
+    my $script = &readInputFile($opt_i);
+    # Pack the source script
+    my $packedscript = &Pack::pack($script,$opt_e, $opt_f, $opt_s);
+    # Show what happened (if not in quiet mode)
+    if (!$opt_q) {showJobDetails($opt_i, $opt_o, $opt_e, $opt_f,$opt_s,\$script,\$packedscript)}
+    # Output the packed script
+    if ($opt_o) {&writeOutputFile($opt_o,\$packedscript)} # to output file if specifed
+      else {print "$packedscript"}                        # otherwise to STDOUT
+  }
+  else { # If no input file is specified, display help
+    &usage();
+  }
+  return(1);
+}
+
+######################
+sub showJobDetails { #
+######################
+# Show details of input/output files, settings and compression ratio
+  my ($inputfile, $outputfile,
+      $encoding, $fastdecode, $specialchars,
+      $instringref, $outstringref) = @_;
+  print "$PROGNAME $Version\n";
+  print "\tSource file : ";
+  print "\"$inputfile\"\n";
+  print (($outputfile) ? ("\tOutput file : \"$outputfile\"\n") : ''); # Print only if output is going to a file
+  print "\tSettings    : encoding=$ENCODINGS{$encoding} fastdecode=$SETTINGS{$fastdecode} specialchars=$SETTINGS{$specialchars}\n";
+  print "\tCompression : " . &compressionRatio($instringref, $outstringref). "\n\n";
+
+}
+
+#####################
+sub readInputFile { #
+#####################
+# Read content (source script) from input file
+  my $filename = shift;
+  open(FH, $filename) || die "Error!!! Problem opening input file \"$filename\"!\n";
+  my @content = <FH>;
+  close(FH);
+  return join('',@content);
+}
+
+#######################
+sub writeOutputFile { #
+#######################
+# Write content (packed script) to output file
+  my ($filename,$refcontent) = @_;
+  open(FH, ">$filename") || die "Error!!! Problem opening output file \"$filename\"\n";
+  print(FH $$refcontent);
+  close(FH);
+}
+
+########################
+sub compressionRatio { #
+########################
+# Calculate the ratio of output string to input string
+  my ($sref1,$sref2) = @_;
+  my $ratio = (length($$sref2) / (length($$sref1)||1));
+  $ratio = sprintf "%.2f", $ratio;
+  return $ratio;
+}
+
+#############
+sub usage { #
+#############
+# Inform user about usage, version and exit
+  my $showusage = 0;
+  my $showversion = 0;
+  my $params = shift;
+  if (defined $params) {
+    if ($params eq "help") {$showusage = 1;}
+      elsif ($params eq "version") {$showversion = 1;}
+    else {$showusage = 1;}
+  }
+  else {$showversion = 1;}
+  if ($showversion) {
+    print<<EOT;
+
+$PROGNAME $Version
+  $Description
+\tBased on "Packer.js" by Dean Edwards <http://dean.edwards.name/>
+\tPorted to Perl by Rob Seiler, ELR Software Pty Ltd <http://www.elr.com.au>
+\tCopyright 2005. License <http://creativecommons.org/licenses/LGPL/2.1/>
+  Use "$PROGNAME -h" for options
+EOT
+  exit(1);
+  }
+  if ($showusage) {
+    print<<EOT;
+
+$PROGNAME $Version
+  $Description
+  Usage:
+\t$PROGNAME -i inputfile [-o outputfile] [-eX] [-f] [-s] [-qvh]\n
+\t-i  <inputfile>  (eg -i myscript.js)
+\t-o  <outputfile> (eg -o myscript-p.js)
+\t-eN <encoding>   [0=None 10=Numeric 62=Normal(alphanumeric) 95=High-ascii]
+\t-f  <fast decode>
+\t-s  <special characters>
+\t-q  quiet mode
+\t-v  version
+\t-h  help
+
+  Examples:
+\t$PROGNAME -i myscript.js
+\t$PROGNAME -i myscript.js -o packed.js
+\t$PROGNAME -i myscript.js -o packed.js -e10 -f -s
+\t$PROGNAME -i myscript.js -e95 -fsq > packed.js
+
+EOT
+  exit(1);
+  }
+}

data/lib/templates/Rakefile.erb

@@ -3,7 +3,13 @@ require 'rubygems' unless ENV['NO_RUBYGEMS']
 
 require 'jquery_plugin_gen/tasks'
 
-# create any new tasks here
+PLUGIN  = '<%= details[:project] %>'
+VERSION = '<%= details[:version] %>'
+
+# Load your custom tasks from tasks folder
+Dir.glob("tasks/*.rake").each{ |t| import t rescue nil }
+
+# Alternatively, create any new tasks here
 # task :default => [:task, :dependencies] do
 #   yours
 # end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jqueryplugingen
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - toddb
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-06 00:00:00 +12:00
+date: 2009-06-07 00:00:00 +12:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -211,14 +211,19 @@ files:
 - jQuery-Plugin-Generator.tmproj
 - lib/jqp/cli.rb
 - lib/jquery_plugin_gen.rb
+- lib/jquery_plugin_gen/compiletask.rb
 - lib/jquery_plugin_gen/generator.rb
 - lib/jquery_plugin_gen/quick_template.rb
+- lib/jquery_plugin_gen/support/build.rake
 - lib/jquery_plugin_gen/support/bundles.rake
 - lib/jquery_plugin_gen/support/jquery.rake
+- lib/jquery_plugin_gen/support/package.rake
 - lib/jquery_plugin_gen/tasks.rb
+- lib/packer/Pack.pm
+- lib/packer/ParseMaster.pm
+- lib/packer/jsPacker.pl
 - lib/templates/History.txt.erb
 - lib/templates/README.txt.erb
-- lib/templates/Makefile.erb
 - lib/templates/Rakefile.erb
 - lib/templates/example.html.erb
 - lib/templates/src/plugin.js.erb

data/lib/templates/Makefile.erb

@@ -1,76 +0,0 @@
-VERSION = <%= details[:version] %>
-
-SRC_DIR = src
-BUILD_DIR = build
-DIST_DIR = dist/${VERSION}
-
-JS_FILES = ${SRC_DIR}/<%= details[:project] %>.js
-
-RELEASE_FILES = README.txt HISTORY.txt
-IMAGES = ${SRC_DIR}/images/*
-CSS = ${SRC_DIR}/css/*
-
-IMAGES_DIST = ${BUILD_DIR}/images
-CSS_DIST = ${BUILD_DIR}/css
-
-WE = ${BUILD_DIR}/jquery.<%= details[:project] %>.js
-WE_PACK = ${BUILD_DIR}/jquery.<%= details[:project] %>.pack.js
-
-WE_ARCH = ${DIST_DIR}/jquery.<%= details[:project] %>.tar.gz
-WE_RELEASE = ${DIST_DIR}/jquery.<%= details[:project] %>-${VERSION}.tar.gz
-
-MERGE = sed -e '1 s/^\xEF\xBB\xBF//' ${JS_FILES} > ${WE}
-PACKER = perl -I$ lib/packer lib/packer/jsPacker.pl -i ${WE} -o ${WE_PACK} -e62
-
-all: archive
-
-merge:
-
-	@@echo " - Cleaning Build dir " ${BUILD_DIR}
-	@@rm -rf ${BUILD_DIR}
-	@@mkdir -p ${BUILD_DIR}
-
-	@@echo "Building" ${WE}
-
-	@@echo " - Merging files"
-	@@${MERGE}
-
-	@@echo ${WE} "- built"
-	@@echo
-
-pack: merge
-	@@echo " - Packing " ${WE_PACK}
-
-	@@echo "Compressing using Packer"
-	@@${PACKER}
-
-	@@echo
-
-archive: pack
-
-	@@echo " - Cleaning Build dir " ${DIST_DIR}
-	@@rm -rf ${DIST_DIR}
-	@@mkdir -p ${DIST_DIR}
-		
-	@@echo "- Making archive" ${WE_RELEASE}
-
-	@@echo "Making DIST dir" ${IMAGES_DIST} ${CSS_DIST}
-	@@mkdir -p ${IMAGES_DIST} ${CSS_DIST}
-
-	@@echo " - Coping CSS and images"
-#	@@cp -R -f ${IMAGES} ${IMAGES_DIST}
-	@@cp -R -f ${CSS} ${CSS_DIST}
-	@@cp -f ${RELEASE_FILES} ${BUILD_DIR}
-	
-	@@echo " - Creating release"
-	@@tar -cjf ${WE_RELEASE} ${BUILD_DIR}
-
-	@@echo "Building" ${WE_ARCH}
-
-	@@echo " - Creating archive"
-	@@rm -f ${WE_ARCH}
-	@@tar --exclude '.DS_Store ._' -czf ${WE_ARCH} .
-
-	
-	
-