duple 0.0.3 → 0.0.4

data/README.md

@@ -50,7 +50,11 @@ figure the application. Read and modify it, or clear it out and write your own.
 
 ## Future
 
-  * Pre- and post- refresh hooks
+  * Custom error classes.
+  * Improve documentation
+  * Support non-Heroku remote PostgreSQL servers.
+  * Move knowledge of endpoint types out of Thor tasks.
+
   * Support for skipping pre- and post- refresh steps.
   * Support for running pre- and post- refresh steps by themselves.
   * Support for other data stores.

data/Rakefile

@@ -10,9 +10,10 @@ begin
 
   desc "Run cane to check quality metrics"
   Cane::RakeTask.new(:cane) do |cane|
+    cane.abc_max = 15
     cane.style_measure = 100
     cane.style_glob = '{lib}/**/*.rb'
-    cane.gte = {'coverage/covered_percent' => 95}
+    cane.gte = {'coverage/covered_percent' => 98}
   end
 rescue LoadError
   warn "cane not available, quality task not provided."

data/lib/duple.rb

@@ -1,3 +1,6 @@
 require 'duple/version'
 require 'duple/configuration'
+require 'duple/endpoint'
+require 'duple/source'
+require 'duple/target'
 require 'duple/cli/root'

data/lib/duple/cli/config.rb

@@ -33,12 +33,15 @@ module Duple
           say
         end
 
-        def print_tasks(header, task_list)
+        def print_tasks(header, tasks)
           say header
           say '-' * 80
-          task_list.each do |task_name, commands|
+          tasks.each do |task|
             say
-            say '  ' + task_name
+            say '  ' + task.name
+            commands = task.commands.map do |c|
+              { subject: c.subject, command_type: c.type, command: c.command }
+            end
             print_table commands, indent: 4
           end
           say

data/lib/duple/cli/helpers.rb

@@ -69,8 +69,16 @@ module Duple
       end
 
       module InstanceMethods
-        def default_config_path
-          File.join('config', 'duple.yml')
+        def config
+          @config ||= parse_config
+        end
+
+        def parse_config
+          config_path = File.join(destination_root, app_config_path)
+          config_data = File.read(config_path)
+          erbed = ERB.new(config_data).result
+          config_hash = YAML.load(erbed) || {}
+          Duple::Configuration.new(config_hash, options)
         end
 
         def app_config_path(verify_file = true)
@@ -81,89 +89,71 @@ module Duple
           config_path
         end
 
+        def default_config_path
+          File.join('config', 'duple.yml')
+        end
+
+        def source
+          @source ||= Duple::Source.new(config, runner)
+        end
+
+        def target
+          @target ||= Duple::Target.new(config, runner)
+        end
+
         def runner
           @runner ||= Duple::Runner.new(dry_run: config.dry_run?)
         end
 
         def postgres
+          # TODO: This should go away as the methods are moved into the endpoint classes.
           @pg_runner ||= Duple::PGRunner.new(runner)
         end
 
         def heroku
+          # TODO: This should go away as the methods are moved into the endpoint classes.
           @heroku ||= Duple::HerokuRunner.new(runner)
         end
 
-        def source_appname
-          @source_appname ||= config.heroku_name(config.source_environment)
-        end
-
         def target_appname
-          @target_appname ||= config.heroku_name(config.target_environment)
+          # TODO: This should go away as the methods are moved into the endpoint classes.
+          target.appname
         end
 
         def dump_dir_path
+          # TODO: This should go on the configuration and be configurable.
           File.join('tmp', 'duple')
         end
 
         def data_file_path
+          # TODO: This should go on the configuration and be configurable.
           @data_file_path ||= File.join(dump_dir_path, "#{config.source_name}-data.dump")
         end
 
         def structure_file_path
+          # TODO: This should go on the configuration and be configurable.
           filename = "#{config.source_name}-structure.dump"
           @structure_file_path ||= File.join(dump_dir_path, filename)
         end
 
         def snapshot_file_path(timestamp)
+          # TODO: This should go on the configuration and be configurable.
           filename = "#{config.source_name}-#{timestamp}.dump"
           @structure_file_path ||= File.join(dump_dir_path, filename)
         end
 
         def source_db_config
-          @source_db_config ||= if config.heroku_source?
-                                  fetch_heroku_db_config(source_appname)
-                                else
-                                  config.db_config(config.source_name)
-                                end
+          # TODO: This should go away as the methods are moved into the endpoint classes.
+          @source_db_config ||= source.db_config
         end
 
         def target_db_config
