arcopy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba25896eb10e1027cf4021ea88ba0fb5517c630907d442bfc5b27ed861f41677
+  data.tar.gz: d035b464d641f563962a1b3040e9fe894c848a0625e458f0e6385c92ffa78a4d
+SHA512:
+  metadata.gz: 7f784501bd721c2be2ccfe16c740f84da92a43edd2b0a02ffe356de940e8db4a0906d701dafc643e1ee5e9d571e10916f46e3f5e2bedb595df4e63e44acfa695
+  data.tar.gz: d856708d946dacd3366015d7d4d11bd3e7aa2e87562b97367b2fd67627e5ccb551b17c719e4b3a526cc8f2f646d0d9c9f6699c547d31eaec2f94438c4f778e25

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2011 Ryan Tomayko <http://tomayko.com/about>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/HACKING

@@ -0,0 +1,61 @@
+Grab a local clone of rtomayko/replicate:
+
+    git clone git://github.com/rtomayko/replicate.git
+    cd replicate
+
+The default rake task installs the latest supported activerecord
+version to a project local GEM_HOME=./vendor and runs the unit
+tests:
+
+    $ rake
+    installing activerecord-3.1.0 to ./vendor/1.8
+    installing sqlite3 to ./vendor/1.8
+    Using activerecord 3.1.0
+    Loaded suite ...
+    Started
+    ....................
+    Finished in 0.150186 seconds.
+
+    20 tests, 106 assertions, 0 failures, 0 errors
+
+Use `rake test:all' to run tests under all activerecord versions:
+
+    $ rake test:all
+    installing activerecord ~> 2.2.3 to ./vendor
+    installing activerecord ~> 2.3.14 to ./vendor
+    installing activerecord ~> 3.0.10 to ./vendor
+    installing activerecord ~> 3.1.0 to ./vendor
+    ==> testing activerecord ~> 2.2.3
+    Started
+    ....................
+    Finished in 0.119517 seconds.
+
+    20 tests, 106 assertions, 0 failures, 0 errors
+    ==> testing activerecord ~> 2.3.14
+    Started
+    ....................
+    Finished in 0.119517 seconds.
+
+    20 tests, 106 assertions, 0 failures, 0 errors
+    <snip>
+
+rake test:all should always be passing under latest stable MRI
+1.8.7 and MRI 1.9.x.
+
+Running individual test files directly requires setting the
+GEM_HOME environment variable and ensuring ./lib is on the load
+path:
+
+    export GEM_HOME=vendor/1.9 # or 1.8.7
+    ruby -Ilib test/active_record_test.rb
+
+You can also control which activerecord version is used in the
+test with the AR_VERSION environment variable:
+
+    rake setup:all
+    export GEM_HOME=vendor/1.8.7
+    AR_VERSION=3.1.0 ruby -rubygems -Ilib test/active_record_test.rb
+
+If you have something worth sharing, please send a pull request:
+
+    https://github.com/rtomayko/replicate

data/README.md

@@ -0,0 +1,285 @@
+Dump and load relational objects between Ruby environments.
+===========================================================
+
+*This repository is archived and no longer actively maintained by @rtomayko as of 2017-11-08. Issues and PRs documenting current issues have been intentionally left open for informational purposes.*
+
+The project started at GitHub to simplify the process of getting real production
+data into development and staging environments. We use it to replicate entire
+repository data (including associated issue, pull request, commit comment, etc.
+records) from production to our development environments with a single command.
+It's excessively useful for troubleshooting issues, support requests, and
+exception reports as well as for establishing real data for evaluating design
+concepts.
+
+Synopsis
+--------
+
+### Installing
+
+    $ gem install replicate
+
+### Dumping objects
+
+Evaluate a Ruby expression, dumping all resulting objects to standard output:
+
+    $ replicate -r ./config/environment -d "User.find(1)" > user.dump
+    ==> dumped 4 total objects:
+    Profile        1
+    User           1
+    UserEmail      2
+
+The `-r ./config/environment` option is used to require environment setup and
+model instantiation code needed by the ruby expression.
+
+### Dumping many objects with a dump script
+
+Dump scripts are normal ruby source files evaluated in the context of the
+dumper. The `dump(object)` method is used to put objects into the dump stream.
+
+```ruby
+# config/replicate/dump-stuff.rb
+require 'config/environment'
+
+%w[rtomayko/tilt rtomayko/bcat].each do |repo_name|
+  repo = Repository.find_by_name_with_owner(repo_name)
+  dump repo
+  dump repo.commit_comments
+  dump repo.issues
+end
+```
+
+Run the dump script:
+
+    $ replicate -d config/replicate/dump-stuff.rb > repos.dump
+    ==> dumped 1479 total objects:
+    AR::Habtm                   101
+    CommitComment                95
+    Issue                       101
+    IssueComment                427
+    IssueEvent                  308
+    Label                         5
+    Language                     19
+    LanguageName                  1
+    Milestone                     3
+    Organization                  4
+    Profile                      82
+    PullRequest                  44
+    PullRequestReviewComment      8
+    Repository                   20
+    Team                          4
+    TeamMember                    6
+    User                         89
+    UserEmail                   162
+
+### Loading many objects:
+
+    $ replicate -r ./config/environment -l < repos.dump
+    ==> loaded 1479 total objects:
+    AR::Habtm                   101
+    CommitComment                95
+    Issue                       101
+    IssueComment                427
+    IssueEvent                  308
+    Label                         5
+    Language                     19
+    LanguageName                  1
+    Milestone                     3
+    Organization                  4
+    Profile                      82
+    PullRequest                  44
+    PullRequestReviewComment      8
+    Repository                   20
+    Team                          4
+    TeamMember                    6
+    User                         89
+    UserEmail                   162
+
+### Dumping and loading over ssh
+
+    $ remote_command="replicate -r /app/config/environment -d 'User.find(1234)'"
+    $ ssh example.org "$remote_command" |replicate -r ./config/environment -l
+
+ActiveRecord
+------------
+
+Basic support for dumping and loading ActiveRecord objects is included. The
+tests pass under ActiveRecord versions 2.2.3, 2.3.5, 2.3.14, 3.0.10, 3.1.0, and 3.2.0 under
+MRI 1.8.7 as well as under MRI 1.9.2.
+
+To use customization macros in your models, require the replicate library after
+ActiveRecord (in e.g., `config/initializers/libraries.rb`):
+
+```ruby
+require 'active_record'
+require 'replicate'
+```
+
+ActiveRecord support works sensibly without customization so this isn't strictly
+necessary to use the `replicate` command. The following sections document the
+available customization macros.
+
+### Association Dumping
+
+The baked in support adds some more or less sensible default behavior for all
+subclasses of `ActiveRecord::Base` such that dumping an object will bring in
+objects related via `belongs_to` and `has_one` associations.
+
+Unlike 1:1 associations, `has_many` and `has_and_belongs_to_many` associations
+are not automatically included. Doing so would quickly lead to the entire
+database being sucked in. It can be useful to mark specific associations for
+automatic inclusion using the `replicate_associations` macro. For instance,
+to always include `EmailAddress` records belonging to a `User`:
+
+```ruby
+class User < ActiveRecord::Base
+  belongs_to :profile
+  has_many   :email_addresses
+
+  replicate_associations :email_addresses
+end
+```
+
+You may also do this by passing an option in your dump script:
+
+```ruby
+dump User.all, :associations => [:email_addresses]
+```
+
+### Natural Keys
+
+By default, the loader attempts to create a new record with a new primary key id
+for all objects. This can lead to unique constraint errors when a record already
+exists with matching attributes. To update existing records instead of
+creating new ones, define a natural key for the model using the `replicate_natural_key`
+macro:
+
+```ruby
+class User < ActiveRecord::Base
+  belongs_to :profile
+  has_many   :email_addresses
+
+  replicate_natural_key :login
+  replicate_associations :email_addresses
+end
+
+class EmailAddress < ActiveRecord::Base
+  belongs_to :user
+  replicate_natural_key :user_id, :email
+end
+```
+
+Multiple attribute names may be specified to define a compound key. Foreign key
+column attributes (`user_id`) are often included in natural keys.
+
+### Omission of attributes and associations
+
+You might want to exclude some attributes or associations from being dumped. For
+this, use the replicate_omit_attributes macro:
+
+```ruby
+class User < ActiveRecord::Base
+  has_one    :profile
+
+  replicate_omit_attributes :created_at, :profile
+end
+```
+
+You can omit belongs_to associations by omitting the foreign key column.
+
+You may also do this by passing an option in your dump script:
+
+```ruby
+dump User.all, :omit => [:profile]
+```
+
+### Validations and Callbacks
+
+__IMPORTANT:__ All ActiveRecord validations and callbacks are disabled on the
+loading side. While replicate piggybacks on AR for relationship information and
+uses `ActiveRecord::Base#save` to write objects to the database, it's designed
+to act as a simple dump / load tool.
+
+It's sometimes useful to run certain types of callbacks on replicate. For
+instance, you might want to create files on disk or load information into a
+separate data store any time an object enters the database. The best way to go
+about this currently is to override the model's `load_replicant` class method:
+
+```ruby
+class User < ActiveRecord::Base
+  def self.load_replicant(type, id, attrs)
+    id, object = super
+    object.register_in_redis
+    object.some_other_callback
+    [id, object]
+  end
+end
+```
+
+This interface will be improved in future versions.
+
+Custom Objects
+--------------
+
+Other object types may be included in the dump stream so long as they implement
+the `dump_replicant` and `load_replicant` methods.
+
+### dump_replicant
+
+The dump side calls `#dump_replicant(dumper, opts={})` on each object. The method must
+call `dumper.write()` with the class name, id, and hash of primitively typed
+attributes for the object:
+
+```ruby
+class User
+  attr_reader   :id
+  attr_accessor :name, :email
+
+  def dump_replicant(dumper, opts={})
+    attributes = { 'name' => name, 'email' => email }
+    dumper.write self.class, id, attributes, self
+  end
+end
+```
+
+### load_replicant
+
+The load side calls `::load_replicant(type, id, attributes)` on the class to
+load each object into the current environment. The method must return an
+`[id, object]` tuple:
+
+```ruby
+class User
+  def self.load_replicant(type, id, attributes)
+    user = User.new
+    user.name  = attributes['name']
+    user.email = attributes['email']
+    user.save!
+    [user.id, user]
+  end
+end
+```
+
+How it works
+------------
+
+The dump format is designed for streaming relational data. Each object is
+encoded as a `[type, id, attributes]` tuple and marshalled directly onto the
+stream. The `type` (class name string) and `id` must form a distinct key when
+combined, `attributes` must consist of only string keys and simply typed values.
+
+Relationships between objects in the stream are managed as follows:
+
+ - An object's attributes may encode references to objects that precede it
+   in the stream using a simple tuple format: `[:id, 'User', 1234]`.
+
+ - The dump side ensures that objects are written to the dump stream in
+   "reference order" such that when an object A includes a reference attribute
+   to an object B, B is guaranteed to arrive before A.
+
+ - The load side maintains a mapping of ids from the dumping system to the newly
+   replicated objects on the loading system. When the loader encounters a
+   reference value `[:id, 'User', 1234]` in an object's attributes, it converts it
+   to the load side id value.
+
+Dumping and loading happens in a streaming fashion. There is no limit on the
+number of objects included in the stream.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rake/clean'
+require 'rake/testtask'
+
+task :default => :test
+
+desc "Run tests"
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+end
+
+CLEAN.include 'test/db'
+
+desc "Build gem"
+task :build do
+  sh "gem build replicate.gemspec"
+end

