yuyi 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8667df310a7caf00f8607e5087c452a1ec32047b
-  data.tar.gz: e9e2e237dcb9a5fe15f0c6b5395841d78f18b2cd
+  metadata.gz: 2d42b24d7281505899a99092cf0deffad8806cfe
+  data.tar.gz: e7f8ae082e4a25f178d530613624def9f28eedb0
 SHA512:
-  metadata.gz: d085644d59271a419c13216437c879667d86f3701a13724e1aca6ea7231f84572881529a045758755be8be84190b6c3313638ab2e3ec3c9331b376c858322276
-  data.tar.gz: 904a13f14634ba63338104d83ff881f10f76725c59f50d0f24191bbd5df2f7a2fc71428bfbd707c97fefb0bd39a68e99ec441302a908680d4340e63216828dd7
+  metadata.gz: e1a8ca7384b13712ec2b6f7929e3e6351ccf1f8e628c40729ee30e9a4746a489bc56bfad9bd396575b84290f2f8ee04751e404df7455b1a14c49c29d80767a34
+  data.tar.gz: 3ef10a04e372744cc27f2b950b636b666674a2be54d61e7acfe9e8d7ca84945f1159658a784ab7feee48f462aa26d8316606031a9f6868da4f525c3d8de3af42

data/.new

@@ -16,4 +16,4 @@ tasks:
       - spec/**/*.rb
 project_name: Yuyi
 type: ruby
-version: 1.0.3
+version: 1.0.4

data/lib/yuyi/menu.rb

@@ -40,13 +40,13 @@ class Yuyi::Menu
   end
 
   # Attempt to load a menu from a file path
-  # defaults to previously stored @path value
   #
   def self.load_from_file path = path
     menu = begin
       File.open(File.expand_path(path))
     rescue
-      Yuyi.run "curl -sS #{path}"
+      response = Yuyi.run "curl -sS #{path}"
+      $?.success? ? response : nil
     end
 
     @object = begin

data/spec/lib/yuyi/menu_spec.rb

@@ -2,194 +2,207 @@ require 'spec_helper'
 
 describe Yuyi::Menu do
   before do
-    @menu = Yuyi::Menu.new 'spec/fixtures/menu.yaml'
+    Yuyi::Menu.send :class_variable_set, :'@@instance', nil
+    Yuyi::Menu.send :instance_variable_set, :'@object', nil
   end
 
-  describe '.load_from_file' do
-    context 'with a local file' do
+  describe '#initialize' do
+    context 'with a valid path' do
       before do
-        Yuyi::Menu.load_from_file 'spec/fixtures/menu2.yaml'
-      end
-
-      it 'should update the menu object' do
-        expect(@menu.object[:rolls][:foo_roll]).to eq({ :bar => 'foo' })
+        Yuyi::Menu.new 'spec/fixtures/menu.yaml'
       end
-    end
 
-    context 'with a remote file' do
-      before do
-        allow(Yuyi).to receive(:run).and_return({ :foo => 'bar' }.to_yaml)
-        Yuyi::Menu.load_from_file 'file://menu.yaml'
+      it 'should set the path var' do
+        expect(Yuyi::Menu.path).to eq 'spec/fixtures/menu.yaml'
       end
 
-      after do
-        allow(Yuyi).to receive(:run).and_call_original
+      it 'should set the instance on the menu class' do
+        expect(Yuyi::Menu.instance).to eq Yuyi::Menu.instance
       end
 
-      it 'should update the menu object' do
-        expect(@menu.object[:foo]).to eq 'bar'
+      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' })
       end
     end
-  end
-
-  describe '.add_roll' do
-    before do
-      class MenuAddRollRoll; end
-      Yuyi::Menu.add_roll :menu_add_roll_roll, MenuAddRollRoll
-    end
-
-    it 'should add a roll instance' do
-      expect(Yuyi::Menu.instance_var(:rolls)[:menu_add_roll_roll]).to be_a MenuAddRollRoll
-    end
-  end
-
-  describe '#initialize' do
-    it 'should set the path var' do
-      expect(@menu.var(:path)).to eq 'spec/fixtures/menu.yaml'
-    end
-
-    it 'should set the instance on the menu class' do
-      expect(Yuyi::Menu.instance).to eq @menu
-    end
-
-    it 'should set the object var' do
-      expect(Yuyi::Menu.instance_var(:object)[:sources][0]).to eq({ :local => 'spec/fixtures/roll_dir' })
-      expect(Yuyi::Menu.instance_var(:object)[:sources][1]).to eq({ :yuyi => 'spec/fixtures/roll_zip.zip' })
-      expect(Yuyi::Menu.instance_var(:object)[:rolls][:foo_roll]).to eq({ :foo => 'bar' })
-    end
 
     context 'with an invalid path' do
       before do
-        @menu = Yuyi::Menu.new 'foo'
+        Yuyi::Menu.new 'foo'
       end
 
-      it 'should not update menu state' do
-        expect(Yuyi::Menu).to_not eq @menu
+      it 'should have a nil instance' do
+        expect(Yuyi::Menu.instance).to be_nil
       end
 
       it 'should have a nil object' do
-        expect(Yuyi::Menu.instance_var(:object)).to be_nil
+        expect(Yuyi::Menu.object).to be_nil
       end
     end
   end
 