-          @target_db_config ||= if config.heroku_target?
-                                  fetch_heroku_db_config(target_appname)
-                                else
-                                  config.db_config(config.target_name)
-                                end
-        end
-
-        def fetch_heroku_db_config(appname)
-          # Run the heroku config command first, even if it's a dry run. So
-          # that the command to get the config will show up in the dry run log.
-          config_vars = heroku.capture(appname, "config")
-
-          if config.dry_run?
-            config.db_config(appname, dry_run: true)
-          else
-            parse_heroku_config(config_vars)
-          end
-        end
-
-        def parse_heroku_config(config_vars)
-          db_url = config_vars.split("\n").detect { |l| l =~ /DATABASE_URL/ }
-          raise ArgumentError.new("Missing DATABASE_URL variable for #{appname}") if db_url.nil?
-
-          db_url.match(
-            /postgres:\/\/(?<username>.*):(?<password>.*)@(?<host>.*):(?<port>\d*)\/(?<database>.*)/
-          )
-        end
-
-        def fetch_latest_snapshot_time(appname)
-          response = heroku.capture(appname, 'pgbackups')
-          last_line = response.split("\n").last
-          timestring = last_line.match(/\w+\s+(?<timestamp>[\d\s\/\:\.]+)\s+.*/)[:timestamp]
-          DateTime.strptime(timestring, '%Y/%m/%d %H:%M.%S')
+          # TODO: This should go away as the methods are moved into the endpoint classes.
+          @target_db_config ||= target.db_config
         end
 
         def reset_database(env)
+          # TODO: This should be moved to the endpoint classes.
           if config.heroku?(env)
             appname = config.heroku_name(env)
             heroku.run(appname, 'pg:reset')
@@ -174,6 +164,7 @@ module Duple
         end
 
         def dump_flags
+          # TODO: This should be moved to the endpoint classes.
           include_tables = config.included_tables
           include_flags = include_tables.map { |t| "-t #{t}" }
 
@@ -182,18 +173,6 @@ module Duple
 
           flags = [ '-Fc -a', include_flags, exclude_flags ].flatten.compact.join(' ')
         end
-
-        def config
-          @config ||= parse_config
-        end
-
-        def parse_config
-          config_path = File.join(destination_root, app_config_path)
-          config_data = File.read(config_path)
-          erbed = ERB.new(config_data).result
-          config_hash = YAML.load(erbed) || {}
-          Duple::Configuration.new(config_hash, options)
-        end
       end
     end
   end

data/lib/duple/cli/refresh.rb

@@ -24,10 +24,6 @@ module Duple
       tables_option
 
       no_tasks do
-        def capture_snapshot?
-          config.capture? && config.heroku_source?
-        end
-
         def fetch_snapshot_url?
           config.heroku_source? && !config.filtered_tables?
         end
@@ -39,24 +35,35 @@ module Duple
         def dump_data?
           config.local_source? || config.filtered_tables?
         end
+
+        def run_tasks(tasks)
+          tasks.each do |task|
+            task.commands.each do |c|
+              source.execute(c) if c.source?
+              target.execute(c) if c.target?
+            end
+          end
+        end
       end
 
-      def capture_snapshot
-        return unless capture_snapshot?
+      def run_prerefresh_tasks
+        run_tasks(config.pre_refresh_tasks)
+      end
 
-        heroku.run(source_appname, 'pgbackups:capture')
+      def capture_snapshot
+        source.capture_snapshot if config.capture?
       end
 
       def fetch_snapshot_url
         return unless fetch_snapshot_url?
 
-        @source_snapshot_url = heroku.capture(source_appname, 'pgbackups:url').strip
+        @source_snapshot_url = source.snapshot_url
       end
 
       def download_snapshot
         return unless download_snapshot?
 
-        timestamp = fetch_latest_snapshot_time(source_appname)
+        timestamp = source.latest_snapshot_time
 
         @snapshot_path = snapshot_file_path(timestamp.strftime('%Y-%m-%d-%H-%M-%S'))
         unless File.exists?(@snapshot_path)
@@ -83,6 +90,10 @@ module Duple
           heroku.run(target_appname, "pgbackups:restore DATABASE #{@source_snapshot_url}")
         end
       end
+
+      def run_postrefresh_tasks
+        run_tasks(config.post_refresh_tasks)
+      end
     end
   end
 end

data/lib/duple/config/command.rb

