yuyi 1.0.8 → 1.1.3

data/spec/lib/yuyi/menu_spec.rb

@@ -2,117 +2,219 @@ require 'spec_helper'
 
 describe Yuyi::Menu do
   before do
-    Yuyi::Menu.send :class_variable_set, :'@@instance', nil
-    Yuyi::Menu.send :instance_variable_set, :'@object', nil
-  end
+    # reset current menu instance
+    Yuyi::Menu.send :class_variable_set, :'@@menu', nil
 
-  describe '#initialize' do
-    context 'with a valid path' do
-      before do
-        Yuyi::Menu.new 'spec/fixtures/menu.yaml'
-      end
+    allow_any_instance_of(Yuyi::Menu).to receive(:load_from_file)
+    allow_any_instance_of(Yuyi::Menu).to receive(:set_sources)
+    allow_any_instance_of(Yuyi::Menu).to receive(:set_rolls)
 
-      it 'should set the path var' do
-        expect(Yuyi::Menu.path).to eq 'spec/fixtures/menu.yaml'
-      end
+    @menu = Yuyi::Menu.new 'spec/fixtures/menu.yaml'
+  end
 
-      it 'should set the instance on the menu class' do
-        expect(Yuyi::Menu.instance).to eq Yuyi::Menu.instance
+  # CLASS METHODS
+  #
+  describe 'class methods' do
+    describe '.add_roll' do
+      before do
+        class MenuAddRollRoll; end
+        Yuyi::Menu.add_roll :menu_add_roll_roll, MenuAddRollRoll
       end
 
-      it 'should set the object var' do
-        expect(Yuyi::Menu.object[:sources][0]).to eq({ :local => 'spec/fixtures/roll_dir' })
-        expect(Yuyi::Menu.object[:sources][1]).to eq({ :yuyi => 'spec/fixtures/roll_zip.zip' })
-        expect(Yuyi::Menu.object[:rolls][:foo_roll]).to eq({ :foo => 'bar' })
+      it 'should add a roll instance' do
+        expect(@menu.instance_var(:rolls)[:menu_add_roll_roll]).to be_a MenuAddRollRoll
       end
     end
+  end
 
-    context 'with an invalid path' do
+  # INSTANCE METHODS
+  #
+  describe 'instance methods' do
+    describe '#load_from_file' do
       before do
-        Yuyi::Menu.new 'foo'
-      end
+        # reset yaml var
+        @menu.send :instance_variable_set, :'@yaml', nil
 
-      it 'should have a nil instance' do
-        expect(Yuyi::Menu.instance).to be_nil
+        allow(@menu).to receive(:load_from_file).and_call_original
+        allow(@menu).to receive(:get_menu_path)
       end
 
-      it 'should have a nil object' do
-        expect(Yuyi::Menu.object).to be_nil
+      after do
+        allow(@menu).to receive(:get_menu_path).and_call_original
       end
-    end
-  end
 
-  context 'when valid menu already initialized' do
-    before do
-      Yuyi::Menu.new 'spec/fixtures/menu.yaml'
-    end
+      context 'when the path is invalid' do
+        before do
+          @menu.send :load_from_file, 'foo'
+        end
+
+        it 'should not set the yaml variable' do
+          expect(@menu.instance_var(:yaml)).to be nil
+        end
+
+        it 'should not set the menu_path variable' do
+          expect(@menu.instance_var(:menu_path)).to be nil
+        end
+
+        it 'should call #get_menu_path' do
+          expect(@menu).to have_received(:get_menu_path)
+        end
+      end
 
-    describe '.load_from_file' do
-      context 'with a local file' do
+      context 'when the path is local' do
         before do
-          Yuyi::Menu.load_from_file 'spec/fixtures/menu2.yaml'
+          @menu.send :load_from_file, 'spec/fixtures/menu.yaml'
+        end
+
+        it 'should set the yaml variable' do
+          expect(@menu.instance_var(:yaml)).to be_a Hash
         end
 
-        it 'should update the menu object' do
-          expect(Yuyi::Menu.instance.object[:rolls][:foo_roll]).to eq({ :bar => 'foo' })
+        it 'should set the yaml variable' do
+          expect(@menu.instance_var(:menu_path)).to be_a String
         end
       end
 
-      context 'with a remote file' do
+      context 'when the path is remote' do
         before do
