jeka 0.1.1 → 0.2.0

data/lib/jeka/compilers/ruby.rb

@@ -0,0 +1,21 @@
+module Jeka
+  module Compiler
+        
+    class Ruby < Compiler
+      def initialize(file, options = {})
+        @files = [file]
+        @options = options
+      end
+      
+    private
+      
+      def _run_command
+        "ruby " << @files[0]
+      end
+      
+      def _build_command
+      end
+      
+    end
+  end
+end

data/lib/jeka/console.rb

@@ -0,0 +1,55 @@
+module Jeka
+  module Console
+    
+    def self.add_algorithms(dir)
+      Jeka::Algorithm.reset
+      Dir.glob(dir).each do |d|
+        load d
+      end
+    end
+    
+    def self.run(n)
+      error = false
+      Jeka::Algorithm.run_all(n) do |p, t, o|
+        self._show(p, t, o, false)
+      end
+    end
+    
+    def self.build
+      error = false
+      Jeka::Algorithm.build_all do |p, t, o|
+        self._show(p, t, o, true)
+      end
+    end
+    
+    def self._show(p, t, o, s)
+      case t
+        when :step
+          p = p.to_s
+          while p.length < 3
+            p = " " + p
+          end
+          puts "[#{p}%] #{o}"
+        when :output
+          if s
+            o = o.join
+            if o.length > 0
+              puts o
+            end
+          end
+        when :error
+          o = o.join
+          if o.length > 0
+            puts o
+          end
+          error = true
+        when :done
+          if error
+            puts "[100%] Some error occurs..."
+          else
+            puts "[100%] Done!"
+          end
+      end
+    end
+  end
+end

data/lib/jeka/implementation.rb

@@ -1,111 +1,36 @@
 require 'yaml'
-require 'benchmark'
 
 module Jeka
-
-  class Implementation < JekaHelper
-    
-    jeka_reader :language
-    jeka_reader :source
-    jeka_reader :comment
-    
-    attr_accessor :algorithm
-    
-    def initialize(folder)
-      super(File.join(folder, "_implementation.yaml"))
-    end
-    
-    def source_code
-      f = File.open(File.join(@folder, source), "r")
-      return f.readlines.join()
+  class Implementation
+    attr_reader :database
+    attr_accessor :name
+    attr_accessor :compiler
+    
+    def initialize(name)
+      @name = name
+      @information = {}
     end
     
-    def build
-      if @jeka["build"]
-        command = @jeka["build"]["command"].gsub("$", @folder)
-        system(command)
-      end
-    end
-    
-    def run(input, verbose)
-      command = "#{@jeka["run"]["command"].gsub("$", @folder)} #{"< #{input}" if input}"
-      if verbose
-        system(command)
+    def information=(info)
+      if info.kind_of? Hash
+        @information = info
       else
-        out = ""
-        IO.popen(command) do |io|
-          out = io.readlines
-        end
-        return out.join("")
+        @yaml = YAML::load(File.open(info))
+        @yaml.each_key {|key| @information[key.to_sym] = @yaml[key]}
       end
     end
     
-    def benchmark(input, n)
-      b = Benchmark.measure {run(input, false)}.to_a
-      bench = Hash.new
-      bench[:user_cpu_time] = b[1]
-      bench[:system_cpu_time] = b[2]
-      bench[:childrens_use_cpu_time] = b[3]
-      bench[:childrens_system_cpu_time] = b[4]
-      bench[:elapsed_real_time] = b[5]
-      (n-1).times do
-        b = Benchmark.measure {run(input, false)}.to_a
-        bench[:user_cpu_time] += b[1]
-        bench[:system_cpu_time] += b[2]
-        bench[:childrens_use_cpu_time] += b[3]
-        bench[:childrens_system_cpu_time] += b[4]
-        bench[:elapsed_real_time] += b[5]
-      end
-      bench[:user_cpu_time] /= n
-      bench[:system_cpu_time] /= n
-      bench[:childrens_use_cpu_time] /= n
-      bench[:childrens_system_cpu_time] /= n
-      bench[:elapsed_real_time] /= n
-      
-      filename = File.join(@folder, File.basename(input).gsub(/\..*/, ".benchmark"))
-      f = File.open(filename, "w")
-      f.write(bench)
-      f.close
-      
-      return bench
+    def information
+      @information
     end
     
