jim 0.1.2 → 0.2.0

data/HISTORY

@@ -0,0 +1,28 @@
+== 0.2.0 [03-16-10]
+
+* Major rewrite of the installer and version parser
+  * Each file in a package is installed separately
+  * Each file is installed with a package.json file that describes the install
+    and is merged with any existing package.json files
+  * version parser was rewritten and handles many different formats 
+  * Existing JIMHOMEs are probably now invalid (SORRY!!)
+* The install, specify, vendor, bundle workflow works from start to finish
+* passing the -o option to bundle or compress outputs to STDOUT
+* New commands:
+  * available
+  * pack
+  
+
+== 0.1.2 [02-21-10]
+
+* Added remove command
+* list returns versions
+* more tests and documentation
+
+== 0.1.1 [02-20-10]
+
+* Fixed dev dependencies and requirements [Thanks jimeh]
+
+== 0.1.0 [02-19-10]
+
+* Initial release

data/README.rdoc

@@ -47,7 +47,7 @@ In your project run:
 
   $ jim init
 
-Which create an empty "Jimfile". Open it up and add your requirements:
+Which creates an empty "Jimfile". Open it up and add your requirements:
 
   // bundled_path: public/javascripts/bundled.js
   // compressed_path: public/javascripts/compressed.js

data/Rakefile

@@ -16,8 +16,9 @@ begin
     gem.homepage = "http://github.com/quirkey/jim"
     gem.authors = ["Aaron Quint"]
     
-    gem.add_dependency "downlow", ">= 0.1.2"
+    gem.add_dependency "downlow", ">= 0.1.3"
     gem.add_dependency "yajl-ruby"
+    gem.add_dependency "version_sorter", ">= 1.1.0"
     
     gem.add_development_dependency "shoulda", ">= 0"
     gem.add_development_dependency "fakeweb", ">= 1.2.8"

data/jim.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{jim}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aaron Quint"]
-  s.date = %q{2010-02-21}
+  s.date = %q{2010-03-16}
   s.default_executable = %q{jim}
   s.description = %q{jim is your friendly javascript library manager. He downloads, stores, bundles, vendors and compresses.}
   s.email = %q{aaron@quirkey.com}
