tryruby 0.0.1

data/lib/tryruby/level.rb

@@ -0,0 +1,23 @@
+module Tryruby
+  # Single tutorial level
+  class Level
+    include Enumerable
+
+    def initialize(*challenges)
+      @challenges = challenges
+    end
+
+    def [](n)
+      @challenges[n]
+    end
+
+    def each(&block)
+      @challenges.each(&block)
+    end
+
+    # Number of challenges in level
+    def length
+      @challenges.length
+    end
+  end
+end

data/lib/tryruby/level_builder.rb

@@ -0,0 +1,21 @@
+require_relative 'level'
+require_relative 'challenge_builder'
+
+module Tryruby
+  # Single tutorial level builder
+  class LevelBuilder
+    def initialize
+      @challenges = []
+    end
+
+    def challenge(&block)
+      builder = ChallengeBuilder.new
+      builder.instance_eval(&block)
+      @challenges << builder.challenge
+    end
+
+    def level
+      Level.new(*@challenges)
+    end
+  end
+end

data/lib/tryruby/next_fix.rb

@@ -0,0 +1,9 @@
+module Tryruby
+  # evals 'next' as 'self.next' instead of keyword
+  module NextFix
+    def loop_eval(str)
+      str = 'self.' + str if str == 'next'
+      super(str)
+    end
+  end
+end

data/lib/tryruby/runner.rb

@@ -0,0 +1,19 @@
+require 'ripl'
+require 'ripl/multi_line'
+require_relative 'shell'
+require_relative 'commands'
+
+module Tryruby
+  # Startup class of the shell
+  class Runner
+    def self.start(tutorials)
+      Ripl::Shell.include Tryruby::Shell
+      Ripl::Commands.include Tryruby::Commands
+      tutorials.each do |tutorial|
+        tutorial.each { |level| Ripl.shell.levels << level }
+        Ripl::Commands.include tutorial.commands
+      end
+      Ripl.start
+    end
+  end
+end

data/lib/tryruby/shell.rb

@@ -0,0 +1,122 @@
+require 'stringio'
+require_relative 'colors'
+require_relative 'next_fix'
+
+module Tryruby
+  # Shell extension
+  module Shell
+    include Tryruby::NextFix
+    attr_writer :levels
+
+    def before_loop
+      super
+      @level, @challenge = 0, -1
+      next_challenge
+      setup_challenge if @challenge_changed
+      @challenge_changed = false
+      @output = ''
+    end
+
+    def loop_once
+      throw :ripl_exit unless challenge
+      super
+      result = @error_raised ? @error : @result
+      if challenge && \
+        challenge.test(repl_self, result, read_variables, @output)
+        puts Colors.success('Success!')
+        next_challenge
+      end
+      setup_challenge if @challenge_changed
+      @challenge_changed = false
+    end
+
+    def loop_eval(str)
+      stdout_saved = $stdout
+      $stdout = StringIO.new
+      begin
+        super(str)
+      ensure
+        @output = $stdout.string
+        $stdout = stdout_saved
+        puts @output if @output != ''
+      end
+    end
+
+    def print_eval_error(error)
+      @error = error
+      super(error)
+    end
+
+    def format_error(error)
+      Colors.error(super(error))
+    end
+
+    def format_result(result)
+      Colors.result(super(result))
+    end
+
+    def levels
+      @levels ||= []
+    end
+
+    def level
+      levels[@level] if @level >= 0
+    end
+
+    def challenge
+      level[@challenge] if level && @challenge >= 0
+    end
+
+    def next_challenge
+      @challenge += 1
+      while level && !challenge
+        @challenge = 0
+        @level += 1
+      end
+      @challenge_changed = true if challenge
+      nil
+    end
+
+    def prev_challenge
+      lvl, chall = @level, @challenge - 1
+      while lvl > 0 && chall < 0
+        lvl -= 1
+        chall = levels[lvl].length - 1
+      end
+      return if chall < 0
+      @level, @challenge = lvl, chall
+      @challenge_changed = true
+      nil
+    end
+
+    def help_challenge
+      puts challenge.help if challenge
+    end
+
+    private
+
+    def repl_self
+      eval('self', @binding)
+    end
+
+    def read_variables
+      vars = eval('local_variables', @binding).map do |var|
+        [var, @binding.local_variable_get(var)]
+      end
+      Hash[vars]
+    end
+
+    def write_variables(vars)
+      vars.each { |sym, value| @binding.local_variable_set(sym, value) }
+    end
+
+    def setup_challenge
+      return unless challenge
+      vars = read_variables
+      challenge.setup(repl_self, vars)
+      write_variables(vars)
+      puts challenge.setup_source if challenge.display_setup
+      help_challenge
+    end
+  end
+end