-    def benchmark_results
-      benchmarks = []
-      n = 0
-      dir = Dir.new(@folder)
-      dir.each do |d|
-        if d.index(/^test_.*\.benchmark$/)
-          f = File.open(File.join(@folder, d), "r")
-          benchmarks << eval(f.readlines.join(""))
-          n += 1
-        end
-      end
-      
-      bench = Hash.new
-      bench[:language] = language
-      bench[:comment] = comment
-      bench[:user_cpu_time] = 0
-      bench[:system_cpu_time] = 0
-      bench[:childrens_use_cpu_time] = 0
-      bench[:childrens_system_cpu_time] = 0
-      bench[:elapsed_real_time] = 0
-      benchmarks.each do |b|
-        bench[:user_cpu_time] += b[:user_cpu_time]
-        bench[:system_cpu_time] += b[:system_cpu_time]
-        bench[:childrens_use_cpu_time] += b[:childrens_use_cpu_time]
-        bench[:childrens_system_cpu_time] += b[:childrens_system_cpu_time]
-        bench[:elapsed_real_time] += b[:elapsed_real_time]
-      end
-      bench[:user_cpu_time] /= n
-      bench[:system_cpu_time] /= n
-      bench[:childrens_use_cpu_time] /= n
-      bench[:childrens_system_cpu_time] /= n
-      bench[:elapsed_real_time] /= n
-      
-      return bench
+    def jekafy
+      @database = Jeka::Analysis::Implementation.create(
+        name: @name,
+        compiler: @compiler.jekafy,
+        implementation_information: Jeka::Analysis::ImplementationInformation.convert(@information)
+      )
     end
     
   end
-  
-end
+end

data/lib/jeka/test.rb

@@ -1,38 +1,22 @@
-require 'yaml'
-
 module Jeka
-  
-  class Test < JekaHelper
+  class Test
+    attr_reader :database
+    attr_accessor :input
+    attr_accessor :output
+    attr_accessor :name
     
-    jeka_reader :name
-    jeka_reader :input
-    jeka_reader :output
-    
-    def initialize(file)
-      super(file)
-      @file = file
-      @generated = false
+    def initialize(name)
+      @name = name
     end
     
-    def generate
-      filename = "#{@file}.input"
-      unless @generated
-        ftest = File.open(filename, "w")
-        ftest.write(input)
-        ftest.close
-      end
-      return filename
+    def jekafy
+      @database = Jeka::Analysis::Test.create(
+        name: @name,
+        output: @output,
+        input: @input
+      )
+      @database
     end
     
   end
-  
-  def Test.test_set(folder)
-    tests = []
-    test_dir = Dir.new(folder)
-    test_dir.each do |d|
-      tests << Test.new(File.join(folder, d)) if d.index(/test_.*\.yaml$/) == 0
-    end
-    return tests
-  end
-  
-end
+end

data/lib/jeka/test_case.rb

@@ -0,0 +1,41 @@
+module Jeka
+  
+  class TestCase
+    attr_reader :database
+    
+    def tests
+      methods.select {|m| m =~ /^test_/}.map {|m| send(m)}
+    end
+        
+    def self.test(name)
+      t = Test.new(name)
+      yield t
+      define_method("test_#{name}".to_sym) do
+        return t
+      end
+    end
+    
+    def self.reset
+      @@test_suites = {}
+    end
+    
+    def self.inherited(klass)
+      @@test_suites ||= {}
+      @@test_suites[klass] = true
+    end
+    
+    def self.test_suites
+      @@test_suites ||= {}
+      @@test_suites.keys.sort_by { |ts| ts.name }.collect{|ts| ts.new}
+    end
+    
+    def jekafy
+      @database = Jeka::Analysis::TestCase.create(
+        name: self.class.to_s,
+        tests: tests.collect {|t| t.jekafy}
+      )
+    end
+    
+  end
+  
+end

data/test/bubble_sort/_tests/_test_01.rb

@@ -0,0 +1,13 @@
+class TestAlgorithmBubbleSort < Jeka::TestCase
+  
+  test 'Decreasing Sequence' do |t|
+    t.input = '9 8 7 6 5 4 3 2 1'
+    t.output = '1 2 3 4 5 6 7 8 9'
+  end
+  
+  test 'Random Sequence' do |t|
+    t.input = '3 1 5 7 6 8 9 4 2'
+    t.output = '1 2 3 4 5 6 7 8 9'
+  end
+  
+end

data/test/bubble_sort/algorithm_bubble_sort.rb

