active_archiver 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bcef705dfea7f0005f7b7eb59cce1cd6cd934704
-  data.tar.gz: d1f50fd1bf33c9ae919a94716dd9a70334d31508
+  metadata.gz: e1aa60b9ed13c4fcec274ab0ba54ae740c8c6761
+  data.tar.gz: 27d6f63c609c7da615408b3d6fecacdc81011f39
 SHA512:
-  metadata.gz: 1f257ece53dd33750e37b8201878b6a59baf1d10df61420a4f9b9e3dc8d64c12f9b1d6bc03a70b9f63398b639f4b5222dab457aabfafe822d6f0212b2d423411
-  data.tar.gz: 6f841954a95e45166e5b7f6004685f61f80b947ca67aea2b614c1cdb98b71b13d2ea8b1986552b698d458392a4071140725959d72fcee8b9f77fbff362aaba89
+  metadata.gz: 99ad9501c2e3ae9f11633b3a5eae1eb2e69ce7367fdb129aeb3d91ec9612071063ffc4f7f00e50def88baa114dfccc1f5057336f0dd6e2a198713ea84fbb6bfd
+  data.tar.gz: 6d880ec17fe0b46e38cc97556b531f80fe73a7a526a44c3d653735e584d162060a5b51527a1ad6046fcedd9661586ef4e70e1d854bfd2828ecd4663f462895a3

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.2

data/Gemfile

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

data/README.md