@@ -0,0 +1,46 @@
+module Duple
+  module Config
+    # Represents a command that can be executed in the source or target environment.
+    class Command
+      SHELL   = 'shell'
+      HEROKU  = 'heroku'
+      VALID_TYPES = [SHELL, HEROKU]
+
+      SOURCE = 'source'
+      TARGET = 'target'
+      VALID_SUBJECTS = [SOURCE, TARGET]
+
+      attr_accessor :subject, :type, :command
+
+      def initialize(config_hash)
+        @command = config_hash['command']
+        @type = config_hash['command_type']
+        @subject = config_hash['subject']
+
+        unless VALID_TYPES.include?(@type)
+          raise ArgumentError.new("Invalid config: #{@type} is not a valid command type.")
+        end
+
+        unless VALID_SUBJECTS.include?(@subject)
+          raise ArgumentError.new("Invalid config: #{@subject} is not a valid command subject.")
+        end
+      end
+
+      def source?
+        subject == Duple::Config::Command::SOURCE
+      end
+
+      def target?
+        subject == Duple::Config::Command::TARGET
+      end
+
+      def heroku?
+        type == Duple::Config::Command::HEROKU
+      end
+
+      def shell?
+        type == Duple::Config::Command::SHELL
+      end
+    end
+  end
+end

data/lib/duple/config/task.rb

@@ -0,0 +1,14 @@
+require 'duple/config/command'
+
+module Duple
+  module Config
+    # Represents a set of commands that can be executed in the source or target environment.
+    class Task
+      attr_accessor :name, :commands
+      def initialize(name, command_list)
+        @name = name
+        @commands = command_list.map { |c| Duple::Config::Command.new(c) }
+      end
+    end
+  end
+end

data/lib/duple/configuration.rb

@@ -1,3 +1,5 @@
+require 'duple/config/task'
+
 module Duple
 
   # Represents the configuration that will be used to perform the data
@@ -181,23 +183,11 @@ module Duple
     end
 
     def pre_refresh_tasks
-      raw_config['pre_refresh'] || {}
-    end
-
-    def pre_refresh_task(task_name)
-      task = pre_refresh_tasks[task_name]
-      raise ArgumentError.new("Invalid pre_refresh task: #{task_name}") if task.nil?
-      task
+      @pre_refresh_tasks ||= build_tasks(raw_config['pre_refresh'])
     end
 
     def post_refresh_tasks
-      raw_config['post_refresh'] || {}
-    end
-
-    def post_refresh_task(task_name)
-      task = post_refresh_tasks[task_name]
-      raise ArgumentError.new("Invalid post_refresh task: #{task_name}") if task.nil?
-      task
+      @post_refresh_tasks ||= build_tasks(raw_config['post_refresh'])
     end
 
     def other_options
@@ -206,6 +196,13 @@ module Duple
 
     protected
 
+    def build_tasks(task_hash)
+      return [] if task_hash.nil?
+      task_hash.map do |name, command_list|
+        Duple::Config::Task.new(name, command_list)
+      end
+    end
+
     def env_names_by_flag(flag_name, flag_value, allow_multiple = false)
       matching_envs = environments.select { |n, c| c[flag_name] == flag_value }
       if matching_envs.size > 1 && !allow_multiple

data/lib/duple/endpoint.rb

