Rename cache_version to cached_version

cache_version is now a reserved word

Author: nygrenh

app/models/course.rb

@@ -69,30 +69,30 @@ class Course < ActiveRecord::Base
   end
 
   def course_as_json
-    as_json(only: %i[
-              name
-              hide_after
-              hidden
-              cache_version
-              spreadsheet_key
-              hidden_if_registered_after
-              refreshed_at
-              locked_exercise_points_visible
-              description
-              paste_visibility
-              formal_name
-              certificate_downloadable
-              certificate_unlock_spec
-              organization_id
-              disabled_status
-              title
-              descrpition
-              material_url
-              course_template_id
-              hide_submission_results
-              external_scoreboard_url
-            ],
-            methods: :organization_slug)
+    {
+      name: name,
+      hide_after: hide_after,
+      hidden: hidden,
+      cache_version: cached_version,
+      spreadsheet_key: spreadsheet_key,
+      hidden_if_registered_after: hidden_if_registered_after,
+      refreshed_at: refreshed_at,
+      locked_exercise_points_visible: locked_exercise_points_visible,
+      description: description,
+      paste_visibility: paste_visibility,
+      formal_name: formal_name,
+      certificate_downloadable: certificate_downloadable,
+      certificate_unlock_spec: certificate_unlock_spec,
+      organization_id: organization_id,
+      disabled_status: disabled_status,
+      title: title,
+      descrpition: descripition,
+      material_url: material_url,
+      course_template_id: course_template_id,
+      hide_submission_results: hide_submission_results,
+      external_scoreboard_url: external_scoreboard_url,
+      organization_slug: organization_slug,
+    }
   end
 
   swagger_schema :CourseLinks do
@@ -143,8 +143,8 @@ def links_as_json(view_context)
   validates :description, length: { maximum: 512 }
   validate :check_name_length
 
-  # If made from template, make sure cache_version is not out of sync.
-  before_save :set_cache_version
+  # If made from template, make sure cached_version is not out of sync.
+  before_save :set_cached_version
   before_validation :save_template
   validates :source_url, presence: true
   # validates :custom_points_url,
@@ -207,7 +207,7 @@ def self.new_from_template(course_template)
                title: course_template.title,
                description: course_template.description,
                material_url: course_template.material_url,
-               cache_version: course_template.cache_version,
+               cached_version: course_template.cached_version,
                course_template: course_template)
   end
 
@@ -285,7 +285,7 @@ def self.cache_root
     "#{FileStore.root}/course"
   end
 
-  delegate :increment_cache_version, to: :course_template_obj
+  delegate :increment_cached_version, to: :course_template_obj
 
   delegate :cache_path, to: :course_template_obj
 
@@ -532,8 +532,8 @@ def parsed_external_scoreboard_url(organization, course, user)
 
   private
 
-    def set_cache_version
-      self.cache_version = course_template_obj.cache_version
+    def set_cached_version
+      self.cached_version = course_template_obj.cached_version
     end
 
     def save_template

app/models/course_template.rb

@@ -72,13 +72,13 @@ def clonable?
   end
 
   def cache_path
-    File.join(Course.cache_root, "#{name}-#{cache_version}")
+    File.join(Course.cache_root, "#{name}-#{cached_version}")
   end
 
-  def increment_cache_version
-    self.cache_version += 1
+  def increment_cached_version
+    self.cached_version += 1
     courses.each do |course|
-      course.cache_version = cache_version
+      course.cached_version = cached_version
     end
   end
 
@@ -101,7 +101,7 @@ def cache_exists?
 
     def update_courses_sourcedata
       courses.each do |c|
-        c.cache_version = cache_version
+        c.cached_version = cached_version
         c.source_url = source_url
         c.git_branch = git_branch
         c.source_backend = source_backend

app/views/course_templates/show.html.erb

@@ -27,7 +27,7 @@
 
 <p>
   <strong>Cache version:</strong>
-  <%= @course_template.cache_version %>
+  <%= @course_template.cached_version %>
 </p>
 
 <p>

db/migrate/20181003140911_rename_cache_version.rb

@@ -0,0 +1,6 @@
+class RenameCacheVersion < ActiveRecord::Migration
+  def change
+    rename_column :courses, :cache_version, :cached_version
+    rename_column :course_templates, :cache_version, :cached_version
+  end
+end

