jsmin-ffi 0.2.2

data/README.textile

@@ -0,0 +1,46 @@
+h2. FFI Javascript minifier
+
+h3. Description
+
+This library was created in order to provide a reasonably fast Javascript
+minifier on JRuby platform.
+Both native Java and Ruby implementations were found to be in several orders
+of magnitude slower.
+The only change from the original C implementation, is that it was changed
+to C++ (in order to make global variables become instance variables),
+and it works with buffers rather than stdin/stdout now.
+
+h3. Synopsis
+
+<pre>
+ require 'jsmin_ffi'
+ input = IO.read('prototype.js')
+ begin
+   output = JsminFFI.minify!(input)
+   File.open('output.js', 'w') {|f| f.write(output)}
+ rescue Jsmin::ParseError => e
+   $stderr.puts "Cannot minify: #{e}"
+ end
+</pre>
+
+or use a native extension:
+<pre>
+ require 'Jsmin'
+ input = IO.read('jquery.js')
+ begin
+   output = Jsmin.minify(input)
+   File.open('output.js', 'w') {|f| f.write(output)}
+ rescue Jsmin::ParseError => e
+   $stderr.puts "Cannot minify: #{e}"
+ end
+</pre>
+
+h3. Bugs
+
+The memory allocated in the C++ code might not be freed when using FFI.
+It depends on how FFI handles the returned char*.
+
+h3. See also
+
+For the original implementation, please see:
+http://www.crockford.com/javascript/jsmin.html

data/Rakefile

@@ -0,0 +1,14 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'jsmin-ffi'
+    gemspec.summary = 'Very fast jsmin implementation using FFI'
+    gemspec.email = 'romanbsd@yahoo.com'
+    gemspec.homepage = 'http://github.com/romanbsd/jsmin-ffi'
+    gemspec.description = gemspec.summary
+    gemspec.authors = ['Roman Shterenzon']
+    gemspec.add_dependency('ffi', '>=0.3.5')
+  end
+rescue LoadError
+end
+Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.2.2

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('Jsmin')

data/ext/jsmin.cpp