@@ -0,0 +1,92 @@
+module Duple
+  module Endpoint
+    def self.included(base)
+      base.send(:attr_reader, :config, :runner)
+    end
+
+    def initialize(config, runner)
+      @config = config
+      @runner = runner
+      if config.heroku?(environment)
+        extend Duple::HerokuEndpoint
+      else
+        extend Duple::PostgreSQLEndpoint
+      end
+    end
+  end
+
+  module HerokuEndpoint
+    def appname
+      @appname ||= config.heroku_name(environment)
+    end
+
+    def heroku
+      @heroku ||= Duple::HerokuRunner.new(runner)
+    end
+
+    def db_config
+      @db_config ||= fetch_db_config
+    end
+
+    def snapshot_url
+      @snapshot_url ||= heroku.capture(appname, 'pgbackups:url').strip
+    end
+
+    def latest_snapshot_time
+      unless @snapshot_time
+        response = heroku.capture(appname, 'pgbackups')
+        last_line = response.split("\n").last
+        timestring = last_line.match(/\w+\s+(?<timestamp>[\d\s\/\:\.]+)\s+.*/)[:timestamp]
+        @snapshot_time = DateTime.strptime(timestring, '%Y/%m/%d %H:%M.%S')
+      end
+      @snapshot_time
+    end
+
+    def fetch_db_config
+      # Run the heroku config command first, even if it's a dry run, so
+      # that the command to get the config will show up in the dry run log.
+      config_vars = heroku.capture(appname, "config")
+
+      if config.dry_run?
+        config.db_config(name, dry_run: true)
+      else
+        parse_config(config_vars)
+      end
+    end
+
+    def parse_config(config_vars)
+      db_url = config_vars.split("\n").detect { |l| l =~ /DATABASE_URL/ }
+      raise ArgumentError.new("Missing DATABASE_URL variable for #{appname}") if db_url.nil?
+
+      db_url.match(
+        /postgres:\/\/(?<username>.*):(?<password>.*)@(?<host>.*):(?<port>\d*)\/(?<database>.*)/
+      )
+    end
+
+    def capture_snapshot
+      heroku.run(appname, 'pgbackups:capture')
+    end
+
+    def execute(cmd)
+      if cmd.shell?
+        heroku.run(appname, "run \"#{cmd.command}\"")
+      elsif cmd.heroku?
+        heroku.run(appname, cmd.command)
+      end
+    end
+  end
+
+  module PostgreSQLEndpoint
+    def db_config
+      config.db_config(name)
+    end
+
+    def capture_snapshot
+      # Do nothing. When we have non-local PostgreSQL endpoints, this will need to be implemented.
+    end
+
+    def execute(cmd)
+      runner.run(cmd.command) if cmd.shell?
+    end
+  end
+end

data/lib/duple/runner.rb

@@ -53,10 +53,6 @@ module Duple
       @options[:recorder]
     end
 
-    def live?
-      !@options[:dry_run]
-    end
-
     def dry_run?
       @options[:dry_run]
     end

data/lib/duple/source.rb

@@ -0,0 +1,14 @@
+module Duple
+  # Represents the source of the data/schema transfer.
+  class Source
+    include Duple::Endpoint
+
+    def environment
+      config.source_environment
+    end
+
+    def name
+      @name ||= config.source_name
+    end
+  end
+end

data/lib/duple/target.rb

@@ -0,0 +1,14 @@
+module Duple
+  # Represents the target of the data/schema transfer.
+  class Target
+    include Duple::Endpoint
+
+    def environment
+      config.target_environment
+    end
+
+    def name
+      @name ||= config.target_name
+    end
+  end
+end

data/lib/duple/version.rb

@@ -1,3 +1,3 @@
 module Duple
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/config/groups.yml

@@ -1,5 +1,3 @@
-dump_dir: tmp
-
 environments:
   development:
     type: local

data/spec/config/kitchensink.yml

@@ -1,6 +1,3 @@
-dump_dir: tmp
-postgres_user: <%= ENV['POSTGRES_DEV_USER'] || 'postgres' %>
-
 environments:
   development:
     type: local
@@ -42,24 +39,21 @@ post_refresh:
       command:      ps:scale worker=1
   migrate:
     - subject:      target
-      command_type: rake
-      command:      db:migrate
+      command_type: shell
+      command:      rake db:migrate
   scrub_data:
     - subject:      target
-      command_type: rake
-      command:      snapshot:scrub
+      command_type: shell
+      command:      rake snapshot:scrub
   test_data:
     - subject:      target
-      command_type: rake
-      command:      snapshot:setup_testers
+      command_type: shell
+      command:      rake snapshot:setup_testers
 
 groups:
   all:
     include_all: true   # Include all tables
 
-  structure:
-    exclude_all: true   # Exclude all tables (structure only)
-
   minimal:
     include_tables:     # Include only the listed tables
       - categories

data/spec/config/simple.yml

@@ -1,5 +1,3 @@
-dump_dir: tmp
-
 environments:
   development:
     type: local

data/spec/config/tasks.yml

@@ -1,5 +1,3 @@
-dump_dir: tmp
-
 environments:
   development:
     type: local

data/spec/duple/cli/config_spec.rb

@@ -1,9 +1,15 @@
 require 'spec_helper'
 
 describe Duple::CLI::Config do
+  let(:script) { Duple::CLI::Config.new }
+  it 'raises an error if an invalid config path is supplied' do
+    expect {
+      script.invoke(:all, [], {config: 'spec/config/nonexistent.yml'})
+    }.to raise_error(ArgumentError, 'Missing config file: spec/config/nonexistent.yml')
+  end
+
   it 'prints the configuration' do
     result = capture_stdout do
-      script = Duple::CLI::Config.new
       script.invoke(:all, [], {config: 'spec/config/kitchensink.yml'})
     end
 