@@ -19,8 +19,8 @@ Gem::Specification.new do |s|
      "README.rdoc"
   ]
   s.files = [
-    ".document",
-     ".gitignore",
+    ".gitignore",
+     "HISTORY",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
@@ -43,6 +43,59 @@ Gem::Specification.new do |s|
      "test/fixtures/mustache.js/mustache.js",
      "test/fixtures/mustache.js/package.json",
      "test/fixtures/noversion.js",
+     "test/fixtures/sammy-0.5.0/HISTORY.md",
+     "test/fixtures/sammy-0.5.0/LICENSE",
+     "test/fixtures/sammy-0.5.0/README.md",
+     "test/fixtures/sammy-0.5.0/Rakefile",
+     "test/fixtures/sammy-0.5.0/examples/backend/README.md",
+     "test/fixtures/sammy-0.5.0/examples/backend/Rakefile",
+     "test/fixtures/sammy-0.5.0/examples/backend/app.rb",
+     "test/fixtures/sammy-0.5.0/examples/backend/app.ru",
+     "test/fixtures/sammy-0.5.0/examples/backend/public/javascripts/app.js",
+     "test/fixtures/sammy-0.5.0/examples/backend/public/javascripts/jquery.cloudkit.js",
+     "test/fixtures/sammy-0.5.0/examples/backend/public/javascripts/jquery.js",
+     "test/fixtures/sammy-0.5.0/examples/backend/public/javascripts/sammy.js",
+     "test/fixtures/sammy-0.5.0/examples/backend/public/templates/index.html.erb",
+     "test/fixtures/sammy-0.5.0/examples/backend/public/templates/task.html.erb",
+     "test/fixtures/sammy-0.5.0/examples/backend/public/templates/task_details.html.erb",
+     "test/fixtures/sammy-0.5.0/examples/backend/views/app.sass",
+     "test/fixtures/sammy-0.5.0/examples/backend/views/index.haml",
+     "test/fixtures/sammy-0.5.0/examples/form_handling/files/form.html",
+     "test/fixtures/sammy-0.5.0/examples/form_handling/index.html",
+     "test/fixtures/sammy-0.5.0/examples/hello_world/index.html",
+     "test/fixtures/sammy-0.5.0/examples/location_override/README.md",
+     "test/fixtures/sammy-0.5.0/examples/location_override/data.html",
+     "test/fixtures/sammy-0.5.0/examples/location_override/index.html",
+     "test/fixtures/sammy-0.5.0/examples/location_override/test.html",
+     "test/fixtures/sammy-0.5.0/lib/min/sammy-0.5.0.min.js",
+     "test/fixtures/sammy-0.5.0/lib/min/sammy-lastest.min.js",
+     "test/fixtures/sammy-0.5.0/lib/plugins/sammy.cache.js",
+     "test/fixtures/sammy-0.5.0/lib/plugins/sammy.haml.js",
+     "test/fixtures/sammy-0.5.0/lib/plugins/sammy.json.js",
+     "test/fixtures/sammy-0.5.0/lib/plugins/sammy.mustache.js",
+     "test/fixtures/sammy-0.5.0/lib/plugins/sammy.nested_params.js",
+     "test/fixtures/sammy-0.5.0/lib/plugins/sammy.storage.js",
+     "test/fixtures/sammy-0.5.0/lib/plugins/sammy.template.js",
+     "test/fixtures/sammy-0.5.0/lib/sammy.js",
+     "test/fixtures/sammy-0.5.0/test/fixtures/partial",
+     "test/fixtures/sammy-0.5.0/test/fixtures/partial.html",
+     "test/fixtures/sammy-0.5.0/test/fixtures/partial.noengine",
+     "test/fixtures/sammy-0.5.0/test/fixtures/partial.template",
+     "test/fixtures/sammy-0.5.0/test/index.html",
+     "test/fixtures/sammy-0.5.0/test/test_sammy_application.js",
+     "test/fixtures/sammy-0.5.0/test/test_sammy_event_context.js",
+     "test/fixtures/sammy-0.5.0/test/test_sammy_location_proxy.js",
+     "test/fixtures/sammy-0.5.0/test/test_sammy_plugins.js",
+     "test/fixtures/sammy-0.5.0/test/test_sammy_storage.js",
+     "test/fixtures/sammy-0.5.0/test/test_server",
+     "test/fixtures/sammy-0.5.0/vendor/jquery-1.4.1.js",
+     "test/fixtures/sammy-0.5.0/vendor/jquery-1.4.1.min.js",
+     "test/fixtures/sammy-0.5.0/vendor/jsdoc/doc.haml",
+     "test/fixtures/sammy-0.5.0/vendor/jsdoc/jsdoc.rb",
+     "test/fixtures/sammy-0.5.0/vendor/jslitmus.js",
+     "test/fixtures/sammy-0.5.0/vendor/qunit-spec.js",
+     "test/fixtures/sammy-0.5.0/vendor/qunit/qunit.css",
+     "test/fixtures/sammy-0.5.0/vendor/qunit/qunit.js",
      "test/helper.rb",
      "test/test_jim_bundler.rb",
      "test/test_jim_cli.rb",
@@ -53,10 +106,12 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/quirkey/jim}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{jim is your friendly javascript library manager}
   s.test_files = [
-    "test/helper.rb",
+    "test/fixtures/sammy-0.5.0/examples/backend/app.rb",
+     "test/fixtures/sammy-0.5.0/vendor/jsdoc/jsdoc.rb",
+     "test/helper.rb",
      "test/test_jim_bundler.rb",
      "test/test_jim_cli.rb",
      "test/test_jim_index.rb",
@@ -69,21 +124,24 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<downlow>, [">= 0.1.2"])
+      s.add_runtime_dependency(%q<downlow>, [">= 0.1.3"])
       s.add_runtime_dependency(%q<yajl-ruby>, [">= 0"])
+      s.add_runtime_dependency(%q<version_sorter>, [">= 1.1.0"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<fakeweb>, [">= 1.2.8"])
       s.add_development_dependency(%q<mocha>, [">= 0"])
     else
-      s.add_dependency(%q<downlow>, [">= 0.1.2"])
+      s.add_dependency(%q<downlow>, [">= 0.1.3"])
       s.add_dependency(%q<yajl-ruby>, [">= 0"])
+      s.add_dependency(%q<version_sorter>, [">= 1.1.0"])
       s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<fakeweb>, [">= 1.2.8"])
       s.add_dependency(%q<mocha>, [">= 0"])
     end
   else
