stuff_arc 0.0.4 → 0.0.6.pre1

data/README.md

@@ -1,9 +1,10 @@
 # stuff_arc - supports Rails portable data dump and restore
 
-## Version 0.0.4
+## Version 0.0.6
 
 stuff_arc adds class level archiving and unarchiving of an ActiveRecord object
-a Rails app.
+a Rails app by Auto-Extending ActiveRecord::Base with two methods: `archive` and
+`unarchive`
 
 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.
@@ -16,23 +17,16 @@ These methods are designed to be used in a Rails Console, not programatically.
 
 ## Install
 
-    gem install stuff_arc
+    Add `gem stuff_arc` to your Gemfile & run `bundle`
 
+    All models (derived from ActiveRecord::Base) will now have `archive` and `unarchive`
+    class methods.
+    
 ## Usage
 
-Include into models in which you want to create archives.
-
-    app/models/foo.rb:
-    
-    require 'stuff_arc'
+Assume:
 
     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.
@@ -56,7 +50,7 @@ included.
 
 ## Creating an Archive
 
-Fire up the rails console [rails c] and . . .
+Fire up the rails console [rails c &lt;development|production&gt;] and . . .
 
 Create an archive in the default directory with default name:
 
@@ -72,6 +66,6 @@ Create an archive in a specified directory with the default name
     
 ## Restoring an Archive
 
-Fire up the rails console [rails c] and . . .
+Fire up the rails console [rails c &lt;development|production&gt;] and . . .
 
 repeat one of the commands above using **Foo.unarchive** instead of *Foo.archive*

data/Rakefile

@@ -13,13 +13,9 @@ 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'
+  system 'ruby test/*'
+# puts "------requiring ./test/#{gem_name}_test"
+  # require "./test/#{gem_name}_test"
 end
 
 desc "build gem"
@@ -31,12 +27,7 @@ task :gem do
   end
 end
 
-desc "push to github"
-task :git_push  do
-  system 'git push'
-end
-
 desc "push to rubygems"
-task :gem_push => :gem do
+task :push_gem => :gem do
   system "gem push #{gem_name}-#{gem_version}.gem"
 end

data/lib/stuff_arc/engine.rb

@@ -0,0 +1,13 @@
+require 'active_record'
+
+module StuffArc
+  class Engine < Rails::Engine
+    if Rails.version =~ /^3.[01]/
+      initializer "active_record.add_stuff_arc" do
+        ActiveSupport.on_load(:active_record) do
+          extend StuffArc::Base
+        end
+      end
+    end
+  end
+end

data/lib/stuff_arc/stuff_arc.rb

@@ -0,0 +1,91 @@
+# 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 'active_model'
+# require 'pry'
+
+module StuffArc
+  VERSION = "0.0.6.pre1"
+  module Base
+    def archive options = {}
+      return self.class.archive options unless self.class == Class
+      mod_lowercase = self.to_s.underscore.pluralize
+      
+      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 |instance|
+        # as_json returns a hash, which we have to change to a JSON string
+        f.write instance.as_json.to_json + "\n"
+      end
+      f.close
+      list.length
+    end
+
+    def unarchive options = {}
+      return self.class.unarchive options unless self.class == Class
+      mod_lowercase = self.to_s.underscore.pluralize
+
+      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
+
+      counter = 0
+      f.lines do |line|
+        tmp = self.new.from_json(line.chomp)
+        begin
+          tmp.save!
+          counter += 1
+        rescue Exception => e
+          puts "exception unarchiving #{self}: \#{e}\n"
+        end
+      end
+
+      f.close
+      counter
+    end
+
+    def self.included(mod)
+      # if I'm included, then I want to extend myself
+      puts "I'm being included in #{mod}!!!!"
+      mod.send :extend, self
+    end
+  end
+end

data/lib/stuff_arc.rb

@@ -11,77 +11,7 @@
 #
 # Both methods are designed to be run from a Rails Console - not programatically.
 
-require 'rails'
-require 'active_model'
-# require 'pry'
-
-module StuffArc
-  VERSION = "0.0.4"
-
-  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}|
-        # as_json returns a hash, which we have to change to a JSON string
-        f.write #{mod_lowercase}.as_json.to_json + "\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} = #{mod}.new.from_json(line.chomp)
-        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
+require 'rails'
+require 'stuff_arc/engine'
+require 'stuff_arc/stuff_arc'

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: stuff_arc
 version: !ruby/object:Gem::Version
-  version: 0.0.4
-  prerelease: 
+  version: 0.0.6.pre1
+  prerelease: 6
 platform: ruby
 authors:
 - Mike Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-08 00:00:00.000000000Z
+date: 2011-09-13 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2166421240 !ruby/object:Gem::Requirement
+  requirement: &2152971800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2166421240
+  version_requirements: *2152971800
 description: stuff_arc - adds class level archiving/unarchiving to ActiveRecord::Base
   children
 email: mike@clove.com
@@ -29,8 +29,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/stuff_arc/engine.rb
+- lib/stuff_arc/stuff_arc.rb
 - lib/stuff_arc.rb
-- tests/stuff_arc_test.rb
 - LICENSE
 - Rakefile
 - README.md
@@ -50,9 +51,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.6

data/tests/stuff_arc_test.rb

@@ -1,99 +0,0 @@
-$LOAD_PATH << File.expand_path("../../lib",  __FILE__)
-require 'test/unit'
-require 'active_model'
-require 'stuff_arc'
-# require 'active_model'
-
-class StuffArcHelper
-  include StuffArc
-  include ActiveModel::Serializers::JSON
-
-  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 attributes
-    {'foo' => @foo, 'bar' => @bar}
-  end
-  
-  def attributes=(hash)
-    hash.each do |k,v|
-      self.instance_variable_set "@#{k}", v
-    end
-  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')
-    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