data/spec/duple/cli/refresh_spec.rb

@@ -293,9 +293,8 @@ describe Duple::CLI::Refresh do
   end
 
   context 'with pre-refresh tasks' do
-    before { pending 'Implement pre-refresh tasks' }
-
     before {
+      stub_prerefresh_tasks
       stub_fetch_url
       stub_fetch_config
       stub_fetch_backups
@@ -305,6 +304,7 @@ describe Duple::CLI::Refresh do
       stub_reset_local
       stub_restore_url
       stub_restore_data
+      stub_postrefresh_tasks
     }
 
     let(:source) { 'production' }
@@ -315,7 +315,7 @@ describe Duple::CLI::Refresh do
       runner.should_receive(:run).once.ordered.with('heroku maintenance:on -a duple-stage')
       runner.should_receive(:run).any_number_of_times.ordered.with(/heroku pgbackups/)
 
-      invoke_refresh(table_options.merge(capture: true))
+      invoke_refresh(task_options.merge(capture: true))
     end
 
     it 'executes the tasks in order' do
@@ -352,8 +352,9 @@ describe Duple::CLI::Refresh do
   end
 
   context 'with post-refresh tasks' do
-    before { pending 'Implement post-refresh tasks' }
+    # before { pending 'Implement post-refresh tasks' }
     before {
+      stub_prerefresh_tasks
       stub_fetch_url
       stub_fetch_config
       stub_fetch_backups
@@ -363,6 +364,7 @@ describe Duple::CLI::Refresh do
       stub_reset_local
       stub_restore_url
       stub_restore_data
+      stub_postrefresh_tasks
     }
 
     let(:source) { 'production' }
@@ -371,9 +373,9 @@ describe Duple::CLI::Refresh do
 
     it 'executes the tasks after refreshing' do
       runner.should_receive(:run).any_number_of_times.ordered.with(/heroku pgbackups/)
-      runner.should_receive(:run).once.ordered.with('heroku maintenance:on -a duple-stage')
+      runner.should_receive(:run).once.ordered.with('heroku maintenance:off -a duple-stage')
 
-      invoke_refresh(table_options.merge(capture: true))
+      invoke_refresh(task_options.merge(capture: true))
     end
 
     it 'executes the tasks in order' do
@@ -401,7 +403,7 @@ describe Duple::CLI::Refresh do
 
       it 'executes the tasks in order' do
         runner.should_receive(:run).once.ordered.with('rake refresh:finish')
-        runner.should_receive(:run).once.ordered.with('heroku maintenance:on -a duple-stage')
+        runner.should_receive(:run).once.ordered.with('heroku maintenance:off -a duple-stage')
         runner.should_receive(:run).once.ordered.with('heroku run "rake refresh:finish" -a duple-stage')
 
         invoke_refresh(task_options)

data/spec/duple/configuration_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 describe Duple::Configuration do
 
-
   describe '#db_config' do
     let(:config_hash) { YAML.load(File.read('spec/config/simple.yml'))}
 

data/spec/duple/runner_spec.rb

@@ -61,5 +61,14 @@ describe Duple::Runner do
       runner.capture('date')
       recorder.string.split("\n").should == ['ls tmp', 'date']
     end
+
+    context 'that is not I/O-like' do
+      let(:recorder) { "" }
+      it 'raises an error' do
+        expect {
+          runner.capture('date')
+        }.to raise_error(ArgumentError, 'Invalid :recorder option: ')
+      end
+    end
   end
 end

data/spec/support/cli_spec_helpers.rb

@@ -25,6 +25,18 @@ module Duple
       File.read('spec/config/heroku_config.txt')
     end
 
