cjohansen-juicer 0.2.0

data/.gitignore

@@ -0,0 +1,2 @@
+*~
+test/data

data/History.txt

@@ -0,0 +1,10 @@
+== 0.2.0 / 2009-xx-xx
+
+* Refactored the minifyers execute method from compress to save
+* Refactored Juicer::Merger::FileMerger -> Juicer::Merger::Base
+* Refactored the mergers and minifyers to be chainable commands.
+* Added Chainable module
+
+== 0.1.0 / 2008-12-17
+
+* Dug up old project and set it up with Mr Bones

data/Manifest.txt

@@ -0,0 +1,40 @@
+.gitignore
+History.txt
+Manifest.txt
+Rakefile
+Readme.rdoc
+bin/juicer
+juicer.gemspec
+lib/juicer.rb
+lib/juicer/chainable.rb
+lib/juicer/cli.rb
+lib/juicer/command/merge.rb
+lib/juicer/merger/base.rb
+lib/juicer/merger/css_dependency_resolver.rb
+lib/juicer/merger/dependency_resolver.rb
+lib/juicer/merger/javascript_dependency_resolver.rb
+lib/juicer/merger/javascript_merger.rb
+lib/juicer/merger/stylesheet_merger.rb
+lib/juicer/minifyer/compressor.rb
+lib/juicer/minifyer/yui_compressor.rb
+test/data/Changelog.txt
+test/data/a.css
+test/data/a.js
+test/data/b.css
+test/data/b.js
+test/data/mappe/a.css
+test/data/mappe/c.css
+test/data/mappe/enda_en_mappe/a.css
+test/data/version-test.txt
+test/data/version.txt
+test/data/version2.txt
+test/juicer/merger/test_base.rb
+test/juicer/merger/test_css_dependency_resolver.rb
+test/juicer/merger/test_javascript_dependency_resolver.rb
+test/juicer/merger/test_javascript_merger.rb
+test/juicer/merger/test_stylesheet_merger.rb
+test/juicer/minifyer/test_compressor.rb
+test/juicer/minifyer/test_yui_compressor.rb
+test/juicer/test_chainable.rb
+test/test_helper.rb
+test/test_juicer.rb

data/Rakefile

@@ -0,0 +1,27 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  load 'tasks/setup.rb'
+end
+
+ensure_in_path 'lib'
+require 'juicer'
+
+task :default => 'test:run'
+
+PROJ.name = 'juicer'
+PROJ.authors = 'Christian Johansen'
+PROJ.email = 'christian@cjohansen.no'
+PROJ.url = 'http://www.cjohansen.no/en/projects/juicer'
+PROJ.version = Juicer::VERSION
+PROJ.rubyforge.name = 'juicer'
+PROJ.readme_file = 'Readme.rdoc'
+
+PROJ.spec.opts << '--color'
+
+depend_on 'cmdparse'

data/Readme.rdoc

