offroad 0.0.1

data/lib/model_extensions.rb

@@ -0,0 +1,377 @@
+module Offroad
+  module ModelExtensions
+    OFFROAD_VALID_MODES = [:group_base, :group_owned, :group_single, :global]
+    OFFROAD_GROUP_MODES = [:group_base, :group_owned, :group_single]
+    
+    def acts_as_offroadable(mode, opts = {})
+      raise ModelError.new("You can only call acts_as_offroadable once per model") if acts_as_offroadable?
+      raise ModelError.new("You must specify a mode, one of " + OFFROAD_VALID_MODES.map(&:inspect).join("/")) unless OFFROAD_VALID_MODES.include?(mode)
+      
+      set_internal_cattr :offroad_mode, mode
+      
+      case mode
+      when :group_owned then
+        raise ModelError.new("For :group_owned models, need to specify :parent") unless opts[:parent]
+        assoc = reflect_on_association(opts.delete(:parent))
+        raise ModelError.new("No such parent associaton") unless assoc
+        raise ModelError.new("Parent association must be a belongs_to association") unless assoc.belongs_to?
+        raise ModelError.new("Parent association must be to a group data model") unless assoc.klass.offroad_group_data?
+
+        set_internal_cattr :offroad_parent_assoc, assoc
+        Offroad::note_group_owned_model(self)
+      when :group_single then
+        Offroad::note_group_single_model(self)
+      when :group_base then
+        Offroad::note_group_base_model(self)
+      when :global then
+        Offroad::note_global_data_model(self)
+      end
+      
+      # We should have deleted all the options from the hash by this point
+      raise ModelError.new("Unknown or inapplicable option(s) specified") unless opts.size == 0
+      
+      case mode
+      when :group_base then
+        named_scope :owned_by_offroad_group, lambda { |group| { :conditions => { :id => group.id } } }
+        named_scope :offline_groups, {
+          :joins =>
+          "INNER JOIN `#{Offroad::GroupState.table_name}` ON `#{Offroad::GroupState.table_name}`.app_group_id = `#{table_name}`.`#{primary_key}`"
+        }
+        named_scope :online_groups, {
+          :joins =>
+          "LEFT JOIN `#{Offroad::GroupState.table_name}` ON `#{Offroad::GroupState.table_name}`.app_group_id = `#{table_name}`.`#{primary_key}`",
+          :conditions =>
+          "`#{Offroad::GroupState.table_name}`.app_group_id IS NULL"
+        }
+      when :group_owned then
+        named_scope :owned_by_offroad_group, lambda { |group| args_for_ownership_scope(group) }
+      when :group_single then
+        named_scope :owned_by_offroad_group, lambda { |group| {
+          :conditions => (Offroad::GroupState.count > 0 && group == Offroad::GroupState.first.app_group) ? "1=1" : "1=0"
+        } }
+      end
+
+      if offroad_group_data?
+        include GroupDataInstanceMethods
+      else
+        include GlobalDataInstanceMethods
+      end
+      include CommonInstanceMethods
+      
+      before_destroy :before_mirrored_data_destroy
+      after_destroy :after_mirrored_data_destroy
+      before_save :before_mirrored_data_save
+      after_save :after_mirrored_data_save
+
+      if Object.const_defined?(:Hobo) and included_modules.include?(Hobo::Model)
+        include HoboPermissionsInstanceMethods
+        [
+          [:create, :save],
+          [:update, :save],
+          [:destroy, :destroy]
+        ].each do |perm_name, check_name|
+          define_method "#{perm_name}_permitted_with_offroad_check?".to_sym do
+            pre_check_passed?("before_mirrored_data_#{check_name}".to_sym) && send("#{perm_name}_permitted_without_offroad_check?")
+          end
+          alias_method_chain "#{perm_name}_permitted?", "offroad_check"
+        end
+      end
+    end
+    
+    def offroad_model_state
+      model_scope = Offroad::ModelState::for_model(self)
+      return model_scope.first || model_scope.create
+    end
+    
+    def acts_as_offroadable?
+      respond_to? :offroad_mode
+    end
+    
+    def safe_to_load_from_cargo_stream?
+      acts_as_offroadable?
+    end
+    
+    def offroad_group_base?
+      acts_as_offroadable? && offroad_mode == :group_base
+    end
+    
+    def offroad_group_data?
+      acts_as_offroadable? && OFFROAD_GROUP_MODES.include?(offroad_mode)
+    end
+    
+    def offroad_global_data?
+      acts_as_offroadable? && offroad_mode == :global
+    end
+    
+    private
+    
+    def set_internal_cattr(name, value)
+      write_inheritable_attribute name, value
+      class_inheritable_reader name
+    end
+    
+    def args_for_ownership_scope(group)
+      included_assocs = []
+      conditions = []
+      assoc_owner = self
+      assoc = offroad_parent_assoc
+      while true
+        if assoc.klass.offroad_group_base?
+          conditions << "`#{assoc_owner.table_name}`.`#{assoc.primary_key_name}` = #{group.id}"
+          break
+        else
+          conditions << "`#{assoc_owner.table_name}`.`#{assoc.primary_key_name}` = `#{assoc.klass.table_name}`.`#{assoc.klass.primary_key}`"
+          included_assocs << assoc
+          assoc_owner = assoc.klass
+          assoc = assoc.klass.offroad_parent_assoc
+        end
+      end
+
+      includes = {}
+      included_assocs.reverse.each do |assoc|
+        includes = {assoc.name => includes}
+      end
+
+      return {:include => includes, :conditions => conditions.join(" AND ")}
+    end
+
+    module CommonInstanceMethods
+      # Methods below this point are only to be used internally by Offroad
+      # However, making all of them private would make using them from elsewhere troublesome
+      
+      # TODO Should put common save and destroy wrappers in here, with access to a method that checks if SRS needed
+      # TODO That method should also be used in import_model_cargo instead of explicitly trying to find the srs
+      
+      #:nodoc:#
+      def validate_changed_id_columns
+        changes.each do |colname, arr|
+          orig_val = arr[0]
+          new_val = arr[1]
+          
+          raise DataError.new("Cannot change id of offroad-tracked records (orig #{orig_val.inspect}, new #{new_val.inspect}") if colname == self.class.primary_key && orig_val != nil
+          
+          # FIXME : Use association reflection instead
+          next unless colname.end_with? "_id"
+          accessor_name = colname[0, colname.size-3]
+          next unless respond_to? accessor_name
+          obj = send(accessor_name)
+          
+          raise DataError.new("Mirrored data cannot hold a foreign key to unmirrored data") unless obj.class.acts_as_offroadable?
+          
+          if !new_record? and offroad_mode == :group_owned and colname == offroad_parent_assoc.primary_key_name
+            # obj is our parent
+            # FIXME: What if we can't find orig_val?
+            if obj.owning_group != obj.class.find(orig_val).owning_group
+              raise DataError.new("Group-owned data cannot be transferred between groups")
+            end
+          end
+
+          if self.class.offroad_group_data?
+            if obj.class.offroad_group_data? && obj.owning_group && obj.owning_group.id != owning_group.id
+              raise DataError.new("Invalid #{colname}: Group data cannot hold a foreign key to data owned by another group")
+            end
+          elsif self.class.offroad_global_data?
+            unless obj.class.offroad_global_data?
+              raise DataError.new("Invalid #{colname}: Global mirrored data cannot hold a foreign key to group data")
+            end
+          end
+        end
+      end
+      
+    end
+    
+    module GlobalDataInstanceMethods
+      # Methods below this point are only to be used internally by Offroad
+      # However, marking all of them private would make using them from elsewhere troublesome
+
+      def locked_by_offroad?
+        Offroad::app_offline?
+      end
+      
+      #:nodoc#
+      def before_mirrored_data_destroy
+        raise ActiveRecord::ReadOnlyRecord if locked_by_offroad?
+        return true
+      end
+      
+      #:nodoc#
+      def after_mirrored_data_destroy
+        Offroad::SendableRecordState::note_record_destroyed(self) if Offroad::app_online?
+        return true
+      end
+      
+      #:nodoc#
+      def before_mirrored_data_save
+        raise ActiveRecord::ReadOnlyRecord if locked_by_offroad?
+        validate_changed_id_columns
+        return true
+      end
+      
+      #:nodoc#
+      def after_mirrored_data_save
+        Offroad::SendableRecordState::note_record_created_or_updated(self) if Offroad::app_online? && changed?
+        return true
+      end
+    end
+    
+    module GroupDataInstanceMethods
+      def locked_by_offroad?
+        return true if Offroad::app_online? && group_offline?
+        return true if Offroad::app_offline? && (!group_state || group_state.group_locked?)
+        return false
+      end
+
+      # If called on a group_owned_model, methods below bubble up to the group_base_model
+
+      def offroad_group_lock!
+        raise DataError.new("Cannot lock groups from online app") if Offroad::app_online?
+        group_state.update_attribute(:group_locked, true)
+      end
+      
+      # Returns a hash with the latest information about this group in the offline app
+      def last_known_status
+        raise DataError.new("This method is only for offline groups") if group_online?
+        s = group_state
+        fields_of_interest = [
+          :last_installer_downloaded_at,
+          :last_installation_at,
+          :last_down_mirror_created_at,
+          :last_down_mirror_loaded_at,
+          :last_up_mirror_created_at,
+          :last_up_mirror_loaded_at,
+          :launcher_version,
+          :app_version,
+          :operating_system
+        ]
+        return fields_of_interest.map {|field_name| s.send(field_name)}
+      end
+      
+      def group_offline?
+        not group_online?
+      end
+      
+      def group_online?
+        return group_state.nil?
+      end
+      
+      def group_offline=(b)
+        raise DataError.new("Unable to change a group's offline status in offline app") if Offroad::app_offline?
+
+        if b and Offroad::group_single_models.size > 0 and Offroad::GroupState.count > 0
+          raise DataError.new("Unable to set more than one group offline if there are any group single models")
+        end
+
+        if b && !group_state
+          Offroad::GroupState.for_group(owning_group).create!
+        elsif group_state
+          group_state.destroy
+        end
+      end
+      
+      def owning_group
+        return nil if unlocked_group_single_record?
+        return Offroad::GroupState.first.app_group if offroad_mode == :group_single
+
+        # Recurse upwards until we get to the group base
+        if self.class.offroad_group_base?
+          return self
+        else
+          parent = send(offroad_parent_assoc.name)
+          if parent
+            return parent.owning_group
+          else
+            return nil
+          end
+        end
+      end
+      
+      # Methods below this point are only to be used internally by Offroad
+      # However, marking them private makes using them from elsewhere troublesome
+      
+      #:nodoc#
+      def before_mirrored_data_destroy
+        if group_offline? && offroad_mode == :group_base
+          group_state.update_attribute(:group_being_destroyed, true)
+        end
+        
+        return true if unlocked_group_single_record?
+        
+        if locked_by_offroad?
+          # The only thing that can be deleted is the entire group (possibly with its dependent records), and only if we're online
+          raise ActiveRecord::ReadOnlyRecord unless Offroad::app_online? and (offroad_mode == :group_base or group_being_destroyed)
+        end
+        
+        # If the app is offline, the only thing that CAN'T be deleted even if unlocked is the group
+        raise ActiveRecord::ReadOnlyRecord if Offroad::app_offline? and offroad_mode == :group_base
+        
+        return true
+      end
+      
+      #:nodoc#
+      def after_mirrored_data_destroy
+        Offroad::SendableRecordState::note_record_destroyed(self) if Offroad::app_offline?
+        Offroad::GroupState::note_group_destroyed(self) if group_offline? && offroad_mode == :group_base
+        return true
+      end
+      
+      #:nodoc#
+      def before_mirrored_data_save
+        return true if unlocked_group_single_record?
+        
+        raise DataError.new("Invalid owning group") unless owning_group
+        
+        if Offroad::app_offline?
+          case offroad_mode
+          when :group_base
+            raise DataError.new("Cannot create groups in offline mode") if new_record?
+          when :group_owned
+            raise DataError.new("Owning group must be the offline group") if owning_group != Offroad::offline_group
+          end
+        end
+        
+        validate_changed_id_columns
+        
+        raise ActiveRecord::ReadOnlyRecord if locked_by_offroad?
+        
+        return true
+      end
+      
+      #:nodoc#
+      def after_mirrored_data_save
+        Offroad::SendableRecordState::note_record_created_or_updated(self) if Offroad::app_offline? && changed?
+        return true
+      end
+      
+      #:nodoc#
+      def group_state
+        Offroad::GroupState.for_group(owning_group).first
+      end
+      
+      #:nodoc:#
+      def group_being_destroyed
+        return true unless owning_group # If the group doesn't exist anymore, then it's pretty well destroyed
+        return group_state.group_being_destroyed
+      end
+
+      #:nodoc:#
+      def unlocked_group_single_record?
+        offroad_mode == :group_single && Offroad::GroupState.count == 0
+      end
+    end
+
+    module HoboPermissionsInstanceMethods
+      private
+
+      def pre_check_passed?(method_name)
+        begin
+          send(method_name)
+        rescue ActiveRecord::ReadOnlyRecord
+          return false
+        rescue Offroad::DataError
+          return false
+        end
+        return true
+      end
+    end
+  end
+end