data/bin/replicate

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+#/ Usage: replicate --dump dumpscript.rb > objects.dump
+#/        replicate [-r <lib>] --dump "<ruby>" [-- <argv>...] > objects.dump
+#/        replicate [-r <lib>] --load < objects.dump
+#/ Dump and load objects between environments.
+#
+#/ The --dump form writes to stdout the objects dumped by the script or
+#/ ruby expression(s) given. Dump scripts are normal Ruby source files but
+#/ must call dump(object) on one or more objects. When a Ruby expression is
+#/ given, all resulting objects are dumped automatically.
+#/
+#/ Dump scripts have access to any additional <argv> provided via the normal
+#/ system ARGV array. This can be used to pass arguments to dump scripts.
+#/
+#/ The --load form reads dump data from stdin and creates objects under the
+#/ current environment.
+#/
+#/ Mode selection:
+#/   -d, --dump           Dump the repository and all related objects to stdout.
+#/   -l, --load           Load dump file data from stdin.
+#/
+#/ Options:
+#/   -r, --require        Require the library. Often used with 'config/environment'.
+#/   -i, --keep-id        Use replicated ids when loading dump file.
+#/   -f, --force          Allow loading in production environments.
+#/   -v, --verbose        Write more status output.
+#/   -q, --quiet          Write less status output.
+$stderr.sync = true
+$stdout = $stderr
+
+require 'optparse'
+
+# default options
+mode     = nil
+verbose  = false
+quiet    = false
+keep_id  = false
+out      = STDOUT
+force    = false
+
+# parse arguments
+file = __FILE__
+usage = lambda { exec "grep ^#/<'#{file}'|cut -c4-" }
+original_argv = ARGV.dup
+ARGV.options do |opts|
+  opts.on("-d", "--dump")      { mode = :dump }
+  opts.on("-l", "--load")      { mode = :load }
+  opts.on("-r", "--require=f") { |file| require file }
+  opts.on("-v", "--verbose")   { verbose = true }
+  opts.on("-q", "--quiet")     { quiet = true }
+  opts.on("-i", "--keep-id")   { keep_id = true }
+  opts.on("--force")           { force = true }
+  opts.on_tail("-h", "--help", &usage)
+  opts.parse!
+end
+
+# load replicate lib and setup AR
+require 'replicate'
+if defined?(ActiveRecord::Base)
+  require 'replicate/active_record'
+  ActiveRecord::Base.replicate_id = keep_id
+  ActiveRecord::Base.connection.enable_query_cache!
+end
+
+# dump mode means we're reading records from the database here and writing to
+# stdout. the database should not be modified at all by this operation.
+if mode == :dump
+  script = ARGV.shift
+  usage.call if script.empty?
+  Replicate::Dumper.new do |dumper|
+    dumper.marshal_to out
+    dumper.log_to $stderr, verbose, quiet
+    if script == '-'
+      code = $stdin.read
+      objects = dumper.instance_eval(code, '<stdin>', 0)
+    elsif File.exist?(script)
+      dumper.load_script script
+    else
+      objects = dumper.instance_eval(script, '<argv>', 0)
+      dumper.dump objects
+    end
+  end
+
+# load mode means we're reading objects from stdin and creating them under
+# the current environment.
+elsif mode == :load
+  if Replicate.production_environment? && !force
+    abort "error: refusing to load in production environment\n" +
+          "       manual override: #{File.basename($0)} --force #{original_argv.join(' ')}"
+  else
+    Replicate::Loader.new do |loader|
+      loader.log_to $stderr, verbose, quiet
+      loader.read $stdin
+    end
+  end
+
+# mode not set means no -l or -d arg was given. show usage and bail.
+else
+  usage.call
+end