portable_model 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in portable_model.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,7 @@
+= PortableModel
+
+Include +PortableModel+ in any +ActiveRecord+ model to enable exporting and
+importing the model's records.
+
+Author::  Clyde Law (mailto:claw@alum.mit.edu)
+License:: Released under the MIT license

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/portable_model/active_record.rb

@@ -0,0 +1,102 @@
+# Enables exporting and importing ActiveRecord associations of ActiveRecord
+# models that include PortableModel.
+#
+module ActiveRecord::Associations
+
+  class NotPortableError < StandardError
+
+    def initialize(assoc)
+      super("#{assoc.proxy_reflection.name}:#{assoc.proxy_reflection.klass.name} is not portable")
+    end
+
+    class << self
+
+      def raise_on_not_portable(assoc)
+        raise NotPortableError.new(assoc) unless assoc.proxy_reflection.klass.include?(PortableModel)
+      end
+
+    end
+
+  end
+
+  class AssociationProxy
+
+    # Export the association to a YAML file.
+    #
+    def export_to_yml(filename)
+      NotPortableError.raise_on_not_portable(self)
+
+      Pathname.new(filename).open('w') do |out|
+        YAML::dump(export_portable_association, out)
+      end
+    end
+
+    # Import the association from a YAML file.
+    #
+    def import_from_yml(filename)
+      NotPortableError.raise_on_not_portable(self)
+      import_portable_association(YAML::load_file(filename))
+    end
+
+  protected
+
+    # Used to make sure that imported records are associated with the
+    # association owner.
+    #
+    def primary_key_hash
+      { proxy_reflection.primary_key_name.to_s => proxy_owner.id }
+    end
+
+  end
+
+  class HasOneAssociation
+
+    # Export the association to a hash.
+    #
+    def export_portable_association
+      NotPortableError.raise_on_not_portable(self)
+      export_to_hash
+    end
+
+    # Import the association from a hash.
+    #
+    def import_portable_association(record_hash)
+      NotPortableError.raise_on_not_portable(self)
+      raise ArgumentError.new('specified argument is not a hash') unless record_hash.is_a?(Hash)
+
+      proxy_owner.transaction do
+        if target.nil?
+          assoc_record = proxy_reflection.klass.import_from_hash(record_hash.merge(primary_key_hash))
+          replace(assoc_record)
+        else
+          raise 'cannot replace existing association record'
+        end
+      end
+    end
+
+  end
+
+  class HasManyAssociation
+
+    # Export the association to an array of hashes.
+    #
+    def export_portable_association
+      NotPortableError.raise_on_not_portable(self)
+      map(&:export_to_hash)
+    end
+
+    # Import the association from an array of hashes.
+    #
+    def import_portable_association(record_hashes)
+      NotPortableError.raise_on_not_portable(self)
+      raise ArgumentError.new('specified argument is not an array of hashes') unless record_hashes.is_a?(Array) && record_hashes.all? { |record_hash| record_hash.is_a?(Hash) }
+
+      proxy_owner.transaction do
+        assoc_records = record_hashes.map { |record_hash| proxy_reflection.klass.import_from_hash(record_hash.merge(primary_key_hash)) }
+        concat(*assoc_records)
+      end
+    end
+
+  end
+
+end

data/lib/portable_model/version.rb

@@ -0,0 +1,3 @@
+module PortableModel
+  VERSION = "0.1.0"
+end

data/lib/portable_model.rb