data/lib/module_funcs.rb

@@ -0,0 +1,94 @@
+module Offroad
+  @@app_online_flag = nil
+  @@group_base_model = nil
+  @@global_data_models = {}
+  @@group_owned_models = {}
+  @@group_single_models = {}
+  
+  # Used in the environment configuration file to set the app to online or offline mode.
+  # This should not be called from within the app.
+  def self.config_app_online(flag)
+    @@app_online_flag = flag
+  end
+  
+  # Returns true if the app is in offline mode (running on a local system without access to the main server)
+  def self.app_offline?
+    not app_online?
+  end
+  
+  # Returns true if the app is in online mode (or in other words, this is the main server)
+  def self.app_online?
+    case @@app_online_flag
+      when true then true
+      when false then false
+      else raise AppModeUnknownError.new
+    end
+  end
+  
+  # Returns a Time that identifies the version of the app
+  # Specifically, the modification timestamp (on the online app) of the most recently modified source file in the app
+  def self.app_version
+    # TODO Implement
+    # Online - When app is launched, scan all application files, returns the Time of the most recently changed file
+    # Offline - Based on the app version noted in the last down-mirror file successfully loaded
+    return 1
+  end
+  
+  #:nodoc#
+  def self.init
+    @@config = YAML.load_file(File.join(RAILS_ROOT, "config", "offroad.yml"))
+  end
+  
+  # Returns the record of the group base model that this app is in charge of
+  # This is only applicable if the app is offline
+  def self.offline_group
+    raise PluginError.new("'Offline group' is only meaningful if the app is offline") unless app_offline?
+    group_base_model.first
+  end
+  
+  private
+  
+  def self.online_url
+    @@config[:online_url] or raise PluginError.new("No online url specified in offroad config")
+  end
+  
+  def self.app_name
+    @@config[:app_name] or raise PluginError.new("No app name specified in offroad config")
+  end
+  
+  def self.note_global_data_model(cls)
+    @@global_data_models[cls.name] = cls
+  end
+  
+  def self.global_data_models
+    @@global_data_models
+  end
+  
+  def self.note_group_base_model(cls)
+    if @@group_base_model and @@group_base_model.to_s != cls.to_s
+      raise ModelError.new("You can only define one group base model")
+    end
+    @@group_base_model = cls
+  end
+  
+  def self.group_base_model
+    raise ModelError.new("No group base model was specified") unless @@group_base_model
+    @@group_base_model
+  end
+  
+  def self.note_group_owned_model(cls)
+    @@group_owned_models[cls.name] = cls
+  end
+  
+  def self.group_owned_models
+    @@group_owned_models
+  end
+  
+  def self.note_group_single_model(cls)
+    @@group_single_models[cls.name] = cls
+  end
+  
+  def self.group_single_models
+    @@group_single_models
+  end
+end

