ktheory-juicer 1.0.0.ktheory1

data/lib/juicer/install/base.rb

@@ -0,0 +1,186 @@
+require 'nokogiri'
+require 'open-uri'
+require 'fileutils'
+require "juicer"
+
+module Juicer
+  module Install
+    #
+    # Installer skeleton. Provides basic functionality like figuring out where
+    # to install, create base directories, remove unneeded directories and more
+    # housekeeping.
+    #
+    class Base
+      attr_reader :install_dir
+
+      #
+      # Create new installer
+      #
+      def initialize(install_dir = Juicer.home)
+        @install_dir = install_dir
+        @path = nil
+        @bin_path = nil
+        @name = nil
+        @dependencies = {}
+      end
+
+      #
+      # Returns the latest available version number. Must be implemented in
+      # subclasses. Raises an exception when called directly.
+      #
+      def latest
+        raise NotImplementedError.new("Implement in subclasses")
+      end
+
+      # Returns the path relative to installation path this installer will
+      # install to
+      def path
+        return @path if @path
+        @path = "lib/" + self.class.to_s.split("::").pop.sub(/Installer$/, "").underscore
+      end
+
+      # Returns the path to search for binaries from
+      #
+      def bin_path
+        return @bin_path if @bin_path
+        @bin_path = File.join(path, "bin")
+      end
+
+      #
+      # Returns name of component. Default implementation returns class name
+      # with "Installer" removed
+      #
+      def name
+        return @name if @name
+        @name = File.basename(path).split("_").inject("") { |str, word| (str + " #{word.capitalize}").strip }
+      end
+
+      #
+      # Checks if the component is currently installed.
+      #
+      # If no version is provided the most recent version is assumed.
+      #
+      def installed?(version = nil)
+        installed = File.exists?(File.join(@install_dir, path, "#{version || latest}"))
+        deps = @dependencies.length == 0 || dependencies.all? { |d, v| d.installed?(v) }
+        installed && deps
+      end
+
+      #
+      # Install the component. Creates basic directory structure.
+      #
+      def install(version = nil)
+        raise "#{name} #{version} is already installed in #{File.join(@install_dir, path)}" if installed?(version)
+        version ||= latest
+        log "Installing #{name} #{version} in #{File.join(@install_dir, path)}"
+
+        if @dependencies.length > 0
+          log "Installing dependencies"
+          dependencies { |dependency, ver| dependency.install(ver) unless dependency.installed?(ver) }
+        end
+
+        # Create directories
+        FileUtils.mkdir_p(File.join(@install_dir, path, "bin"))
+        FileUtils.mkdir_p(File.join(@install_dir, path, version))
+
+        # Return resolved version for subclass to use
+        version
+      end
+
+      #
+      # Uninstalls the given version of the component.
+      #
+      # If no version is provided the most recent version is assumed.
+      #
+      # If there are no more files left in INSTALLATION_PATH/<path>, the
+      # whole directory is removed.
+      #
+      # This method takes a block and can be used from subclasses like so:
+      #
+      #   def self.uninstall(install_dir = nil, version = nil)
+      #     super do |home_dir, version|
+      #       # Custom uninstall logic
+      #     end
+      #   end
+      #
+      #
+      def uninstall(version = nil)
+        version ||= self.latest
+        install_dir = File.join(@install_dir, path, version)
+        raise "#{name} #{version} is not installed" if !File.exists?(install_dir)
+
+        FileUtils.rm_rf(install_dir)
+
+        yield(File.join(@install_dir, path), version) if block_given?
+
+        files = Dir.glob(File.join(@install_dir, path, "**", "*")).find_all { |f| File.file?(f) }
+        FileUtils.rm_rf(File.join(@install_dir, path)) if files.length == 0
+      end
+
+      #
+      # Download a file to Juicer temporary directory. The file will be kept
+      # until #purge is called to wipe it. If the installer receives a request
+      # to download the same file again, the disk cache will be used unless the
+      # force argument is true (default false)
+      #
+      def download(url, force = false)
+        filename = File.join(@install_dir, "download", path.sub("lib/", ""), File.basename(url))
+        return filename if File.exists?(filename) && !force
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.delete(filename) if File.exists?(filename) && force
+
+        log "Downloading #{url}"
+        File.open(filename, "wb") do |file|
+          webpage = open(url)
+          file.write(webpage.read)
+          webpage.close
+        end
+
+        filename
+      end
+
+      #
+      # Display a message to the user through Juicer::LOGGER
+      #
+      def log(str)
+        Juicer::LOGGER.info str
+      end
+
+      #
+      # Add a dependency. Dependency should be a Juicer::Install::Base installer
+      # class (not instance) OR a symbol/string like :rhino/"rhino" (which will
+      # be expanded unto Juicer::Install::RhinoInstaller). Version is optional
+      # and defaults to latest and greatest.
+      #
+      def dependency(dependency, version = nil)
+        dependency = Juicer::Install.get(dependency) if [String, Symbol].include?(dependency.class)
+
+        @dependencies[dependency.to_s + (version || "")] = [dependency, version]
+      end
+
+      #
+      # Yields depencies one at a time: class and version and returns an array
+      # of arrays: [dependency, version] where dependency is an instance and
+      # version a string.
+      #
+      def dependencies(&block)
+        @dependencies.collect do |name, dependency|
+          version = dependency[1]
+          dependency = dependency[0].new(@install_dir)
+          block.call(dependency, version) if block
+          [dependency, version]
+        end
+      end
+    end
+
+    #
+    # Returns the installer. Accepts installer classes (which are returned
+    # directly), strings or symbols. Strings and symbols may be on the form
+    # :my_module which is expanded to Juicer::Install::MyModuleInstaller
+    #
+    def self.get(nameOrClass)
+      return nameOrClass if nameOrClass.is_a? Class
+      (nameOrClass.to_s + "_installer").classify(Juicer::Install)
+    end
+  end
+end