@@ -0,0 +1,306 @@
+/* jsmin.c
+   2011-01-22
+
+Copyright (c) 2002 Douglas Crockford  (www.crockford.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "jsmin.h"
+
+Jsmin::Jsmin()
+{
+  index_in = 0;
+  index_out = 0;
+  theLookahead = EOF;
+  output_buf = NULL;
+  input_buf = NULL;
+}
+
+Jsmin::~Jsmin() {
+	if (output_buf) {
+		free(output_buf);
+	}
+}
+/* isAlphanum -- return true if the character is a letter, digit, underscore,
+        dollar sign, or non-ASCII character.
+*/
+
+int Jsmin::isAlphanum(int c)
+{
+    return ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
+        (c >= 'A' && c <= 'Z') || c == '_' || c == '$' || c == '\\' ||
+        c > 126);
+}
+
+
+/* get -- return the next character from stdin. Watch out for lookahead. If
+        the character is a control character, translate it to a space or
+        linefeed.
+*/
+
+int Jsmin::get()
+{
+    int c = theLookahead;
+    theLookahead = EOF;
+    if ( index_in >= m_size ) {
+        return EOF;
+    }
+    if (c == EOF) {
+        c = input_buf[index_in++];
+    }
+    if (c >= ' ' || c == '\n' || c == EOF) {
+        return c;
+    }
+    if (c == '\r') {
+        return '\n';
+    }
+    return ' ';
+}
+
+
+/* peek -- get the next character without getting it.
+*/
+
+int Jsmin::peek()
+{
+    theLookahead = get();
+    return theLookahead;
+}
+
+
+/* next -- get the next character, excluding comments. peek() is used to see
+        if a '/' is followed by a '/' or '*'.
+*/
+
+int Jsmin::next()
+{
+    int c = get();
+    if  (c == '/') {
+        switch (peek()) {
+        case '/':
+            for (;;) {
+                c = get();
+                if (c <= '\n') {
+                    return c;
+                }
+            }
+        case '*':
+            get();
+            for (;;) {
+                switch (get()) {
+                case '*':
+                    if (peek() == '/') {
+                        get();
+                        return ' ';
+                    }
+                    break;
+                case EOF:
+                    throw("!Unterminated comment");
+                }
+            }
+        default:
+            return c;
+        }
+    }
+    return c;
+}
+
+
+/* action -- do something! What you do is determined by the argument:
+        1   Output A. Copy B to A. Get the next B.
+        2   Copy B to A. Get the next B. (Delete A).
+        3   Get the next B. (Delete B).
+   action treats a string as a single character. Wow!
+   action recognizes a regular expression if it is preceded by ( or , or =.
+*/
+
+void Jsmin::action(int d)
+{
+    switch (d) {
+    case 1:
+        output_buf[index_out++] = theA;
+    case 2:
+        theA = theB;
+        if (theA == '\'' || theA == '"') {
+            for (;;) {
+                output_buf[index_out++] = theA;
+                theA = get();
+                if (theA == theB) {
+                    break;
+                }
+                if (theA == '\\') {
+                    output_buf[index_out++] = theA;
+                    theA = get();
+                }
+                if (theA == EOF) {
+                    throw("!Unterminated string literal");
+                }
+            }
+        }
+    case 3:
+        theB = next();
+        if (theB == '/' && (theA == '(' || theA == ',' || theA == '=' ||
+                            theA == ':' || theA == '[' || theA == '!' ||
+                            theA == '&' || theA == '|' || theA == '?' ||
+                            theA == '{' || theA == '}' || theA == ';' ||
+                            theA == '\n')) {
+            output_buf[index_out++] = theA;
+            output_buf[index_out++] = theB;
+            for (;;) {
+                theA = get();
+                if (theA == '[') {
+                    for (;;) {
+                        output_buf[index_out++] = theA;
+                        theA = get();
+                        if (theA == ']') {
+                            break;
+                        }
+                        if (theA == '\\') {
+                            output_buf[index_out++] = theA;
+                            theA = get();
+                        }
+                        if (theA == EOF) {
+                            throw("!Unterminated set in Regular Expression literal");
+                        }
+                    }
+                } else if (theA == '/') {
+                    break;
+                } else if (theA =='\\') {
+                    output_buf[index_out++] = theA;
+                    theA = get();
+                }
+                if (theA == EOF) {
+                    throw("!Unterminated Regular Expression literal");
+                }
+                output_buf[index_out++] = theA;
+            }
+            theB = next();
+        }
+    }
+}
+
+
+/* minify -- Copy the input to the output, deleting the characters which are
+        insignificant to JavaScript. Comments will be removed. Tabs will be
+        replaced with spaces. Carriage returns will be replaced with linefeeds.
+        Most spaces and linefeeds will be removed.
+*/
+
+char* Jsmin::minify(const char *original)
+{
+    input_buf = original;
+    index_in = 0;
+    index_out = 0;
+
+    if (output_buf != NULL) {
+      free(output_buf);
+      output_buf = NULL;
+    }
+    m_size = strlen(original);
+    output_buf = (char *)malloc(sizeof(char) * (m_size+1));
+
+    theA = ';';
+    action(3);
+    while (theA != EOF) {
+        switch (theA) {
+        case ' ':
+            if (isAlphanum(theB)) {
+                action(1);
+            } else {
+                action(2);
+            }
+            break;
+        case '\n':
+            switch (theB) {
+            case '{':
+            case '[':
+            case '(':
+            case '+':
+            case '-':
+                action(1);
+                break;
+            case ' ':
+                action(3);
+                break;
+            default:
+                if (isAlphanum(theB)) {
+                    action(1);
+                } else {
+                    action(2);
+                }
+            }
+            break;
+        default:
+            switch (theB) {
+            case ' ':
+                if (isAlphanum(theA)) {
+                    action(1);
+                    break;
+                }
+                action(3);
+                break;
+            case '\n':
+                switch (theA) {
+                case '}':
+                case ']':
+                case ')':
+                case '+':
+                case '-':
+                case '"':
+                case '\'':
+                    action(1);
+                    break;
+                default:
+                    if (isAlphanum(theA)) {
+                        action(1);
+                    } else {
+                        action(3);
+                    }
+                }
+                break;
+            default:
+                action(1);
+                break;
+            }
+        }
+    }
+    output_buf[index_out] = 0;
+    return output_buf;
+}
+
+extern "C" {
+  char* minify(const char *in)
+  {
+    char *out;
+    Jsmin m;
+    try {
+      out = strdup(m.minify(in));
+    }
+    catch (char const *e) {
+      out = strdup(e);
+    }
+    return out;
+  }
+}

data/ext/jsmin.h

