cafe-grader-web Commit - r216:fa11dca6b078

cafe-grader-web

Commit `r216:fa11dca6b078` public

parent | child

Description:

added submission_status to store grading results, first page shows only unpassed problems.

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r216:fa11dca6b078 - Sat, 23 Jan 2010 16:17:06 - 10 files changed: 149 inserted, 74 deleted

app/models/submission_status.rb created 644 ¶ +6

@@ -0,0 +1,6
	1	+ class SubmissionStatus < ActiveRecord::Base
	2	+
	3	+ belongs_to :user
	4	+ belongs_to :problem
	5	+
	6	+ end

app/views/main/_problem.html.haml created 644 ¶ +18

@@ -0,0 +1,18
	1	+ .problem-panel{:id => "problem-panel-#{problem.id}", :style => "display:none"}
	2	+ .problem-form{:id => "problem-form-#{problem.id}"}
	3	+ - form_tag({ :action => 'download_input', :id => problem.id }, :method => :post) do
	4	+ %b Input:
	5	+ %input{:type => "submit", :value => "Download input"}
	6	+ - form_tag({ :action => 'submit_solution', :id => problem.id }, :method => :post, :multipart => true) do
	7	+ %b Submit output:
	8	+ %input{:type => "file", :name => "file"}
	9	+ %input{:type => "submit", :value => "Submit solution"}
	10	+
	11	+ .problem-description
	12	+ - if problem.description!=nil
	13	+ - if problem.description.markdowned
	14	+ = markdown(problem.description.body)
	15	+ - else
	16	+ = problem.description.body
	17	+ - else
	18	+ (not available)

db/migrate/20100123154326_create_submission_statuses.rb created 644 ¶ +16

@@ -0,0 +1,16
	1	+ class CreateSubmissionStatuses < ActiveRecord::Migration
	2	+ def self.up
	3	+ create_table :submission_statuses do \|t\|
	4	+ t.integer :user_id
	5	+ t.integer :problem_id
	6	+ t.boolean :passed
	7	+ t.integer :submission_count
	8	+
	9	+ t.timestamps
	10	+ end
	11	+ end
	12	+
	13	+ def self.down
	14	+ drop_table :submission_statuses
	15	+ end
	16	+ end

test/fixtures/submission_statuses.yml created 644 ¶ +13

@@ -0,0 +1,13
	1	+ # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
	2	+
	3	+ one:
	4	+ user_id: 1
	5	+ problem_id: 1
	6	+ passed: false
	7	+ submission_count: 1
	8	+
	9	+ two:
	10	+ user_id: 1
	11	+ problem_id: 1
	12	+ passed: false
	13	+ submission_count: 1

test/unit/submission_status_test.rb created 644 ¶ +8

@@ -0,0 +1,8
	1	+ require 'test_helper'
	2	+
	3	+ class SubmissionStatusTest < ActiveSupport::TestCase
	4	+ # Replace this with your real tests.
	5	+ test "the truth" do
	6	+ assert true
	7	+ end
	8	+ end

app/controllers/main_controller.rb ¶ +68 -46

               class MainController < ApplicationController
                 SYSTEM_MODE_CONF_KEY = 'system.mode'
                 before_filter :authenticate, :except => [:index, :login]
                 before_filter :check_viewability, :except => [:index, :login]
                 # COMMENTED OUT: filter in each action instead
                 # before_filter :verify_time_limit, :only => [:submit]
