jim 0.2.3 → 0.3.0.pre

data/lib/jim/index.rb

@@ -2,16 +2,21 @@ module Jim
   # Index managages a list of directories which are searched to find requirements
   class Index
     attr_reader :directories
-    
+
+    # Initialize an Index with a list of directories. The firse directory
+    # is assumed to be the JIMHOME
     def initialize(*directories)
       @directories = [directories].flatten.compact
       @jimhome_re  = /#{Pathname.new(@directories.first).expand_path.to_s}/
     end
 
+    # Add a directory to the index
     def add(directory)
       @directories.unshift directory
     end
-    
+
+    # List all available files in the directories or only those matching `search`.
+    # Returns a sorted array of arrays.
     def list(search = nil)
       list = {}
       each_file_in_index('.js') do |filename|
@@ -33,9 +38,12 @@ module Jim
       list.sort
     end
 
+    # Find a file in the index by `name` and an optional `version`.
+    # If found, returns a `Pathname` where the file can be retrieved.
     def find(name, version = nil)
       name     = Pathname.new(name)
       stem     = name.basename
+      version  = version && version.strip != '' ? version.strip : nil
       ext      = '.js'
       possible_paths = if version
         [
@@ -60,20 +68,23 @@ module Jim
       end
       final
     end
-    
-    def in_jimhome?(path)
-      !!(path.to_s =~ @jimhome_re)
-    end
-    
+
+    # Find _all_ paths matching `name` and `version`. Returning an array.
     def find_all(name, version = nil)
       matched = []
       find(name, version) {|p| matched << p }
       matched
     end
-    
+
+    # Is this path in the JIMHOME
+    def in_jimhome?(path)
+      !!(path.to_s =~ @jimhome_re)
+    end
+
+    # Iterate through every file in the index yielding the path to the block
     def each_file_in_index(ext, &block)
       Jim.each_path_in_directories(@directories, ext, [], &block)
     end
 
   end
-end
+end

data/lib/jim/installer.rb

@@ -1,11 +1,11 @@
 module Jim
-  # Installer is the workhorse of Jim. It handles taking an install path 
-  # (a url, a local path, anything that Downlow.get can handle), staging it 
-  # into a temporary directory and extracting the file(s) into a path for the 
-  # specific name and version of the lib. names and versions are determined 
-  # automatically or can be passed in as options. 
+  # Installer is the workhorse of Jim. It handles taking an install path
+  # (a url, a local path, anything that Downlow.get can handle), staging it
+  # into a temporary directory and extracting the file(s) into a path for the
+  # specific name and version of the lib. names and versions are determined
+  # automatically or can be passed in as options.
   class Installer
-    
+
     IGNORE_DIRS = %w{
       vendor
       external
@@ -19,113 +19,113 @@ module Jim
       \_([^\/]+)
       \.([^\/]+)
     }
-    
-    # get the tmp_root where files are staged
+
+    # Get the tmp_root where files are staged
     def self.tmp_root
       @tmp_root ||= Pathname.new('/tmp/jim')
     end
-    
-    # set the tmp_root where files are staged. Default: '/tmp/jim'
+
+    # Set the tmp_root where files are staged. Default: '/tmp/jim'
     def self.tmp_root=(new_tmp_root)
       @tmp_root = Pathname.new(new_tmp_root)
     end
-        
+
     attr_reader :fetch_path, :install_path, :options, :fetched_path, :name, :version, :package_json
-    
-    # create an installer. fetch_path is anything that Downlow can understand.
-    # install path is the final directory
+
+    # Create an installer. fetch_path is anything that Downlow can understand.
+    # Install path is the final directory
     def initialize(fetch_path, install_path, options = {})
       @fetch_path   = Pathname.new(fetch_path)
       @install_path = Pathname.new(install_path)
       @options      = options
     end
 
-    # fetch the file at fetch_path with and stage into a tmp directory. 
-    # returns the staged directory of fetched file(s).
+    # Fetch the file at fetch_path with and stage into a tmp directory.
+    # Returns the staged directory of fetched file(s).
     def fetch
-      logger.info "fetching #{fetch_path}"
+      logger.info "Fetching #{fetch_path}"
       @fetched_path = Downlow.get(fetch_path, tmp_path, :tmp_dir => tmp_root)
-      logger.debug "fetched #{@fetched_path}"
+      logger.debug "Fetched #{@fetched_path}"
       @fetched_path
     end
 
-    # fetch and install the files determining their name and version if not provided.
-    # if the fetch_path contains a directory of files, it itterates over the directory
+    # Fetch and install the files determining their name and version if not provided.
+    # If the fetch_path contains a directory of files, it iterates over the directory
     # installing each file that isn't in IGNORE_DIRS and a name and version can be
     # determined for. It also installs a package.json file along side the JS file
     # that contains meta data including the name and version, also merging with the
     # original package.json if found.
-    # 
+    #
     # If options[:shallow] == true it will just copy the single file without any leading
     # directories or a package.json. 'shallow' installation is used for Bundle#vendor
     def install
       fetch
       parse_package_json
       determine_name_and_version
-      
+
       if !name || name.to_s =~ /^\s*$/ # blank
-        raise(Jim::InstallError, "could not determine name for #{@fetched_path}")
+        raise(Jim::InstallError, "Could not determine name for #{@fetched_path}")
       end
-      
-      logger.info "installing #{name} #{version}"
+
+      logger.info "Installing #{name} #{version}"
       logger.debug "fetched_path #{@fetched_path}"
-      
+
       if options[:shallow]
         shallow_filename = [name, (version == "0" ? nil : version)].compact.join('-')
         final_path = install_path + "#{shallow_filename}#{fetched_path.extname}"
       else
         final_path = install_path + 'lib' + "#{name}-#{version}" + "#{name}.js"
       end
-      
+
       if @fetched_path.directory?
         # install every js file
         installed_paths = []
         sub_options = options.merge({
-          :name => nil, 
+          :name => nil,
           :version => nil,
-          :parent_version => version, 
+          :parent_version => version,
           :package_json => package_json.merge("name" => nil)
         })
         Jim.each_path_in_directories([@fetched_path], '.js', IGNORE_DIRS) do |subfile|
-          logger.info "found file #{subfile}"
+          logger.info "Found file #{subfile}"
           installed_paths << Jim::Installer.new(subfile, install_path, sub_options).install
         end
-        logger.info "extracted to #{install_path}, #{installed_paths.length} file(s)"
+        logger.info "Extracted to #{install_path}, #{installed_paths.length} file(s)"
         return installed_paths
       end
-      
-      logger.debug "installing to #{final_path}"
-      if final_path.exist? 
+
+      logger.debug "Installing to #{final_path}"
+      if final_path.exist?
         logger.debug "#{final_path} already exists"
         if options[:force]
           FileUtils.rm_rf(final_path)
         elsif Digest::MD5.hexdigest(File.read(final_path)) == Digest::MD5.hexdigest(File.read(@fetched_path))
-          logger.info "duplicate file, skipping"
+          logger.info "Duplicate file, skipping"
           return final_path
         else
           raise(Jim::FileExists.new(final_path))
         end
       end
-      
+
       Downlow.extract(@fetched_path, :destination => final_path, :tmp_dir => tmp_root)
       # install json
       install_package_json(final_path.dirname + 'package.json') if !options[:shallow]
       installed = final_path.directory? ? Dir.glob(final_path + '**/*').length : 1
-      logger.info "extracted to #{final_path}, #{installed} file(s)"
+      logger.info "Extracted to #{final_path}, #{installed} file(s)"
       final_path
     ensure
       FileUtils.rm_rf(@fetched_path) if @fetched_path && @fetched_path.exist?
       final_path
     end
-    
-    # determine the name and version of the @fetched_path. Tries a number of 
+
+    # Determine the name and version of the @fetched_path. Tries a number of
     # strategies in order until both name and version are found:
     #
     # * from options (options[:name] ...)
     # * from comments (// name: )
     # * from a package.json ({"name": })
     # * from the filename (name-1.0.js)
-    # 
+    #
     # If no version can be found, version is set as "0"
     def determine_name_and_version
       (name && version) ||
@@ -138,7 +138,7 @@ module Jim
 
     private
     def tmp_root
-      @tmp_root ||= make_tmp_root 
+      @tmp_root ||= make_tmp_root
     end
 
     def tmp_dir
@@ -152,17 +152,17 @@ module Jim
     def logger
       Jim.logger
     end
-    
+
     def make_tmp_root
       self.class.tmp_root + (Time.now.to_i + rand(10000)).to_s
     end
-    
+
     def make_tmp_dir
       dir = tmp_root + fetch_path.stem
       dir.mkpath
       dir
     end
-    
+
     def parse_package_json
       @package_json = @options[:package_json] || {}
       package_json_path = if fetched_path.directory?
@@ -180,7 +180,7 @@ module Jim
 
     def install_package_json(to_path, options = {})
       hash = @package_json.merge({
-        "name" =>  name, 
+        "name" =>  name,
         "version" => version,
         "install" => {
           "at" => Time.now.httpdate,
@@ -235,4 +235,4 @@ module Jim
     end
 
   end
-end
+end

data/lib/jim/rack.rb

@@ -2,51 +2,88 @@ require 'jim'
 
 module Jim
   # Jim::Rack is a Rack middleware for allowing live bundling and compression
-  # of the requirements in your Jimfile without having to rebundle using the command
+  # of the bunldes in your Jimfile without having to rebundle using the command
   # line. You can specify a number of options:
   #
   # :jimfile: Path to your Jimfile (default ./Jimfile)
   # :jimhome: Path to your JIMHOME directory (default ENV['JIMHOME'] or ~/.jim)
-  # :bundled_uri: URI to serve the bundled requirements
-  # :compressed_uri: URI to serve the compressed requirements
+  # :bundle_uri: URI to serve the bundled requirements (default '/javascripts/')
+  #
+  # The `bundle_uri` should be ~ a directory and a bundle can be generated by
+  # requesting the bundlename.js behind the directory. For example, given a Jimfile
+  # like:
+  #
+  #       {
+  #         "bundles": {
+  #           "default": [
+  #             "jquery",
+  #             "jquery.color",
+  #             ["sammy", "0.6.3"]
+  #           ]
+  #         }
+  #       }
+  #
+  # You could get the 'default' bundle by
+  #
+  #   GET /javascripts/default.js
+  #
+  # Or the compressed version with:
+  #
+  #   GET /javascripts/default.min.js
+  #
   class Rack
-   
+
     def initialize(app, options = {})
       @app = app
       jimfile = Pathname.new(options[:jimfile] || 'Jimfile')
       jimhome = Pathname.new(options[:jimhome] || ENV['JIMHOME'] || '~/.jim').expand_path
       @bundler = Jim::Bundler.new(jimfile, Jim::Index.new(jimhome), options)
-      @bundled_uri    = options[:bundled_uri] || @bundler.options[:bundled_path]
-      @compressed_uri = options[:compressed_uri] || @bundler.options[:compressed_path]
+      # unset the bundlers bundle dir so it returns a string
+      @bundler.bundle_dir = nil
+      @bundle_uri = options[:bundle_uri] || '/javascripts/'
     end
-   
+
     def call(env)
       dup._call(env)
     end
-   
+
     def _call(env)
       uri = env['PATH_INFO']
-      if uri == @bundled_uri
-        run_action(:bundle!)
-      elsif uri == @compressed_uri
-        run_action(:compress!)
+      if uri =~ bundle_matcher
+        name = $1
+        if name =~ compressed_matcher
+          run_action(:compress!, name.gsub(compressed_matcher, ''))
+        else
+          run_action(:bundle!, name)
+        end
       else
         @app.call(env)
       end
     end
-    
-    def run_action(which)
+
+    private
+    def bundle_matcher
+      @bundle_matcher ||= /^#{@bundle_uri}([\w\d\-\.]+)\.js$/
+    end
+
+    def compressed_matcher
+      @compressed_matcher ||= /#{@bundler.options[:compressed_suffix]}$/
+    end
+
+    def run_action(action, *args)
       begin
-        [200, {'Content-Type' => 'text/javascript'}, @bundler.send(which, false)]
+        [200, {
+          'Content-Type' => 'text/javascript'
+        }, [@bundler.send(action , *args)]]
       rescue => e
-        [500, {'Content-Type' => 'text/html'}, <<-EOT 
-          <p>Jim failed in helping you out. There was an error when trying to #{which}.</p>
+        response = <<-EOT
+          <p>Jim failed in helping you out. There was an error when trying to run #{action}(#{args}).</p>
           <p>#{e}</p>
           <pre>#{e.backtrace}</pre>
         EOT
-        ]
+        [500, {'Content-Type' => 'text/html'}, [response]]
       end
     end
-    
+
   end
-end
+end

data/lib/jim/templates/jimfile

@@ -1,6 +1,12 @@
-// bundled_path: public/javascripts/bundled.js
-// compressed_path: public/javascripts/compressed.js
-// vendor_dir: public/javascripts/vendor
-
-/ start adding your requirements below:
+{
+  "bundle_dir": "public/javascripts/",
+  "vendor_dir": "public/javascripts/vendor",
+  "bundles": {
+    /* 
+      "default": [
+        "jquery"
+      ]
+    */
+  }
+}
 

data/lib/jim/version_parser.rb

@@ -8,9 +8,9 @@ module Jim
       extension = f.scan(/\.[^\.\d\s\-\_][^\.]*$/)[0]
       if NOT_EXTENSIONS.include?(extension)
         extension = nil
-      else 
+      else
         f.gsub!(/#{extension}$/, '')
-      end 
+      end
 
       name, after_name, delimiter, version = f.scan(/^([a-z\.\-\_]+)(([\.\-\_\s])v?(([\w\d]{6,7})|(\d[\d\w\.]*)))?$/i)[0]
       [name || f, version || "0"]
@@ -23,4 +23,4 @@ module Jim
 
 
   end
-end
+end

data/test/fixtures/infoincomments.js

@@ -1,4 +1,4 @@
 // This file has its info in the comments
 // name:    myproject
 // version: 1.2.2
-(function() {});
+(function() {});

data/test/fixtures/jimfile

@@ -1,7 +1,14 @@
-// bundled_path: test/tmp/public/javascripts/bundled.js
-// compressed_path: test/tmp/public/javascripts/compressed.js
-// vendor_dir: test/tmp/public/javascripts/vendor 
-
-jquery 1.4.1
-myproject
-localfile
+{
+  "bundle_dir": "test/tmp/",
+  "vendor_dir": "test/tmp/public/javascripts/vendor",
+  "bundles": {
+    "default": [
+      ["jquery", "1.4.1"],
+      "myproject",
+      "localfile"
+    ],
+    "base": [
+      "jquery"
+    ]
+  }
+}