db/schema.rb

@@ -11,7 +11,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20181003103718) do
+ActiveRecord::Schema.define(version: 20181003140911) do
 
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
@@ -81,7 +81,7 @@
     t.string   "source_url"
     t.boolean  "dummy",          default: false,    null: false
     t.boolean  "hidden",         default: false
-    t.integer  "cache_version",  default: 0,        null: false
+    t.integer  "cached_version", default: 0,        null: false
     t.string   "source_backend", default: "git",    null: false
     t.string   "git_branch",     default: "master", null: false
     t.datetime "expires_at"
@@ -95,7 +95,7 @@
     t.datetime "updated_at"
     t.datetime "hide_after"
     t.boolean  "hidden",                                   default: false, null: false
-    t.integer  "cache_version",                            default: 0,     null: false
+    t.integer  "cached_version",                           default: 0,     null: false
     t.string   "spreadsheet_key"
     t.datetime "hidden_if_registered_after"
     t.datetime "refreshed_at"

lib/course_refresher.rb

@@ -103,7 +103,7 @@ def refresh_course(course, options)
 
           @old_cache_path = @course.cache_path
 
-          @course.increment_cache_version                         unless options[:no_directory_changes] # causes @course.*_path to return paths in the new cache
+          @course.increment_cached_version                         unless options[:no_directory_changes] # causes @course.*_path to return paths in the new cache
 
           FileUtils.rm_rf(@course.cache_path)                     unless options[:no_directory_changes]
           FileUtils.mkdir_p(@course.cache_path)                   unless options[:no_directory_changes]

spec/controllers/setup/course_details_controller_spec.rb

@@ -58,14 +58,14 @@
 
         it "does directory changes when course is first created from template, but doesn't do changes when creating more courses from same template" do
           expect(CourseTemplate.last.dummy).to be true
-          expect(CourseTemplate.last.cache_version).to eq(0)
+          expect(CourseTemplate.last.cached_version).to eq(0)
           post :create, organization_id: @organization.slug, course: { name: 'NewCourse', title: 'New Course', course_template_id: @ct.id }
-          expect(Course.all.order(:id).pluck(:cache_version)).to eq([0, 1])
+          expect(Course.all.order(:id).pluck(:cached_version)).to eq([0, 1])
 
-          expect(CourseTemplate.find(@ct.id).cache_version).to eq(1)
+          expect(CourseTemplate.find(@ct.id).cached_version).to eq(1)
           post :create, organization_id: @organization.slug, course: { name: 'NewCourse2', title: 'New Course 2', course_template_id: @ct.id }
-          expect(Course.all.order(:id).pluck(:cache_version)).to eq([0, 1, 1])
-          expect(CourseTemplate.find(@ct.id).cache_version).to eq(1)
+          expect(Course.all.order(:id).pluck(:cached_version)).to eq([0, 1, 1])
+          expect(CourseTemplate.find(@ct.id).cached_version).to eq(1)
           expect(Dir["#{@test_tmp_dir}/cache/git_repos/*"].count).to be(1)
         end
       end
@@ -205,9 +205,9 @@
 
       it 'does directory changes via refresh' do
         post :create, organization_id: @organization.slug, course: { name: 'NewCourse', title: 'New Course', source_url: @ct.source_url }
-        expect(Course.last.cache_version).to eq(1)
+        expect(Course.last.cached_version).to eq(1)
         post :create, organization_id: @organization.slug, course: { name: 'NewCourse2', title: 'New Course 2', source_url: @ct.source_url }
-        expect(Course.all.pluck(:cache_version)).to eq([0, 1, 1])
+        expect(Course.all.pluck(:cached_version)).to eq([0, 1, 1])
         expect(Dir["#{@test_tmp_dir}/cache/git_repos/*"].count).to be(2)
       end
     end

spec/lib/course_refresher_spec.rb

@@ -678,19 +678,19 @@ def sabotage
     end
 
     it 'should roll back any database changes' do
-      old_cache_version = @course.cache_version
+      old_cached_version = @course.cached_version
       old_exercises = Exercise.order(:id).to_a
       old_points = AvailablePoint.order(:id).to_a
 
       sabotage
       expect { refresh_courses }.to raise_error
 
       @template.reload