-  describe '#set_sources' do
+  context 'when valid menu already initialized' do
     before do
-      Yuyi::Menu.instance_var :object, { :sources => [{ :foo_source => 'foo/path' }]}
+      Yuyi::Menu.new 'spec/fixtures/menu.yaml'
+    end
 
-      class FooSource; end
-      allow(Yuyi::Source).to receive(:new).and_return FooSource
+    describe '.load_from_file' do
+      context 'with a local file' do
+        before do
+          Yuyi::Menu.load_from_file 'spec/fixtures/menu2.yaml'
+        end
 
-      @menu.send :set_sources
-    end
+        it 'should update the menu object' do
+          expect(Yuyi::Menu.instance.object[:rolls][:foo_roll]).to eq({ :bar => 'foo' })
+        end
+      end
 
-    it 'should set the sources var' do
-      expect(@menu.var(:sources).size).to eq(1)
-      expect(@menu.var(:sources)[0]).to eq FooSource
-    end
-  end
+      context 'with a remote file' do
+        before do
+          allow(Yuyi).to receive(:run).and_return({ :foo => 'bar' }.to_yaml)
+          Yuyi::Menu.load_from_file 'file://menu.yaml'
+        end
 
-  describe '#find_roll' do
-    before do
-      allow(@menu).to receive :require_roll
+        after do
+          allow(Yuyi).to receive(:run).and_call_original
+        end
+
+        it 'should update the menu object' do
+          expect(Yuyi::Menu.instance.object[:foo]).to eq 'bar'
+        end
+      end
     end
 
-    context 'when a source is specified' do
+    describe '.add_roll' do
       before do
-        @menu.send :find_roll, :foo_roll, { :source => 'foo_source' }
+        class MenuAddRollRoll; end
+        Yuyi::Menu.add_roll :menu_add_roll_roll, MenuAddRollRoll
       end
 
-      it 'should require the specific roll' do
-        expect(@menu).to have_received(:require_roll).once.with(:foo_roll, 'foo_source/foo_roll')
+      it 'should add a roll instance' do
+        expect(Yuyi::Menu.instance_var(:rolls)[:menu_add_roll_roll]).to be_a MenuAddRollRoll
       end
     end
 
-    context 'when no source is specified' do
+    describe '#set_sources' 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' })
+        Yuyi::Menu.instance_var :object, { :sources => [{ :foo_source => 'foo/path' }]}
+
+        class FooSource; end
+        allow(Yuyi::Source).to receive(:new).and_return FooSource
 
-        @menu.var :sources, [TestSourceA, TestSourceB]
+        Yuyi::Menu.instance.send :set_sources
       end
 
-      it 'should require the first roll found' do
-        expect(@menu).to receive(:require_roll).once.with(:bar_roll, 'bar_roll')
-        @menu.send :find_roll, :bar_roll
+      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
       end
     end
 
-    context 'when no roll is found' do
+    describe '#find_roll' do
       before do
-        class TestSource; end
-        allow(TestSource).to receive(:available_rolls).and_return({})
+        allow(Yuyi::Menu.instance).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' }
+        end
 
-        @menu.var :sources, [TestSource]
+        it 'should require the specific roll' do
+          expect(Yuyi::Menu.instance).to have_received(:require_roll).once.with(:foo_roll, 'foo_source/foo_roll')
+        end
       end
 
-      it 'should not attempt to require a roll' do
-        expect(@menu).to_not receive(:require_roll)
-        @menu.send :find_roll, :no_roll
+      context 'when no source is specified' 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' })
+
+          Yuyi::Menu.instance.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
+        end
       end
-    end
-  end
 
-  describe '#on_the_menu?' do
-    before do
-      allow(@menu).to receive(:object).and_return({ :rolls => { :foo => nil }})
-    end
+      context 'when no roll is found' do
+        before do
+          class TestSource; end
+          allow(TestSource).to receive(:available_rolls).and_return({})
 
-    it 'should return true if on the menu' do
-      expect(@menu.on_the_menu?(:foo)).to be true
+          Yuyi::Menu.instance.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
+        end
+      end
     end
-  end
 
-  describe '#sorted_rolls' do
-    before do
-      class DependencyRoll
-        def dependencies; ['foo', 'bar']; end
+    describe '#on_the_menu?' do
+      before do
+        allow(Yuyi::Menu.instance).to receive(:object).and_return({ :rolls => { :foo => nil }})
       end
-      class EmptyDependencyRoll
-        def dependencies; []; end
+
+      it 'should return true if on the menu' do
+        expect(Yuyi::Menu.instance.on_the_menu?(:foo)).to be true
       end
-      allow(@menu).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(@menu.send(:sorted_rolls).sort_by { |sym| sym.to_s }).to eq([:bar, :dependency_roll, :foo])
-    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
 
-  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(@menu).to receive(:sorted_rolls).and_return([:menu_order_rolls_one, :menu_order_rolls_two])
-      allow(@menu).to receive(:rolls).and_return({ :menu_order_rolls_one => MenuOrderRollsOne,  :menu_order_rolls_two => MenuOrderRollsTwo })
-
-      @menu.send :order_rolls
+      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
 
-    after do
-      allow(@menu).to receive(:sorted_rolls).and_call_original
-      allow(@menu).to receive(:rolls).and_call_original
-    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
 
-    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
+        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
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yuyi
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Ryan Brewster