-          allow(Yuyi).to receive(:run).and_return({ :foo => 'bar' }.to_yaml)
-          Yuyi::Menu.load_from_file 'file://menu.yaml'
+          @tmp_dir = Dir.mktmpdir
+          stub_const 'Yuyi::DEFAULT_MENU', File.join(@tmp_dir, 'yuyi_menu')
+          remote_file = 'file://' << File.join(File.dirname(__FILE__), '../../fixtures/menu.yaml')
+          @menu.send :load_from_file, remote_file
         end
 
         after do
-          allow(Yuyi).to receive(:run).and_call_original
+          FileUtils.rm File.join(@tmp_dir, 'yuyi_menu_remote')
+        end
+
+        it 'should set the yaml variable' do
+          expect(@menu.instance_var(:yaml)).to be_a Hash
         end
 
-        it 'should update the menu object' do
-          expect(Yuyi::Menu.instance.object[:foo]).to eq 'bar'
+        it 'should set the yaml variable' do
+          expect(@menu.instance_var(:menu_path)).to be_a String
+        end
+
+        it 'should create a _remote local menu file' do
+          expect(File.exist?(File.join(@tmp_dir, 'yuyi_menu_remote'))).to be true
         end
       end
     end
 
-    describe '.add_roll' do
+    describe '#get_menu_path' do
       before do
-        class MenuAddRollRoll; end
-        Yuyi::Menu.add_roll :menu_add_roll_roll, MenuAddRollRoll
+        tmp_dir = Dir.mktmpdir
+        FileUtils.cp File.join(File.dirname(__FILE__), '../../fixtures/menu.yaml'), tmp_dir
+        stub_const 'Yuyi::DEFAULT_MENU', File.join(tmp_dir, 'menu.yaml')
+        @menu.send :instance_variable_set, :'@yaml', nil
+
+        allow(Readline).to receive(:readline).and_return('foo', 'bar', '')
+        allow(@menu).to receive(:load_from_file).and_call_original
       end
 
-      it 'should add a roll instance' do
-        expect(Yuyi::Menu.instance_var(:rolls)[:menu_add_roll_roll]).to be_a MenuAddRollRoll
+      after do
+        allow(Readline).to receive(:readline).and_call_original
+      end
+
+      it 'should prompt the user to enter a menu path' do
+        expect(@menu).to receive(:load_from_file).exactly(3).times
+        @menu.send :get_menu_path
       end
     end
 
     describe '#set_sources' do
       before do
-        Yuyi::Menu.instance_var :object, { :sources => [{ :foo_source => 'foo/path' }]}
+        allow(Yuyi::Source).to receive(:new)
+        allow(@menu).to receive(:set_sources).and_call_original
 
-        class FooSource; end
-        allow(Yuyi::Source).to receive(:new).and_return FooSource
+        @menu.send :instance_variable_set, :'@yaml', { :sources => { :foo => 'bar' }}
+        @menu.send :set_sources
+      end
 
-        Yuyi::Menu.instance.send :set_sources
+      after do
+        allow(Yuyi::Source).to receive(:new).and_call_original
       end
 
