trackler 2.0.0.8 → 2.0.0.9

data/tracks/crystal/exercises/forth/src/example.cr

@@ -0,0 +1,187 @@
+class Token
+  property type : Symbol
+  property string_value : String
+  property int_value : Int32
+
+  def initialize
+    @type = :EOF
+    @string_value = ""
+    @int_value = 0_i32
+  end
+
+  def eof?
+    type == :EOF
+  end
+end
+
+class Lexer
+  getter reader
+  getter token
+
+  def initialize(code : String)
+    @reader = Char::Reader.new(code)
+    @token = Token.new
+  end
+
+  def create_token
+    @token = Token.new unless @token.eof?
+  end
+
+  def next_token
+    create_token
+    skip_whitespace
+    case current_char
+    when '\0'
+      @token.type = :EOF
+    when ':'
+      next_char :":"
+    when ';'
+      next_char :";"
+    when .number?
+      @token.type = :INT
+      consume_number
+    else
+      @token.type = :WORD
+      consume_string
+    end
+
+    @token
+  end
+
+  private def consume_string
+    start_pos = current_pos
+
+    while valid_word_char?
+      next_char
+    end
+
+    @token.string_value = reader.string.byte_slice(start_pos, current_pos - start_pos)
+  end
+
+  private def consume_number
+    integer = 0
+
+    while '0' <= current_char <= '9'
+      integer *= 10
+      integer += current_char.to_i
+      next_char
+    end
+
+    @token.int_value = integer
+  end
+
+  private def next_char(token_type)
+    @token.type = token_type
+    next_char
+  end
+
+  private def current_pos
+    reader.pos
+  end
+
+  private def skip_whitespace
+    while current_char.whitespace? || current_char.control?
+      break unless reader.has_next?
+      next_char
+    end
+  end
+
+  private def valid_word_char?
+    !current_char.number? && !current_char.whitespace? && !(current_char == '\0')
+  end
+
+  private delegate current_char, to: @reader
+  private delegate next_char, to: @reader
+end
+
+class Forth
+  def self.evaluate(code_string)
+    new(code_string).evaluate
+  end
+
+  def initialize(code_string)
+    @lexer = Lexer.new(code_string)
+    @stack = Array(Int32).new
+    @defs = Hash(String, Array(Token)).new
+  end
+
+  def evaluate
+    loop do
+      evaluate_token(next_token)
+      return stack if token.eof?
+    end
+  end
+
+  private def evaluate_token(t)
+    case t.type
+    when :INT
+      parse_number(t)
+    when :WORD
+      parse_word(t)
+    when :":"
+      parse_def
+    when :EOF
+      return
+    else
+      raise "Unexpected Token!"
+    end
+  end
+
+  private def parse_number(t)
+    stack.push(t.int_value)
+  end
+
+  private def parse_word(t)
+    if defs[t.string_value.upcase]?
+      return defs[t.string_value.upcase].each { |t| evaluate_token(t) }
+    end
+
+    case t.string_value.upcase
+    when "+"
+      pop_twice { |a, b| stack.push(b + a) }
+    when "-"
+      pop_twice { |a, b| stack.push(b - a) }
+    when "*"
+      pop_twice { |a, b| stack.push(b * a) }
+    when "/"
+      pop_twice { |a, b| stack.push(b / a) }
+    when "DUP"
+      pop_once { |a| stack.push(a).push(a) }
+    when "DROP"
+      pop_once { }
+    when "SWAP"
+      pop_twice { |a, b| stack.push(a).push(b) }
+    when "OVER"
+      pop_twice { |a, b| stack.push(b).push(a).push(b) }
+    else
+      raise "Unknown word"
+    end
+  end
+
+  private def parse_def
+    next_token
+    raise "Invalid method name" if token.type == :INT
+    name = token.string_value.upcase
+    defs[name] = [] of Token
+    while next_token
+      raise "Invalid Definition" if token.type == :EOF
+      break if token.type == :";"
+      defs[name] << token
+    end
+  end
+
+  private def pop_once(&block)
+    raise "Invalid program" if stack.empty?
+    yield(stack.pop)
+  end
+
+  private def pop_twice(&block)
+    raise "Invalid program" if stack.size < 2
+    yield(stack.pop, stack.pop)
+  end
+
+  private property defs
+  private getter stack
+  private delegate token, to: @lexer
+  private delegate next_token, to: @lexer
+end

data/tracks/crystal/exercises/hello-world/spec/hello_world_spec.cr

