jeka 0.1.1 → 0.2.0

data/lib/jeka.rb

@@ -1,7 +1,9 @@
 ROOT_PATH = File.expand_path(File.dirname(__FILE__))
 
-require File.join(ROOT_PATH, '/jeka/jeka_helper')
-require File.join(ROOT_PATH, '/jeka/algorithm')
-require File.join(ROOT_PATH, '/jeka/test')
+require File.join(ROOT_PATH, '/jeka/compilers')
 require File.join(ROOT_PATH, '/jeka/implementation')
-require File.join(ROOT_PATH, '/jeka/make')
+require File.join(ROOT_PATH, '/jeka/test')
+require File.join(ROOT_PATH, '/jeka/algorithm')
+require File.join(ROOT_PATH, '/jeka/test_case')
+require File.join(ROOT_PATH, '/jeka/console')
+require File.join(ROOT_PATH, '/jeka/analysis')

data/lib/jeka/algorithm.rb

@@ -1,38 +1,120 @@
 require 'yaml'
 
 module Jeka
+  class Algorithm
     
-  class Algorithm < JekaHelper
+    attr_reader :database
     
-    jeka_reader :name
-    jeka_reader :type
-    jeka_reader :complexity
-    jeka_reader :description
-    jeka_reader :references
+    def implementations
+      methods.select {|m| m =~ /^implementation_/}.map {|m| send(m)}
+    end
     
-    def initialize(folder)
-      super(File.join(folder, "_algorithm.yaml"))
-      @implementations = nil
-      @tests = nil
+    def self.implementation(name)
+      imp = Implementation.new(name)
+      yield imp
+      define_method("implementation_#{name}".to_sym) do
+        return imp
+      end
     end
     
-    def tests
-      return @tests = Test::test_set(File.join(@folder, "_tests")) unless @tests
-      return @tests
+    def self.add_tests(test_dir)
+      Jeka::TestCase.reset
+      Dir.glob(test_dir).each do |d|
+        eval(File.open(d).readlines.join)
+      end
+      test_suites = Jeka::TestCase.test_suites
+      
+      define_method(:test_suites) do
+        return test_suites
+      end
+      
     end
     
-    def implementations
-      unless @implementations
-        @implementations = []
-        @jeka["implementations"].each do |i|
-          imp = Implementation.new(File.join(@folder, i))
-          imp.algorithm = self
-          @implementations << imp
+    def jekafy
+      @database = Jeka::Analysis::Algorithm.create(
+        name: self.class.to_s,
+        implementations: implementations.collect {|imp| imp.jekafy},
+        test_cases: test_suites.collect {|tc| tc.jekafy}
+      )
+    end
+    
+    def build(&block)
+      implementations.each do |imp|
+        b = imp.compiler.build
+        block.call(nil, :output, b[0]) if block_given?
+        block.call(nil, :error, b[1]) if block_given? and (not b[2] == 0)
+      end
+    end
+    
+    def run(n=1, &block)
+      implementations.each do |imp|
+        test_suites.each do |ts|
+          ts.tests.each do |test|
+            n.times do
+              test_result = imp.compiler.run("#{test.input}\n")
+              block.call(nil, :output, test_result[0]) if block_given?
+              block.call(nil, :error, test_result[1]) if block_given? and (not test_result[2] == 0)
+              Jeka::Analysis::Result.create(
+                stdout: test_result[0].join,
+                stderr: test_result[1].join,
+                exit_status: test_result[2],
+                user_cpu_time: test_result[3][:user_cpu_time],
+                system_cpu_time: test_result[3][:system_cpu_time],
+                childrens_use_cpu_time: test_result[3][:childrens_use_cpu_time],
+                childrens_system_cpu_time: test_result[3][:childrens_system_cpu_time],
+                elapsed_real_time: test_result[3][:elapsed_real_time],
+                implementation: imp.database,
+                test: test.database
+              )
+            end
+          end
         end
       end
-      return @implementations
     end