-      it 'should set the sources var' do
-        expect(Yuyi::Menu.instance.var(:sources).size).to eq(1)
-        expect(Yuyi::Menu.instance.var(:sources)[0]).to eq FooSource
+      it 'should create a source object from the menu' do
+        expect(Yuyi::Source).to have_received(:new).with :foo, 'bar'
+      end
+    end
+
+    describe '#set_rolls' do
+      before do
+        allow(@menu).to receive(:set_rolls).and_call_original
+        allow(@menu).to receive(:find_roll)
+
+        @menu.send :instance_variable_set, :'@yaml', { :rolls => { :foo_roll => {}}}
+        @menu.send :set_rolls
+      end
+
+      after do
+        allow(@menu).to receive(:find_roll).and_call_original
+      end
+
+      it 'should require rolls' do
+        expect(@menu).to have_received(:find_roll)
+      end
+    end
+
+    describe '#order' do
+      before do
+        class MenuOrderOne; end
+        class MenuOrderTwo; end
+        allow(MenuOrderOne).to receive :appetizers
+        allow(MenuOrderTwo).to receive :appetizers
+        allow(MenuOrderOne).to receive :entree
+        allow(MenuOrderTwo).to receive :entree
+        allow(MenuOrderOne).to receive :dessert
+        allow(MenuOrderTwo).to receive :dessert
+
+        allow(@menu).to receive(:sorted_rolls).and_return([:menu_order_one, :menu_order_two])
+        @menu.instance_var :rolls, { :menu_order_one => MenuOrderOne,  :menu_order_two => MenuOrderTwo }
+
+        @menu.send :order
+      end
+
+      after do
+        allow(@menu).to receive(:sorted_rolls).and_call_original
+      end
+
+      it 'should initialize a roll with the roll options' do
+        expect(MenuOrderOne).to have_received(:appetizers).ordered
+        expect(MenuOrderTwo).to have_received(:appetizers).ordered
+        expect(MenuOrderOne).to have_received(:entree).ordered
+        expect(MenuOrderTwo).to have_received(:entree).ordered
+        expect(MenuOrderOne).to have_received(:dessert).ordered
+        expect(MenuOrderTwo).to have_received(:dessert).ordered
+      end
+    end
+
+    describe '#sorted_rolls' do
+      before do
+        @menu.instance_var :rolls, {
+          :dependency_roll => OpenStruct.new({ :dependencies => ['foo', 'bar'] }),
+          :foo => OpenStruct.new({ :dependencies => [] }),
+          :bar => OpenStruct.new({ :dependencies => [] })
+        }
+      end
+
+      it 'should add the roll to the class var' do
+        expect(@menu.send(:sorted_rolls).sort_by { |sym| sym.to_s }).to eq([:bar, :dependency_roll, :foo])
       end
     end
 
     describe '#find_roll' do
       before do
-        allow(Yuyi::Menu.instance).to receive :require_roll
+        allow(@menu).to receive :require_roll
       end
 
       context 'when a source is specified' do
         before do
-          Yuyi::Menu.instance.send :find_roll, :foo_roll, { :source => 'foo_source' }
+          @menu.send :find_roll, :foo_roll, { :source => 'foo_source' }
         end
 
         it 'should require the specific roll' do
-          expect(Yuyi::Menu.instance).to have_received(:require_roll).once.with(:foo_roll, 'foo_source/foo_roll')
+          expect(@menu).to have_received(:require_roll).once.with(:foo_roll, 'foo_source/foo_roll')
         end
       end
 
@@ -120,88 +222,46 @@ describe Yuyi::Menu do
         before do
           class TestSourceA; end
           class TestSourceB; end
-          allow(TestSourceA).to receive(:available_rolls).and_return({ :foo_roll => 'foo_roll' })
-          allow(TestSourceB).to receive(:available_rolls).and_return({ :bar_roll => 'bar_roll' })
+          allow(TestSourceA).to receive(:rolls).and_return({ :foo_roll => 'foo_roll' })
+          allow(TestSourceB).to receive(:rolls).and_return({ :bar_roll => 'bar_roll' })
 
-          Yuyi::Menu.instance.var :sources, [TestSourceA, TestSourceB]
+          @menu.var :sources, [TestSourceA, TestSourceB]
         end
 
         it 'should require the first roll found' do
-          expect(Yuyi::Menu.instance).to receive(:require_roll).once.with(:bar_roll, 'bar_roll')
-          Yuyi::Menu.instance.send :find_roll, :bar_roll
+          expect(@menu).to receive(:require_roll).once.with(:bar_roll, 'bar_roll')
+          @menu.send :find_roll, :bar_roll
         end
       end
 
       context 'when no roll is found' do
         before do
           class TestSource; end
-          allow(TestSource).to receive(:available_rolls).and_return({})
+          allow(TestSource).to receive(:rolls).and_return({})
 
-          Yuyi::Menu.instance.var :sources, [TestSource]
+          @menu.var :sources, [TestSource]
         end
 
         it 'should not attempt to require a roll' do
-          expect(Yuyi::Menu.instance).to_not receive(:require_roll)
-          Yuyi::Menu.instance.send :find_roll, :no_roll
+          expect(@menu).to_not receive(:require_roll)
+          @menu.send :find_roll, :no_roll
         end
       end
     end
 
-    describe '#on_the_menu?' do
+    describe '#options' do
       before do