@@ -0,0 +1,108 @@
+= Juicer
+Christian Johansen (http://www.cjohansen.no)
+
+== DESCRIPTION:
+
+Juicer is a command line tool aimed at easing JavaScript and CSS development.
+Currently it only provides a wrapper to YUI Compressor along with a module that
+can dynamically link together files, but there are plans for more functionality.
+
+== FEATURES:
+
+Juicer can read @import statements in CSS files and use them to combine all your
+stylesheets into a single file. This file may be minified using the YUI
+Compressor. Eventually it will support other minifying tools too.
+
+Juicer can treat your JavaScript files much the same way too, parsing a comment
+switch @depends, as this example shows:
+
+  /**
+   * My script file
+   *
+   * @depend jquery-1.2.0.js
+   */
+  var myNS = {
+      myObject = {}
+  };
+
+Running <tt>juicer merge</tt> on this file will result in a minified file
+<tt>filename.min.js</tt> containing the file jquery-1.2.0.js (located in the
+same directory) and the code above.
+
+== 0.1.0 STATUS:
+
+Juicer is currently in a very early stage, please expect it to be unstable,
+poorly documented and otherwise unfinished. Some of this code is a bit old, and
+a brush up is planned that will likely result in several API changes.
+
+== PLANNED FEATURES:
+
+There are several things on the pipeline:
+
+* Support more minifiers, JsMin (Ruby port), Packer and possibly others
+* Wrap code quality assurance tools, such as JsLint and CSS Tidy
+    juicer check design/*
+* A tool to build a whole proect based on a configuration file or something
+  like that
+
+As you see, Juicer will mostly rely heavily on other peoples great work. Juicers
+strength will be that it provides a single simple to use interface to run these
+tools on your project, as well as sewing it all together.
+
+If you have any ideas, feature requests, want to contribute or whatever, fork
+the proect on github, or get in touch through christian (at) cjohansen.no.
+
+== SYNOPSIS:
+
+  juicer merge myfile.css
+  -> Produces myfile.min.css which may contain several CSS files, minified
+
+  juicer merge myfile.js
+  -> Produces myfile.min.js, minified and combined
+
+== REQUIREMENTS:
+
+In order to use YUI Compressor you need Java installed and the java executable
+available on your path.
+
+== INSTALL:
+
+  $ wget http://www.cjohansen.no/juicer-0.1.0.gem
+  $ gem install juicer-0.1.0.gem
+
+You need Java installed, and you need the YUI Compressor jar file. Get it from
+http://developer.yahoo.com/yui/compressor/
+
+Download the YUI Compressor package and unzip on your file system. Either create
+an environment variable <tt>$YUIC_HOME</tt> that points to where the file is
+found, or provide the path like so:
+  juicer merge --path ~/sources/yuicompressor/build [...]
+
+Alternatively you can keep a copy of the jar file in the same directory that you
+run the <tt>juicer</tt> command from. I imagine that would only make sense in a
+testing scenario.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Christian Johansen
+
+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 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.

data/bin/juicer

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+dir = File.dirname(File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__)
+base = File.expand_path(File.join(dir, %w[.. lib juicer]))
+require base
+require File.join(base, "cli")
+
+Juicer::Cli.run(ARGV)

data/juicer.gemspec

@@ -0,0 +1,38 @@
+Gem::Specification.new do |s|
+  s.name = %q{juicer}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Christian Johansen"]
+  s.date = %q{2009-01-04}
+  s.default_executable = %q{juicer}
+  s.description = %q{Juicer is a command line tool aimed at easing JavaScript and CSS development. Currently it only provides a wrapper to YUI Compressor along with a module that can dynamically link together files, but there are plans for more functionality.}
+  s.email = %q{christian@cjohansen.no}
+  s.executables = ["juicer"]
+  s.extra_rdoc_files = ["History.txt", "Readme.rdoc", "bin/juicer", "test/data/Changelog.txt", "test/data/version-test.txt", "test/data/version.txt", "test/data/version2.txt"]
+  s.files = [".gitignore", "History.txt", "Manifest.txt", "Rakefile", "Readme.rdoc", "bin/juicer", "juicer.gemspec", "lib/juicer.rb", "lib/juicer/chainable.rb", "lib/juicer/cli.rb", "lib/juicer/command/merge.rb", "lib/juicer/merger/base.rb", "lib/juicer/merger/css_dependency_resolver.rb", "lib/juicer/merger/dependency_resolver.rb", "lib/juicer/merger/javascript_dependency_resolver.rb", "lib/juicer/merger/javascript_merger.rb", "lib/juicer/merger/stylesheet_merger.rb", "lib/juicer/minifyer/compressor.rb", "lib/juicer/minifyer/yui_compressor.rb", "test/data/Changelog.txt", "test/data/a.css", "test/data/a.js", "test/data/b.css", "test/data/b.js", "test/data/mappe/a.css", "test/data/mappe/c.css", "test/data/mappe/enda_en_mappe/a.css", "test/data/version-test.txt", "test/data/version.txt", "test/data/version2.txt", "test/juicer/merger/test_base.rb", "test/juicer/merger/test_css_dependency_resolver.rb", "test/juicer/merger/test_javascript_dependency_resolver.rb", "test/juicer/merger/test_javascript_merger.rb", "test/juicer/merger/test_stylesheet_merger.rb", "test/juicer/minifyer/test_compressor.rb", "test/juicer/minifyer/test_yui_compressor.rb", "test/juicer/test_chainable.rb", "test/test_helper.rb", "test/test_juicer.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://www.cjohansen.no/en/projects/juicer}
+  s.rdoc_options = ["--main", "Readme.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{juicer}
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{Juicer is a command line tool aimed at easing JavaScript and CSS development}
+  s.test_files = ["test/test_helper.rb", "test/juicer/test_chainable.rb", "test/juicer/merger/test_javascript_dependency_resolver.rb", "test/juicer/merger/test_css_dependency_resolver.rb", "test/juicer/merger/test_base.rb", "test/juicer/merger/test_javascript_merger.rb", "test/juicer/merger/test_stylesheet_merger.rb", "test/juicer/minifyer/test_compressor.rb", "test/juicer/minifyer/test_yui_compressor.rb", "test/test_juicer.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+      s.add_runtime_dependency(%q<cmdparse>, [">= 2.0.2"])
+      s.add_development_dependency(%q<bones>, [">= 2.2.0"])
+    else
+      s.add_dependency(%q<cmdparse>, [">= 2.0.2"])
+      s.add_dependency(%q<bones>, [">= 2.2.0"])
+    end
+  else
+    s.add_dependency(%q<cmdparse>, [">= 2.0.2"])
+    s.add_dependency(%q<bones>, [">= 2.2.0"])
+  end
+end

data/lib/juicer/chainable.rb

@@ -0,0 +1,105 @@
+module Juicer
+  #
+  # Facilitates the chain of responsibility pattern. Wraps given methods and
+  # calls them in a chain.
+  #
+  # To make an object chainable, simply include the module and call the class
+  # method chain_method for each method that should be chained.
+  #
+  # Example is a simplified version of the Wikipedia one
+  # (http://en.wikipedia.org/wiki/Chain-of-responsibility_pattern)
+  #
+  #  class Logger
+  #    include Juicer::Chainable
+  #
+  #    ERR = 3
+  #    NOTICE = 5
+  #    DEBUG = 7
+  #
+  #    def initialize(level)
+  #      @level = level
+  #    end
+  #
+  #    def log(str, level)
+  #      if level <= @level
+  #        write str
+  #      else
+  #        abort_chain
+  #      end
+  #    end
+  #
+  #    def write(str)
+  #      puts str
+  #    end
+  #
+  #    chain_method :message
+  #  end
+  #
+  #  class EmailLogger < Logger
+  #    def write(str)
+  #      p "Logging by email"
+  #      # ...
+  #    end
+  #  end
+  #
+  #  logger = Logger.new(Logger::NOTICE)
+  #  logger.next_in_chain = EmailLogger.new(Logger::ERR)
+  #
+  #  logger.log("Some message", Logger::DEBUG) # Ignored
+  #  logger.log("A warning", Logger::NOTICE)   # Logged to console
+  #  logger.log("An error", Logger::ERR)       # Logged to console and email
+  #
+  module Chainable
+
+    #
+    # Add the chain_method to classes that includes the module
+    #
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    #
+    # Sets the next command in the chain
+    #
+    def next_in_chain=(next_obj)
+      @_next_in_chain = next_obj
+    end
+
+    alias_method :set_next, :next_in_chain=
+
+    #
+    # Get next command in chain
+    #
+    def next_in_chain
+      @_next_in_chain ||= nil
+      @_next_in_chain
+    end
+
+   private
+    #
+    # Abort the chain for the current message
+    #
+    def abort_chain
+      @_abort_chain = true
+    end
+
+    module ClassMethods
+      #
+      # Sets up a method for chaining
+      #
+      def chain_method(method)
+        original_method = "execute_#{method}".to_sym
+        alias_method original_method, method
+
+        self.class_eval <<-RUBY
+          def #{method}(*args, &block)
+            @_abort_chain = false
+            #{original_method}(*args, &block)
+            next_in_chain.#{method}(*args, &block) if !@_abort_chain && next_in_chain
+            @_abort_chain = false
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/juicer/cli.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'cmdparse'
+
+# Command line interpreter for Juicer
+#
+module Juicer
+  class Cli
+    def initialize
+      $verbose = false
+    end
+
+    # Set up command parser and parse arguments
+    #
+    def parse(arguments = ARGV)
+      @cmd = CmdParse::CommandParser.new(true, true)
+      @cmd.program_name = "juicer"
+      @cmd.program_version = Juicer.version.split(".")
+
+      # @cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+      #  opt.separator "Global options:"
+      #  opt.on("--verbose", "Be verbose when outputting info") {|t| $verbose = true }
+      # end
+
+      add_commands
+      @cmd.parse(arguments)
+    end
+
+    # Run CLI
+    #
+    def self.run(arguments = ARGV)
+      juicer = self.new
+      juicer.parse(arguments)
+    end
+
+   private
+    # Adds commands supported by juicer. Instantiates all classes in the
+    # Juicer::Command namespace.
+    #
+    def add_commands
+      @cmd.add_command(CmdParse::HelpCommand.new)
+      @cmd.add_command(CmdParse::VersionCommand.new)
+
+      if Juicer.const_defined?("Command")
+        Juicer::Command.constants.each do |const|
+          const = Juicer::Command.const_get(const)
+          @cmd.add_command(const.new) if const.kind_of?(Class)
+        end
+      end
+    end
+  end
+end

data/lib/juicer/command/merge.rb

@@ -0,0 +1,90 @@
+require 'rubygems'
+require 'cmdparse'
+require 'tempfile'
+
+module Juicer
+  module Command
+    # The compress command combines and minifies CSS and JavaScript files
+    #
+    class Merge < CmdParse::Command
+      # Initializes compress command
+      #
+      def initialize
+        super('merge', false, true)
+        @types = { :js => Juicer::Merger::JavaScriptMerger,
+                   :css => Juicer::Merger::StylesheetMerger }
+        @output = nil
+        @force = false
+        @minifyer = "yui_compressor"
+        @opts = {}
+        self.short_desc = "Combines and minifies CSS and JavaScript files"
+        self.description = <<-EOF
+Each file provided as input will be checked for dependencies to other files,
+and those files will be added to the final output
+
+For CSS files the dependency checking is done through regular @import
+statements.
+
+For JavaScript files you can tell Juicer about dependencies through special
+comment switches. These should appear inside a multi-line comment, specifically
+inside the first multi-line comment. The switch is @depend or @depends, your
+choice.
+
+The -m --minifyer switch can be used to select which minifyer to use. Currently
+only YUI Compressor is supported, ie -m yui_compressor (default). When using
+the YUI Compressor the path should be the path to where the jar file is found.
+        EOF
+
+        self.options = CmdParse::OptionParserWrapper.new do |opt|
+          opt.on( '-o', '--output [OUTPUT]', 'Output filename' ) { |filename| @output = filename }
+          opt.on( '-p', '--path [PATH]', 'Path to compressor binary' ) { |path| @opts[:bin_path] = path }
+          opt.on( '-m', '--minifyer [MINIFYER]', 'Which minifer to use. Currently only supports YUI Compressor' ) { |name| @minifyer = name }
+          opt.on( '-f', '--force', 'Force overwrite of target file' ) { @force = true }
+        end
+      end
+
+      # Execute command
+      #
+      def execute(args)
+        if args.length == 0
+          raise OptionParser::ParseError.new('Please provide atleast one input file')
+        end
+
+        # If no file name is provided, use name of first input with .min
+        # prepended to suffix
+        @output = @output || args[0].sub(/\.([^\.]+)$/, '.min.\1')
+
+        if File.exists?(@output) && !@force
+          puts "Unable to continue, #{@output} exists. Run again with --force to overwrite"
+          exit
+        end
+
+        merger = @types[@output.split(/\.([^\.]*)$/)[1].to_sym].new(args)
+        merger.set_next(minifyer)
+        merger.save(@output)
+
+        # Print report
+        puts "Produced #{@output}"
+      end
+
+     private
+      #
+      # Resolve and load minifyer
+      #
+      def minifyer
+        begin
+          minifyer = @minifyer.split("_").collect { |p| p.capitalize! }.join
+          compressor = Juicer::Minifyer.const_get(minifyer).new(@opts)
+        rescue NameError
+          puts "No such minifyer '#{minifyer}', aborting"
+          exit
+        rescue Exception => e
+          puts e.message
+          exit
+        end
+
+        compressor
+      end
+    end
+  end
+end

data/lib/juicer/merger/base.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "chainable"))
+
+# Merge several files into one single output file
+module Juicer
+  module Merger
+    class Base
+      include Chainable
+      attr_accessor :dependency_resolver
+      attr_reader :files
+
+      def initialize(files = [], options = {})
+        @files = []
+        @dependency_resolver ||= nil
+        self.append files
+      end
+
+      #
+      # Append contents to output. Resolves dependencies and adds
+      # required files recursively
+      # file = A file to add to merged content
+      #
+      def append(file)
+        return file.each { |f| self << f } if file.class == Array
+        return if @files.include?(file)
+
+        if !@dependency_resolver.nil?
+          path = File.expand_path(file)
+          resolve_dependencies(path)
+        elsif !@files.include?(file)
+          @files << file
+        end
+      end
+
+      alias_method :<<, :append
+
+      #
+      # Save the merged contents. If a filename is given the new file is
+      # written. If a stream is provided, contents are written to it.
+      #
+      def save(file_or_stream)
+        output = file_or_stream
+        output = File.open(output, 'w') if output.is_a? String
+
+        @files.each { |f| output.puts(merge(f)) }
+        output.close if file_or_stream.is_a? String
+      end
+
+      chain_method :save
+
+     private
+      def resolve_dependencies(file)
+        @dependency_resolver.resolve(file) do |f|
+          if @files.include?(f)
+            false
+          else
+            @files << f
+            resolve_dependencies(f)
+            true
+          end
+        end
+
+        @files
+      end
+
+      # Fetch contents of a single file. May be overridden in subclasses to provide
+      # custom content filtering
+      def merge(file)
+        IO.read(file) + "\n"
+      end
+    end
+  end
+end

data/lib/juicer/merger/css_dependency_resolver.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "dependency_resolver"))
+
+module Juicer
+  module Merger
+    # Resolves @import statements in CSS files and builds a list of all
+    # files, in order.
+    #
+    class CssDependencyResolver < DependencyResolver
+      # Regexp borrowed from similar project:
+      # http://github.com/cgriego/front-end-blender/tree/master/lib/front_end_architect/blender.rb
+      @@import_pattern = /^\s*@import(?: url\(| )(['"]?)([^\?'"\)\s]+)(\?(?:[^'"\)]+)?)?\1\)?(?:[^?;]+)?;?/im
+
+     private
+      def parse(line, imported_file = nil)
+        return $2 if line =~ @@import_pattern
+
+        # At first sight of actual CSS rules we abort (TODO: This does not take
+        # into account the fact that rules may be commented out and that more
+        # imports may follow)
+        throw :done if imported_file && line =~ %r{/*}
+        throw :done if line =~ /^[\.\#a-zA-Z\:]/
+      end
+    end
+  end
+end

data/lib/juicer/merger/dependency_resolver.rb

@@ -0,0 +1,64 @@
+module Juicer
+  module Merger
+    class DependencyResolver
+      attr_reader :files
+
+      # Constructor
+      def initialize(options = {})
+        @files = []
+        @options = options
+      end
+
+      #
+      # Resolve dependencies.
+      # This method accepts an optional block. The block will receive each
+      # file in succession. The file is included in the returned collection
+      # if the block is true for the given file. Without a block every found
+      # file is returned.
+      #
+      def resolve(file)
+        imported_file = nil
+        @files = []
+
+        catch(:done) do
+          IO.foreach(file) do |line|
+            imported_file = parse(line, imported_file)
+
+            if imported_file
+              imported_file = resolve_path(imported_file, file)
+              @files << imported_file if !block_given? || yield(imported_file)
+            end
+          end
+        end
+
+        file = File.expand_path(file)
+        @files << file if !block_given? || yield(file)
+      end
+
+      #
+      # Resolves a path relative to another. If the path is absolute (ie it
+      # starts with a protocol or /) the <tt>:web_root</tt> options has to be
+      # set as well.
+      #
+      def resolve_path(path, reference)
+        # Absolute URL
+        if path =~ %r{^(/|[a-z]+:)}
+          if @options[:web_root].nil?
+            msg = "Cannot resolve absolute path '#{path}' without web root option"
+            raise ArgumentError.new(msg)
+          end
+
+          path.sub!(%r{^[a-z]+://[^/]+/}, '')
+          return File.expand_path(File.join(@options[:web_root], path))
+        end
+
+        File.expand_path(File.join(File.dirname(reference), path))
+      end
+
+     private
+      def parse(line)
+        raise NotImplementedError.new
+      end
+    end
+  end
+end

data/lib/juicer/merger/javascript_dependency_resolver.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "dependency_resolver"))
+
+module Juicer
+  module Merger
+    # Resolves @depends and @depend statements in comments in JavaScript files.
+    # Only the first comment in a JavaScript file is parsed
+    #
+    class JavaScriptDependencyResolver < DependencyResolver
+      @@depends_pattern = /\@depends?\s+([^\s\'\"\;]+)/
+
+     private
+      def parse(line, imported_file = nil)
+        return $1 if line =~ @@depends_pattern
+
+        # If we have already skimmed through some @depend/@depends or a
+        # closing comment we're done.
+        throw :done unless imported_file.nil? || !(line =~ /\*\//)
+      end
+    end
+  end
+end