-      expect(@template.cache_version).to eq(old_cache_version)
+      expect(@template.cached_version).to eq(old_cached_version)
       @course.reload
-      expect(@course.cache_version).to eq(old_cache_version)
+      expect(@course.cached_version).to eq(old_cached_version)
       @course2.reload
-      expect(@course2.cache_version).to eq(old_cache_version)
+      expect(@course2.cached_version).to eq(old_cached_version)
       expect(Exercise.order(:id).to_a).to eq(old_exercises)
       expect(AvailablePoint.order(:id).to_a).to eq(old_points)
     end
@@ -718,14 +718,14 @@ def sabotage
   end
 
   describe 'with no_directory_changes flag' do
-    it "doesn't increment cache_version" do
+    it "doesn't increment cached_version" do
       refresh_courses
-      expect(@template.cache_version).not_to eq(2)
-      expect(@course.cache_version).not_to eq(2)
-      expect(@course2.cache_version).not_to eq(2)
-      expect(@template.cache_version).to eq(1)
-      expect(@course.cache_version).to eq(1)
-      expect(@course2.cache_version).to eq(1)
+      expect(@template.cached_version).not_to eq(2)
+      expect(@course.cached_version).not_to eq(2)
+      expect(@course2.cached_version).not_to eq(2)
+      expect(@template.cached_version).to eq(1)
+      expect(@course.cached_version).to eq(1)
+      expect(@course2.cached_version).to eq(1)
     end
 
     it "doesn't create duplicate repository folder" do

spec/models/course_spec.rb

@@ -347,18 +347,18 @@ def assert_destroyed(obj)
     end
   end
 
-  it 'increments own cache_version if custom course' do
+  it 'increments own cached_version if custom course' do
     course = FactoryGirl.create :course
     expect do
-      course.increment_cache_version
+      course.increment_cached_version
       course.save!
-    end.to change { course.cache_version }.by(1)
+    end.to change { course.cached_version }.by(1)
   end
 
-  it "increments template's cache_version if templated" do
+  it "increments template's cached_version if templated" do
     template = FactoryGirl.create :course_template
     course = FactoryGirl.create :course, course_template: template, source_url: template.source_url
-    expect { course.increment_cache_version }.to change { template.cache_version }.by(1)
+    expect { course.increment_cached_version }.to change { template.cached_version }.by(1)
   end
 
   it "templated course's cache path is template's cache path, regardless of names" do

spec/models/course_template_spec.rb

@@ -77,24 +77,24 @@ def should_be_invalid_params(params)
     template.courses << FactoryGirl.create(:course, course_template: template, source_url: template.source_url)
     template.courses << FactoryGirl.create(:course, course_template: template, source_url: template.source_url)
     template.courses << FactoryGirl.create(:course, course_template: template, source_url: template.source_url)
-    expect(template.cache_version).to eq(0)
-    expect(Course.all.pluck(:cache_version)).to eq([0, 0, 0])
+    expect(template.cached_version).to eq(0)
+    expect(Course.all.pluck(:cached_version)).to eq([0, 0, 0])
 
     template.refresh
-    expect(template.cache_version).to eq(1)
-    expect(Course.all.pluck(:cache_version)).to eq([1, 1, 1])
+    expect(template.cached_version).to eq(1)
+    expect(Course.all.pluck(:cached_version)).to eq([1, 1, 1])
   end
 
-  it "keeps course's cache_versions synchronized" do
+  it "keeps course's cached_versions synchronized" do
     template = FactoryGirl.create :course_template
     template.courses << FactoryGirl.create(:course, course_template: template, source_url: template.source_url)
     template.courses << FactoryGirl.create(:course, course_template: template, source_url: template.source_url)
-    expect(template.cache_version).to eq(0)
-    expect(Course.all.pluck(:cache_version)).to eq([0, 0])
+    expect(template.cached_version).to eq(0)
+    expect(Course.all.pluck(:cached_version)).to eq([0, 0])
     template.refresh
     template.courses << FactoryGirl.create(:course, course_template: template, source_url: template.source_url)
-    expect(template.cache_version).to eq(1)
-    expect(Course.all.pluck(:cache_version)).to eq([1, 1, 1])
+    expect(template.cached_version).to eq(1)
+    expect(Course.all.pluck(:cached_version)).to eq([1, 1, 1])
   end
 
   it "keeps course's source url and git branch synchronized" do