-        allow(Yuyi::Menu.instance).to receive(:object).and_return({ :rolls => { :foo => nil }})
+        @menu.instance_var :yaml, {
+          :rolls => {
+            :foo_roll => {
+              :foo => :bar
+            }
+          }
+        }
       end
 
-      it 'should return true if on the menu' do
-        expect(Yuyi::Menu.instance.on_the_menu?(:foo)).to be true
-      end
-    end
-
-    describe '#sorted_rolls' do
-      before do
-        class DependencyRoll
-          def dependencies; ['foo', 'bar']; end
-        end
-        class EmptyDependencyRoll
-          def dependencies; []; end
-        end
-        allow(Yuyi::Menu.instance).to receive(:rolls).and_return({ :dependency_roll => DependencyRoll.new, :foo => EmptyDependencyRoll.new, :bar => EmptyDependencyRoll.new })
-      end
-
-      it 'should add the roll to the class var' do
-        expect(Yuyi::Menu.instance.send(:sorted_rolls).sort_by { |sym| sym.to_s }).to eq([:bar, :dependency_roll, :foo])
-      end
-    end
-
-    describe '#order_rolls' do
-      before do
-        class MenuOrderRollsOne; end
-        class MenuOrderRollsTwo; end
-        allow(MenuOrderRollsOne).to receive :appetizers
-        allow(MenuOrderRollsTwo).to receive :appetizers
-        allow(MenuOrderRollsOne).to receive :entree
-        allow(MenuOrderRollsTwo).to receive :entree
-        allow(MenuOrderRollsOne).to receive :dessert
-        allow(MenuOrderRollsTwo).to receive :dessert
-
-        allow(Yuyi::Menu.instance).to receive(:sorted_rolls).and_return([:menu_order_rolls_one, :menu_order_rolls_two])
-        allow(Yuyi::Menu.instance).to receive(:rolls).and_return({ :menu_order_rolls_one => MenuOrderRollsOne,  :menu_order_rolls_two => MenuOrderRollsTwo })
-
-        Yuyi::Menu.instance.send :order_rolls
-      end
-
-      after do
-        allow(Yuyi::Menu.instance).to receive(:sorted_rolls).and_call_original
-        allow(Yuyi::Menu.instance).to receive(:rolls).and_call_original
-      end
-
-      it 'should initialize a roll with the roll options' do
-        expect(MenuOrderRollsOne).to have_received(:appetizers).ordered
-        expect(MenuOrderRollsTwo).to have_received(:appetizers).ordered
-        expect(MenuOrderRollsOne).to have_received(:entree).ordered
-        expect(MenuOrderRollsTwo).to have_received(:entree).ordered
-        expect(MenuOrderRollsOne).to have_received(:dessert).ordered
-        expect(MenuOrderRollsTwo).to have_received(:dessert).ordered
+      it 'should return roll options' do
+        expect(@menu.options(:foo_roll)[:foo]).to eq :bar
       end
     end
   end

data/spec/lib/yuyi/roll_spec.rb

@@ -1,41 +1,20 @@
 require 'spec_helper'
 
 describe Yuyi::Roll do
-  before do
-    allow(Yuyi::Menu).to receive :add_roll
-    allow(Yuyi::Menu).to receive :find_roll
-    allow(Yuyi::Menu).to receive(:options).and_return({ :foo => 'menu option' })
-    allow(Yuyi::Menu).to receive(:on_the_menu?).and_return false
+  describe '.dependencies' do
+    before do
+      allow(Yuyi::Menu).to receive(:find_roll)
+    end
 
-    class Yuyi::TestRoll < Yuyi::Roll
-      pre_install { :pre_install }
-      install { :install }
-      post_install { :post_install }
-      uninstall { :uninstall }
-      upgrade { :upgrade }
-      installed? { :installed? }
-      dependencies :foo
-      options({
-        :foo => {
-          :description => 'Foo.',
-          :example => 'foo example',
-          :default => 'foo default',
-          :required => true
-        },
-        :bar => {
-          :description => 'Bar.',
-          :example => 'bar example',
-          :default => 'bar default'
-        }
-      })
+    after do
+      allow(Yuyi::Menu).to receive(:find_roll).and_call_original
     end
-  end
 