data/lib/juicer/install/closure_compiler_installer.rb

@@ -0,0 +1,69 @@
+require "juicer"
+require "juicer/install/base"
+require "zip/zip"
+
+module Juicer
+  module Install
+    #
+    # Install and uninstall routines for the Google Closure Compiler.
+    # Installation downloads the Closure Compiler distribution, unzips it and
+    # storesthe jar file on disk along with the README.
+    #
+    class ClosureCompilerInstaller < Base
+      def initialize(install_dir = Juicer.home)
+        super(install_dir)
+        @latest = nil
+        @website = "http://code.google.com/p/closure-compiler/downloads/list"
+        @download_link = "http://closure-compiler.googlecode.com/files/compiler-%s.zip"
+      end
+
+      #
+      # Install the Closure Compiler. Downloads the distribution and keeps the jar
+      # file inside PATH/closure_compiler/bin and the README in
+      # PATH/closere_compiler/yyyymmdd/ where yyyymmdd is the version, most recent if
+      # not specified otherwise.
+      #
+      # Path defaults to environment variable $JUICER_HOME or default Juicer
+      # home
+      #
+      def install(version = nil)
+        version = super(version)
+        base = "closure-compiler-#{version}"
+        filename = download(@download_link % version)
+        target = File.join(@install_dir, path)
+
+        Zip::ZipFile.open(filename) do |file|
+          file.extract("README", File.join(target, version, "README"))
+          file.extract("compiler.jar", File.join(target, "bin", "#{base}.jar"))
+        end
+      end
+
+      #
+      # Uninstalls the given version of Closure Compiler. If no location is
+      # provided the environment variable $JUICER_HOME or Juicers default home
+      # directory is used.
+      #
+      # If no version is provided the most recent version is assumed.
+      #
+      # If there are no more files left in INSTALLATION_PATH/closure_compiler, the
+      # whole directory is removed.
+      #
+      def uninstall(version = nil)
+        super(version) do |dir, version|
+          File.delete(File.join(dir, "bin/closure-compiler-#{version}.jar"))
+        end
+      end
+
+      #
+      # Check which version is the most recent
+      #
+      def latest
+        return @latest if @latest
+        webpage = Nokogiri::HTML(open(@website))
+        @latest = (webpage / "//table[@id='resultstable']//td/a[contains(@href, 'compiler')]").map{|link|
+          link.get_attribute('href')[/\d{8}/].to_i
+        }.sort.last.to_s
+      end
+    end
+  end
+end

data/lib/juicer/install/jslint_installer.rb