-    s.add_dependency(%q<downlow>, [">= 0.1.2"])
+    s.add_dependency(%q<downlow>, [">= 0.1.3"])
     s.add_dependency(%q<yajl-ruby>, [">= 0"])
+    s.add_dependency(%q<version_sorter>, [">= 1.1.0"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<fakeweb>, [">= 1.2.8"])
     s.add_dependency(%q<mocha>, [">= 0"])

data/lib/jim/bundler.rb

@@ -23,15 +23,18 @@ module Jim
     
     # create a new bundler instance passing in the Jimfile as a `Pathname` or a
     # string. `index` is a Jim::Index
-    def initialize(jimfile, index = nil, options = {})
+    def initialize(jimfile, index = nil, extra_options = {})
       self.jimfile      = jimfile.is_a?(Pathname) ? jimfile.read : jimfile
       self.index        = index || Jim::Index.new
       self.options      = {}
       self.requirements = []
       parse_jimfile
-      self.options.merge(options)
-      self.add(options[:vendor_dir]) if options[:vendor_dir]
+      self.options = options.merge(extra_options)
       self.paths        = []
+      if options[:vendor_dir]
+        logger.debug "adding vendor dir to index #{options[:vendor_dir]}"
+        self.index.add(options[:vendor_dir]) 
+      end
     end
 
     # resove the requirements specified into Jimfile or raise a MissingFile error
@@ -43,7 +46,7 @@ module Jim
           raise(MissingFile, 
           "Could not find #{name} #{version} in any of these paths #{index.directories.join(':')}")
         end
-        self.paths << path
+        self.paths << [path, name, version]
       end
       paths
     end
@@ -54,8 +57,8 @@ module Jim
       resolve! if paths.empty?
       to = options[:bundled_path] if to.nil? && options[:bundled_path]
       io = io_for_path(to)
-      logger.info "bundling to #{to}" if to
-      paths.each do |path|
+      logger.info "Bundling to #{to}" if to
+      paths.each do |path, name, version|
         io << path.read << "\n"
       end
       io
@@ -67,20 +70,20 @@ module Jim
     def compress!(to = nil)
       to = options[:compressed_path] if to.nil? && options[:compressed_path]
       io = io_for_path(to)
-      logger.info "compressing to #{to}"
+      logger.info "Compressing to #{to}"
       io << compress_js(bundle!(false))
       io
     end
 
     # copy each of the requirements into the dir specified with `dir` or the path
     # specified with the :vendor_dir option
-    def vendor!(dir = nil)
+    def vendor!(dir = nil, force = false)
       resolve! if paths.empty?
       dir ||= options[:vendor_dir]
       dir ||= 'vendor' # default
-      logger.info "vendoring to #{dir}"
-      paths.each do |path|
-        Jim::Installer.new(path, dir, :shallow => true).install
+      logger.info "Vendoring to #{dir}"
+      paths.each do |path, name, version|
+        Jim::Installer.new(path, dir, :shallow => true, :force => force).install
       end
     end
 

data/lib/jim/cli.rb

@@ -8,7 +8,7 @@ module Jim
   # the different public methods represent 1-1 the commands provided by the bin.
   class CLI
     
-    attr_accessor :jimfile, :jimhome, :force
+    attr_accessor :jimfile, :jimhome, :force, :stdout
     
     # create a new instance with the args passed from the command line i.e. ARGV
     def initialize(args)
@@ -32,6 +32,8 @@ module Jim
         @output << "No action found for #{command}. Run -h for help."
       end
       @output
+    rescue ArgumentError => e
+      @output << "#{e.message} for #{command}"
     rescue Jim::FileExists => e
       @output << "#{e.message} already exists, bailing. Use --force if you're sure"
     rescue => e
@@ -49,19 +51,20 @@ module Jim
     def cheat
       logger.info "Usage: jim [options] [command] [args]\n"
       logger.info "Commands:"
-      logger.info template('commands').find_all {|l| l.match(/^\w/) }.join("")
+      logger.info [*template('commands')].grep(/^\w/).join
       logger.info "run commands for details"
     end
+    alias :help :cheat
     
     # initialize the current dir with a new Jimfile
     def init(dir = nil)
       dir = Pathname.new(dir || '')
       jimfile_path = dir + 'Jimfile'
       if jimfile_path.readable? && !force
-        raise Jim::FileExists(jimfile_path)
+        raise Jim::FileExists.new(jimfile_path)
       else
         File.open(jimfile_path, 'w') do |f|
-          f << template('Jimfile')
+          f << template('jimfile')
         end
         logger.info "wrote Jimfile to #{jimfile_path}"
       end
@@ -74,24 +77,39 @@ module Jim
     
     # bundle the files specified in Jimfile into `to`
     def bundle(to = nil)
+      to = STDOUT if stdout
       path = bundler.bundle!(to)
+      logger.info "Wrote #{File.size(path) / 1024}kb"
     end
     
     # compress the files specified in Jimfile into `to`
     def compress(to = nil)
+      to = STDOUT if stdout
       path = bundler.compress!(to)
+      logger.info "Wrote #{File.size(path) / 1024}kb"
     end
     
     # copy/vendor all the files specified in Jimfile to `dir`
     def vendor(dir = nil)
-      bundler.vendor!(dir)
+      bundler.vendor!(dir, force)
     end
     
-    # list the installed projects and versions
+    # list the only the _installed_ projects and versions
     def list
-      logger.info "Getting list of installed files in #{index.directories.join(':')}"
+      logger.info "Getting list of installed files in\n#{installed_index.directories.join(':')}"
+      list = installed_index.list
+      logger.info "Installed:"
+      print_version_list(list)
+    end
+    alias :installed :list
+    
+    # list all available projects and versions including those in the local path, or 
+    # paths specified in a jimfile
+    def available
+      logger.info "Getting list of all available files in\n#{index.directories.join("\n")}"
       list = index.list
-      logger.info "Installed:\n#{list.collect {|i| "#{i[0]} (#{i[1].join(', ')})"}.join("\n")}"
+      logger.info "Available:"
+      print_version_list(list)
     end
     
     # Iterates over matching files and prompts for removal
@@ -116,13 +134,25 @@ module Jim
         logger.info "No installed files matched."
       end
     end
+    alias :uninstall :remove
     
     # list the files and their resolved paths specified in the Jimfile
     def resolve
       resolved = bundler.resolve!
-      logger.info "Files:\n#{resolved.join("\n")}"
+      logger.info "Files:"
+      resolved.each do |r|
+        logger.info r.join(" | ")
+      end
       resolved
     end
+    
+    # vendor to dir, then bundle and compress the Jimfile contents
+    def pack(dir = nil)
+      logger.info "packing the Jimfile for this project"
+      vendor(dir)
+      bundle
+      compress
+    end
         
     private
     def parse_options(runtime_args)
@@ -148,10 +178,16 @@ module Jim
           logger.level = Logger::DEBUG
         }
         
