activerecord-archiver 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0bea1df0fa0ebd3cdf2f49f5c2773357810a8dc6
+  data.tar.gz: d2153f6d8ff024cce3bdbcc71df74db5acb99d2f
+SHA512:
+  metadata.gz: f9aec4a4adccee5eba5488e7947323a51ac97e7c18395ff02d2a1cd0ac8bd7b7ae6d1fee25e8fe2f37fbd1af892494d20b4aad62037a5ec8fea5530ad65d37cf
+  data.tar.gz: 2f3fb76e833265d4a63e194fb710811f7f334748e50026916f23c71cff36a015cdea4b153542883d0bc2e47e0ee7a79c26c21143cc2354f778d5df0b9f714670

data/lib/activerecord-archiver/archiver.rb

@@ -0,0 +1,79 @@
+class ActiveRecordArchiver
+  def self.has_attribute? model, attribute
+    model.columns_hash.with_indifferent_access.has_key? attribute
+  end
+  
+  def self.relation model, attribute
+    model.reflections.with_indifferent_access[attribute]
+  end
+  
+  def self.relation_model model, attribute
+    relation(model, attribute).class_name.constantize
+  end
+  
+  def self.belongs_to? model, attribute
+    !!relation(model, attribute).try(:belongs_to?)
+  end
+  
+  def self.column model, attribute
+    model.columns_hash.with_indifferent_access[attribute]
+  end
+  
+  def self.column_required model, attribute
+    column(model, attribute).null == false
+  end
+  
+  def self.relation_index record, attribute
+    relevant_records = @models_hash[relation_model(record.class, attribute)].first
+    relevant_records.present? && relevant_records.index(record.send(attribute))
+  end
+  
+  def self.relation_id model, key, value
+    relation_model_name = relation(model, key).class_name
+    @data[relation_model_name][value][:id]
+  end
+  
+  def self.relation_foreign_key model, key
+    relation(model, key).foreign_key
+  end
+  
+  def self.insertable_hash model, hash
+    ret = {}
+    hash.each_pair do |key, value|
+      if column(model, key)
+        ret[column(model, key)] = value
+      elsif belongs_to?(model, key)
+        foreign_key = relation_foreign_key(model, key)
+        if !hash.include?(foreign_key) and column_required(model, foreign_key)
+          # if the foreign key is required connect it to the first available record temporarily
+          ret[column(model, foreign_key)] = relation_model(model, key).first.id
+        end
+      else
+        raise "#{key} is not an attribute or belongs_to relation of #{model}"
+      end
+    end
+    ret
+  end
+  
+  def self.relations_update_hash(model, record)
+    ret = {}
+    record.each_pair do |key, value|
+      if belongs_to?(model, key)
+        ret[relation_foreign_key(model, key)] = relation_id(model, key, value)
+      end
+    end
+    ret.presence
+  end
+  
+  def self.assert_instance_of instance, klass
+    unless instance.class <= klass
+      raise "Object #{instance} is not an instance of the #{klass} model"
+    end
+  end
+  
+  def self.assert_model model
+    unless model < ActiveRecord::Base
+      raise "#{model} is not an activerecord model"
+    end
+  end
+end

data/lib/activerecord-archiver/export.rb

