offroad 0.0.2 → 0.0.3

data/lib/app/models/offroad/mirror_info.rb

@@ -1,53 +1,53 @@
-module Offroad
-  private
-  
-  # Non-database model representing general information attached to any mirror file
-  # Based on the pattern found here: http://stackoverflow.com/questions/315850/rails-model-without-database
-  class MirrorInfo < ActiveRecord::Base
-    self.abstract_class = true
-    
-    def self.columns
-      @columns ||= []
-    end
-    
-    [
-      [:created_at, :datetime],
-      [:online_site, :string],
-      [:app, :string],
-      [:app_mode, :string],
-      [:app_version, :string],
-      [:operating_system, :string],
-      [:generator, :string],
-      [:schema_migrations, :string],
-      [:initial_file, :boolean]
-    ].each do |attr_name, attr_type|
-      columns << ActiveRecord::ConnectionAdapters::Column.new(attr_name.to_s, nil, attr_type.to_s, true)
-      validates_presence_of attr_name unless attr_type == :boolean
-    end
-    
-    def self.safe_to_load_from_cargo_stream?
-      true
-    end
-    
-    def self.new_from_group(group, initial_file = false)
-      mode = Offroad::app_online? ? "online" : "offline"
-      migration_query = "SELECT version FROM schema_migrations ORDER BY version"
-      migrations = Offroad::group_base_model.connection.select_all(migration_query).map{ |r| r["version"] }
-      return MirrorInfo.new(
-        :created_at => Time.now.to_s,
-        :online_site => Offroad::online_url,
-        :app => Offroad::app_name,
-        :app_mode => mode.titleize,
-        :app_version => Offroad::app_version,
-        :operating_system => RUBY_PLATFORM,
-        :generator => "Offroad " + Offroad::VERSION,
-        :schema_migrations => migrations.join(","),
-        :initial_file => initial_file
-      )
-    end
-    
-    def save
-      raise DataError.new("Cannot save MirrorInfo records")
-    end
-  end
-end
+module Offroad
+  private
+  
+  # Non-database model representing general information attached to any mirror file
+  # Based on the pattern found here: http://stackoverflow.com/questions/315850/rails-model-without-database
+  class MirrorInfo < ActiveRecord::Base
+    self.abstract_class = true
+    
+    def self.columns
+      @columns ||= []
+    end
+    
+    [
+      [:created_at, :datetime],
+      [:online_site, :string],
+      [:app, :string],
+      [:app_mode, :string],
+      [:app_version, :string],
+      [:operating_system, :string],
+      [:generator, :string],
+      [:schema_migrations, :string],
+      [:initial_file, :boolean]
+    ].each do |attr_name, attr_type|
+      columns << ActiveRecord::ConnectionAdapters::Column.new(attr_name.to_s, nil, attr_type.to_s, true)
+      validates_presence_of attr_name unless attr_type == :boolean
+    end
+    
+    def self.safe_to_load_from_cargo_stream?
+      true
+    end
+    
+    def self.new_from_group(group, initial_file = false)
+      mode = Offroad::app_online? ? "online" : "offline"
+      migration_query = "SELECT version FROM schema_migrations ORDER BY version"
+      migrations = Offroad::group_base_model.connection.select_all(migration_query).map{ |r| r["version"] }
+      return MirrorInfo.new(
+        :created_at => Time.now.to_s,
+        :online_site => Offroad::online_url,
+        :app => Offroad::app_name,
+        :app_mode => mode.titleize,
+        :app_version => Offroad::app_version,
+        :operating_system => RUBY_PLATFORM,
+        :generator => "Offroad " + Offroad::VERSION,
+        :schema_migrations => migrations.join(","),
+        :initial_file => initial_file
+      )
+    end
+    
+    def save
+      raise DataError.new("Cannot save MirrorInfo records")
+    end
+  end
+end

data/lib/app/models/offroad/model_state.rb

