tryruby 0.0.1

data/spec/commands_spec.rb

@@ -0,0 +1,50 @@
+require_relative 'spec_helper'
+require 'ripl'
+require_relative '../lib/tryruby/commands'
+require_relative '../lib/tryruby/next_fix'
+
+# mocking shell
+module TestShellModule
+  class << self; attr_reader :called; end
+  @called = {}
+
+  def next_challenge
+    TestShellModule.called[:next_challenge] = true
+  end
+
+  def prev_challenge
+    TestShellModule.called[:prev_challenge] = true
+  end
+
+  def help_challenge
+    TestShellModule.called[:help_challenge] = true
+  end
+end
+
+Ripl::Shell.include TestShellModule
+Ripl::Shell.include Tryruby::NextFix
+Ripl::Commands.include Tryruby::Commands
+Ripl.shell.before_loop
+
+describe Tryruby::Commands do
+  let(:input) { nil }
+  before(:each) do
+    TestShellModule.called.clear
+    Ripl.shell.eval_input(input)
+  end
+  subject { TestShellModule.called }
+  describe '#next' do
+    let(:input) { 'next' }
+    it { is_expected.to eq next_challenge: true }
+  end
+
+  describe '#back' do
+    let(:input) { 'back' }
+    it { is_expected.to eq prev_challenge: true }
+  end
+
+  describe '#help' do
+    let(:input) { 'help' }
+    it { is_expected.to eq help_challenge: true }
+  end
+end

data/spec/level_builder_spec.rb

@@ -0,0 +1,21 @@
+require_relative 'spec_helper'
+require_relative '../lib/tryruby/level_builder'
+
+describe Tryruby::LevelBuilder do
+  subject { described_class.new }
+
+  describe '#challenge' do
+    it 'adds challenges' do
+      subject.challenge do
+        help 'first'
+      end
+      subject.challenge do
+        help 'second'
+      end
+      level = subject.level
+      expect(level[0].help).to eq 'first'
+      expect(level[1].help).to eq 'second'
+      expect(level.length).to eq 2
+    end
+  end
+end

data/spec/level_spec.rb

@@ -0,0 +1,30 @@
+require_relative 'spec_helper'
+require_relative '../lib/tryruby/level'
+require_relative '../lib/tryruby/challenge'
+
+describe Tryruby::Level do
+  let(:a) { Tryruby::Challenge.new('a') }
+  let(:b) { Tryruby::Challenge.new('b') }
+  subject { described_class.new(a, b) }
+
+  describe '#[]' do
+    it 'returns proper item' do
+      expect(subject[0]).to eq a
+      expect(subject[1]).to eq b
+    end
+  end
+
+  describe '#each' do
+    it 'iterates through items' do
+      yielded = []
+      subject.each { |i| yielded << i }
+      expect(yielded).to eq [a, b]
+    end
+  end
+
+  describe '#length' do
+    it 'returns number of items' do
+      expect(subject.length).to eq 2
+    end
+  end
+end

data/spec/next_fix_spec.rb

@@ -0,0 +1,22 @@
+require_relative 'spec_helper'
+require_relative '../lib/tryruby/next_fix'
+
+describe Tryruby::NextFix do
+  # mocking module to properly inherit
+  module API
+    def loop_eval(str)
+      str
+    end
+  end
+
+  include API
+  include described_class
+
+  it 'converts next to self.next' do
+    expect(loop_eval('next')).to eq 'self.next'
+  end
+
+  it 'does not convert "next"' do
+    expect(loop_eval('"next"')).to eq '"next"'
+  end
+end

data/spec/shell_spec.rb