-            -   verify :method => :post, :only => [:submit, :new_input, :download_input, :submit_solution],
+            +   verify :method => :post, :only => [:submit, :download_input, :submit_solution],
                        :redirect_to => { :action => :index }
                 # COMMENT OUT: only need when having high load
                 # caches_action :index, :login
                 # NOTE: This method is not actually needed, 'config/routes.rb' has
                 # assigned action login as a default action.
                 def index
                   redirect_to :action => 'login'
                 end
                 def login
                   saved_notice = flash[:notice]
                   reset_session
                   flash[:notice] = saved_notice
                   # EXPERIMENT:
                   # Hide login if in single user mode and the url does not
                   # explicitly specify /login
                   #
                   # logger.info "PATH: #{request.path}"
                   # if Configuration['system.single_user_mode'] and
                   #     request.path!='/main/login'
                   #   @hidelogin = true
                   # end
                   @announcements = Announcement.find_for_frontpage
                   render :action => 'login', :layout => 'empty'
                 end
                 def list
                   prepare_list_information
                 end
                 def help
                   @user = User.find(session[:user_id])
                 end
                 def submit
                   user = User.find(session[:user_id])
                   @submission = Submission.new(params[:submission])
                   @submission.user = user
                   @submission.language_id = 0
                   if (params['file']) and (params['file']!='')
                     @submission.source = params['file'].read
                     @submission.source_filename = params['file'].original_filename
                   end
                   end
                   prepare_grading_result(@submission)
                 end
                 def load_output
                   if !Configuration.show_grading_result or params[:num]==nil
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   case_num = params[:num].to_i
                   out_filename = output_filename(@user.login,
                                                  @submission.problem.name,
                                                  @submission.id,
                                                  case_num)
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   response.headers['Content-Type'] = "application/force-download"
                   response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
                   response.headers["X-Sendfile"] = out_filename
                   response.headers['Content-length'] = File.size(out_filename)
                   render :nothing => true
                 end
                 def error
                   @user = User.find(session[:user_id])
                 end
                 # announcement refreshing and hiding methods
                 def announcements
                   if params.has_key? 'recent'
                     prepare_announcements(params[:recent])
                   else
                     prepare_announcements
                   end
                   render(:partial => 'announcement',
                          :collection => @announcements,
                          :locals => {:announcement_effect => true})
                 end
+            +   #
                 # actions for Code Jom
-            -   def new_input
+            +   #
+            +   def download_input
                   problem = Problem.find(params[:id])
                   user = User.find(session[:user_id])
                   if user.can_request_new_test_pair_for? problem
                     assignment = user.get_new_test_pair_assignment_for problem
                     assignment.save
                     send_data(assignment.test_pair.input,
                               { :filename => "#{problem.name}-#{assignment.request_number}.in",
                                 :type => 'text/plain' })
-            -     else
+            +     else
-            -       flash[:notice] = 'You cannot request new input now.'
+            +       recent_assignment = user.get_recent_test_pair_assignment_for problem
-            -       redirect_to :action => 'list'
-            -     end
-            -   end
-            -   def download_input
-            -     problem = Problem.find(params[:id])
-            -     user = User.find(session[:user_id])
-            -     recent_assignment = user.get_recent_test_pair_assignment_for problem
-            -     if recent_assignment != nil
                     send_data(recent_assignment.test_pair.input,
                               { :filename => "#{problem.name}-#{recent_assignment.request_number}.in",
                                 :type => 'text/plain' })
-            -     else
-            -       flash[:notice] = 'You have not requested for any input data for this problem.'
-            -       redirect_to :action => 'list'
                   end
                 end
                 def submit_solution
                   problem = Problem.find(params[:id])
                   user = User.find(session[:user_id])
                   recent_assignment = user.get_recent_test_pair_assignment_for problem
