ruby-clean-css 0.0.2

data/lib/ruby-clean-css.rb

@@ -0,0 +1,6 @@
+require 'therubyracer'
+require 'commonjs'
+require 'ruby-clean-css/version'
+require 'ruby-clean-css/exports'
+require 'ruby-clean-css/compressor'
+require 'ruby-clean-css/railtie'  if defined?(Rails)

data/lib/ruby-clean-css/compressor.rb

@@ -0,0 +1,142 @@
+class RubyCleanCSS::Compressor
+
+  LIB_PATH = File.expand_path(File.dirname(__FILE__)+'/../javascript')
+
+  attr_reader(:last_result)
+
+
+  def initialize(options = {})
+    @js_options = js_options_from_hash(options)
+  end
+
+
+  def compress(stream_or_string)
+    @last_result = result = { :min => nil }
+    begin
+      minifier.minify(stream_or_string.to_s, lambda { |this, errs, data|
+        result[:min] = data
+      })
+    rescue => e
+      raise(e)
+    ensure
+      result[:errors] = minifier.context.errors
+      result[:warnings] = minifier.context.warnings
+      GC.start # This prevents unexplained segmentation faults in the ref gem!
+    end
+    result[:min]
+  end
+
+
+  def minifier
+    @minifier ||= minifier_class.call(@js_options)
+  end
+
+
+  protected
+
+    def js_runtime
+      if @js_runtime
+        @js_runtime
+      else
+        @js_runtime = V8::Context.new
+        @js_runtime['process'] = RubyCleanCSS::Exports::Process.new
+        @js_runtime['console'] = RubyCleanCSS::Exports::Console.new
+        @js_runtime['Buffer'] = RubyCleanCSS::Exports::Buffer.new
+        @js_runtime
+      end
+    end
+
+
+    def js_env
+      if @js_env
+        @js_env
+      else
+        @js_env = CommonJS::Environment.new(js_runtime, :path => LIB_PATH)
+        @js_env.native('path', RubyCleanCSS::Exports::Path)
+        @js_env.native('util', RubyCleanCSS::Exports::Util)
+        @js_env.native('fs', RubyCleanCSS::Exports::FS)
+        @js_env.native('url', RubyCleanCSS::Exports::Url)
+        @js_env.native('http', RubyCleanCSS::Exports::Http.new)
+        @js_env.native('https', RubyCleanCSS::Exports::Http.new)
+        @js_env
+      end
+    end
+
+
+    def minifier_class
+      @minifier_class ||= js_env.require('clean-css/index')
+    end
+
+
+    # See README.md for a description of each option, and see
+    # https://github.com/GoalSmashers/clean-css#how-to-use-clean-css-programmatically
+    # for the JS translation.
+    #
+    def js_options_from_hash(options)
+      js_opts = {}
+
+      if options.has_key?(:keep_special_comments)
+        js_opts['keepSpecialComments'] = {
+          'all' => '*',
+          'first' => 1,
+          'none' => 0,
+          '*' => '*',
+          '1' => 1,
+          '0' => 0
+        }[options[:keep_special_comments].to_s]
+      end
+
+      if options.has_key?(:keep_breaks)
+        js_opts['keepBreaks'] = options[:keep_breaks] ? true : false
+      end
+
+      if options.has_key?(:root)
+        js_opts['root'] = options[:root].to_s
+      end
+
+      if options.has_key?(:relative_to)
+        js_opts['relativeTo'] = options[:relative_to].to_s
+      end
+
+      if options.has_key?(:no_rebase)
+        js_opts['noRebase'] = options[:no_rebase] ? true : false
+      elsif !options[:rebase_urls].nil?
+        js_opts['noRebase'] = options[:rebase_urls] ? false : true
+      end
+
+      if options.has_key?(:no_advanced)
+        js_opts['noAdvanced'] = options[:no_advanced] ? true : false
+      elsif !options[:advanced].nil?
+        js_opts['noAdvanced'] = options[:advanced] ? false : true
+      end
+
+      if options.has_key?(:rounding_precision)
+        js_opts['roundingPrecision'] = options[:rounding_precision].to_i
+      end
+
+      if options.has_key?(:compatibility)
+        js_opts['compatibility'] = options[:compatibility].to_s
+        unless ['ie7', 'ie8'].include?(js_opts['compatibility'])
+          raise(
+            'Ruby-Clean-CSS: unknown compatibility setting: '+
+            js_opts['compatibility']
+          )
+        end
+      end
+
+      if options.has_key?(:process_import)
+        raise('Ruby-Clean-CSS: processImport option is not yet supported')
+      end
+
+      if options.has_key?(:benchmark)
+        raise('Ruby-Clean-CSS: benchmark option is not yet supported')
+      end
+
+      if options.has_key?(:debug)
+        raise('Ruby-Clean-CSS: debug option is not yet supported')
+      end
+
+      js_opts
+    end
+
+end