data/lib/tryruby/tutorial.rb

@@ -0,0 +1,53 @@
+require_relative 'level_builder'
+
+module Tryruby
+  # Base module for level DSL
+  class Tutorial
+    extend Enumerable
+
+    # Commands to be imported
+    module Commands
+    end
+
+    def initialize
+      @levels = []
+      self.class.each do |block|
+        builder = LevelBuilder.new
+        builder.instance_eval(&block)
+        @levels << builder.level
+      end
+    end
+
+    def [](i)
+      @levels[i]
+    end
+
+    def each(&block)
+      @levels.each(&block)
+    end
+
+    def length
+      @levels.length
+    end
+
+    def commands
+      self.class::Commands
+    end
+
+    def self.each(&block)
+      levels.each(&block)
+    end
+
+    def self.level(&block)
+      levels << block
+    end
+
+    def self.levels
+      @levels ||= []
+    end
+
+    class << self
+      private :level, :levels
+    end
+  end
+end

data/lib/tryruby/version.rb

@@ -0,0 +1,4 @@
+# Version
+module Tryruby
+  VERSION = '0.0.1'
+end

data/spec/challenge_buider_spec.rb

@@ -0,0 +1,39 @@
+require_relative 'spec_helper'
+require_relative '../lib/tryruby/challenge_builder'
+
+describe Tryruby::ChallengeBuilder do
+  subject { described_class.new }
+
+  it 'passes help' do
+    subject.help <<-EOF
+HELP! HELP!
+I'm being oppressed!
+    EOF
+    expect(subject.challenge.help).to eq "HELP! HELP!\nI'm being oppressed!\n"
+  end
+
+  it 'passes test' do
+    called = []
+    subject.test do |result, vars, out|
+      called << [self, result, vars, out]
+      true
+    end
+    expect(subject.challenge.test('self', 42, { foo: 'bar' }, '')).to eq true
+    expect(called).to eq [['self', 42, { foo: 'bar' }, '']]
+  end
+
+  it 'passes setup' do
+    called = []
+    subject.setup do |vars|
+      called << [self, vars]
+      true
+    end
+    expect(subject.challenge.setup('self', foo: 'bar')).to eq true
+    expect(called).to eq [['self', foo: 'bar']]
+  end
+
+  it 'passes display_setup' do
+    subject.display_setup true
+    expect(subject.challenge.display_setup).to eq true
+  end
+end

data/spec/challenge_spec.rb

@@ -0,0 +1,91 @@
+require_relative 'spec_helper'
+require_relative '../lib/tryruby/challenge'
+
+describe Tryruby::Challenge do
+  let(:help) { '' }
+  let(:test) { nil }
+  let(:setup) { nil }
+  let(:display_setup) { false }
+
+  subject { described_class.new(help, test, setup, display_setup) }
+
+  describe '#help' do
+    let(:help) { 'This is help' }
+    it 'returns help' do
+      expect(subject.help).to eq 'This is help'
+    end
+  end
+
+  describe '#test' do
+    context 'non-empty test' do
+      called = []
+      let(:test) do
+        proc do |res, vars, out|
+          called << self << res << vars.clone << out
+          vars[:foobar] = 24
+          true
+        end
+      end
+
+      it 'runs the test' do
+        expect(subject.test('self', 42, vars = { foo: 'bar' }, '')).to eq true
+        expect(called).to eq ['self', 42, { foo: 'bar' }, '']
+        expect(vars[:foobar]).to eq 24
+      end
+    end
+
+    context 'empty test' do
+      it 'returns nil' do
+        expect(subject.test(nil, nil, {}, '')).to eq nil
+      end
+    end
+  end
+
+  describe '#setup' do
+    context 'non-empty setup' do
+      called = []
+      let(:setup) do
+        proc do |vars|
+          called << self << vars.clone
+          vars[:foobar] = 24
+          true
+        end
+      end
+
+      it 'runs the setup' do
+        expect(subject.setup('self', vars = { foo: 'bar' })).to eq true
+        expect(called).to eq ['self', { foo: 'bar' }]
+        expect(vars[:foobar]).to eq 24
+      end
+    end
+
+    context 'empty setup' do
+      it 'returns nil' do
+        expect(subject.setup(nil, {})).to eq nil
+      end
+    end
+  end
+
+  describe '#setup_source' do
+    let(:setup) do
+      proc do |vars|
+        puts 42
+        vars[:foo] = vars[:bar]
+      end
+    end
+
+    it 'formats setup source' do
+      expect(subject.setup_source).to eq <<-EOS
+puts(42)
+foo = bar
+      EOS
+    end
+  end
+
+  describe '#display_setup' do
+    let(:display_setup) { true }
+    it 'returns display_setup' do
+      expect(subject.display_setup).to eq true
+    end
+  end
+end