-  after do
-    allow(Yuyi::Menu).to receive(:add_roll).and_call_original
-    allow(Yuyi::Menu).to receive(:find_roll).and_call_original
-    allow(Yuyi::Menu).to receive(:options).and_call_original
-    allow(Yuyi::Menu).to receive(:on_the_menu?).and_call_original
+    it 'should call find dependency rolls' do
+      expect(Yuyi::Menu).to receive(:find_roll).with :foo
+      expect(Yuyi::Menu).to receive(:find_roll).with :bar
+      Yuyi::Roll.dependencies :foo, :bar
+    end
   end
 
   describe '.class_to_title' do
@@ -51,223 +30,55 @@ describe Yuyi::Roll do
   end
 
   context 'when inherited' do
-    it 'should add the roll to the menu' do
-      allow(Yuyi::Menu).to receive :add_roll
-
-      class Yuyi::TestInheritRoll < Yuyi::Roll
-        install {}
-        uninstall {}
-        upgrade {}
-        installed? {}
-      end
-
-      expect(Yuyi::Menu).to have_received(:add_roll).with :roll_spec, Yuyi::TestInheritRoll
-    end
-
-    # DSL Methods
-    #
-
-    it 'should add dependencies' do
-      expect(Yuyi::Menu).to have_received(:find_roll).with :foo
-    end
-
-    it 'should create a title' do
-      expect(Yuyi::TestRoll.title).to eq 'Test Roll'
-    end
-
-    it 'should create a file name' do
-      expect(Yuyi::TestRoll.file_name).to eq :roll_spec
-    end
-
-    it 'should respond to .pre_install' do
-      expect(Yuyi::TestRoll.pre_install).to be_a Proc
-    end
-
-    it 'should respond to .install' do
-      expect(Yuyi::TestRoll.install).to be_a Proc
-    end
-
-    it 'should respond to .post_install' do
-      expect(Yuyi::TestRoll.post_install).to be_a Proc
-    end
-
-    it 'should respond to .uninstall' do
-      expect(Yuyi::TestRoll.uninstall).to be_a Proc
-    end
-
-    it 'should respond to .upgrade' do
-      expect(Yuyi::TestRoll.upgrade).to be_a Proc
-    end
-
-    it 'should respond to .installed?' do
-      expect(Yuyi::TestRoll.installed?).to be_a Proc
-    end
-
-    it 'should return .dependencies' do
-      expect(Yuyi::TestRoll.dependencies).to eq([:foo])
-    end
-
-    it 'should return .options' do
-      expect(Yuyi::TestRoll.options[:foo][:default]).to eq 'foo default'
-    end
-  end
-
-  context 'when initialized' do
     before do
-      @test_roll = Yuyi::TestRoll.new
-    end
-
-    it 'should return the title' do
-      expect(@test_roll.title).to eq 'Test Roll'
-    end
-
-    it 'should return the file_name' do
-      expect(@test_roll.file_name).to eq :roll_spec
-    end
-
-    it 'should add dependencies' do
-      expect(@test_roll.dependencies).to eq([:foo])
-    end
-
-    it 'should return the pre_install results' do
-      expect(@test_roll.send(:pre_install)).to eq :pre_install
+      allow(Yuyi::Menu).to receive(:add_roll)
     end
 
-    it 'should return the install results' do
-      expect(@test_roll.send(:install)).to eq :install
+    after do
+      allow(Yuyi::Menu).to receive(:add_roll).and_call_original
     end
 
-    it 'should return the post_install results' do
-      expect(@test_roll.send(:post_install)).to eq :post_install
-    end
-
-    it 'should return the uninstall results' do
-      expect(@test_roll.send(:uninstall)).to eq :uninstall
+    it 'should add the roll to the menu' do
+      class RollSpecInheritedRoll < Yuyi::Roll; end
+      expect(Yuyi::Menu).to have_received(:add_roll).with :roll_spec, RollSpecInheritedRoll
     end
 
-    it 'should return the upgrade results' do
-      expect(@test_roll.send(:upgrade)).to eq :upgrade
+    it 'should respond to title' do
+      class RollSpecTitle < Yuyi::Roll; end
+      expect(RollSpecTitle.title).to eq  'Roll Spec Title'
     end
 