-        
+    
+    def self.reset
+      @@algorithms = {}
+    end
+    
+    def self.inherited(klass)
+      @@algorithms ||= {}
+      @@algorithms[klass] = true
+    end
+    
+    def self.algorithms
+      @@algorithms ||= {}
+      @@algorithms.keys.sort_by { |ts| ts.name }.collect{|ts| ts.new}
+    end
+    
+    def self.build_all(&block)
+      block.call(0, :step, "Building algorithms...") if block_given?
+      n = self.algorithms.length + 1
+      i = 0
+      self.algorithms.each do |alg|
+        i += 1
+        block.call(100*i/n, :step, "Building #{alg.class.to_s}") if block_given?
+        block_given? ? alg.build(&block) : alg.build
+      end
+      block.call(100, :done, "Done") if block_given?
+    end
+    
+    def self.run_all(n=1, &block)
+      Jeka::Analysis::Database.create(File.join(Dir.getwd, "analysis.jeka"))
+      block.call(0, :step, "Running algorithms...") if block_given?
+      s = self.algorithms.length + 1
+      i = 0
+      self.algorithms.each do |alg|
+        alg.jekafy
+        i += 1
+        block.call(100*i/s, :step, "Running #{alg.class.to_s}...") if block_given?
+        if block_given?
+          alg.run(n, &block)
+        else
+          alg.run(n)
+        end
+      end
+      block.call(100, :done, "Done") if block_given?
+    end
+    
   end
-  
-end
+end

data/lib/jeka/analysis.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'data_mapper'
+require  'dm-migrations'
+
+
+require File.join(ROOT_PATH, 'jeka/analysis/database')
+require File.join(ROOT_PATH, 'jeka/analysis/algorithm')
+require File.join(ROOT_PATH, 'jeka/analysis/implementation')
+require File.join(ROOT_PATH, 'jeka/analysis/implementation_information')
+require File.join(ROOT_PATH, 'jeka/analysis/compiler')
+require File.join(ROOT_PATH, 'jeka/analysis/compiler_option')
+require File.join(ROOT_PATH, 'jeka/analysis/source_file')
+require File.join(ROOT_PATH, 'jeka/analysis/test')
+require File.join(ROOT_PATH, 'jeka/analysis/test_case')
+require File.join(ROOT_PATH, 'jeka/analysis/result')

data/lib/jeka/analysis/algorithm.rb

@@ -0,0 +1,13 @@
+module Jeka
+  module Analysis
+    class Algorithm
+      include DataMapper::Resource
+      
+      property  :id ,     Serial
+      property  :name,    String
+      
+      has n, :implementations
+      has n, :test_cases
+    end
+  end
+end

data/lib/jeka/analysis/compiler.rb

@@ -0,0 +1,14 @@
+module Jeka
+  module Analysis
+    class Compiler
+      include DataMapper::Resource
+      
+      property  :id,        Serial
+      property  :name,      String
+      
+      belongs_to  :implementation
+      has n,      :compiler_options
+      has n,      :source_files
+    end
+  end
+end

data/lib/jeka/analysis/compiler_option.rb

@@ -0,0 +1,24 @@
+module Jeka
+  module Analysis
+    class CompilerOption
+      include DataMapper::Resource
+      
+      property  :id ,     Serial
+      property  :name,    String
+      property  :value,   String
+      
+      belongs_to  :compiler
+      
+      def self.convert(hash)
+        opt = []
+        hash.each do |key, value|
+          opt << CompilerOption.new(
+            name: key,
+            value: value
+          )
+        end
+        opt
+      end
+    end
+  end
+end

data/lib/jeka/analysis/database.rb

@@ -0,0 +1,11 @@
+module Jeka
+  module Analysis
+    class Database
+      def self.create(path)
+        DataMapper.finalize
+        DataMapper.setup(:default, "sqlite://#{path}")
+        DataMapper.auto_migrate!
+      end
+    end
+  end
+end

data/lib/jeka/analysis/implementation.rb

@@ -0,0 +1,15 @@
+module Jeka
+  module Analysis
+    class Implementation
+      include DataMapper::Resource
+      
+      property    :id,          Serial
+      property    :name,        String
+      
+      belongs_to  :algorithm
+      has 1,      :compiler
+      has n,      :implementation_information
+      has n,      :results
+    end
+  end
+end

data/lib/jeka/analysis/implementation_information.rb