-            -     if recent_assignment != nil
+            +     if recent_assignment == nil
-            -       submitted_solution = params[:file].read
+            +       flash[:notice] = 'You have not requested for any input data for this problem.  Please download an input first.'
-            -       test_pair = recent_assignment.test_pair
+            +       redirect_to :action => 'list' and return
-            -       passed = test_pair.grade(submitted_solution)
+            +     end
-            -       points = passed ? 100 : 0
-            -       submission = Submission.new(:user => user,
+            +     if recent_assignment.submitted
-            -                                   :problem => problem,
+            +       flash[:notice] = 'You have already submitted an incorrect solution for this input.  Please download a new input data.'
-            -                                   :source => params[:file].read,
+            +       redirect_to :action => 'list' and return
-            -                                   :source_filename => params['file'].original_filename,
+            +     end
-            -                                   :language_id => 0,
-            -                                   :submitted_at => Time.new.gmtime,
+            +     if params[:file] == nil
-            -                                   :graded_at => Time.new.gmtime,
+            +       flash[:notice] = 'You have not submitted any output.'
-            -                                   :points => points)
+            +       redirect_to :action => 'list' and return
-            -       submission.save
+            +     end
-            -       recent_assignment.submitted = true
-            -       recent_assignment.save
+            +     submitted_solution = params[:file].read
-            -       if passed
+            +     test_pair = recent_assignment.test_pair
-            -         flash[:notice] = 'Correct solution'
+            +     passed = test_pair.grade(submitted_solution)
-            -       else
+            +     points = passed ? 100 : 0
-            -         flash[:notice] = 'Incorrect solution'
+            +     submission = Submission.new(:user => user,
-            -       end
+            +                                 :problem => problem,
-            -       redirect_to :action => 'list'
+            +                                 :source => submitted_solution,
+            +                                 :source_filename => params['file'].original_filename,
+            +                                 :language_id => 0,
+            +                                 :submitted_at => Time.new.gmtime,
+            +                                 :graded_at => Time.new.gmtime,
+            +                                 :points => points)
+            +     submission.save
+            +     recent_assignment.submitted = true
+            +     recent_assignment.save
+            +
+            +     status = user.get_submission_status_for(problem)
+            +     if status == nil
+            +       status = SubmissionStatus.new :user => user, :problem => problem, :submission_count => 0
+            +     end
+            +
+            +     status.submission_count += 1
+            +     status.passed = passed
+            +     status.save
+            +
+            +     if passed
+            +       flash[:notice] = 'Correct solution.'
                   else
-            -       flash[:notice] = 'You have not requested for any input data for this problem.'
+            +       flash[:notice] = 'Incorrect solution.'
-            -       redirect_to :action => 'list'
                   end
+            +     redirect_to :action => 'list'
                 end
                 protected
                 def prepare_announcements(recent=nil)
                   if Configuration.show_tasks_to?(@user)
                     @announcements = Announcement.find_published(true)
                   else
                     @announcements = Announcement.find_published
                   end
                   if recent!=nil
                     recent_id = recent.to_i
                     @announcements = @announcements.find_all { |a| a.id > recent_id }
                   end
                 end
                 def prepare_list_information
-            -     @problems = Problem.find_available_problems
+            +     @user = User.find(session[:user_id])
+            +
+            +     all_problems = Problem.find_available_problems
+            +
+            +     passed = {}
+            +     sub_count = {}
+            +     @user.submission_statuses.each do |status|
+            +       if status.passed
+            +         passed[status.problem_id] = true
+            +       end
+            +       sub_count[status.problem_id] = status.submission_count
+            +     end
+            +
+            +     @problems = all_problems.reject { |problem| passed.has_key? problem.id }
+            +
                   @prob_submissions = Array.new
-            -     @user = User.find(session[:user_id])
                   @problems.each do |p|
-            -       sub = Submission.find_last_by_user_and_problem(@user.id,p.id)
+            +       if sub_count.has_key? p.id
-            -       if sub!=nil
+            +         @prob_submissions << { :count => sub_count[p.id] }
-            -         @prob_submissions << { :count => sub.number, :submission => sub }
                     else
-            -         @prob_submissions << { :count => 0, :submission => nil }
+            +         @prob_submissions << { :count => 0 }
                     end
                   end
                   prepare_announcements
                 end
                 def check_viewability
                   @user = User.find(session[:user_id])
                   if (!Configuration.show_tasks_to?(@user)) and
                       ((action_name=='submission') or (action_name=='submit'))
                     redirect_to :action => 'list' and return
                   end
                 end
                 def prepare_grading_result(submission)
                   if Configuration.task_grading_info.has_key? submission.problem.name
                     grading_info = Configuration.task_grading_info[submission.problem.name]
                   else
                     # guess task info from problem.full_score
                     cases = submission.problem.full_score / 10
                     grading_info = {
                       'testruns' => cases,
                       'testcases' => cases
                     }
                   end
                   @test_runs = []
                   if grading_info['testruns'].is_a? Integer
                     trun_count = grading_info['testruns']
                     trun_count.times do |i|
                       @test_runs << [ read_grading_result(@user.login,
                                                           submission.problem.name,
                                                           submission.id,
                                                           i+1) ]
                     end
                   else
                     grading_info['testruns'].keys.sort.each do |num|
                       run = []
                       testrun = grading_info['testruns'][num]
                       testrun.each do |c|
                         run << read_grading_result(@user.login,
                                                    submission.problem.name,
                                                    submission.id,
                                                    c)
                       end
                       @test_runs << run
                     end
                   end
                 end