data/lib/offroad.rb

@@ -0,0 +1,30 @@
+# Offroad
+
+require 'version'
+require 'module_funcs'
+require 'cargo_streamer'
+require 'exceptions'
+require 'mirror_data'
+
+path = File.join(File.dirname(__FILE__), 'app', 'models')
+$LOAD_PATH << path
+ActiveSupport::Dependencies.autoload_paths << path
+
+require 'ar-extensions' # External dependency
+
+require 'controller_extensions'
+class ActionController::Base
+  extend Offroad::ControllerExtensions
+end
+
+require 'model_extensions'
+class ActiveRecord::Base
+  extend Offroad::ModelExtensions
+end
+
+require 'view_helper'
+class ActionView::Base
+  include Offroad::ViewHelper
+end
+
+Offroad::init

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Offroad
+  VERSION = "0.0.1"
+end

data/lib/view_helper.rb

@@ -0,0 +1,7 @@
+module Offroad
+  module ViewHelper
+    def link_to_online_app(name = nil)
+      link_to(name ? name : Offroad::online_url, Offroad::online_url)
+    end
+  end
+end

data/templates/offline.rb

@@ -0,0 +1,36 @@
+# This file defines the offline envrionment
+# "Offline" means that the application is running on a local network, with only a subset of the real online app's data
+# It is implemented by the gem Offroad 
+
+# Settings specified here will take precedence over those in config/environment.rb
+
+# Use the offline database configuration file instead of the regular one
+config.database_configuration_file = "config/offline_database.yml"
+
+# Code is not reloaded between requests
+config.cache_classes = true
+
+# Full error reports are disabled and caching is turned on
+config.action_controller.consider_all_requests_local = false
+config.action_controller.perform_caching             = true
+config.action_view.cache_template_loading            = true
+
+# See everything in the log (default is :info)
+# config.log_level = :debug
+
+# Use a different logger for distributed setups
+# config.logger = SyslogLogger.new
+
+# Use a different cache store in production
+# config.cache_store = :mem_cache_store
+
+# Enable serving of images, stylesheets, and javascripts from an asset server
+# config.action_controller.asset_host = "http://assets.example.com"
+
+# Disable delivery errors, bad email addresses will be ignored
+# config.action_mailer.raise_delivery_errors = false
+
+# Enable threaded mode
+# config.threadsafe!
+
+Offroad::config_app_online(false)