@@ -0,0 +1,111 @@
+# ActiveArchiver
+
+Provide export / import to ActiveRecord and support CarrierWave.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_archiver', github:'zaru/active_archiver'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+### sample code
+
+```
+export = User.find(1).export
+
+User.find(1).destroy
+User.find(1)
+=> ActiveRecord::RecordNotFound: Couldn't find User with 'id'=1
+
+User.import(export)
+User.find(1)
+=> #<User id: 1, ...>
+```
+
+### export
+
+Returns the specified model object as a hash. Images uploaded with CarrierWave are encoded in Base64.
+
+```ruby
+export = User.last.export
+
+=> {:attributes=>
+  {"id"=>3,
+   "last_name"=>"hoge",
+   "first_name"=>"piyo",
+   "email"=>"hogepiyo@example.com",
+   "created_at"=>Sun, 06 Nov 2016 21:04:11 JST +09:00,
+   "updated_at"=>Tue, 22 Nov 2016 12:16:28 JST +09:00},
+ :associations=>[]}
+```
+
+If you want to export related models as well
+
+```ruby
+export = User.last.export(includes: [:photos])
+
+=> {:attributes=>
+  {"id"=>3,
+   "last_name"=>"hoge",
+   "first_name"=>"piyo",
+   "email"=>"hogepiyo@example.com",
+   "created_at"=>Sun, 06 Nov 2016 21:04:11 JST +09:00,
+   "updated_at"=>Tue, 22 Nov 2016 12:16:28 JST +09:00},
+ :associations=>
+   [{:model_name=>"Photo",
+     :association_name=>:photos,
+     :attributes=>
+      {"id"=>57,
+       "user_id"=>3,
+       "image"=>
+        {:url=>"https://example.com/uploads/hoge.png",
+         :file_name=>"hoge.png",
+         :blob=>
+          "data:image/png;base64,iVBORw...
+```
+
+To specify a nested model.
+
+```
+class User < ApplicationRecord
+  has_many :photos
+  has_many :pets
+end
+
+class Pet < ApplicationRecord
+  has_many :pet_photos
+end
+```
+
+```
+export = User.last.export(includes: [:photos, pets:[:pet_photos]])
+```
+
+### import
+
+```
+User.import(export)
+```
+
+### archive
+
+Write the temporary file.
+
+```
+Hoge.find(1).archive
+
+=> #<File:/tmp/20161125-12571-ak10w5.json (closed)>
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zaru/active_archiver.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/active_archiver.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_archiver/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_archiver"
+  spec.version       = ActiveArchiver::VERSION
+  spec.authors       = ["zaru"]
+  spec.email         = ["zarutofu@gmail.com"]
+
+  spec.summary       = %q{Provide export / import to ActiveRecord}
+  spec.description   = %q{Provide export / import to ActiveRecord}
+  spec.homepage      = "https://github.com/zaru/active_archiver"
+  
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 4"
+  spec.add_dependency "activesupport", ">= 4"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "active_archiver"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/active_archiver.rb

@@ -0,0 +1,11 @@
+require "active_archiver/version"
+require "carrierwave/serialization"
+require "active_archiver/base64_decode"
+require "active_archiver/active_record_ext"
+
+module ActiveArchiver
+end
+
+ActiveSupport.on_load :active_record do
+  ActiveRecord::Base.include(ActiveArchiver::ActiveRecordExt)
+end

data/lib/active_archiver/active_record_ext.rb

@@ -0,0 +1,99 @@
+module ActiveArchiver
+  module ActiveRecordExt
+
+    def self.included(model)
+      model.extend ClassMethods
+    end
+
+    def export(includes: [])
+      CarrierWave::Uploader::Base.active_archiver_blob_data = true
+      hash = {}
+      hash[:attributes] = self.serializable_hash
+      hash[:associations] = []
+      hash = recursive_export(hash, self, includes)
+      CarrierWave::Uploader::Base.active_archiver_blob_data = false
+      hash
+    end
+
+    def archive(includes: [], basename: ["", ".json"], dir: Dir.tmpdir)
+      Tempfile.open(basename, dir) do |fp|
+        fp.puts export(includes: includes).to_json
+        fp
+      end
+    end
+
+    private
+
+    def recursive_export(hash, receiver, models)
+      case models
+        when Array
+          models.each do |v|
+            recursive_export(hash, receiver, v)
+          end
+        when Hash
+          models.each do |k,v|
+            recursive_export(hash, receiver, k)
+            recursive_export(hash, receiver.send(k), v)
+          end
+        else
+          if receiver.respond_to?(:class_name)
+            receiver.each do |rec|
+              hash = set_data(hash, rec, models)
+            end
+          else
+            hash = set_data(hash, receiver, models)
+          end
+      end
+
+      hash
+    end
+
+    def set_data(hash, receiver, models)
+      if receiver.send(models).respond_to?(:class_name)
+        model_name = receiver.send(models).class_name
+        receiver.send(models).all.each do |r|
+          hash[:associations] << data_struct(model_name, models, r.serializable_hash)
+        end
+      else
+        model_name = receiver.send(models).class.class_name
+        hash[:associations] << data_struct(model_name, models, receiver.send(models).serializable_hash)
+      end
+      hash
+    end
+
+    def data_struct(model_name, association_name, attributes)
+      {
+        model_name: model_name,
+        association_name: association_name,
+        attributes: attributes
+      }
+    end
+
+    module ClassMethods
+      def import(hash, validate: false)
+        hash = hash.with_indifferent_access
+        obj = self.find_or_initialize_by(id: hash["attributes"]["id"])
+        obj.attributes = hash["attributes"]
+        obj = restore_image(obj, hash)
+        obj.save(validate: validate)
+
+        hash["associations"].each do |r|
+          r_obj = Object.const_get(r["model_name"]).find_or_initialize_by(id: r["attributes"]["id"])
+          r_obj.attributes = r["attributes"]
+          r_obj = restore_image(r_obj, r)
+          r_obj.save(validate: validate)
+        end
+      end
+
+      private
+
+      def restore_image(obj, data)
+        blobs = data["attributes"].select{|k,v| v.is_a?(Hash) && v.has_key?("blob") }
+        blobs.each do |key, blob|
+          obj.send("#{key}=", ActiveArchiver::Base64Decode.create_from_canvas_base64(blob["blob"], blob["file_name"]))
+        end
+        obj
+      end
+    end
+  end
+end

data/lib/active_archiver/base64_decode.rb

@@ -0,0 +1,28 @@
+module ActiveArchiver
+  class Base64Decode < StringIO
+    def self.create_from_canvas_base64(str, file_name)
+      return nil if str.nil?
+      head, data = str.split(",", 2)
+      return nil if data.nil?
+      _, mime_type = head.split(/:|;/)
+      bin = Base64.decode64(data)
+
+      self.new(bin, mime_type, file_name)
+    end
+
+    def initialize(blob, content_type, file_name)
+      super(blob)
+      @content_type = content_type
+      @file_name = file_name
+      self
+    end
+
+    def original_filename
+      @file_name
+    end
+
+    def content_type
+      @content_type
+    end
+  end
+end

data/lib/active_archiver/version.rb

@@ -0,0 +1,3 @@
+module ActiveArchiver
+  VERSION = "0.1.3"
+end

data/lib/carrierwave/serialization.rb

@@ -0,0 +1,30 @@
+module CarrierWave
+  module Uploader
+    class Base
+
+      @@active_archiver_blob_data = false
+
+      class << self
+        def active_archiver_blob_data=(flag)
+          @@active_archiver_blob_data = flag
+        end
+      end
+
+      def serializable_hash(options = nil)
+        if @@active_archiver_blob_data
+        {
+          url: url,
+          file_name: File.basename(url),
+          blob: "data:#{content_type};base64,#{Base64.strict_encode64(read)}"
+        }.merge Hash[versions.map { |name, version| [name, {
+          url: version.url,
+          file_name: File.basename(version.url),
+          blob: "data:#{version.content_type};base64,#{Base64.strict_encode64(version.read)}"
+        }] }]
+        else
+          super
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: active_archiver
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - zaru
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 2016-12-05 00:00:00.000000000 Z
 dependencies:
@@ -86,7 +86,21 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- active_archiver.gemspec
+- bin/console
+- bin/setup
+- lib/active_archiver.rb
+- lib/active_archiver/active_record_ext.rb
+- lib/active_archiver/base64_decode.rb
+- lib/active_archiver/version.rb
+- lib/carrierwave/serialization.rb
 homepage: https://github.com/zaru/active_archiver
 licenses: []
 metadata: {}