data/lib/ruby-clean-css/exports.rb

@@ -0,0 +1,258 @@
+# Attribution: much of this stubbly code is drawn from
+# https://github.com/cowboyd/less.rb/blob/master/lib/less/loader.rb
+#
+# Thanks!
+#
+
+
+require 'net/http'
+require 'pathname'
+require 'uri'
+
+module RubyCleanCSS::Exports
+
+  class Process # :nodoc:
+
+    def nextTick
+      lambda { |global, fn| fn.call }
+    end
+
+
+    def cwd
+      lambda { Dir.pwd }
+    end
+
+
+    def exit(*args)
+      warn("JS process.exit(#{args.first}) called from: \n#{caller.join("\n")}")
+    end
+
+  end
+
+
+
+  class Console # :nodoc:
+
+    def log(*msgs)
+      STDOUT.puts(msgs.join(', '))
+    end
+
+
+    def warn(*msgs)
+      STDERR.puts(msgs.join(', '))
+    end
+
+  end
+
+
+
+  module Path # :nodoc:
+
+    def self.join(*components)
+      # node.js expands path on join
+      File.expand_path(File.join(*components))
+    end
+
+
+    def self.dirname(path)
+      File.dirname(path)
+    end
+
+
+    def self.resolve(path)
+      File.expand_path(path)
+    end
+
+
+    def self.relative(base, path)
+      Pathname.new(path).relative_path_from(Pathname.new(base)).to_s
+    end
+
+  end
+
+
+
+  module Util # :nodoc:
+
+    def self.error(*errors)
+      raise errors.join(' ')
+    end
+
+
+    def self.puts(*args)
+      args.each { |arg| STDOUT.puts(arg) }
+    end
+
+  end
+
+
+
+  module FS # :nodoc:
+
+    def self.statSync(path)
+      out = File.stat(path)
+      if out.respond_to?(:define_singleton_method)
+        out.define_singleton_method(:isFile) { lambda { File.file?(path) } }
+      else
+        out.instance_variable_set(:@isFile, File.file?(path))
+        def out.isFile; lambda { @isFile }; end
+      end
+      out
+    end
+
+
+    def self.existsSync(path)
+      File.exists?(path)
+    end
+
+
+    def self.readFile(path, encoding, callback)
+      callback.call(nil, File.read(path))
+    end
+
+
+    def self.readFileSync(path, encoding = nil)
+      IO.read(path)
+    end
+
+  end
+
+
+
+  class Buffer # :nodoc:
+
+    def isBuffer(data)
+      false
+    end
+
+  end
+
+
+
+  module Url # :nodoc:
+
+    def self.resolve(*args)
+      URI.join(*args)
+    end
+
+
+    def self.parse(url_string)
+      u = URI.parse(url_string)
+      result = {}
+      result['protocol'] = u.scheme+':'  if u.scheme
+      result['hostname'] = u.host  if u.host
+      result['pathname'] = u.path  if u.path
+      result['port'] = u.port  if u.port
+      result['query'] = u.query  if u.query
+      result['search'] = '?'+u.query  if u.query
+      result['hash'] = '#'+u.fragment  if u.fragment
+      result
+    end
+
+  end
+
+
+
+  class Http # :nodoc:
+
+    attr_reader :get
+
+    def initialize
+      @get = lambda { |global, options, callback|
+        err = nil
+        uri_hash = {}
+        uri_hash[:host] = options['hostname'] || options['host']
+        path = options['path'] || options['pathname'] || ''
+        # We do this because node expects path and query to be combined:
+        path_components = path.split('?', 2)
+        if path_components.length > 1
+          uri_hash[:path] = path_components[0]
+          uri_hash[:query] = path_components[0]
+        else
+          uri_hash[:path] = path_components[0]
+        end
+        uri_hash[:port] = options['port'] ? options['port'] : Net::HTTP.http_default_port
+        # We check this way because of node's http.get:
+        uri_hash[:scheme] = uri_hash[:port] == Net::HTTP.https_default_port ? 'https' : 'http'
+        case uri_hash[:scheme]
+        when 'http'
+          uri = URI::HTTP.build(uri_hash)
+        when 'https'
+          uri = URI::HTTPS.build(uri_hash)
+        else
+          raise(Exception, 'import only supports http and https')
+        end
+        http = Net::HTTP.new(uri.host, uri.port)
+        if uri.scheme == 'https'
+          # Hurrah for insecurity
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          http.use_ssl = true
+        end
+        response = nil
+        http.start { |req| response = req.get(uri.to_s) }
+        begin
+          callback.call(
+            ServerResponse.new(response.read_body, response.code.to_i)
+          )
+        rescue => e
+          err = e
+        end
+        HttpGetResult.new(err);
+      }
+    end
+
+
+
+    class HttpGetResult
+
+      attr_accessor :err
+
+
+      def initialize(err)
+        @err = err
+      end
+
+
+      def on(event, callback)
+        if event == 'error' && @err
+          callback.call(@err)
+        end
+        self
+      end
+
+
+      def setTimeout(timer, callback)
+        # TODO?
+      end
+
+    end
+
+
+
+    class ServerResponse
+
+      attr_accessor :statusCode
+      attr_accessor :data # faked because ServerResponse actually implements WriteableStream
+
+
+      def initialize(data, status_code)
+        @data = data
+        @statusCode = status_code
+      end
+
+
+      def on(event, callback)
+        case event
+        when 'data'
+          callback.call(@data)
+        else
+          callback.call()
+        end
+        self
+      end
+
+    end
+
+  end
+
+end

