yuyi 0.0.3

data/spec/lib/yuyi/cli_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+
+options = Yuyi::Cli::CLI_OPTIONS.keys
+
+describe Yuyi::Cli do
+  before do
+    class CliTest; extend Yuyi::Cli; end
+    allow(CliTest).to receive(:say)
+  end
+
+  describe 'CLI_OPTIONS' do
+    it 'should have options with a unique first character' do
+      flags = options.map{ |option| option.to_s.chars.first }
+
+      expect(flags.uniq.length).to eq options.length
+    end
+  end
+
+  describe '#init' do
+    context 'without arguments' do
+      before do
+        allow(CliTest).to receive :start
+        CliTest.init []
+      end
+
+      it 'should call start' do
+        expect(CliTest).to have_received(:start)
+      end
+    end
+
+    context 'with an invalid argument' do
+      before do
+        allow(CliTest).to receive :help
+        CliTest.init 'foo'
+      end
+
+      it 'should call the help method' do
+        expect(CliTest).to have_received(:help)
+      end
+    end
+
+    context 'with the respective argument' do
+      options.each do |option|
+        before do
+          allow(CliTest).to receive option.to_s.downcase.to_sym
+
+          # Test both option forms
+          CliTest.init "-#{option.to_s.chars.first}"
+          CliTest.init "--#{option}"
+        end
+
+        the "#{option} option is valid" do
+          expect(CliTest).to have_received(option.to_s.downcase.to_sym).twice
+        end
+      end
+    end
+  end
+
+  describe '#say' do
+    before do
+      allow(CliTest).to receive(:say).and_call_original
+      allow(STDOUT).to receive(:puts)
+    end
+
+    after do
+      allow(STDOUT).to receive(:puts).and_call_original
+    end
+
+    it 'should output the correct type' do
+      expect(STDOUT).to receive(:puts).with("\e[31mfoo type\e[0m")
+      CliTest.say 'foo type', :type => :fail
+    end
+
+    it 'should output the correct color' do
+      expect(STDOUT).to receive(:puts).with("\e[123mfoo color\e[0m")
+      CliTest.say 'foo color', :color => 123
+    end
+
+    it 'should output the correct justification & padding' do
+      expect(STDOUT).to receive(:puts).with(' foo justify padding  ')
+      CliTest.say 'foo justify padding', :justify => :center, :padding => 22
+    end
+
+    it 'should output the correct indentation' do
+      expect(STDOUT).to receive(:puts).with('  foo indent')
+      CliTest.say 'foo indent', :indent => 2
+    end
+  end
+
+  describe '#ask' do
+    before do
+      allow(CliTest).to receive(:say)
+      allow(STDIN).to receive(:gets).and_return 'foo'
+    end
+
+    after do
+      allow(STDIN).to receive(:gets).and_call_original
+    end
+
+    it 'should pass the user input to the block' do
+      CliTest.ask 'why?' do |response|
+        expect(response).to eq 'foo'
+      end
+    end
+  end
+
+  describe '#command?' do
+    it 'should return true if command exists' do
+      expect(CliTest.command?('ruby -v')).to eq true
+    end
+
+    it 'should return false if command does not exist' do
+      expect(CliTest.command?('rubyfoo')).to eq false
+    end
+  end
+
+  describe '#write_to_file' do
+    before do
+      CliTest.write_to_file 'test', 'foo'
+    end
+
+    after do
+      FileUtils.rm 'test'
+    end
+
+    it 'should create a file if it doesnt exist' do
+      expect(File.exists?('test')).to be true
+    end
+
+    it 'should append to the file' do
+      CliTest.write_to_file 'test', 'bar'
+      expect(File.open('test').read).to eq "foo\nbar\n"
+    end
+
+    it 'should accept multiple text arguments' do
+      CliTest.write_to_file 'test', 'arg1', 'arg2'
+      expect(File.open('test').read).to eq "foo\narg1\narg2\n"
+    end
+  end
+
+  describe '#delete_from_file' do
+    before do
+      CliTest.write_to_file 'test', 'foo', 'remove1', 'remove2', 'bar'
+    end
+
+    after do
+      FileUtils.rm 'test'
+    end
+
+    it 'should remove a line from the file' do
+      CliTest.delete_from_file 'test', 'remove1'
+      expect(File.open('test').read).to eq "foo\nremove2\nbar\n"
+    end
+
+    it 'should accept multiple text arguments' do
+      CliTest.delete_from_file 'test', 'remove1', 'remove2'
+      expect(File.open('test').read).to eq "foo\nbar\n"
+    end
+  end
+
+  describe '#get_menu' do
+    before do
+      stub_const 'Yuyi::DEFAULT_MENU', 'spec/fixtures/menu.yaml'
+      allow(Yuyi::Menu).to receive(:load_from_file).and_return true
+    end
+
+    after do
+      CliTest.send :get_menu
+      allow(Readline).to receive(:readline).and_call_original
+      allow(Yuyi::Menu).to receive(:new).and_call_original
+      allow(Yuyi::Menu).to receive(:load_from_file).and_call_original
+    end
+
+    context 'when no input is given' do
+      before do
+        allow(Readline).to receive(:readline).and_return('')
+        allow(Yuyi::Menu).to receive(:new).and_return(true)
+      end
+
+      it 'should load the default menu' do
+        expect(Yuyi::Menu).to receive(:new).with('spec/fixtures/menu.yaml')
+      end
+    end
+
+    context 'when an invalid path is given' do
+      before do
+        allow(Readline).to receive(:readline).and_return('foo', 'bar', '')
+        allow(Yuyi::Menu).to receive(:new).and_return(false, false, true)
+      end
+
+      it 'should request input again' do
+        expect(Yuyi::Menu).to receive(:new).exactly(3).times
+      end
+    end
+
+    context 'when a custom path is given' do
+      before do
+        allow(Readline).to receive(:readline).and_return('spec/fixtures/menu.yaml')
+        allow(Yuyi::Menu).to receive(:new).and_return(true)
+      end
+
+      it 'should load the menu' do
+        expect(Yuyi::Menu).to receive(:new).with('spec/fixtures/menu.yaml')
+      end
+    end
+  end
+
+  describe '#present_options' do
+    before do
+      @output = ''
+      allow(CliTest).to receive :say do |o, p|
+        @output << (o || '')
+      end
+
+      class PresentOptionsRoll; end
+      allow(PresentOptionsRoll).to receive(:title).and_return 'Present Options Roll'
+      allow(PresentOptionsRoll).to receive(:file_name).and_return :present_options_roll
+      allow(PresentOptionsRoll).to receive(:options).and_return({ :option_foo => '3.0' })
+      allow(PresentOptionsRoll).to receive(:option_defs).and_return({
+        :option_foo => {
+          :description => 'foo description',
+          :example => '1.0',
+          :default => '2.0'
+        }
+      })
+
+      CliTest.send :present_options, PresentOptionsRoll
+    end
+
+    it 'should output the neccessary information' do
+      expect(@output).to include 'Present Options Roll'
+      expect(@output).to include 'present_options_roll'
+      expect(@output).to include 'foo description'
+      expect(@output).to include '1.0'
+      expect(@output).to include '2.0'
+    end
+  end
+
+  # Argument Methods
+  #
+  describe '#help' do
+    before do
+      stub_const 'Yuyi::Cli::CLI_OPTIONS', {
+        :FOO => 'doo',
+        :bar => 'boo'
+      }
+
+      @output = ''
+      allow(CliTest).to receive :say do |o, p|
+        @output << (o || '')
+      end
+
+      CliTest.send :help
+    end
+
+    it 'should return options' do
+      expect(@output).to include '-F'
+      expect(@output).to include '--FOO'
+      expect(@output).to include 'doo'
+      expect(@output).to include '-b'
+      expect(@output).to include '--bar'
+      expect(@output).to include 'boo'
+    end
+  end
+
+  describe '#list' do
+    before do
+      class ListRollSource; end
+      allow(ListRollSource).to receive(:available_rolls).and_return({ :list_roll => nil })
+
+      allow(CliTest).to receive :get_menu
+      allow(Yuyi::Menu).to receive :set_sources
+      allow(Yuyi::Menu).to receive(:sources).and_return([ ListRollSource ])
+
+      @output = ''
+      allow(CliTest).to receive :say do |o, p|
+        @output << (o || '')
+      end
+
+      CliTest.send :list
+    end
+
+    after do
+      allow(Yuyi::Menu).to receive(:set_sources).and_call_original
+    end
+
+    it 'should return all rolls' do
+      expect(@output).to include 'list_roll'
+    end
+  end
+end