+    def stub_prerefresh_tasks
+      runner.stub(:run).with(/heroku run "rake refresh:prepare/)
+      runner.stub(:run).with(/rake refresh:prepare/)
+      runner.stub(:run).with(/heroku maintenance:on/)
+    end
+
+    def stub_postrefresh_tasks
+      runner.stub(:run).with(/heroku run "rake refresh:finish/)
+      runner.stub(:run).with(/rake refresh:finish/)
+      runner.stub(:run).with(/heroku maintenance:off/)
+    end
+
     def stub_fetch_url
       runner.stub(:capture).with(/heroku pgbackups:url/)
         .and_return(heroku_pgbackups_url_response)

data/templates/config/duple.yml

@@ -1,71 +1,64 @@
-dump_dir: tmp
-postgres_user: <%= ENV['POSTGRES_DEV_USER'] || 'postgres' %>
-
 environments:
   development:
-    type: local
-    default_target: true
+    type: local                 # The "development" database is hosted on your machine.
+    default_target: true        # Use "development" as the default data target.
+    database: duple_development # The name of the "development" database is "duple_development"
 
   backstage:
-    type: heroku
-    appname: duple-backstage
+    type: heroku                # The "backstage" database is hosted on Heroku.
+    appname: duple-backstage    # The "backstage" app is called "duple-backstage" on Heroku.
 
   stage:
-    type: heroku
-    appname: duple-stage
-    default_source: true
+    type: heroku                # The "stage" database is hosted on Heroku.
+    appname: duple-stage        # The "stage" app is called "duple-stage" on Heroku.
+    default_source: true        # Use "stage" as the default data source.
 
   production:
-    type: heroku
-    appname: duple-production
-    allow_target: false
+    type: heroku                # The "production" database is hosted on Heroku.
+    appname: duple-production   # The "production" app is called "duple-production" on Heroku.
+    allow_target: false         # The "production" database cannot be used as a data target.
 
 pre_refresh:
-  disable_target:
-    - subject:      target
-      command_type: heroku
-      command:      maintenance:on
-    - subject:      target
-      command_type: heroku
-      command:      ps:scale worker=0
+  prepare_source:                         # Defines a set of commands called "prepare_source"
+    - subject:      source                #   Execute "rake refresh:prepare" in the source shell.
+      command_type: shell
+      command:      rake refresh:prepare
+  prepare_target:                         # Defines a set of commands called "prepare_target"
+    - subject:      target                #   Execute "heroku maintenance:on" on the target.
+      command_type: heroku                #   Note: The command will not be executed in a local
+      command:      maintenance:on        #         environment.
+    - subject:      target                #   Execute "rake refresh:prepare" on the target.
+      command_type: shell
+      command:      rake refresh:prepare
 
 post_refresh:
-  enable_target:
-    - subject:      target
-      command_type: heroku
-      command:      restart
-    - subject:      target
+  finish_source:                        # Defines a set of commands called "finish_source"
+    - subject:      source              #   Execute "rake refresh:finish" in the source shell.
+      command_type: shell
+      command:      rake refresh:finish
+
+  finish_target:                        # Defines a set of commands called "finish_source"
+    - subject:      target              #   Execute "heroku maintenance:off" on the target.
       command_type: heroku
       command:      maintenance:off
-    - subject:      target
-      command_type: heroku
-      command:      ps:scale worker=1
-  migrate:
-    - subject:      target
-      command_type: rake
-      command:      db:migrate
-  scrub_data:
-    - subject:      target
-      command_type: rake
-      command:      snapshot:scrub
-  test_data:
-    - subject:      target
-      command_type: rake
-      command:      snapshot:setup_testers
+    - subject:      target              #   Execute "rake refresh:finish" on the target.
+      command_type: shell
+      command:      rake refresh:finish
 
 groups:
-  all:
-    include_all: true   # Include all tables
+  all:                  # Defines a group called "all"
+    include_all: true   #   Include all tables
 
-  structure:
-    exclude_all: true   # Exclude all tables (structure only)
-
-  minimal:
-    include_tables:     # Include only the listed tables
+  minimal:              # Defines a group called "minimal"
+    include_tables:     #   Include only the listed tables
       - categories
       - links
 
-  no_comments:
-    exclude_tables:     # Include all but the listed tables
+  no_comments:          # Defines a group called "no_comments"
+    exclude_tables:     #   Include all but the listed tables
       - comments
-      - comments_posts
+
+  all_but_comments:     # Defines a group called "all_but_comments"
+    include_all: true   #   Include all tables...
+    exclude_tables:     #   Except for comments
+      - comments        #   NOTE: This behaves identically to the no_comments group.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duple
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-22 00:00:00.000000000 Z
+date: 2012-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -134,10 +134,15 @@ files:
 - lib/duple/cli/refresh.rb
 - lib/duple/cli/root.rb
 - lib/duple/cli/structure.rb
+- lib/duple/config/command.rb
+- lib/duple/config/task.rb
 - lib/duple/configuration.rb
+- lib/duple/endpoint.rb
 - lib/duple/heroku_runner.rb
 - lib/duple/pg_runner.rb
 - lib/duple/runner.rb
+- lib/duple/source.rb
+- lib/duple/target.rb
 - lib/duple/version.rb
 - spec/config/groups.yml
 - spec/config/heroku_config.txt