@@ -1,36 +1,36 @@
-module Offroad
-  private
-  
-  class ModelState < ActiveRecord::Base
-    set_table_name "offroad_model_states"
-    
-    validates_presence_of :app_model_name
-    
-    def validate
-      model = nil
-      begin
-        model = app_model
-      rescue NameError
-        errors.add_to_base "Given model name does not correspond to a constant"
-      end
-      
-      if model
-        errors.add_to_base "Constant is not a mirrored model" unless self.class.valid_model?(model)
-      end
-    end
-    
-    named_scope :for_model, lambda { |model| { :conditions => {
-      :app_model_name => valid_model?(model) ? model.name : nil
-    } } }
-    
-    def app_model
-      app_model_name.constantize
-    end
-    
-    private
-    
-    def self.valid_model?(model)
-      model.respond_to?(:acts_as_offroadable?) && model.acts_as_offroadable?
-    end
-  end
-end
+module Offroad
+  private
+  
+  class ModelState < ActiveRecord::Base
+    set_table_name "offroad_model_states"
+    
+    validates_presence_of :app_model_name
+    
+    def validate
+      model = nil
+      begin
+        model = app_model
+      rescue NameError
+        errors.add_to_base "Given model name does not correspond to a constant"
+      end
+      
+      if model
+        errors.add_to_base "Constant is not a mirrored model" unless self.class.valid_model?(model)
+      end
+    end
+    
+    named_scope :for_model, lambda { |model| { :conditions => {
+      :app_model_name => valid_model?(model) ? model.name : nil
+    } } }
+    
+    def app_model
+      app_model_name.constantize
+    end
+    
+    private
+    
+    def self.valid_model?(model)
+      model.respond_to?(:acts_as_offroadable?) && model.acts_as_offroadable?
+    end
+  end
+end

data/lib/app/models/offroad/received_record_state.rb