data/spec/colors_spec.rb

@@ -0,0 +1,69 @@
+require_relative 'spec_helper'
+require_relative '../lib/tryruby/colors'
+require 'paint'
+
+describe Tryruby::Colors do
+  let(:string) { 'test' }
+  subject { described_class }
+
+  context 'module' do
+    it 'formats strings' do
+      expect(subject.black(string)).to eq Paint[string, :black]
+      expect(subject.red(string)).to eq Paint[string, :red]
+      expect(subject.green(string)).to eq Paint[string, :green]
+      expect(subject.yellow(string)).to eq Paint[string, :yellow]
+      expect(subject.blue(string)).to eq Paint[string, :blue]
+      expect(subject.magenta(string)).to eq Paint[string, :magenta]
+      expect(subject.cyan(string)).to eq Paint[string, :cyan]
+      expect(subject.white(string)).to eq Paint[string, :white]
+      expect(subject.bg_black(string)).to eq Paint[string, nil, :black]
+      expect(subject.bg_red(string)).to eq Paint[string, nil, :red]
+      expect(subject.bg_green(string)).to eq Paint[string, nil, :green]
+      expect(subject.bg_yellow(string)).to eq Paint[string, nil, :yellow]
+      expect(subject.bg_blue(string)).to eq Paint[string, nil, :blue]
+      expect(subject.bg_magenta(string)).to eq Paint[string, nil, :magenta]
+      expect(subject.bg_cyan(string)).to eq Paint[string, nil, :cyan]
+      expect(subject.bg_white(string)).to eq Paint[string, nil, :white]
+      expect(subject.reset(string)).to eq Paint[string, :reset]
+      expect(subject.bold(string)).to eq Paint[string, :bold]
+      expect(subject.underline(string)).to eq Paint[string, :underline]
+      expect(subject.inverse(string)).to eq Paint[string, :inverse]
+      expect(subject.hide(string)).to eq Paint[string, :hide]
+      expect(subject.title(string)).to eq Paint[string, :bold, :underline]
+      expect(subject.result(string)).to eq Paint[string, :blue]
+      expect(subject.error(string)).to eq Paint[string, :red, :bold]
+      expect(subject.success(string)).to eq Paint[string, :green, :bold]
+    end
+  end
+
+  context 'included' do
+    include described_class
+    it 'formats strings' do
+      expect(black(string)).to eq Paint[string, :black]
+      expect(red(string)).to eq Paint[string, :red]
+      expect(green(string)).to eq Paint[string, :green]
+      expect(yellow(string)).to eq Paint[string, :yellow]
+      expect(blue(string)).to eq Paint[string, :blue]
+      expect(magenta(string)).to eq Paint[string, :magenta]
+      expect(cyan(string)).to eq Paint[string, :cyan]
+      expect(white(string)).to eq Paint[string, :white]
+      expect(bg_black(string)).to eq Paint[string, nil, :black]
+      expect(bg_red(string)).to eq Paint[string, nil, :red]
+      expect(bg_green(string)).to eq Paint[string, nil, :green]
+      expect(bg_yellow(string)).to eq Paint[string, nil, :yellow]
+      expect(bg_blue(string)).to eq Paint[string, nil, :blue]
+      expect(bg_magenta(string)).to eq Paint[string, nil, :magenta]
+      expect(bg_cyan(string)).to eq Paint[string, nil, :cyan]
+      expect(bg_white(string)).to eq Paint[string, nil, :white]
+      expect(reset(string)).to eq Paint[string, :reset]
+      expect(bold(string)).to eq Paint[string, :bold]
+      expect(underline(string)).to eq Paint[string, :underline]
+      expect(inverse(string)).to eq Paint[string, :inverse]
+      expect(hide(string)).to eq Paint[string, :hide]
+      expect(title(string)).to eq Paint[string, :bold, :underline]
+      expect(result(string)).to eq Paint[string, :blue]
+      expect(error(string)).to eq Paint[string, :red, :bold]
+      expect(success(string)).to eq Paint[string, :green, :bold]
+    end
+  end
+end