@@ -0,0 +1,24 @@
+module Jeka
+  module Analysis
+    class ImplementationInformation
+      include DataMapper::Resource
+      
+      property    :id,      Serial
+      property    :name,    String
+      property    :value,   String
+      
+      belongs_to  :implementation
+      
+      def self.convert(hash)
+        info = []
+        hash.each do |key, value|
+          info << ImplementationInformation.new(
+            name: key,
+            value: value
+          )
+        end
+        info
+      end
+    end
+  end
+end

data/lib/jeka/analysis/result.rb

@@ -0,0 +1,20 @@
+module Jeka
+  module Analysis
+    class Result
+      include DataMapper::Resource
+      
+      property    :id ,                         Serial
+      property    :stdout,                      String
+      property    :stderr,                      String
+      property    :exit_status,                 String
+      property    :user_cpu_time,               Float
+      property    :system_cpu_time,             Float
+      property    :childrens_use_cpu_time,      Float
+      property    :childrens_system_cpu_time,   Float
+      property    :elapsed_real_time,           Float
+      
+      belongs_to  :implementation
+      belongs_to  :test
+    end
+  end
+end

data/lib/jeka/analysis/source_file.rb

@@ -0,0 +1,24 @@
+module Jeka
+  module Analysis
+    class SourceFile
+      include DataMapper::Resource
+      
+      property    :id,        Serial
+      property    :name,      String
+      property    :source,    Text
+      
+      belongs_to  :compiler
+      
+      def self.convert(array)
+        files = []
+        array.each do |file|
+          files << SourceFile.new(
+            name: File.basename(file),
+            source: File.open(file).readlines.join
+          )
+        end
+        files
+      end
+    end
+  end
+end

data/lib/jeka/analysis/test.rb

@@ -0,0 +1,15 @@
+module Jeka
+  module Analysis
+    class Test
+      include DataMapper::Resource
+      
+      property    :id,        Serial
+      property    :name,      String
+      property    :output,    String
+      property    :input,     String
+      
+      belongs_to  :test_case
+      has n,      :results
+    end
+  end
+end

data/lib/jeka/analysis/test_case.rb

@@ -0,0 +1,13 @@
+module Jeka
+  module Analysis
+    class TestCase
+      include DataMapper::Resource
+      
+      property  :id,        Serial
+      property  :name,      String
+      
+      belongs_to :algorithm
+      has n, :tests
+    end
+  end
+end

data/lib/jeka/compilers.rb

@@ -0,0 +1,3 @@
+require File.join(ROOT_PATH, 'jeka/compilers/compiler')
+require File.join(ROOT_PATH, 'jeka/compilers/gpp')
+require File.join(ROOT_PATH, 'jeka/compilers/ruby')

data/lib/jeka/compilers/compiler.rb

@@ -0,0 +1,48 @@
+require 'benchmark'
+require 'open3'
+
+module Jeka
+  module Compiler
+    class Compiler
+      attr_reader :database
+      
+      def command(cmd)
+        stdout_ = nil
+        stderr_ = nil
+        exit_status_ = nil
+        
+        b = Benchmark.measure do
+          Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+            stdout_ = stdout.readlines
+            stderr_ = stderr.readlines
+            exit_status_ = wait_thr.value
+          end
+        end.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]
+        return stdout_, stderr_, exit_status_.exitstatus, bench
+      end
+      
+      def build(&block)
+        return _build_command ? command(_build_command) : [[], [], 0, 0]
+      end
+      
+      def run(input = '')
+        return command("echo '#{input}' | #{_run_command}")
+      end
+      
+      def jekafy
+        @database = Jeka::Analysis::Compiler.create(
+          name: self.class.to_s,
+          compiler_options: Jeka::Analysis::CompilerOption.convert(@options),
+          source_files: Jeka::Analysis::SourceFile.convert(@files)
+        )
+      end
+    end
+  end
+end

data/lib/jeka/compilers/gpp.rb

@@ -0,0 +1,29 @@
+module Jeka
+  module Compiler
+        
+    class Gpp < Compiler
+      def initialize(files, options = {})
+        @files = files
+        @options = options
+      end
+      
+    private
+      
+      def _run_command
+        cmd = './' << @options[:o]
+      end
+      
+      def _build_command
+        cmd = 'g++ '
+        @files.each do |f|
+          cmd << f << ' '
+        end
+        @options.each do |opt, value|
+          cmd << '-' << opt.to_s << ' ' << value
+        end
+        return cmd
+      end
+      
+    end
+  end
+end