-    it 'should return the installed? boolean' do
-      expect(@test_roll.send(:installed?)).to eq true
-    end
-
-    it 'should return options' do
-      expect(@test_roll.options).to eq({
-        :foo => 'menu option',
-        :bar => 'bar default'
-      })
-
-      expect(@test_roll.option_defs).to eq({
-        :foo => {
-          :description => 'Foo.',
-          :example => 'foo example',
-          :default => 'foo default',
-          :required => true
-        },
-        :bar => {
-          :description => 'Bar.',
-          :example => 'bar example',
-          :default => 'bar default'
-        }
-      })
+    it 'should respond to file_name' do
+      class RollSpecFileName < Yuyi::Roll; end
+      expect(RollSpecFileName.file_name).to eq  :roll_spec
     end
   end
 
-  context '#order' do
+  describe 'instance' do
     before do
-      @roll = Yuyi::TestRoll.new
-      allow(@roll).to receive(:install)
-      allow(@roll).to receive(:uninstall)
-      allow(@roll).to receive(:upgrade)
-    end
+      allow(Yuyi::Menu).to receive(:add_roll)
+      allow(Yuyi::Menu).to receive(:find_roll)
 
-    context 'when not installed' do
-      before do
-        allow(@roll).to receive(:installed?).and_return false
-        @roll.send :order
+      class RollSpecInstance < Yuyi::Roll
+        dependencies :foo, :bar
+        installed? { false }
+        pre_install { 'Pre Install' }
       end
 
-      it 'should call install' do
-        expect(@roll).to have_received :install
-        expect(@roll).to_not have_received :uninstall
-        expect(@roll).to_not have_received :upgrade
-      end
+      @roll = RollSpecInstance.new
     end
 
-    context 'when installed' do
-      before do
-        allow(@roll).to receive(:installed?).and_return true
-      end
-
-      context 'when uninstall option is set' do
-        before do
-          allow(Yuyi::Menu).to receive(:options).and_return({ :uninstall => true })
-          @roll.send :order
-        end
-
-        it 'should call uninstall' do
-          expect(@roll).to_not have_received :install
-          expect(@roll).to have_received :uninstall
-          expect(@roll).to_not have_received :upgrade
-        end
-      end
-
-      context 'when uninstall option is not set & upgrade is true' do
-        before do
-          allow(@roll).to receive(:upgrade?).and_return true
-          @roll.send :order
-        end
-
-        it 'should call upgrade' do
-          expect(@roll).to_not have_received :install
-          expect(@roll).to_not have_received :uninstall
-          expect(@roll).to have_received :upgrade
-        end
-      end
+    after do
+      allow(Yuyi::Menu).to receive(:add_roll).and_call_original
+      allow(Yuyi::Menu).to receive(:find_roll).and_call_original
     end
-  end
-end
-
-describe 'Yuyi::RollModel' do
-  before do
-    allow(Yuyi::Menu).to receive(:add_roll)
-
-    class Yuyi::FooRollModel < Yuyi::Roll
-      def self.inherited klass; add_roll klass, caller; end
-      def self.foo_name name
-        install { name }
-        installed? { false }
-      end
 
+    it 'should respond to pre_install' do
+      expect(@roll.pre_install).to eq 'Pre Install'
     end
 
-    class Yuyi::FooModelRoll < Yuyi::FooRollModel
-      foo_name 'Foo Name'
-      installed? { true }
+    it 'should respond to dependencies' do
+      expect(@roll.dependencies).to eq [ :foo, :bar ]
     end
   end
-
-  after do
-    allow(Yuyi::Menu).to receive(:add_roll).and_call_original
-  end
-
-  it 'should not add the roll model' do
-    class Yuyi::BarRollModel < Yuyi::Roll; end
-    expect(Yuyi::Menu).to_not have_received(:add_roll).with :roll_spec, Yuyi::BarRollModel
-  end
-
-  it 'should add the inherited roll' do
-    class Yuyi::FooInheritedRoll < Yuyi::FooRollModel; end
-    expect(Yuyi::Menu).to have_received(:add_roll).with :roll_spec, Yuyi::FooInheritedRoll
-  end
-
-  it 'should use the roll model methods' do
-    expect(Yuyi::FooModelRoll.new.send(:install)).to eq 'Foo Name'
-  end
-
-  it 'should prefer the roll methods over the model methods' do
-    expect(Yuyi::FooModelRoll.new.send(:installed?)).to be true
-  end
 end