stuff_arc 0.0.3

data/Gemfile

@@ -0,0 +1,5 @@
+gem 'rake'
+gem 'i18n'
+gem 'rails', "~> 3.1.0"
+
+gem 'pry'

data/LICENSE

@@ -0,0 +1 @@
+include LGPL 3

data/README.md

@@ -0,0 +1,77 @@
+# stuff_arc - supports Rails portable data dump and restore
+
+## Version 0.0.2
+
+stuff_arc adds class level archiving and unarchiving of an ActiveRecord object
+a Rails app.
+
+Archives are JSON data, one line per model instance with the 'id' value omitted so that
+the data can be restored w/o worrying about primary key clashes.
+
+Restoration is performed by instantiating the model and then calling save!. **save!** exceptions
+are trapped and generate simple error messages, thus Rails validations can be used to avoid
+data duplication and data clobbering.
+
+These methods are designed to be used in a Rails Console, not programatically.
+
+## Install
+
+    gem install stuff_arc
+
+## Usage
+
+Include into models in which you want to create archives.
+
+    app/models/foo.rb:
+    
+    require 'stuff_arc'
+
+    class Foo < ActiveRecord::Base
+      include StuffArc
+      
+      . . .
+    end
+
+This will add two class methods to Foo:
+
+* Foo.archive(options = {}) - which will create the file 'foos.json' containing JSON serializations
+of every record retrieved by Foo.all with the 'id' entry is excluded.
+* Foo.unarchive(options = {}) - which reads the file 'foos.json', decodes each record and attempts
+to save! them to the database.
+
+The options are:
+
+* :fname - name of archive file. Defaults to the _underscored_, _pluralized_ version of the
+class name with the '.json' suffix.
+* :lib\_dir - path to directory archives are placed/looked for in. **NOTE:** :lib\_dir is ignored if
+:fname is an absolute path. Defaults to:
+
+      &lt;app root&gt;/lib/stuff\_arc - if Rails.public\_path is defined
+        
+      '.' - if Rails.public\_path is not defined
+
+
+This creates a portable dump and restore facility for each model in which StuffArc is
+included.
+
+## Creating an Archive
+
+Fire up the rails console [rails c] and . . .
+
+Create an archive in the default directory with default name:
+
+    Foo.archive
+    
+Create an archive in the default directory with a different name
+
+    Foo.archive :fname => 'foobar'
+
+Create an archive in a specified directory with the default name
+
+    Foo.archive :lib_dir => '/tmp'
+    
+## Restoring an Archive
+
+Fire up the rails console [rails c] and . . .
+
+repeat one of the commands above using **Foo.unarchive** instead of *Foo.archive*

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+
+gem_name = 'stuff_arc'
+
+# snarf gemspec and set version
+gem_spec = eval File.new("#{gem_name}.gemspec").read
+gem_version = gem_spec.version.to_s
+
+gem_zip = "#{gem_name}_#{gem_version}.zip"
+gem_tgz = "#{gem_name}_#{gem_version}.tgz"
+
+task :default => :test
+
+desc "Run unit tests"
+task :test do
+  system 'ruby tests/*'
+  # require "./test/#{gem_name}_base_test"
+end
+
+desc "run rdoc to create doc"
+task :doc do
+  system 'rdoc'
+end
+
+desc "build gem"
+task :gem do
+  system "gem build #{gem_name}.gemspec"
+  if 'mike.local' == IO.popen('hostname').read.chomp
+    system "cp #{gem_name}-#{gem_version}.gem ~/Rails/GemCache/gems/"
+    system "(cd ~/Rails/GemCache ; gem generate_index -d . )"
+  end
+end
+
+desc "push to github"
+task :git_push  do
+  system 'git push'
+end
+
+desc "push to rubygems"
+task :gem_push => :gem do
+  system "gem push #{gem_name}-#{gem_version}.gem"
+end

data/lib/stuff_arc.rb