@@ -0,0 +1,86 @@
+=begin
+
+method ActiveRecordArchiver::export
+
+Arguments:
+  A hash with ActiveRecord Model classes as keys and Array pairs for values.
+  The first element of each value is an iterable of ActiveRecord Record instances and
+  the second element of each value is an iterable of attribute keys and belongs_to relations.
+  Whenever a belongs relation is specified ActiveRecordArchiver will check whether the related
+  record is also included in this export and raise an Exception if it is not.
+  If it is included then it will be specified in the output as an index into the relevant array.
+
+Returns:
+  A string of serialized JSON that contains the specified data including relations
+
+Example:
+  # model definition
+  class Node < ActiveRecord::Base
+    # has attributes :name, and :next_id
+    belongs_to :next, :class_name => 'Node'
+  end
+  
+  # create a cycle of nodes
+  nodes = [ Node.create(:name => 'a'),
+            Node.create(:name => 'b'),
+            Node.create(:name => 'c') ]
+  nodes[0].update_attribute :next_id, nodes[1].id
+  nodes[1].update_attribute :next_id, nodes[2].id
+  nodes[2].update_attribute :next_id, nodes[0].id
+  
+  # export
+  json = ActiveRecordArchiver.export Node => [nodes, [:name, :next]]
+  
+  # json is '{"Node":[{"name":"a","next":1},{"name":"b","next":2},{"name":"c","next":0}]}'
+
+=end
+
+class ActiveRecordArchiver
+  def self.export models_hash
+    
+    @models_hash = models_hash
+    
+    result = {}
+    
+    # serialize
+    @models_hash.each_pair do |model, pair|
+      records, attributes = pair
+      
+      result[model.to_s] = []
+      records.each do |record|
+        
+        assert_instance_of record, model
+        
+        rec = {}
+        attributes.each do |attribute|
+          attribute, placeholder = if attribute.is_a? Array
+                                   then attribute
+                                   else [attribute, nil] end
+          
+          if has_attribute? model, attribute
+            # store attribute
+            rec[attribute] = if placeholder.nil?
+                             then record.send attribute
+                             else placeholder end
+          elsif belongs_to?(model, attribute)
+            # store relation
+            if (index = relation_index(record, attribute))
+              rec[attribute] = index
+              if placeholder
+                rec[relation_foreign_key(model, attribute)] = placeholder
+              end
+            else
+              raise "#{record} belongs_to #{attribute} which is not included in the export"
+            end
+          else
+            raise "#{attribute} is not an attribute or belongs_to relation of #{model}"
+          end
+        end
+        result[model.to_s] << rec
+      end
+    end
+    
+    # encode
+    JSON.dump result
+  end
+end

data/lib/activerecord-archiver/import.rb

@@ -0,0 +1,51 @@
+=begin
+
+method ActiveRecordArchiver::import
+
+Arguments:
+  A string of JSON generated by ActiveRecordArchiver::export
+
+Returns:
+  true on success, raises an Exception and rolls back the db on failure
+
+Effects:
+  Attempts to create and save a new record for each item in the input JSON structure and
+  connects the specified belongs_to relations
+
+=end
+
+class ActiveRecordArchiver
+  def self.import json
+    
+    @data = JSON.parse json
+    
+    ActiveRecord::Base.transaction do
+      
+      # insert records
+      @data.each_pair do |model_name, records|
+        model = model_name.constantize
+        
+        assert_model model
+        
+        records.each do |record|
+          record[:id] = model.all.insert(insertable_hash(model, record))
+        end
+      end
+      
+      # add relations
+      @data.each_pair do |model_name, records|
+        model = model_name.constantize
+        
+        records.each do |record|
+          if (update_hash = relations_update_hash(model, record))
+            instance = model.find(record[:id])
+            instance.update update_hash
+          end
+        end
+      end
+      
+    end
+    
+    true
+  end
+end

data/lib/activerecord-archiver.rb

@@ -0,0 +1,3 @@
+require_relative 'activerecord-archiver/archiver'
+require_relative 'activerecord-archiver/export'
+require_relative 'activerecord-archiver/import'

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-archiver
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Sam Auciello
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-05 00:00:00.000000000 Z
+dependencies: []
+description: |
+  ActiveRecord-Archiver is a simple tool for taking a subset of the records in one environment
+  and exporting them for use in another environment.
+
+  Design Constraints:
+  - leave out ids so as not to create collisions in the new environment
+  - preserve relations between records
+  - Allow for cyclic relationships
+email: sam@greenriver.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/activerecord-archiver.rb
+- lib/activerecord-archiver/archiver.rb
+- lib/activerecord-archiver/export.rb
+- lib/activerecord-archiver/import.rb
+homepage: https://github.com/greenriver/activerecord-archiver
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: A simle tool for exporting/importing subsets of activerecord tables as JSON.
+test_files: []