data/templates/offline_database.yml

@@ -0,0 +1,7 @@
+# This database config file is used by the 'offline' environment
+
+offline:
+  adapter: sqlite3
+  database: db/offline.sqlite3
+  pool: 5
+  timeout: 5000

data/templates/offroad.yml

@@ -0,0 +1,6 @@
+# Configuration for Offroad
+# :online_url: The URL for the regular online version of the app 
+# :app_name: The name of the application, to be used in helpful messages in the generated mirror data files.
+
+:online_url: "http://example.com"
+:app_name: Example Application

data/test/app_root/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/test/app_root/app/controllers/group_controller.rb

@@ -0,0 +1,28 @@
+class GroupController < ApplicationController
+  offroad_group_controller
+
+  def download_down_mirror
+    render_down_mirror_file Group.find(params[:id]), "down-mirror-file", :layout => "mirror"
+  end
+  
+  def download_initial_down_mirror
+    render_down_mirror_file Group.find(params[:id]), "down-mirror-file", :layout => "mirror", :initial_mode => true
+  end
+  
+  def download_up_mirror
+    render_up_mirror_file Group.find(params[:id]), "up-mirror-file", :layout => "mirror"
+  end
+  
+  def upload_up_mirror
+    load_up_mirror_file Group.find(params[:id]), params[:mirror_data]
+  end
+  
+  def upload_down_mirror
+    load_down_mirror_file Group.find(params[:id]), params[:mirror_data]
+  end
+  
+  def upload_initial_down_mirror
+    load_down_mirror_file nil, params[:mirror_data], :initial_mode => true
+    render :upload_down_mirror
+  end
+end