@@ -2,15 +2,15 @@ require "spec"
 require "../src/*"
 
 describe "HelloWorld" do
-  it "tests no name" do
+  it "no name" do
     HelloWorld.hello.should eq("Hello, World!")
   end
 
-  pending "tests sample name" do
+  pending "sample name" do
     HelloWorld.hello("Alice").should eq("Hello, Alice!")
   end
 
-  pending "tests other sample name" do
+  pending "other sample name" do
     HelloWorld.hello("Bob").should eq("Hello, Bob!")
   end
 end

data/tracks/crystal/src/generator/exercises/acronym.cr

@@ -29,6 +29,6 @@ class AcronymTestCase < ExerciseTestCase
   end
 
   def test_name
-    description
+    "does #{description}"
   end
 end

data/tracks/crystal/src/generator/exercises/exercise_generator.cr

@@ -9,6 +9,7 @@ abstract class ExerciseGenerator
   end
 
   def generate
+    raise "There are no test cases for #{exercise_name}" if test_cases.empty?
     File.write(test_file, to_s)
   end
 
@@ -16,8 +17,8 @@ abstract class ExerciseGenerator
     exercise_name.split('-').map(&.capitalize).join
   end
 
-  abstract def exercise_name : String
-  abstract def test_cases : Array(ExerciseTestCase)
+  abstract def exercise_name
+  abstract def test_cases
 
   private def root
     File.expand_path(File.join("..", "..", "..", ".."), __FILE__)

data/tracks/crystal/src/generator/exercises/forth.cr

@@ -0,0 +1,56 @@
+require "./exercise_generator"
+require "./exercise_test_case"
+
+class ForthGenerator < ExerciseGenerator
+  def exercise_name
+    "forth"
+  end
+
+  def test_cases
+    test_cases = [] of JSON::Any
+    JSON.parse(data).each do |k, v|
+      v.each do |a, b|
+        test_cases.concat(b) if a.as_s == "cases"
+      end
+    end
+    test_cases.map do |test_case|
+      ForthTestCase.new(test_case)
+    end
+  end
+end
+
+class ForthTestCase < ExerciseTestCase
+  private getter input : JSON::Any | String
+  private getter description : JSON::Any
+  private getter expected : JSON::Any
+
+  def initialize(test_case)
+    @input = test_case["input"].as_a.join
+    @description = test_case["description"]
+    @expected = fix_empty_array(test_case["expected"])
+  end
+
+  def workload
+    if !(expected == nil)
+      "Forth.evaluate(#{input.inspect}).should eq(#{expected})"
+    else
+      <<-WL
+      expect_raises do
+            Forth.evaluate(#{input.inspect})
+          end
+      WL
+    end
+  end
+
+  def test_name
+    description
+  end
+
+  private def fix_empty_array(json)
+    if json.to_s.match(/\[\]/)
+      JSON.parse("[] of Int32".to_json)
+    else
+      json
+    end
+  end
+end

data/tracks/crystal/src/generator/exercises/templates/example.tt

@@ -1,9 +1,9 @@
 require "spec"
 require "../src/*"
 
-describe <%= "#{describe_name.inspect} do" %>
+describe <%= "#{describe_name.inspect} do" -%>
 <% test_cases.each_with_index do |test_case, index| %>
-  <%= test_case.pending?(index) %> "tests <%= test_case.test_name %>" do
+  <%= test_case.pending?(index) %> "<%= test_case.test_name %>" do
     <%= test_case.workload %>
   end
 <% end -%>

data/tracks/crystal/src/generator/spec/exercise_generator_spec.cr

@@ -19,9 +19,11 @@ describe "ExerciseGenerator" do
     end
   end
 
-  describe "#to_s" do
-    it "will output the generator test file using the example.tt" do
-      DummyGenerator.new.to_s.should eq("require \"spec\"\nrequire \"../src/*\"\n\ndescribe \"Dummy\" do\nend\n")
+  describe "#generate" do
+    it "raises an error if no test cases exist" do
+      expect_raises do
+        DummyGenerator.generate
+      end
     end
   end
 end

data/tracks/csharp/exercises/wordy/WordyTest.cs

@@ -109,8 +109,8 @@ public class WordProblemTest
 
     [Ignore("Remove to run test")]
     [Test]
-    public void Irrelevent_problems_are_not_valid()
+    public void Irrelevant_problems_are_not_valid()
     {
         Assert.That(() => WordProblem.Solve("Who is the president of the United States?"), Throws.ArgumentException);
     }
-}
+}