@@ -1,115 +1,115 @@
-module Offroad
-  private
-  
-  class ReceivedRecordState < ActiveRecord::Base
-    set_table_name "offroad_received_record_states"
-    
-    belongs_to :model_state, :class_name => "::Offroad::ModelState"
-    
-    belongs_to :group_state, :class_name => "::Offroad::GroupState"
-    
-    def validate
-      unless model_state
-        errors.add_to_base "Cannot find associated model state"
-        return
-      end
-      model = model_state.app_model
-
-      if Offroad::app_offline?
-        if model.offroad_group_data?
-          errors.add_to_base "Cannot allow received record state for group data in offline app"
-        end
-      elsif Offroad::app_online?
-        if model.offroad_global_data?
-          errors.add_to_base "Cannot allow received record state for global records in online app"
-        elsif group_state.nil?
-          errors.add_to_base "Cannot allow received record state for online group records in online app"
-        end
-      end
-
-      if model.offroad_global_data? && group_state
-        errors.add_to_base "Cannot allow received record state for global records to also be assoc with a group"
-      end
-
-      begin
-        app_record
-      rescue ActiveRecord::RecordNotFound
-        errors.add_to_base "Cannot find associated app record"
-      end
-    end
-    
-    named_scope :for_model, lambda { |model| { :conditions => {
-      :model_state_id => model.offroad_model_state.id
-    } } }
-
-    named_scope :for_model_and_group_if_apropos, lambda { |model, group| { :conditions => {
-      :model_state_id => model.offroad_model_state.id,
-      :group_state_id => (group && model.offroad_group_data? && group.group_state) ? group.group_state.id : 0
-    } } }
-    
-    named_scope :for_record, lambda { |rec| { :conditions => {
-      :model_state_id => rec.class.offroad_model_state.id,
-      :group_state_id => (rec.class.offroad_group_data? && rec.group_state) ? rec.group_state.id : 0,
-      :local_record_id => rec.id
-    } } }
-
-    def app_record
-      model_state.app_model.find(local_record_id)
-    end
-
-    def self.redirect_to_local_ids(records, column, model, group)
-      column = column.to_sym
-      source = self.for_model_and_group_if_apropos(model, group)
-      already_allocated = source.all(:conditions => { :remote_record_id => records.map{|r| r[column]} }).index_by(&:remote_record_id)
-
-      remaining = {} # Maps newly discovered remote id to list of records in batch that reference that id
-      records.each do |r|
-        remote_id = r[column]
-        next unless remote_id && remote_id > 0
-        # TODO Check for illegal references here (i.e. group model referencing global model)
-        if already_allocated.has_key?(remote_id)
-          r[column] = already_allocated[remote_id].local_record_id
-        else
-          # Target doesn't exist yet, we'll figure out what its local id will be later
-          if remaining.has_key?(remote_id)
-            remaining[remote_id] << r
-          else
-            remaining[remote_id] = [r]
-          end
-        end
-      end
-
-      return unless remaining.size > 0
-
-      # Reserve access to a block of local ids
-      if model.connection.adapter_name.downcase.include?("postgres")
-        nextval_cmd = model.connection.select_value("SELECT column_default FROM information_schema.columns WHERE table_name = '#{model.table_name}' AND column_name = '#{model.primary_key}'")
-        local_ids = model.connection.select_values("SELECT #{nextval_cmd} FROM generate_series(1,#{remaining.size})").map(&:to_i)
-      else
-        # Reserve access to a block of local ids by creating temporary records to advance the autoincrement counter
-        # TODO I'm pretty sure this is safe because it'll always be used in a transaction, but I should check
-        model.import([model.primary_key.to_sym], [[nil]]*remaining.size, :validate => false, :timestamps => false)
-        last_id = model.last(:select => model.primary_key, :order => model.primary_key).id
-        local_ids = ((last_id+1-remaining.size)..last_id).to_a
-        model.delete(local_ids)
-      end
-
-      # Create the corresponding RRSes
-      model_state_id = model.offroad_model_state.id
-      group_state = model.offroad_group_data? && group ? group.group_state : nil
-      group_state_id = group_state ? group_state.id : 0
-      self.import(
-        [:model_state_id, :group_state_id, :local_record_id, :remote_record_id],
-        local_ids.zip(remaining.keys).map{|here, there| [model_state_id, group_state_id, here, there]},
-        :validate => false, :timestamps => false
-      )
-      
-      # Finally do the redirection to the new ids
-      remaining.each_key.each_with_index do |remote_id, i|
-        remaining[remote_id].each do |r|
-          r[column] = local_ids[i]
-        end
-      end
-    end
-  end
-end
+module Offroad
+  private
+  
+  class ReceivedRecordState < ActiveRecord::Base
+    set_table_name "offroad_received_record_states"
+    
+    belongs_to :model_state, :class_name => "::Offroad::ModelState"
+    
+    belongs_to :group_state, :class_name => "::Offroad::GroupState"
+    
+    def validate
+      unless model_state
+        errors.add_to_base "Cannot find associated model state"
+        return
+      end
+      model = model_state.app_model
+
+      if Offroad::app_offline?
+        if model.offroad_group_data?
+          errors.add_to_base "Cannot allow received record state for group data in offline app"
+        end
+      elsif Offroad::app_online?
+        if model.offroad_global_data?
+          errors.add_to_base "Cannot allow received record state for global records in online app"
+        elsif group_state.nil?
+          errors.add_to_base "Cannot allow received record state for online group records in online app"
+        end
+      end
+
+      if model.offroad_global_data? && group_state
+        errors.add_to_base "Cannot allow received record state for global records to also be assoc with a group"
+      end
+
+      begin
+        app_record
+      rescue ActiveRecord::RecordNotFound
+        errors.add_to_base "Cannot find associated app record"
+      end
+    end
+    
+    named_scope :for_model, lambda { |model| { :conditions => {
+      :model_state_id => model.offroad_model_state.id
+    } } }
+
+    named_scope :for_model_and_group_if_apropos, lambda { |model, group| { :conditions => {
+      :model_state_id => model.offroad_model_state.id,
+      :group_state_id => (group && model.offroad_group_data? && group.group_state) ? group.group_state.id : 0
+    } } }
+    
+    named_scope :for_record, lambda { |rec| { :conditions => {
+      :model_state_id => rec.class.offroad_model_state.id,
+      :group_state_id => (rec.class.offroad_group_data? && rec.group_state) ? rec.group_state.id : 0,
+      :local_record_id => rec.id
+    } } }
+
+    def app_record
+      model_state.app_model.find(local_record_id)
+    end
+
+    def self.redirect_to_local_ids(records, column, model, group)
+      column = column.to_sym
+      source = self.for_model_and_group_if_apropos(model, group)
+      already_allocated = source.all(:conditions => { :remote_record_id => records.map{|r| r[column]} }).index_by(&:remote_record_id)
+
+      remaining = {} # Maps newly discovered remote id to list of records in batch that reference that id
+      records.each do |r|
+        remote_id = r[column]
+        next unless remote_id && remote_id > 0
+        # TODO Check for illegal references here (i.e. group model referencing global model)
+        if already_allocated.has_key?(remote_id)
+          r[column] = already_allocated[remote_id].local_record_id
+        else
+          # Target doesn't exist yet, we'll figure out what its local id will be later
+          if remaining.has_key?(remote_id)
+            remaining[remote_id] << r
+          else
+            remaining[remote_id] = [r]
+          end
+        end
+      end
+
+      return unless remaining.size > 0
+
+      # Reserve access to a block of local ids
+      if model.connection.adapter_name.downcase.include?("postgres")
+        nextval_cmd = model.connection.select_value("SELECT column_default FROM information_schema.columns WHERE table_name = '#{model.table_name}' AND column_name = '#{model.primary_key}'")
+        local_ids = model.connection.select_values("SELECT #{nextval_cmd} FROM generate_series(1,#{remaining.size})").map(&:to_i)
+      else
+        # Reserve access to a block of local ids by creating temporary records to advance the autoincrement counter
+        # TODO I'm pretty sure this is safe because it'll always be used in a transaction, but I should check
+        model.import([model.primary_key.to_sym], [[nil]]*remaining.size, :validate => false, :timestamps => false)
+        last_id = model.last(:select => model.primary_key, :order => model.primary_key).id
+        local_ids = ((last_id+1-remaining.size)..last_id).to_a
+        model.delete(local_ids)
+      end
+
+      # Create the corresponding RRSes
+      model_state_id = model.offroad_model_state.id
+      group_state = model.offroad_group_data? && group ? group.group_state : nil
+      group_state_id = group_state ? group_state.id : 0
+      self.import(
+        [:model_state_id, :group_state_id, :local_record_id, :remote_record_id],
+        local_ids.zip(remaining.keys).map{|here, there| [model_state_id, group_state_id, here, there]},
+        :validate => false, :timestamps => false
+      )
+      
+      # Finally do the redirection to the new ids
+      remaining.each_key.each_with_index do |remote_id, i|
+        remaining[remote_id].each do |r|
+          r[column] = local_ids[i]
+        end
+      end
+    end
+  end
+end

