compare-code/app/controllers/api/compile_controller.rb

class Api::CompileController < ApplicationController 
  include Judge::Helper
  protect_from_forgery :except => :realtime_test  #realtime_test
  respond_to :json 

  #status 0 success  -1 language is not supported
  def realtime_test
    #err =  check_params(params)

    body = {}
    logger.debug "#{Time.now} enter code compare"

    #mkdir by
    code_dirname = params[:homeid].to_s
    logger.debug "homeworkid=#{code_dirname}"
    lan = params[:language].to_i

    logger.debug "This language is #{lan}"

    filetype = ""

    #check params
    if params[:factor] == nil || params[:factor].count <= 1
      body[:status] = -2

      render :json => body
      return
    end

    case lan
      #c/c++
      when 1
        filetype = ".c"
      when 2
        filetype = ".cpp"
      #java
      when 4
        filetype = ".java"
      else
        logger.debug "This language is not supported!=#{lan}"
        body[:status] = -1

        render :json => body
        return
    end

    `mkdir #{code_dirname}`

    worktime = {}
    results = {}

    logger.debug "code compare count =#{params[:factor].count} "

    params[:factor].each do |factor|
      src = factor["des"]
      work_id = factor["work_id"].to_i

      results[work_id] = {simiworkid:0,simivalue:0,simitime:0}

      worktime[work_id] = factor["created_at"]

      #create file
      filename = work_id.to_s + filetype

      aFile = File.new(code_dirname+'/'+filename, "w+")
      if aFile
        aFile.syswrite(src)
      else
        logger.debug "Unable to open file!"
      end
    end

    # add -vl can show use time
    `java -jar app/controllers/api/jplag-2.11.8-SNAPSHOT-jar-with-dependencies.jar -vl -l c/c++ -t 22 #{code_dirname+'/'}`.each_line do |line|
        #puts line.split(" ")[1] if line.match("Comparing")
        logger.debug line
        if line.match("Comparing")
          tmp = line.split(" ")

          #first file
          name_1 = tmp[1].split("-")[0].split(filetype)[0].to_i
          #second file
          name_2 = tmp[1].split("-")[1].split(filetype+':')[0].to_i
          #Similarity
          simivalue = tmp[2].to_i

          #befor time is your Similarity
          if worktime[name_1] > worktime[name_2]
            if simivalue > 0 && simivalue > results[name_1][:simivalue]
              results[name_1] = {simiworkid:name_2,simivalue:simivalue,simitime:worktime[name_2]}
            elsif simivalue > 0 && simivalue == results[name_1][:simivalue] &&  worktime[name_2] < results[name_1][:simitime]
              results[name_1] = {simiworkid:name_2,simivalue:simivalue,simitime:worktime[name_2]}
            end
          else
            if simivalue > 0 && simivalue > results[name_2][:simivalue]
              results[name_2] = {simiworkid:name_1,simivalue:simivalue,simitime:worktime[name_1]}
            elsif simivalue > 0 && simivalue == results[name_2][:simivalue] &&  worktime[name_1] < results[name_2][:simitime]
              results[name_2] = {simiworkid:name_1,simivalue:simivalue,simitime:worktime[name_1]}
            end
          end
        end
    end

    `rm -rf #{code_dirname} `
    `rm -rf result `

    body[:results] = results
    body[:status] = 0

    logger.debug "#{Time.now} leave code compare"
    render :json => body
  end
=begin
  def realtime_test
    body = {results: []}
    err =  check_params(params)
    if err
      body[:error_msg] = err
      body[:status] = -1
    else
      src = params[:src]
      compile_result = compile(src, params[:language].to_i)
      unless compile_result
        body[:error_msg] = @compiler.errmsg
        body[:status] = -2
      else
        result = 0
        params[:factor].each do |factor|
          output = factor["output"]
          input = factor["input"]
          test_id =factor["id"]
          opt = {program_param: input, src: params[:src], time_limit: '200'}
          rs,option,time_used,memory_used = run(params[:language].to_i, opt)
          logger.debug "rs #{rs}, option #{option} time_used #{time_used} memory_used #{memory_used}"
          execute_output = @executor.result
          logger.debug "result #{execute_output} output #{output} input #{input}"
          if rs==0
            status = -2
          else
            status = rs
          end

          if rs==0 && cmp(execute_output, output)
            status = 0 
          else
            result = -1
          end

          body[:results] << {
            input: replace_r(input), 
            output: replace_r(output), 
            memory_used: memory_used,
            time_used: time_used,
            result: replace_r(execute_output[0,100]),
            status: status}
        end
        body[:status] = result 
      end 
    end
    write_log(params, body)
    render :json => body
  end
=end

  private

  def check_params(params)
    return "不支持的语言类型" if params[:language].to_i <= 0
    return "没有没测试集" unless params[:factor]
    nil
  end

  def write_log(params, body)
    log = Log.new
    log.src = params[:src]
    log.result = body.to_json
    log.language = params[:language]
    log.test_id = params[:test_id]
    log.status = body[:status]
    unless log.save
      logger.error log.errors.full_messages
    end
  end
end