@@ -0,0 +1,15 @@
+class AlgorithmBubbleSort < Jeka::Algorithm
+  
+  add_tests File.join(File.dirname(__FILE__), '_tests', '**', '_test_*.rb')
+  
+  implementation 'c++' do |imp|
+    imp.information = {language: 'c++', comment: 'Simple implementation in C++'}
+    imp.compiler = Jeka::Compiler::Gpp.new([File.join(File.dirname(__FILE__), 'cpp', 'bubble_sort.cpp')], {:o => 'bubble_sort_cpp'})
+  end
+  
+  implementation 'ruby' do |imp|
+    imp.information = {language: 'ruby', comment: 'Simple implementation in Ruby'}
+    imp.compiler = Jeka::Compiler::Ruby.new(File.join(File.dirname(__FILE__), 'ruby', 'bubble_sort.rb'))
+  end
+  
+end

data/test/bubble_sort/cpp/_implementation.yaml

@@ -0,0 +1,3 @@
+language: c++
+source: bubble_sort.cpp
+comment: Simple implementation in C++

data/test/{example/01_bubble_sort/cpp/bubble.cpp → bubble_sort/cpp/bubble_sort.cpp}

@@ -5,8 +5,9 @@
 using namespace std;
 
 vector<int> bubble_sort(vector<int> numbers) {
-  for(int i = 0; i < 9; i++) {
-    for(int j = i; j < 9; j++) {
+  int n = numbers.size();
+  for(int i = 0; i < n; i++) {
+    for(int j = i; j < n; j++) {
       if (numbers[i] > numbers[j]) {
         int temp = numbers[i];
         numbers[i] = numbers[j];
@@ -19,21 +20,19 @@ vector<int> bubble_sort(vector<int> numbers) {
 
 int main() {
   vector<int> numbers;
-  int max, v;
+  int v;
   
   // Reading the input
-  cin >> max;
-  for (int i = 0; i < max; i++) {
-    cin >> v;
+  while (cin >> v)
     numbers.push_back(v);
-  }
   
   numbers = bubble_sort(numbers);
   
   // Printing the output
-  for (int i=0; i< 8; i++)
-    cout << numbers[i] << " ";
-  cout << numbers[8] << endl;
+  vector<int>::iterator it;
+  for (it = numbers.begin(); it < numbers.end()-1; it++)
+    cout << (*it) << " ";
+  cout << (*it);
     
   return 0;
 }

data/test/bubble_sort/ruby/_implementation.yaml

@@ -0,0 +1,3 @@
+language: ruby
+source: bubble_sort.rb
+comment: Simple implementation in Ruby

data/test/{example/01_bubble_sort/ruby/bubble.rb → bubble_sort/ruby/bubble_sort.rb}

@@ -11,11 +11,8 @@ def bubble(numbers)
   numbers
 end
 
-# Reading the input
-input = gets
-input = input.split(' ')[1..-1].map {|c| c.to_i }
+input = STDIN.gets.split(" ").collect {|i| i.to_i}
 
 bubble(input)
 
-# Printing the output
-puts input.inject {|output, n| "#{output} #{n}"}
+print input.inject {|output, n| "#{output} #{n}"}

data/test/double/_tests/_test_01.rb

@@ -0,0 +1,13 @@
+class TestAlgorithmDouble < Jeka::TestCase
+  
+  test 'One' do |t|
+    t.input = '1'
+    t.output = '2'
+  end
+  
+  test 'Two' do |t|
+    t.input = '2'
+    t.output = '4'
+  end
+  
+end

data/test/double/algorithm_double.rb

@@ -0,0 +1,15 @@
+class AlgorithmDouble < Jeka::Algorithm
+  
+  add_tests File.join(File.dirname(__FILE__), '_tests', '**', '_test_*.rb')
+  
+  implementation 'c++' do |imp|
+    imp.information = {language: 'c++', comment: 'Simple implementation in C++'}
+    imp.compiler = Jeka::Compiler::Gpp.new([File.join(File.dirname(__FILE__), 'cpp', 'double.cpp')], {:o => 'double_cpp'})
+  end
+  
+  implementation 'ruby' do |imp|
+    imp.information = {language: 'ruby', comment: 'Simple implementation in Ruby'}
+    imp.compiler = Jeka::Compiler::Ruby.new(File.join(File.dirname(__FILE__), 'ruby', 'double.rb'))
+  end
+  
+end

data/test/double/cpp/double.cpp

@@ -0,0 +1,10 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+  int n;
+  cin >> n;
+  cout << 2*n;
+  return 0;
+}