@@ -0,0 +1,89 @@
+# StuffArc - supports portable Rails databases dump and restore
+#
+# defines two class level methods for archiving and unarchiving ActiveRecord::Base
+# objects.
+#
+# archive - creates an archive named <class.underscore>.json containing JSON representations
+# of each instance of the model
+#
+# unarchive - which reads a file created by **archive** (named <class.underscore>.json) and
+# saves each record in the datbase.
+#
+# Both methods are designed to be run from a Rails Console - not programatically.
+
+require 'rails'
+# require 'pry'
+# require 'active_support'
+# require 'active_support/inflector'
+# require 'active_support/json'
+
+module StuffArc
+  VERSION = "0.0.3"
+
+  def self.included(mod)
+    mod_lowercase = mod.to_s.underscore.pluralize
+    tmp =<<-EOF
+    def self.archive options = {}
+      unless (lib_dir = options.delete(:lib_dir))
+        if Rails.public_path
+          lib_dir =  File.join( File.dirname(::Rails.public_path), 'lib', 'stuff_arc' )
+          Dir.mkdir(lib_dir) unless File.exists? lib_dir
+        else
+          lib_dir = '.'
+        end
+      end
+      fname = options.delete(:fname) || '#{mod_lowercase}.json'
+      fname = File.join(lib_dir, fname) unless fname[0] == File::SEPARATOR
+      
+      if File.exists? fname
+        back_name = fname + '~'
+        File.unlink back_name if File.exists? back_name
+        File.rename fname, back_name
+      end
+      f = File.open(fname, 'w')
+      list = self.all
+      list.each do |#{mod_lowercase}|
+        json_str = ActiveSupport::JSON.encode #{mod_lowercase}, :include_root_in_json => false, :except => :id
+        f.write json_str + "\n"
+      end
+      f.close
+      list.length
+    end
+    EOF
+    
+    mod.instance_eval tmp, __FILE__, __LINE__
+
+    tmp =<<-EOF
+    def self.unarchive options = {}
+      unless (lib_dir = options.delete(:lib_dir))
+        if Rails.public_path
+          lib_dir =  File.join( File.dirname(::Rails.public_path), 'lib', 'stuff_arc' )
+          Dir.mkdir(lib_dir) unless File.exists? lib_dir
+        else
+          lib_dir = '.'
+        end
+      end
+      fname = options.delete(:fname) || '#{mod_lowercase}.json'
+      fname = File.join(lib_dir, fname) unless fname[0] == File::SEPARATOR
+
+      return nil unless File.exists? fname
+
+      f = File.new fname
+
+      f.lines do |line|
+        #{mod_lowercase} = self.new Hash[ActiveSupport::JSON.decode(line).map { |k,v| [k.to_sym, v] }]
+        begin
+          #{mod_lowercase}.save!
+        rescue Exception => e
+          puts "exception unarchiving #{mod_lowercase}: \#{e}\n"
+        end
+      end
+
+      f.close
+    end
+    EOF
+    
+    mod.instance_eval tmp, __FILE__, __LINE__
+
+  end
+end

data/tests/stuff_arc_test.rb

@@ -0,0 +1,86 @@
+$LOAD_PATH << File.expand_path("../../lib",  __FILE__)
+require 'test/unit'
+require 'stuff_arc'
+# require 'active_model'
+
+class StuffArcHelper
+  include StuffArc
+
+  class <<self
+    attr_accessor :db
+
+    def init_db
+      self.db = []
+    end
+  end
+
+  attr_accessor :foo, :bar
+  
+  def initialize args = nil
+    unless args.nil?
+      self.foo = args[:foo] if args[:foo]
+      self.bar = args[:bar] if args[:bar]
+    end
+  end
+  
+  def ==(other)
+    self.foo == other.foo && self.bar == other.bar
+  end
+
+  def self.all
+    [self.new({foo: 'foo', bar: 'bar'}), self.new({foo: 'foo2', bar: 'bar2'})]
+  end
+  
+  def save!
+    StuffArcHelper.db << self
+  end
+end
+
+class StuffArcTest < Test::Unit::TestCase
+  # def setup
+  #   puts "StuffArcHelper.public_methods: #{StuffArcHelper.public_methods.grep /arc/}"
+  # end
+  
+  def teardown
+    fname = StuffArcHelper.to_s.underscore.pluralize + '.json'
+    [fname, fname + '~'].each do |fn|
+      File.unlink(fn) if File.exists? fn
+    end
+  end
+  
+  def test_methods_exist
+    assert StuffArcHelper.respond_to?(:archive), "StuffArcHelper has class method :archive"
+    assert StuffArcHelper.respond_to?(:unarchive), "StuffArcHelper has class method :unarchive"
+  end
+  
+  def test_creates_archive
+    StuffArcHelper.archive
+    fname = StuffArcHelper.to_s.underscore
+    assert_equal 'stuff_arc_helper', fname, "underscore should transform class name correctly"
+    assert File.exists?('stuff_arc_helpers.json'), "archive creates a file"
+  end
+  
+  def test_reads_archive
+    StuffArcHelper.archive
+    StuffArcHelper.init_db
+    assert_equal [], StuffArcHelper.db, "StuffArcHelper.init_db should empty db"
+    StuffArcHelper.unarchive
+    assert_equal StuffArcHelper.all, StuffArcHelper.db, "Unarchiving should fill db"
+  end
+  
+  def test_full_path_to_archive
+    path = File.join(Dir.pwd, 'path-to-archive')
+    Dir.mkdir(path) unless File.exists? path
+    StuffArcHelper.archive :lib_dir => path
+    assert File.exists?(File.join(path, 'stuff_arc_helpers.json')), "archive should be in #{path}"
+    File.unlink File.join(path, 'stuff_arc_helpers.json') if File.exists? File.join(path, 'stuff_arc_helpers.json')
+    Dir.rmdir path if File.exists? path
+  end
+  
+  def test_fname_override
+    fname = 'foo-stuff'
+    StuffArcHelper.archive :fname => fname
+    assert File.exists?(fname), "file #{fname} should exist"
+    File.unlink(fname) if File.exists? fname
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: stuff_arc
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Mike Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-07 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2166654720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2166654720
+description: stuff_arc - adds class level archiving/unarchiving to ActiveRecord::Base
+  children
+email: mike@clove.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/stuff_arc.rb
+- tests/stuff_arc_test.rb
+- LICENSE
+- Rakefile
+- README.md
+- Gemfile
+homepage: http://github.com/mikehoward/stuff_arc
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: stuff_arc - adds class level archiving/unarchiving to ActiveRecord::Base
+  children
+test_files: []