@@ -0,0 +1,27 @@
+#ifndef JSMIN_H
+#define JSMIN_H
+
+class Jsmin
+{
+public:
+  Jsmin();
+  ~Jsmin();
+  char* minify(const char *);
+
+private:
+  int   theA;
+  int   theB;
+  int   theLookahead;
+  size_t index_in;
+  size_t index_out;
+  const char *input_buf;
+  char *output_buf;
+  size_t m_size;
+
+  int isAlphanum(int c);
+  int get();
+  int peek();
+  int next();
+  void action(int d);
+};
+#endif

data/ext/jsmin_wrap.c

@@ -0,0 +1,51 @@
+/* This trivial wrapper can be used for native extension
+ * currently unused.
+ */
+
+#include <ruby.h>
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) (RSTRING(str)->ptr)
+#endif
+
+extern char *minify(char *);
+
+static VALUE rb_eParseError;
+
+/*
+ *  call-seq:
+ *     Jsmin.minify(str)   -> new_str
+ *
+ *  Returns a new string object containing a minified copy of <i>str</i>.
+ *  May raise Jsmin::ParseError if parsing fails.
+ */
+static VALUE minify_wrap(VALUE self, VALUE arg)
+{
+	char *input;
+	char *res;
+	VALUE str, rv;
+
+	str = StringValue(arg);
+	input = RSTRING_PTR(str);
+
+	res = minify(input);
+
+	if (res[0] == '!') {
+		rv = rb_str_new2(res+1);
+		free(res);
+		rb_raise(rb_eParseError, "%s", RSTRING_PTR(rv));
+	}
+
+	rv = rb_str_new2(res);
+	free(res);
+
+	return rv;
+}
+
+static VALUE mJsmin;
+
+void Init_Jsmin(void) {
+	mJsmin = rb_define_module("Jsmin");
+	rb_eParseError = rb_define_class_under(mJsmin, "ParseError", rb_eRuntimeError);
+	rb_define_module_function(mJsmin, "minify", minify_wrap, 1);
+}

data/jsmin-ffi.gemspec

@@ -0,0 +1,48 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{jsmin-ffi}
+  s.version = "0.2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Roman Shterenzon"]
+  s.date = %q{2011-03-28}
+  s.description = %q{Very fast jsmin implementation using FFI}
+  s.email = %q{romanbsd@yahoo.com}
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = [
+    "README.textile"
+  ]
+  s.files = [
+    "README.textile",
+    "Rakefile",
+    "VERSION",
+    "ext/extconf.rb",
+    "ext/jsmin.cpp",
+    "ext/jsmin.h",
+    "ext/jsmin_wrap.c",
+    "jsmin-ffi.gemspec",
+    "lib/jsmin_ffi.rb"
+  ]
+  s.homepage = %q{http://github.com/romanbsd/jsmin-ffi}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Very fast jsmin implementation using FFI}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ffi>, [">= 0.3.5"])
+    else
+      s.add_dependency(%q<ffi>, [">= 0.3.5"])
+    end
+  else
+    s.add_dependency(%q<ffi>, [">= 0.3.5"])
+  end
+end
+

data/lib/jsmin_ffi.rb

@@ -0,0 +1,23 @@
+require 'ffi'
+
+module JsminFFI
+  extend FFI::Library
+  ffi_lib File.dirname(__FILE__) + '/Jsmin.' + (RUBY_PLATFORM=~/darwin/ ? 'bundle' : 'so')
+  attach_function :minify, [:string], :string
+
+  class ParseError < RuntimeError; end
+
+  extend self
+
+  # Minify the provided javascript
+  # @param [String] buf Javascript text
+  # @return [String] minified Javascript text
+  # @raise [ParseError] when parsing fails
+  def minify!(buf)
+    res = minify(buf)
+    if res[0..0] == '!'
+      raise ParseError.new(res.tr('!', ''))
+    end
+    res
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: jsmin-ffi
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 2
+  version: 0.2.2
+platform: ruby
+authors: 
+- Roman Shterenzon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-28 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        - 5
+        version: 0.3.5
+  type: :runtime
+  version_requirements: *id001
+description: Very fast jsmin implementation using FFI
+email: romanbsd@yahoo.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.textile
+files: 
+- README.textile
+- Rakefile
+- VERSION
+- ext/extconf.rb
+- ext/jsmin.cpp
+- ext/jsmin.h
+- ext/jsmin_wrap.c
+- jsmin-ffi.gemspec
+- lib/jsmin_ffi.rb
+has_rdoc: true
+homepage: http://github.com/romanbsd/jsmin-ffi
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Very fast jsmin implementation using FFI
+test_files: []
+