data/spec/lib/yuyi/core_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Hash do
+  describe '.deep_symbolize_keys!' do
+    before do
+      @hash = {
+        'foo' => 'bar',
+        'nested_hash' => { 'nested_key' => 'nested_value'},
+        'nested_array' => ['array_element']
+      }
+
+      @hash.deep_symbolize_keys!
+    end
+
+    it 'should recursively symbolize keys' do
+      expect(@hash).to eq({
+        :foo => 'bar',
+        :nested_hash => { :nested_key => 'nested_value' },
+        :nested_array => ['array_element']
+      })
+    end
+  end
+
+  describe '.deep_stringify_keys!' do
+    before do
+      @hash = {
+        :foo => 'bar',
+        :nested_hash => { :nested_key => 'nested_value' },
+        :nested_array => ['array_element']
+      }
+
+      @hash.deep_stringify_keys!
+    end
+
+    it 'should recursively symbolize keys' do
+      expect(@hash).to eq({
+        'foo' => 'bar',
+        'nested_hash' => { 'nested_key' => 'nested_value'},
+        'nested_array' => ['array_element']
+      })
+    end
+  end
+end

data/spec/lib/yuyi/menu_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Yuyi::Menu do
+  before do
+    @menu = Yuyi::Menu.new 'spec/fixtures/menu.yaml'
+  end
+
+  describe '.load_from_file' 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' })
+    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 '.pre_install' do
+    before do
+      @pre_install = lambda {}
+      Yuyi::Menu.instance_var :pre_installs, [@pre_install,]
+      allow(@pre_install).to receive(:call)
+      Yuyi::Menu.pre_install
+    end
+
+    after do
+      allow(@pre_install).to receive(:call).and_call_original
+    end
+
+    it 'should run pre_installs' do
+      expect(@pre_install).to have_received(:call)
+    end
+  end
+
+  describe '.post_install' do
+    before do
+      @post_install = lambda {}
+      Yuyi::Menu.instance_var :post_installs, [@post_install,]
+      allow(@post_install).to receive(:call)
+      Yuyi::Menu.post_install
+    end
+
+    after do
+      allow(@post_install).to receive(:call).and_call_original
+    end
+
+    it 'should run post_installs' do
+      expect(@post_install).to have_received(:call)
+    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'
+      end
+
+      it 'should not update menu state' do
+        expect(Yuyi::Menu).to_not eq @menu
+      end
+
+      it 'should have a nil object' do
+        expect(Yuyi::Menu.instance_var(:object)).to be_nil
+      end
+    end
+  end
+
+  describe '#set_sources' do
+    before do
+      Yuyi::Menu.instance_var :object, { :sources => [{ :foo_source => 'foo/path' }]}
+
+      class FooSource; end
+      allow(Yuyi::Source).to receive(:new).and_return FooSource
+
+      @menu.send :set_sources
+    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
+
+  describe '#find_roll' do
+    before do
+      allow(@menu).to receive :require_roll
+    end
+
+    context 'when a source is specified' do
+      before do
+        @menu.send :find_roll, :foo_roll, { :source => 'foo_source' }
+      end
+
+      it 'should require the specific roll' do
+        expect(@menu).to have_received(:require_roll).once.with(:foo_roll, 'foo_source/foo_roll')
+      end
+    end
+
+    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' })
+
+        @menu.var :sources, [TestSourceA, TestSourceB]
+      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
+      end
+    end
+
+    context 'when no roll is found' do
+      before do
+        class TestSource; end
+        allow(TestSource).to receive(:available_rolls).and_return({})
+
+        @menu.var :sources, [TestSource]
+      end
+
+      it 'should not attempt to require a roll' do
+        expect(@menu).to_not receive(:require_roll)
+        @menu.send :find_roll, :no_roll
+      end
+    end
+  end
+
+  describe '#on_the_menu?' do
+    before do
+      allow(@menu).to receive(:object).and_return({ :rolls => { :foo => nil }})
+    end
+
+    it 'should return true if on the menu' do
+      expect(@menu.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(@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 '#order_rolls' do
+    before do
+      class MenuOrderRollsRoll; end
+      allow(MenuOrderRollsRoll).to receive :order
+
+      allow(Yuyi::Menu).to receive(:pre_install)
+      allow(Yuyi::Menu).to receive(:post_install)
+      allow(@menu).to receive(:sorted_rolls).and_return([:order_rolls_roll])
+      allow(@menu).to receive(:rolls).and_return({ :order_rolls_roll => MenuOrderRollsRoll })
+
+      @menu.send :order_rolls
+    end
+
+    after do
+      allow(Yuyi::Menu).to receive(:pre_install).and_call_original
+      allow(Yuyi::Menu).to receive(:post_install).and_call_original
+      allow(@menu).to receive(:sorted_rolls).and_call_original
+      allow(@menu).to receive(:rolls).and_call_original
+    end
+
+    it 'should initialize a roll with the roll options' do
+      expect(Yuyi::Menu).to have_received(:pre_install).ordered
+      expect(MenuOrderRollsRoll).to have_received(:order).ordered
+      expect(Yuyi::Menu).to have_received(:post_install).ordered
+    end
+  end
+end