+        opts.on("-o", "--stdout", "write output of commands (like bundle and compress to STDOUT)") {|o| 
+          logger.level = Logger::ERROR
+          self.stdout = true
+        }
+        
         opts.on("-v", "--version", "print version") {|d|
           puts "jim #{Jim::VERSION}"
           exit
         }
+      
         
         opts.on_tail("-h", "--help", "Show this message. Run jim commands for list of commands.") do
           puts opts.help
@@ -188,5 +224,11 @@ module Jim
       Jim.logger
     end
     
+    def print_version_list(list)
+      list.each do |file, versions|
+        logger.info "#{file} (#{VersionSorter.rsort(versions.collect {|v| v[0] }).join(',')})"
+      end
+    end
+    
   end
 end

data/lib/jim/index.rb

@@ -4,7 +4,7 @@ module Jim
     attr_reader :directories
     
     def initialize(*directories)
-      @directories = directories.flatten
+      @directories = directories.flatten.compact
     end
 
     def add(directory)
@@ -14,7 +14,7 @@ module Jim
     def list
       list = {}
       each_file_in_index('.js') do |filename|
-        if /lib\/([^\/]+)-([\d\w\.\-]+)\/.+/.match filename
+        if /lib\/([^\/\-]+)-([\d\w\.\-]+)\/.+/.match filename
           name    = $1
           version = $2
         else
@@ -63,11 +63,7 @@ module Jim
     end
     
     def each_file_in_index(ext, &block)
-      @directories.each do |dir|
-        Dir.glob(Pathname.new(dir) + '**' + "*#{ext}") do |filename|
-          yield Pathname.new(filename)
-        end
-      end
+      Jim.each_path_in_directories(@directories, ext, [], &block)
     end
 
   end

data/lib/jim/installer.rb

@@ -1,73 +1,148 @@
 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. 
   class Installer
     