data/lib/app/models/offroad/sendable_record_state.rb

@@ -1,91 +1,91 @@
-module Offroad
-  private
-  
-  class SendableRecordState < ActiveRecord::Base
-    set_table_name "offroad_sendable_record_states"
-    
-    belongs_to :model_state, :class_name => "::Offroad::ModelState"
-    
-    def validate
-      unless model_state
-        errors.add_to_base "Cannot find associated model state"
-        return
-      end
-      
-      rec = nil
-      unless deleted
-        begin
-          rec = app_record
-        rescue ActiveRecord::RecordNotFound
-          errors.add_to_base "Cannot find associated app record"
-        end
-      end
-      
-      if rec
-        if Offroad::app_offline? && app_record.class.offroad_global_data?
-          errors.add_to_base "Cannot create sendable record state for global data in offline app"
-        elsif Offroad::app_online? && app_record.class.offroad_group_data?
-          errors.add_to_base "Cannot create sendable record state for group data in online app"
-        end
-      end
-    end
-    
-    named_scope :for_model, lambda { |model| { :conditions => {
-      :model_state_id => model.offroad_model_state.id
-    } } }
-    
-    named_scope :for_deleted_records, :conditions => { :deleted => true }
-    named_scope :for_non_deleted_records, :conditions => { :deleted => false }
-    
-    named_scope :with_version_greater_than, lambda { |v| { :conditions => ["mirror_version > ?", v] } }
-    
-    named_scope :for_record, lambda { |rec| { :conditions => {
-      :model_state_id => rec.class.offroad_model_state.id,
-      :local_record_id => rec.id
-    } } }
-    
-    def app_record
-      model_state.app_model.find(local_record_id)
-    end
-    
-    # We put SRS records in mirror files to represent deleted records
-    def self.safe_to_load_from_cargo_stream?
-      true
-    end
-    
-    def self.note_record_destroyed(record)
-      mark_record_changes(record) do |rec|
-        rec.deleted = true
-      end
-    end
-    
-    def self.note_record_created_or_updated(record)
-      mark_record_changes(record)
-    end
-
-    def self.setup_imported(model, batch)
-      model_state_id = model.offroad_model_state.id
-      mirror_version = SystemState::current_mirror_version
-      self.import(
-        [:model_state_id, :local_record_id, :mirror_version],
-        batch.map{|r| [model_state_id, r.id, mirror_version]},
-        :validate => false,
-        :timestamps => false
-      )
-    end
-
-    private
-    
-    def self.mark_record_changes(record)
-      transaction do
-        scope = for_record(record)
-        rec_state = scope.first || scope.create
-        rec_state.lock!
-        rec_state.mirror_version = SystemState::current_mirror_version
-        yield(rec_state) if block_given?
-        rec_state.save!
-      end
-    end
-    
-  end
-end
+module Offroad
+  private
+  
+  class SendableRecordState < ActiveRecord::Base
+    set_table_name "offroad_sendable_record_states"
+    
+    belongs_to :model_state, :class_name => "::Offroad::ModelState"
+    
+    def validate
+      unless model_state
+        errors.add_to_base "Cannot find associated model state"
+        return
+      end
+      
+      rec = nil
+      unless deleted
+        begin
+          rec = app_record
+        rescue ActiveRecord::RecordNotFound
+          errors.add_to_base "Cannot find associated app record"
+        end
+      end
+      
+      if rec
+        if Offroad::app_offline? && app_record.class.offroad_global_data?
+          errors.add_to_base "Cannot create sendable record state for global data in offline app"
+        elsif Offroad::app_online? && app_record.class.offroad_group_data?
+          errors.add_to_base "Cannot create sendable record state for group data in online app"
+        end
+      end
+    end
+    
+    named_scope :for_model, lambda { |model| { :conditions => {
+      :model_state_id => model.offroad_model_state.id
+    } } }
+    
+    named_scope :for_deleted_records, :conditions => { :deleted => true }
+    named_scope :for_non_deleted_records, :conditions => { :deleted => false }
+    
+    named_scope :with_version_greater_than, lambda { |v| { :conditions => ["mirror_version > ?", v] } }
+    
+    named_scope :for_record, lambda { |rec| { :conditions => {
+      :model_state_id => rec.class.offroad_model_state.id,
+      :local_record_id => rec.id
+    } } }
+    
+    def app_record
+      model_state.app_model.find(local_record_id)
+    end
+    
+    # We put SRS records in mirror files to represent deleted records
+    def self.safe_to_load_from_cargo_stream?
+      true
+    end
+    
+    def self.note_record_destroyed(record)
+      mark_record_changes(record) do |rec|
+        rec.deleted = true
+      end
+    end
+    
+    def self.note_record_created_or_updated(record)
+      mark_record_changes(record)
+    end
+
+    def self.setup_imported(model, batch)
+      model_state_id = model.offroad_model_state.id
+      mirror_version = SystemState::current_mirror_version
+      self.import(
+        [:model_state_id, :local_record_id, :mirror_version],
+        batch.map{|r| [model_state_id, r.id, mirror_version]},
+        :validate => false,
+        :timestamps => false
+      )
+    end
+
+    private
+    
+    def self.mark_record_changes(record)
+      transaction do
+        scope = for_record(record)
+        rec_state = scope.first || scope.create
+        rec_state.lock!
+        rec_state.mirror_version = SystemState::current_mirror_version
+        yield(rec_state) if block_given?
+        rec_state.save!
+      end
+    end
+    
+  end
+end