@@ -0,0 +1,205 @@
+require_relative 'spec_helper'
+require_relative '../lib/tryruby/shell'
+require_relative '../lib/tryruby/challenge'
+
+# mocking shell
+class TestShell
+  class << self; public :include; end
+
+  def initialize
+    @binding = create_binding
+    @result = false
+  end
+
+  # mocking module to properly inherit
+  module API
+    def before_loop
+    end
+
+    def loop_once
+    end
+  end
+
+  def create_binding
+    foo = 42
+    bar = 24
+    binding
+  end
+
+  include API
+end
+
+TestShell.include Tryruby::Shell
+
+describe Tryruby::Shell do
+  called = []
+  let(:test) do
+    proc do |result, vars, output|
+      called << [:test, self, result, vars.dup, output]
+      result
+    end
+  end
+  let(:setup) do
+    proc do |vars|
+      called << [:setup, self, vars.dup]
+      vars[:test_var] ||= 0
+      vars[:test_var] += 1
+    end
+  end
+  let(:a) { Tryruby::Challenge.new('a', test, setup) }
+  let(:b) { Tryruby::Challenge.new('b', nil, setup) }
+  let(:c) { Tryruby::Challenge.new('c', test) }
+  let(:levels) { [[a, b], [], [c]] }
+  let(:shell) { TestShell.new.tap { |sh| sh.levels = levels } }
+
+  def test_var
+    eval('test_var', shell.instance_eval('@binding'))
+  end
+
+  subject { shell.challenge }
+
+  before(:each) do
+    called = []
+    shell.before_loop
+  end
+
+  describe '#before_loop' do
+    it 'prints help and calls setup' do
+      is_expected.to eq a
+      expect(called).to eq [[:setup, shell, { foo: 42, bar: 24 }]]
+      expect(test_var).to eq 1
+    end
+  end
+
+  describe '#next_challenge' do
+    let(:test) {}
+    it 'prints helps and calls setups' do
+      expect do
+        shell.next_challenge
+        shell.loop_once
+      end.to match_stdout('b')
+      expect(shell.challenge).to eq b
+      expect(test_var).to eq 2
+      expect do
+        shell.next_challenge
+        shell.loop_once
+      end.to match_stdout('c')
+      expect(shell.challenge).to eq c
+      expect(test_var).to eq 2
+      expect do
+        shell.next_challenge
+        shell.loop_once
+      end.to throw_symbol(:ripl_exit)
+      expect(shell.challenge).to eq nil
+      expect(test_var).to eq 2
+      expect(called).to eq [
+        [:setup, shell, { foo: 42, bar: 24 }],
+        [:setup, shell, { foo: 42, bar: 24, test_var: 1 }]
+      ]
+    end
+  end
+
+  describe '#prev_challenge' do
+    let(:test) {}
+    it 'prints helps and calls setups' do
+      2.times do
+        shell.next_challenge
+        shell.loop_once
+      end
+      expect(shell.challenge).to eq c
+      expect(test_var).to eq 2
+      expect do
+        shell.prev_challenge
+        shell.loop_once
+      end.to match_stdout('b')
+      expect(shell.challenge).to eq b
+      expect(test_var).to eq 3
+      expect do
+        shell.prev_challenge
+        shell.loop_once
+      end.to match_stdout('a')
+      expect(shell.challenge).to eq a
+      expect(test_var).to eq 4
+      expect do
+        shell.prev_challenge
+        shell.loop_once
+      end.to match_stdout('')
+      expect(shell.challenge).to eq a
+      expect(test_var).to eq 4
+      expect(called).to eq [
+        [:setup, shell, { foo: 42, bar: 24 }],
+        [:setup, shell, { foo: 42, bar: 24, test_var: 1 }],
+        [:setup, shell, { foo: 42, bar: 24, test_var: 2 }],
+        [:setup, shell, { foo: 42, bar: 24, test_var: 3 }]
+      ]
+    end
+  end
+
+  describe '#loop_once' do
+    context 'with fulfilled test' do
+      let(:test) do
+        proc do |result, vars, output|
+          called << [:test, self, result, vars, output]
+          !result
+        end
+      end
+      it 'goes to next challenge' do
+        expect { shell.loop_once }.to match_stdout('Success!')
+        expect(called).to eq [
+          [:setup, shell, { foo: 42, bar: 24 }],
+          [:test, shell, false, { foo: 42, bar: 24, test_var: 1 }, ''],
+          [:setup, shell, { foo: 42, bar: 24, test_var: 1 }]
+        ]
+        expect(shell.challenge).to eq b
+      end
+    end
+    context 'with failed test' do
+      it 'does not go to next challenge' do
+        expect { shell.loop_once }.to match_stdout('')
+        expect(called).to eq [
+          [:setup, shell, { foo: 42, bar: 24 }],
+          [:test, shell, false, { foo: 42, bar: 24, test_var: 1 }, '']
+        ]
+        expect(shell.challenge).to eq a
+      end
+    end
+  end
+
+  describe '#level' do
+    it 'returns current level\'s challenges' do
+      expect(shell.level).to eq [a, b]
+    end
+  end
+
+  describe '#challenge' do
+    it 'returns current challenge' do
+      is_expected.to eq a
+    end
+  end
+
+  describe '#help_challenge' do
+    it 'prints help' do
+      expect { shell.help_challenge }.to match_stdout('a')
+    end
+  end
+
+  context 'without challenge' do
+    let(:levels) { [] }
+
+    describe '#loop_once' do
+      it { expect { shell.loop_once }.to throw_symbol(:ripl_exit) }
+    end
+
+    describe '#level' do
+      it { expect(shell.level).to eq nil }
+    end
+
+    describe '#challenge' do
+      it { is_expected.to eq nil }
+    end
+
+    describe '#help_challenge' do
+      it { expect { shell.help_challenge }.to match_stdout('') }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'stringio'
+$LOAD_PATH << '../lib/tryruby'
+
+RSpec.configure do |c|
+  c.color = true
+  c.formatter = :documentation
+  c.tty = true
+end
+
+# mtm @ http://stackoverflow.com/questions/6372763/rspec-how-do-i-write-a-test-that-expects-certain-output-but-doesnt-care-about
+RSpec::Matchers.define :match_stdout do |check|
+  @capture = nil
+
+  match do |block|
+    begin
+      stdout_saved = $stdout
+      $stdout      = StringIO.new
+      block.call
+    ensure
+      @capture     = $stdout
+      $stdout      = stdout_saved
+    end
+
+    @capture.string.match check
+  end
+
+  failure_message do
+    "expected to #{description}"
+  end
+  failure_message_when_negated do
+    "expected not to #{description}"
+  end
+  description do
+    "match [#{check}] on stdout [#{@capture.string}]"
+  end
+
+  def supports_block_expectations?
+    true
+  end
+end