app/models/submission.rb ¶ +1 -1

               class Submission < ActiveRecord::Base
                 belongs_to :language
                 belongs_to :problem
                 belongs_to :user
                 before_validation :assign_problem
                 before_validation :assign_language
                 validates_presence_of :source
                 validates_length_of :source, :maximum => 100_000, :allow_blank => true, :message => 'too long'
                 validates_length_of :source, :minimum => 1, :allow_blank => true, :message => 'too short'
                 validate :must_have_valid_problem
-            -   validate :must_specify_language
+            +   #validate :must_specify_language
                 before_save :assign_latest_number_if_new_recond
                 def self.find_last_by_user_and_problem(user_id, problem_id)
                   last_sub = find(:first,
                                   :conditions => {:user_id => user_id,
                                     :problem_id => problem_id},
                                   :order => 'number DESC')
                   return last_sub
                 end
                 def self.find_all_last_by_problem(problem_id)
                   # need to put in SQL command, maybe there's a better way
                   Submission.find_by_sql("SELECT * FROM submissions " +
               			   "WHERE id = " +
               			   "(SELECT MAX(id) FROM submissions AS subs " +
               			   "WHERE subs.user_id = submissions.user_id AND " +
                                          "problem_id = " + problem_id.to_s + " " +
               			   "GROUP BY user_id) " +
                                          "ORDER BY user_id")
                 end
                 def self.find_last_for_all_available_problems(user_id)
                   submissions = Array.new
                   problems = Problem.find_available_problems
                   problems.each do |problem|
                     sub = Submission.find_last_by_user_and_problem(user_id, problem.id)
                     submissions << sub if sub!=nil
                   end
                   submissions
                 end
                 def self.find_by_user_problem_number(user_id, problem_id, number)
                   Submission.find(:first,
                                   :conditions => {
                                     :user_id => user_id,
                                     :problem_id => problem_id,
                                     :number => number
                                   })
                 end
                 def self.find_all_by_user_problem(user_id, problem_id)
                   Submission.find(:all,
                                   :conditions => {
                                     :user_id => user_id,
                                     :problem_id => problem_id,
                                   })
                 end

app/models/user.rb ¶ +9

               require 'digest/sha1'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
                 has_many :test_requests, :order => "submitted_at DESC"
                 has_many :messages,
                          :class_name => "Message",
                          :foreign_key => "sender_id",
                          :order => 'created_at DESC'
                 has_many :replied_messages,
                          :class_name => "Message",
                          :foreign_key => "receiver_id",
                          :order => 'created_at DESC'
                 has_many :test_pair_assignments, :dependent => :delete_all