+    IGNORE_DIRS = %w{
+      vendor
+      external
+      test
+      tests
+      unit
+      site
+      examples
+      demo
+      min
+      \_([^\/]+)
+      \.([^\/]+)
+    }
+    
+    # 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'
     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
     
-    attr_reader :fetch_path, :install_path, :options, 
-    :fetched_path, :name, :version
-
+    # 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).
     def fetch
       logger.info "fetching #{fetch_path}"
-      @fetched_path = Downlow.get(fetch_path, tmp_path)
+      @fetched_path = Downlow.get(fetch_path, tmp_path, :tmp_dir => tmp_root)
       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
+    # 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}")
+      end
+      
       logger.info "installing #{name} #{version}"
       logger.debug "fetched_path #{@fetched_path}"
+      
       if options[:shallow]
-        final_path = install_path + "#{name}#{fetched_path.extname}"
+        shallow_filename = [name, (version == "0" ? nil : version)].compact.join('-')
+        final_path = install_path + "#{shallow_filename}#{fetched_path.extname}"
       else
-        final_dir = install_path + 'lib' + "#{name}-#{version}"
-        final_path = (fetched_path.to_s =~ /\.js$/) ? final_dir + "#{name}.js" : final_dir
+        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, 
+          :version => nil,
+          :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}"
+          installed_paths << Jim::Installer.new(subfile, install_path, sub_options).install
+        end
+        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 "#{final_path} already exists"
-        options[:force] ? FileUtils.rm_rf(final_path) : raise(Jim::FileExists.new(final_path))
+        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"
+          return final_path
+        else
+          raise(Jim::FileExists.new(final_path))
+        end
       end
-      Downlow.extract(@fetched_path, :destination => final_path)
+      
+      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.exist?
+      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 
+    # 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) ||
       name_and_version_from_options ||
       name_and_version_from_comments ||
       name_and_version_from_package_json ||
       name_and_version_from_filename
-      @version ||= '0'
+      @version = (version == "0" && options[:parent_version]) ? options[:parent_version] : version
     end
 
     private
     def tmp_root
-      self.class.tmp_root
+      @tmp_root ||= make_tmp_root 
     end
 
     def tmp_dir
-      dir = tmp_root + fetch_path.stem
-      dir.mkpath
-      dir
+      @tmp_dir ||= make_tmp_dir
     end
 
     def tmp_path
@@ -77,10 +152,51 @@ 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?
+        fetched_path + 'package.json'
+      elsif options[:shallow] && fetch_path.file?
+        fetch_path.dirname + 'package.json'
+      else
+        fetched_path.dirname + 'package.json'
+      end
+      logger.debug "package.json path: #{package_json_path}"
+      if package_json_path.readable?
+        @package_json = Yajl::Parser.parse(package_json_path.read)
+      end
+    end
+
+    def install_package_json(to_path, options = {})
+      hash = @package_json.merge({
+        "name" =>  name, 
+        "version" => version,
+        "install" => {
+          "at" => Time.now.httpdate,
+          "from" => fetch_path,
+          "with" => "jim #{Jim::VERSION}"
+        }
+      }).merge(options)
+      Pathname.new(to_path).open('w') do |f|
+        Yajl::Encoder.encode(hash, f, :pretty => true)
+      end
+    end
 
     def name_and_version_from_options
       @name = options[:name] if options[:name] && !name
       @version = options[:version] if options[:version] && !version
+      logger.debug "name and version from options: #{name} #{version}"
       name && version
     end
 
@@ -97,15 +213,16 @@ module Jim
           end
         end
       end
+      logger.debug "name and version from comments: #{name} #{version}"
       name && version
     end
 
     def name_and_version_from_package_json
-      if !fetched_path.file? && (fetched_path + 'package.json').readable?
-        sname, sversion = VersionParser.parse_package_json((fetched_path + "package.json").read)
-        @name ||= sname
-        @version ||= sversion
-      end
+      parse_package_json if !@package_json
+      sname, sversion = @package_json['name'], @package_json['version']
+      @name ||= sname
+      @version ||= sversion
+      logger.debug "name and version from package.json: #{name} #{version}"
       name && version
     end
 
@@ -113,6 +230,7 @@ module Jim
       fname, fversion = VersionParser.parse_filename(fetched_path.basename.to_s)
       @name ||= fname
       @version ||= fversion
+      logger.debug "name and version from filename: #{name} #{version}"
       name && version
     end