@@ -0,0 +1,151 @@
+require 'portable_model/version'
+require 'portable_model/active_record'
+
+# Include PortableModel in any ActiveRecord model to enable exporting and
+# importing the model's records.
+#
+module PortableModel
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Export the record to a hash.
+  #
+  def export_to_hash
+    # Export portable attributes.
+    record_hash = self.class.portable_attributes.inject({}) do |hash, attr_name|
+      hash[attr_name] = attributes[attr_name]
+      hash
+    end
+
+    # Include the exported attributes of portable associations.
+    self.class.portable_associations.inject(record_hash) do |hash, assoc_name|
+      assoc = self.__send__(assoc_name)
+      hash[assoc_name] = assoc.export_portable_association if assoc
+      hash
+    end
+
+    record_hash
+  end
+
+  # Export the record to a YAML file.
+  #
+  def export_to_yml(filename)
+    Pathname.new(filename).open('w') do |out|
+      YAML::dump(export_to_hash, out)
+    end
+  end
+
+  # Export values from the record's association.
+  #
+  def export_from_association(assoc_name)
+    self.__send__(assoc_name).export_portable_association
+  end
+
+  # Import values into the record's association.
+  #
+  def import_into_association(assoc_name, assoc_value)
+    assoc = self.__send__(assoc_name)
+    if assoc
+      assoc.import_portable_association(assoc_value)
+    else
+      assoc_reflection = self.class.reflect_on_association(assoc_name.to_sym)
+      raise 'nil can only be handled for direct has_one associations' unless assoc_reflection.macro == :has_one && !assoc_reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      assoc = ActiveRecord::Associations::HasOneAssociation.new(self, assoc_reflection)
+      assoc.import_portable_association(assoc_value)
+      association_instance_set(assoc_reflection.name, assoc.target.nil? ? nil : assoc)
+    end
+  end
+
+  module ClassMethods
+
+    # Import a record from a hash.
+    #
+    def import_from_hash(record_hash)
+      raise ArgumentError.new('specified argument is not a hash') unless record_hash.is_a?(Hash)
+
+      # Override any necessary attributes before importing.
+      record_hash = record_hash.merge(overridden_imported_attrs)
+
+      transaction do
+        if (columns_hash.include?(inheritance_column) &&
+            (record_type_name = record_hash[inheritance_column.to_s]) &&
+            !record_type_name.blank? &&
+            record_type_name != sti_name)
+          # The model implements STI and the record type points to a different
+          # class; call the method in that class instead.
+          return compute_type(record_type_name).import_from_hash(record_hash)
+        end
+
+        # First split out the attributes that correspond to portable
+        # associations.
+        assoc_attrs = portable_associations.inject({}) do |hash, assoc_name|
+          hash[assoc_name] = record_hash.delete(assoc_name) if record_hash.has_key?(assoc_name)
+          hash
+        end
+
+        # Create a new record.
+        record = create!(record_hash)
+
+        # Import each of the record's associations into the record.
+        assoc_attrs.each do |assoc_name, assoc_value|
+          record.import_into_association(assoc_name, assoc_value)
+        end
+
+        record
+      end
+    end
+
+    # Export a record from a YAML file.
+    #
+    def import_from_yml(filename, additional_attrs = {})
+      record_hash = YAML::load_file(filename)
+      import_from_hash(record_hash.merge(additional_attrs))
+    end
+
+    # Returns the names of portable attributes, which are any attributes that
+    # are not primary or foreign keys.
+    #
+    def portable_attributes
+      columns.reject do |column|
+        # TODO: Consider rejecting counter_cache columns as well; this will involve retrieving a has_many association's corresponding belongs_to association to retrieve its counter_cache_column.
+        column.primary || column.name.in?(reflect_on_all_associations(:belongs_to).map(&:association_foreign_key))
+      end.map(&:name).map(&:to_s)
+    end
+
+    # Returns names of portable associations, which are has_one and has_many
+    # associations that do not go through other associations and that also
+    # include PortableModel.
+    #
+    # Because has_and_belongs_to_many associations are bi-directional, they are
+    # not portable.
+    #
+    def portable_associations
+      reflect_on_all_associations.select do |assoc_reflection|
+        assoc_reflection.macro.in?([:has_one, :has_many]) &&
+          !assoc_reflection.is_a?(ActiveRecord::Reflection::ThroughReflection) &&
+          assoc_reflection.klass.include?(PortableModel)
+      end.map(&:name).map(&:to_s)
+    end
+
+  protected
+
+    # Overrides the specified attributes whenever a record is imported.
+    #
+    def override_attributes_on_import(attrs)
+      attrs.inject(overridden_imported_attrs) do |overridden_attrs, (attr_name, attr_value)|
+        overridden_attrs[attr_name.to_s] = attr_value
+        overridden_attrs
+      end
+    end
+
+  private
+
+    def overridden_imported_attrs
+      @overridden_imported_attrs ||= {}
+    end
+
+  end
+
+end

data/portable_model.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "portable_model/version"
+
+Gem::Specification.new do |s|
+  s.name        = "portable_model"
+  s.version     = PortableModel::VERSION
+  s.authors     = ["Clyde Law"]
+  s.email       = ["claw@alum.mit.edu"]
+  s.homepage    = %q{http://github.com/Umofomia/portable_model}
+  s.summary     = %q{Enables exporting and importing an ActiveRecord model's records.}
+  s.description = %q{Enables exporting and importing an ActiveRecord model's records.}
+
+  s.add_dependency('activerecord',  '>= 2.3.8')
+
+  s.rubyforge_project = "portable_model"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: portable_model
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Clyde Law
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 3
+        - 8
+        version: 2.3.8
+  type: :runtime
+  version_requirements: *id001
+description: Enables exporting and importing an ActiveRecord model's records.
+email: 
+- claw@alum.mit.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/portable_model.rb
+- lib/portable_model/active_record.rb
+- lib/portable_model/version.rb
+- portable_model.gemspec
+has_rdoc: true
+homepage: http://github.com/Umofomia/portable_model
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: portable_model
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Enables exporting and importing an ActiveRecord model's records.
+test_files: []
+