+            +   has_many :submission_statuses
                 belongs_to :site
                 belongs_to :country
                 named_scope :activated_users, :conditions => {:activated => true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /^[\_A-Za-z0-9]+$/
                 validates_length_of :login, :within => 3..30
                 validates_presence_of :full_name
                 validates_length_of :full_name, :minimum => 1
                 validates_presence_of :password, :if => :password_required?
                 validates_length_of :password, :within => 4..20, :if => :password_required?
                 validates_confirmation_of :password, :if => :password_required?
                 validates_format_of :email,
                                     :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i,
                                     :if => :email_validation?
                 validate :uniqueness_of_email_from_activated_users,
                          :if => :email_validation?
                 validate :enough_time_interval_between_same_email_registrations,
                          :if => :email_validation?
                 # these are for ytopc
                 # disable for now
                 #validates_presence_of :province
                 attr_accessor :password
                 before_save :encrypt_new_password
                 before_save :assign_default_site
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   return user if user && user.authenticated?(password)
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def admin?
                   self.roles.detect {|r| r.name == 'admin' }
                 end
                 # These are methods related to test pairs
                 def get_test_pair_assignments_for(problem)
                   test_pair_assignments.find_all { |a| a.problem_id == problem.id }
                 end
                 def get_recent_test_pair_assignment_for(problem)
                   assignments = get_test_pair_assignments_for problem
                   if assignments.length == 0
                     return nil
                   else
                     recent = assignments[0]
                     assignments.each do |a|
                       recent = a if a.request_number > recent.request_number
                     end
                     return recent
                   end
                 end
                 def can_request_new_test_pair_for?(problem)
                   recent = get_recent_test_pair_assignment_for problem
                   return (recent == nil or recent.submitted)
                 end
                 def get_new_test_pair_assignment_for(problem)
                   previous_assignment_numbers =
                     get_test_pair_assignments_for(problem).collect {|a| a.test_pair_number }
                   test_pair = problem.random_test_pair(previous_assignment_numbers)
                   if test_pair
                     assignment = TestPairAssignment.new(:user => self,
                                                         :problem => problem,
                                                         :test_pair => test_pair,
                                                         :test_pair_number => test_pair.number,
                                                         :request_number =>
                                                         previous_assignment_numbers.length + 1,
                                                         :submitted => false)
                     return assignment
                   else
                     return nil
                   end
                 end
+            +   def get_submission_status_for(problem)
+            +     SubmissionStatus.find(:first,
+            +                           :conditions => {
+            +                             :user_id => id,
+            +                             :problem_id => problem.id
+            +                           })
+            +   end
+            +
                 def email_for_editing
                   if self.email==nil
                     "(unknown)"
                   elsif self.email==''
                     "(blank)"
                   else
                     self.email
                   end
                 end
                 def email_for_editing=(e)
                   self.email=e
                 end
                 def alias_for_editing
                   if self.alias==nil
                     "(unknown)"
                   elsif self.alias==''
                     "(blank)"
                   else
                     self.alias
                   end
                 end
                 def alias_for_editing=(e)
                   self.alias=e
                 end
                 def activation_key
                   if self.hashed_password==nil
                     encrypt_new_password
                   end
                   Digest::SHA1.hexdigest(self.hashed_password)[0..7]
                 end
                 def verify_activation_key(key)
                   key == activation_key
                 end
                 def self.random_password(length=5)
                   chars = 'abcdefghjkmnopqrstuvwxyz'
                   password = ''
                   length.times { password << chars[rand(chars.length - 1)] }
                   password
                 end
                 def self.find_non_admin_with_prefix(prefix='')
                   users = User.find(:all)

db/schema.rb ¶ +10 -1

               # This file is auto-generated from the current state of the database. Instead of editing this file,
               # please use the migrations feature of Active Record to incrementally modify your database, and
               # then regenerate this schema definition.
               #
               # Note that this schema.rb definition is the authoritative source for your database schema. If you need
               # to create the application database on another system, you should be using db:schema:load, not running
               # all the migrations from scratch. The latter is a flawed and unsustainable approach (the more migrations
               # you'll amass, the slower it'll run and the greater likelihood for issues).
               #
               # It's strongly recommended to check this file into your version control system.
-            - ActiveRecord::Schema.define(:version => 20100118174404) do
+            + ActiveRecord::Schema.define(:version => 20100123154326) do
                 create_table "announcements", :force => true do |t|
                   t.string   "author"
                   t.text     "body"
                   t.boolean  "published"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.boolean  "frontpage",    :default => false
                   t.boolean  "contest_only", :default => false
                   t.string   "title"
                 end
                 create_table "configurations", :force => true do |t|
                   t.string   "key"
                   t.string   "value_type"
                   t.string   "value"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "countries", :force => true do |t|
                   t.string   "name"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "descriptions", :force => true do |t|
                   t.text     "body"
                   t.boolean  "markdowned"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "grader_processes", :force => true do |t|
                   t.string   "host",       :limit => 20
                   t.integer  "pid"
                   t.string   "mode"
                   t.boolean  "active"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.integer  "task_id"
                   t.string   "task_type"
                   t.boolean  "terminated"
                 end
                 add_index "grader_processes", ["host", "pid"], :name => "index_grader_processes_on_ip_and_pid"
                 create_table "languages", :force => true do |t|
                   t.integer "description_id"
                   t.boolean "test_allowed"
                   t.boolean "output_only"
                 end
                 create_table "rights", :force => true do |t|
                   t.string "name"
                   t.string "controller"
                   t.string "action"
                 end
                 create_table "rights_roles", :id => false, :force => true do |t|
                   t.integer "right_id"
                   t.integer "role_id"
                 end
                 add_index "rights_roles", ["role_id"], :name => "index_rights_roles_on_role_id"
                 create_table "roles", :force => true do |t|
                   t.string "name"
                 end
                 create_table "roles_users", :id => false, :force => true do |t|
                   t.integer "role_id"
                   t.integer "user_id"
                 end
                 add_index "roles_users", ["user_id"], :name => "index_roles_users_on_user_id"
                 create_table "sessions", :force => true do |t|
                   t.string   "session_id"
                   t.text     "data"
                   t.datetime "updated_at"
                 end
                 add_index "sessions", ["session_id"], :name => "index_sessions_on_session_id"
                 add_index "sessions", ["updated_at"], :name => "index_sessions_on_updated_at"
                 create_table "sites", :force => true do |t|
                   t.string   "name"
                   t.boolean  "started"
                   t.datetime "start_time"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.integer  "country_id"
                   t.string   "password"
                 end
+            +   create_table "submission_statuses", :force => true do |t|
+            +     t.integer  "user_id"
+            +     t.integer  "problem_id"
+            +     t.boolean  "passed"
+            +     t.integer  "submission_count"
+            +     t.datetime "created_at"
+            +     t.datetime "updated_at"
+            +   end
+            +
                 create_table "submissions", :force => true do |t|
                   t.integer  "user_id"
                   t.integer  "problem_id"
                   t.integer  "language_id"
                   t.text     "source"
                   t.binary   "binary"
                   t.datetime "submitted_at"
                   t.datetime "compiled_at"
                   t.text     "compiler_message"
                   t.datetime "graded_at"
                   t.integer  "points"
                   t.text     "grader_comment"
                   t.integer  "number"
                   t.string   "source_filename"
                 end
                 add_index "submissions", ["user_id", "problem_id", "number"], :name => "index_submissions_on_user_id_and_problem_id_and_number", :unique => true
                 add_index "submissions", ["user_id", "problem_id"], :name => "index_submissions_on_user_id_and_problem_id"
                 create_table "tasks", :force => true do |t|
                   t.integer  "submission_id"
                   t.datetime "created_at"
                   t.integer  "status"
                   t.datetime "updated_at"
                 end
                 create_table "test_pair_assignments", :force => true do |t|
                   t.integer  "user_id"
                   t.integer  "problem_id"
                   t.integer  "test_pair_id"
                   t.integer  "test_pair_number"
                   t.integer  "request_number"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.boolean  "submitted"
                 end
                 create_table "test_pairs", :force => true do |t|
                   t.integer  "problem_id"
                   t.text     "input"
                   t.text     "solution"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.integer  "number"
                 end
                 create_table "test_requests", :force => true do |t|
                   t.integer  "user_id"

app/views/main/_problem.html.erb removed ¶ -26

deleted file

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r216:fa11dca6b078 - Sat, 23 Jan 2010 16:17:06 - 10 files changed: 149 inserted, 74 deleted

Sign in to your account

Commit r216:fa11dca6b078 public

Author

r216:fa11dca6b078 - Sat, 23 Jan 2010 16:17:06 - 10 files changed: 149 inserted, 74 deleted

Commit `r216:fa11dca6b078` public