Load the path to hobo file and use that path to load UUID

lib/hobo/env.rb

@@ -2,6 +2,7 @@ require 'yaml'
 
 module Hobo
   class Env
+    HOBOFILE_NAME = "hobofile"
     HOME =  File.expand_path('~/.hobo')
     CONFIG = { File.join(HOME, 'config.yml') => '/config/default.yml' }
     ENSURE = {
@@ -9,9 +10,16 @@ module Hobo
       :dirs => [HOME] #additional dirs go mhia!
     }
 
+    # Initialize class variables used
+    @@persisted_uuid = nil
+    @@root_path = nil
 
     class << self
+      def persisted_uuid; @@persisted_uuid; end
+      def root_path; @@root_path; end
+
       def load!
+        load_root_path!
         load_config!
         load_uuid!
       end
@@ -38,23 +46,31 @@ module Hobo
       end
 
       def load_uuid!
-        @@persisted_uuid = load_dotfile
+        File.open(File.join(root_path, Hobo.config[:dotfile_name])) do |f|
+          @@persisted_uuid = f.read
+        end
+      rescue Errno::ENOENT
+        @@persisted_uuid = nil
       end
 
-      def load_dotfile(path=Pathname.new(Dir.pwd))
+      def load_root_path!(path=Pathname.new(Dir.pwd))
-        return nil if path.to_s == '/'
+        if path.to_s == '/'
-
+          error_and_exit("UH OH")
-        file = "#{path}/#{Hobo.config[:dotfile_name]}"
+          return
-        if File.exists?(file)
-          # TODO check multiple lines after the first for information
-          return File.open(file, 'r').first
         end
 
-        load_dotfile(path.parent)
+        file = "#{path}/#{HOBOFILE_NAME}"
+        if File.exist?(file)
+          @@root_path = path.to_s
+          return
+        end
+
+        load_root_path!(path.parent)
       end
 
-      def persisted_uuid
+      def error_and_exit(error)
-        @@persisted_uuid
+        puts error
+        exit
       end
     end
   end

test/hobo/env_test.rb

@@ -1,7 +1,33 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class EnvTest < Test::Unit::TestCase
-  context "Hobo environment handler" do
+  def dot_file_expectation
+    File.expects(:exists?).at_least_once.returns(true)
+    File.expects(:open).with(dotfile, 'r').returns(['foo'])
+  end
+
+  def config_file_expectation
+    YAML.expects(:load_file).with(Hobo::Env::CONFIG.keys.first).returns(hobo_mock_config)
+  end
+
+  def dotfile(dir=Dir.pwd)
+    "#{dir}/#{hobo_mock_config[:dotfile_name]}"
+  end
+
+  setup do
+    Hobo::Env.stubs(:error_and_exit)
+  end
+
+  context "initial load" do
+    test "load! should load the config and set the persisted_uid" do
+      Hobo::Env.expects(:load_config!).once
+      Hobo::Env.expects(:load_uuid!).once
+      Hobo::Env.expects(:load_root_path!).once
+      Hobo::Env.load!
+    end
+  end
+
+  context "loading config" do
     setup do
       @handler = Hobo::Env
       @ensure = Hobo::Env::ENSURE
@@ -51,48 +77,55 @@ class EnvTest < Test::Unit::TestCase
     test "Hobo.config should be nil unless loaded" do
       assert_equal Hobo.config, nil
     end
+  end
 
+  context "loading the UUID out from the persisted file" do
     test "loading of the uuid from the dotfile" do
-      dot_file_expectation
       Hobo.config! hobo_mock_config
+
+      filemock = mock("filemock")
+      filemock.expects(:read).returns("foo")
+      File.expects(:open).with(File.join(Hobo::Env.root_path, hobo_mock_config[:dotfile_name])).once.yields(filemock)
       Hobo::Env.load_uuid!
       assert_equal Hobo::Env.persisted_uuid, 'foo'
     end
 
-    test "load! should load the config and set the persisted_uid" do
+    test "uuid should be nil if dotfile didn't exist" do
-      config_file_expectation
+      File.expects(:open).raises(Errno::ENOENT)
-      dot_file_expectation
-      Hobo::Env.load!
-    end
-
-    test "when no dotfile exists uuid should be nil" do
-      Hobo.config! hobo_mock_config.merge(:dotfile_name => 'unpossiblyunpossiblfilename')
       Hobo::Env.load_uuid!
-      assert_equal Hobo::Env.persisted_uuid, nil
+      assert_nil Hobo::Env.persisted_uuid
+    end
+  end
+
+  context "loading the root path" do
+    test "should walk the parent directories looking for hobofile" do
+      paths = [
+        Pathname.new("/foo/bar/baz"),
+        Pathname.new("/foo/bar"),
+        Pathname.new("/foo")
+      ]
+
+      search_seq = sequence("search_seq")
+      paths.each do |path|
+        File.expects(:exist?).with("#{path}/#{Hobo::Env::HOBOFILE_NAME}").returns(false).in_sequence(search_seq)
+      end
+
+      assert_nil Hobo::Env.load_root_path!(paths.first)
     end
 
-    test "should walk the parent directories looking for the dotfile" do
+    test "should print out an error and exit if not found" do
-      Hobo.config! hobo_mock_config
+      path = Pathname.new("/")
 
-      #Expects exists with the current directory and .hobo 
+      Hobo::Env.expects(:error_and_exit).once
-      File.expects(:exists?).with(dotfile).returns(false)
+      Hobo::Env.load_root_path!(path)
-      File.expects(:exists?).with(dotfile(Dir.pwd.split('/')[0..-2].join('/'))).returns(true)
-      File.expects(:open).returns(['foo'])
-      Hobo::Env.load_uuid!
-      assert_equal Hobo::Env.persisted_uuid, 'foo'
     end
 
-    def dot_file_expectation
+    test "should set the path for the Hobofile" do
-      File.expects(:exists?).at_least_once.returns(true)
+      path = "/foo"
-      File.expects(:open).with(dotfile, 'r').returns(['foo'])
+      File.expects(:exist?).with("#{path}/#{Hobo::Env::HOBOFILE_NAME}").returns(true)
-    end
+      Hobo::Env.load_root_path!(Pathname.new(path))
 
-    def config_file_expectation
+      assert_equal path, Hobo::Env.root_path
-      YAML.expects(:load_file).with(Hobo::Env::CONFIG.keys.first).returns(hobo_mock_config)
-    end
-
-    def dotfile(dir=Dir.pwd)
-      "#{dir}/#{hobo_mock_config[:dotfile_name]}"
     end
   end
 end