data/test/app_root/app/models/global_record.rb

@@ -0,0 +1,10 @@
+class GlobalRecord < ActiveRecord::Base
+  include CommonHobo if HOBO_TEST_MODE
+  acts_as_offroadable :global
+  validates_presence_of :title
+  belongs_to :unmirrored_record
+  belongs_to :some_group, :class_name => "Group"
+  belongs_to :friend, :class_name => "GlobalRecord"
+  validates_numericality_of :should_be_odd, :odd => true
+  attr_protected :protected_integer
+end

data/test/app_root/app/models/group.rb

@@ -0,0 +1,12 @@
+class Group < ActiveRecord::Base
+  include CommonHobo if HOBO_TEST_MODE
+  acts_as_offroadable :group_base
+  validates_presence_of :name
+  has_many :group_owned_records, :dependent => :destroy
+  belongs_to :favorite, :class_name => "GroupOwnedRecord"
+  belongs_to :unmirrored_record
+  belongs_to :global_record
+  def to_s
+    name
+  end
+end

data/test/app_root/app/models/group_owned_record.rb

@@ -0,0 +1,68 @@
+class GroupOwnedRecord < ActiveRecord::Base
+  include CommonHobo if HOBO_TEST_MODE
+  belongs_to :group
+  acts_as_offroadable :group_owned, :parent => :group
+
+  belongs_to :parent, :class_name => "GroupOwnedRecord"
+  belongs_to :unmirrored_record
+  belongs_to :global_record
+  has_many :children, :foreign_key => "parent_id", :class_name => "GroupOwnedRecord"
+  has_many :subrecords
+  validates_presence_of :description, :group
+  validates_numericality_of :should_be_even, :even => true
+  attr_protected :protected_integer
+
+  def to_s
+    description
+  end
+
+  def before_save
+    @@callback_called = true
+  end
+
+  def after_save
+    @@callback_called = true
+  end
+
+  def before_destroy
+    @@callback_called = true
+  end
+
+  def after_destroy
+    @@callback_called = true
+  end
+
+  def self.reset_callback_called
+    @@callback_called = false
+  end
+
+  def self.callback_called
+    @@callback_called
+  end
+
+  def after_offroad_upload
+    @@after_upload_count ||= 0
+    @@after_upload_count += 1
+  end
+
+  def self.reset_after_upload_count
+    @@after_upload_count = 0
+  end
+
+  def self.after_upload_count
+    @@after_upload_count
+  end
+  
+  def after_offroad_destroy
+    @@after_destroy_count ||= 0
+    @@after_destroy_count += 1
+  end
+
+  def self.reset_after_destroy_count
+    @@after_destroy_count = 0
+  end
+
+  def self.after_destroy_count
+    @@after_destroy_count
+  end
+end