data/spec/tutorial_spec.rb

@@ -0,0 +1,74 @@
+require_relative 'spec_helper'
+require_relative '../lib/tryruby/tutorial'
+
+describe Tryruby::Tutorial do
+  subject { described_class.new }
+
+  describe '#[]' do
+    it { expect(subject[0]).to eq nil }
+  end
+
+  describe '#each' do
+    it 'returns Enumerator without block' do
+      expect(subject.each.class).to be Enumerator
+    end
+    it 'iterates through levels' do
+      yielded = []
+      subject.each { |i| yielded << i }
+      expect(yielded).to eq []
+    end
+  end
+
+  describe '#length' do
+    it { expect(subject.length).to eq 0 }
+  end
+
+  describe '#commands' do
+    it 'return Commands module' do
+      expect(subject.commands).to eq described_class::Commands
+    end
+  end
+
+  context 'subclass' do
+    # Tutorial subclass
+    class TestTutorial < described_class
+      # Test commands
+      module Commands
+        def test
+          'test'
+        end
+      end
+      level do
+      end
+    end
+
+    subject { TestTutorial.new }
+
+    describe '#[]' do
+      it { expect(subject[0].class).to eq Tryruby::Level }
+    end
+
+    describe '#each' do
+      it 'returns Enumerator without block' do
+        expect(subject.each.class).to be Enumerator
+      end
+      it 'iterates through levels' do
+        yielded = []
+        subject.each { |i| yielded << i.class }
+        expect(yielded).to eq [Tryruby::Level]
+      end
+    end
+
+    describe '#length' do
+      it { expect(subject.length).to eq 1 }
+    end
+
+    describe '#commands' do
+      it 'return Commands module' do
+        expect(subject.commands).to eq TestTutorial::Commands
+        expect(subject.commands.instance_methods).to eq [:test]
+        expect(described_class.new.commands.instance_methods).to eq []
+      end
+    end
+  end
+end