@@ -0,0 +1,51 @@
+require "juicer"
+require "juicer/install/base"
+require "zip/zip"
+
+module Juicer
+  module Install
+    #
+    # Install and uninstall routines for the JSLint library by Douglas Crockford.
+    # Installation downloads the jslintfull.js and rhino.js files and stores
+    # them in the Juicer installation directory.
+    #
+    class JSLintInstaller < Base
+      attr_reader :latest
+
+      def initialize(install_dir = Juicer.home)
+        super(install_dir)
+        @latest = "1.0"
+        @website = "http://www.jslint.com/"
+        @path = "lib/jslint"
+        @name = "JsLint"
+        dependency :rhino
+      end
+
+      #
+      # Install JSLint. Downloads the two js files and stores them in the
+      # installation directory.
+      #
+      def install(version = nil)
+        version = super(version)
+        filename = download(File.join(@website, "rhino/jslint.js"))
+        FileUtils.copy(filename, File.join(@install_dir, path, "bin", "jslint-#{version}.js"))
+      end
+
+      #
+      # Uninstalls JSLint
+      #
+      def uninstall(version = nil)
+        super(version) do |dir, version|
+          File.delete(File.join(dir, "bin", "jslint-#{version}.js"))
+        end
+      end
+    end
+
+    #
+    # This class makes it possible to do Juicer.install("jslint") instead of
+    # Juicer.install("j_s_lint"). Sugar, sugar...
+    #
+    class JslintInstaller < JSLintInstaller
+    end
+  end
+end

data/lib/juicer/install/rhino_installer.rb

@@ -0,0 +1,53 @@
+require "juicer"
+require "juicer/install/base"
+require "zip/zip"
+
+module Juicer
+  module Install
+    #
+    # Install and uninstall routines for the Mozilla Rhino jar.
+    #
+    class RhinoInstaller < Base
+      attr_reader :latest
+
+      def initialize(install_dir = Juicer.home)
+        super(install_dir)
+        @latest = "1_7R2-RC1"
+        @website = "http://ftp.mozilla.org/pub/mozilla.org/js/"
+      end
+
+      #
+      # Install Rhino. Downloads the jar file and stores it in the installation
+      # directory along with the License text.
+      #
+      def install(version = nil)
+        version = super((version || latest).gsub(/\./, "_"))
+        base = "rhino#{version}"
+        filename = download(File.join(@website, "#{base}.zip"))
+        target = File.join(@install_dir, path)
+
+        Zip::ZipFile.open(filename) do |file|
+          FileUtils.mkdir_p(File.join(target, version))
+
+          begin
+            file.extract("#{base.sub(/-RC\d/, "")}/LICENSE.txt", File.join(target, version, "LICENSE.txt"))
+          rescue Exception
+            # Fail silently, some releases don't carry the license
+          end
+
+          file.extract("#{base.sub(/-RC\d/, "")}/js.jar", File.join(target, "bin", "#{base}.jar"))
+        end
+      end
+
+      #
+      # Uninstalls Rhino
+      #
+      def uninstall(version = nil)
+        super((version || latest).gsub(/\./, "_")) do |dir, version|
+          base = "rhino#{version}"
+          File.delete(File.join(dir, "bin/", "#{base}.jar"))
+        end
+      end
+    end
+  end
+end

data/lib/juicer/install/yui_compressor_installer.rb