data/lib/ruby-clean-css/railtie.rb

@@ -0,0 +1,27 @@
+require 'action_controller/railtie'
+require 'ruby-clean-css/sprockets'
+
+class RubyCleanCSS::Railtie < ::Rails::Railtie
+
+  initializer(
+    'ruby-clean-css.environment',
+    :after => 'sprockets.environment'
+  ) { |app|
+    RubyCleanCSS::Sprockets.register(app.assets)
+  }
+
+
+  initializer(
+    'ruby-clean-css.setup',
+    :after => :setup_compression,
+    :group => :all
+  ) { |app|
+    if app.config.assets.enabled
+      curr = app.config.assets.css_compressor
+      unless curr.respond_to?(:compress)
+        app.config.assets.css_compressor = RubyCleanCSS::Sprockets::LABEL
+      end
+    end
+  }
+
+end

data/lib/ruby-clean-css/sprockets.rb

@@ -0,0 +1,19 @@
+module RubyCleanCSS::Sprockets
+
+  LABEL = :cleancss
+
+  def self.register(sprockets)
+    klass = RubyCleanCSS::Compressor
+    if sprockets.respond_to?(:register_compressor)
+      sprockets.register_compressor('text/css', LABEL, klass.new)
+      sprockets.css_compressor = LABEL
+    else
+      Sprockets::Compressors.register_css_compressor(
+        LABEL,
+        klass.to_s,
+        :default => true
+      )
+    end
+  end
+
+end