@@ -0,0 +1,67 @@
+require "juicer"
+require "juicer/install/base"
+require "zip/zip"
+
+module Juicer
+  module Install
+    #
+    # Install and uninstall routines for the YUI Compressor.
+    # Installation downloads the YUI Compressor distribution, unzips it and
+    # storesthe jar file on disk along with the license.
+    #
+    class YuiCompressorInstaller < Base
+      def initialize(install_dir = Juicer.home)
+        super(install_dir)
+        @latest = nil
+        @website = "http://yuilibrary.com/downloads/"
+      end
+
+      #
+      # Install the Yui Compressor. Downloads the distribution and keeps the jar
+      # file inside PATH/yui_compressor/bin and the README and CHANGELOG in
+      # PATH/yui_compressor/x.y.z/ where x.y.z is the version, most recent if
+      # not specified otherwise.
+      #
+      # Path defaults to environment variable $JUICER_HOME or default Juicer
+      # home
+      #
+      def install(version = nil)
+        version = super(version)
+        base = "yuicompressor-#{version}"
+        filename = download(File.join(@website, "yuicompressor", "#{base}.zip"))
+        target = File.join(@install_dir, path)
+
+        Zip::ZipFile.open(filename) do |file|
+          file.extract("#{base}/doc/README", File.join(target, version, "README"))
+          file.extract("#{base}/doc/CHANGELOG", File.join(target, version, "CHANGELOG"))
+          file.extract("#{base}/build/#{base}.jar", File.join(target, "bin", "#{base}.jar"))
+        end
+      end
+
+      #
+      # Uninstalls the given version of YUI Compressor. If no location is
+      # provided the environment variable $JUICER_HOME or Juicers default home
+      # directory is used.
+      #
+      # If no version is provided the most recent version is assumed.
+      #
+      # If there are no more files left in INSTALLATION_PATH/yui_compressor, the
+      # whole directory is removed.
+      #
+      def uninstall(version = nil)
+        super(version) do |dir, version|
+          File.delete(File.join(dir, "bin/yuicompressor-#{version}.jar"))
+        end
+      end
+
+      #
+      # Check which version is the most recent
+      #
+      def latest
+        return @latest if @latest
+        webpage = Nokogiri::HTML(open(@website))
+        @latest = (webpage / "//h2[@id='yuicompressor']/../../../..//a")[0].get_attribute("href").match(/(\d\.\d\.\d)/)[1]
+      end
+    end
+  end
+end

data/lib/juicer/jslint.rb

@@ -0,0 +1,90 @@
+require "juicer/binary"
+
+module Juicer
+  #
+  # A Ruby API to Douglas Crockfords genious JsLint program
+  # http://www.jslint.com/
+  #
+  # JsLint parses JavaScript code and identifies (potential) problems.
+  # Effectively, JsLint defines a subset of JavaScript which is safe to use, and
+  # among other things make code minification a substantially less dangerous
+  # task.
+  #
+  class JsLint
+    include Juicer::Binary
+
+    def initialize(options = {})
+      super(options[:java] || "java")
+      path << options[:bin_path] if options[:bin_path]
+    end
+
+    #
+    # Checks if a files has problems. Also includes experimental support for CSS
+    # files. CSS files should begin with the line @charset "UTF-8";
+    #
+    # Returns a Juicer::JsLint::Report object
+    #
+    def check(file)
+      rhino_jar = rhino
+      js_file = locate_lib
+
+      raise FileNotFoundError.new("Unable to locate Rhino jar '#{rhino_jar}'") if !rhino_jar || !File.exists?(rhino_jar)
+      raise FileNotFoundError.new("Unable to locate JsLint '#{js_file}'") if !js_file || !File.exists?(js_file)
+      raise FileNotFoundError.new("Unable to locate input file '#{file}'") unless File.exists?(file)
+
+      lines = execute(%Q{-jar "#{rhino}" "#{locate_lib}" "#{file}"}).split("\n")
+      return Report.new if lines.length == 1 && lines[0] =~ /jslint: No problems/
+
+      report = Report.new
+      lines = lines.reject { |line| !line || "#{line}".strip == "" }
+      report.add_error(lines.shift, lines.shift) while lines.length > 0
+
+      return report
+    end
+
+    def rhino
+      files = locate("**/rhino*.jar", "RHINO_HOME")
+      !files || files.empty? ? nil : files.sort.last
+    end
+
+    def locate_lib
+      files = locate("**/jslint-*.js", "JSLINT_HOME")
+      !files || files.empty? ? nil : files.sort.last
+    end
+
+    #
+    # Represents the results of a JsLint run
+    #
+    class Report
+      attr_accessor :errors
+
+      def initialize(errors = [])
+        @errors = errors
+      end
+
+      def add_error(message, code)
+        @errors << JsLint::Error.new(message, code)
+      end
+
+      def ok?
+        @errors.nil? || @errors.length == 0
+      end
+    end
+
+    #
+    # A JsLint error
+    #
+    class Error
+      attr_accessor :message, :code
+
+      def initialize(message, code)
+        @message = message
+        @code = code
+      end
+
+      def to_s
+        "#@message\n#@code"
+      end
+    end
+  end
+end