sqrbl 0.1.0

data/spec/unit/group_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include Sqrbl
+
+describe Group do
+  before(:each) do
+    @mig = mock('Migration')
+  end
+
+  it "should evaluate the block in its own context" do
+    group = Group.new(@mig, "foo", :skip_block_evaluation => true) do
+      hello_world()
+    end
+    group.should_receive(:hello_world)
+    group.send(:evaluate_block!)
+  end
+
+  it "should delegate method_missing calls back to the migration object" do
+    @mig.should_receive(:goodbye_world)
+    group = Group.new(@mig, "foo") do
+      goodbye_world()
+    end
+  end
+
+  it "methods defined in the group block should become available as methods on the Group instance" do
+    group = Group.new(@mig, "foo") do
+      def hello_world
+        "Hello, world!"
+      end
+    end
+    group.should respond_to(:hello_world)
+    group.hello_world.should == "Hello, world!"
+  end
+
+  describe "when #todo is called" do
+    it "should create a Todo object that saves the message" do
+      group = Group.new(@mig, 'foo') { todo 'bar' }
+      group.todos.map(&:message).should == ['bar']
+    end
+
+    it "should create a Todo object that saves the location of the #todo call" do
+      group = Group.new(@mig, 'foo') { todo 'bar' }; line_num = __LINE__
+      group.todos.first.location.should == [__FILE__, line_num].join(':')
+    end
+  end
+
+  describe "when #step is called" do
+    it "should create a StepPair object and pass it the group, the description, and the block arg" do
+      test_self = self
+      group = Group.new(@mig, "foo") do
+        StepPair.should_receive(:new).with(self, 'do something').and_yield # Look weird?  See ./README.txt
+        step('do something') {}
+      end
+    end
+  end
+
+  describe :valid? do
+    it "should return false if steps is empty" do
+      group = Group.new(@mig, "foo") {}
+      group.should_not be_valid
+    end
+
+    it "should return false if steps is not empty, but any step is invalid" do
+      group = Group.new(@mig, "foo") { step("foo") {} }
+      group.steps.map(&:valid?).should include(false)
+      group.should_not be_valid
+    end
+
+    it "should return true if steps is not empty, and all steps are themselves valid" do
+      group = Group.new(@mig, "foo") do
+        step("foo") do
+          up {}
+          down {}
+        end
+      end
+      group.should be_valid
+    end
+  end
+
+  it "should have a unix_name property that consists of the regular name with characters sanitized" do
+    group = Group.new(@mig, "This be a test, matey!  ARRR!!") {}
+    group.unix_name.should == 'this_be_a_test_matey_arrr'
+  end
+
+end

data/spec/unit/migration_spec.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include Sqrbl
+
+describe Migration do
+  describe "A new migration" do
+    it "should know the file that created it" do
+      mig = Migration.new
+      mig.creating_file.should == File.expand_path(__FILE__)
+    end
+  end
+
+  describe "A migration built with Migration.build" do
+    it "should still know the file that created it" do
+      mig = Migration.build {}
+      mig.creating_file.should == File.expand_path(__FILE__)
+    end
+
+    describe "when the block calls #group once" do
+      it "should have one group with the proper description" do
+        mig = Migration.build do
+          group "first group" do
+            'hello world'
+          end
+        end
+        mig.groups.all? { |group| group.should be_kind_of(Group) }
+        mig.groups.map(&:description).should == ['first group']
+      end
+    end
+
+    describe "when the block calls #group twice" do
+      it "should have two group with the proper descriptions" do
+        mig = Migration.build do
+          group "first group" do
+            'hello world'
+          end
+          group "second group" do
+            'goodbye world'
+          end
+        end
+        mig.groups.all? { |group| group.should be_kind_of(Group) }
+        mig.groups.map(&:description).should == ['first group', 'second group']
+      end
+    end
+
+    it "should pass itself as a dependency to any group it builds" do
+      mig = Migration.build do
+        group("first group"    ) { '' }
+        group("second group"   ) { '' }
+        group("group the third") { '' }
+      end
+
+      mig.groups.all? { |group| group.migration.should == mig }
+    end
+  end
+
+  describe "when #todo is called" do
+    it "should create a Todo object that saves the message" do
+      mig = Migration.build { todo 'foo' }
+      mig.todos.map(&:message).should == ['foo']
+    end
+
+    it "should create a Todo object that saves the location of the #todo call" do
+      mig = Migration.build { todo 'foo' }; line_num = __LINE__
+      mig.todos.first.location.should == [__FILE__, line_num].join(':')
+    end
+  end
+end

data/spec/unit/sqrbl_spec.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include Sqrbl
+
+describe Sqrbl do
+  it ".build_migration should return an instance of Sqrbl::Migration" do
+    migration = Sqrbl.build_migration { 'hello, world!' }
+    migration.should be_kind_of(Sqrbl::Migration)
+  end
+
+  it ".migration should take the return value from Sqrbl::Migration.build and pass it to write_migration" do
+    mig = mock('Migration')
+    Migration.should_receive(:build).and_yield.and_return(mig)
+    Sqrbl.should_receive(:write_migration!).with(mig)
+    Sqrbl.migration { 'Hello, world!' }
+  end
+
+  describe :write_migration! do
+    it "should take a migration object and pass it off to any and all writers that exist" do
+      mig = mock('Migration')
+      BaseMigrationWriter.subclasses.each do |writer_class|
+        writer_class.should_receive(:write_migration!).with(mig)
+      end
+      Sqrbl.write_migration!(mig)
+    end
+  end
+
+end

data/spec/unit/step_pair_spec.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include Sqrbl
+
+describe StepPair do
+  before(:each) do
+    @group = mock('Group')
+  end
+
+  it "should evaluate the block in its own context" do
+    step_pair = StepPair.new(@group, "foo", :skip_block_evaluation => true) do
+      hello_world()
+    end
+    step_pair.should_receive(:hello_world)
+    step_pair.send(:evaluate_block!)
+  end
+
+  it "should delegate method_missing calls back to the group object" do
+    @group.should_receive(:goodbye_world)
+    step_pair = StepPair.new(@group, "foo") do
+      goodbye_world()
+    end
+  end
+
+  it "methods defined in the step_pair block should become available as methods on the StepPair instance" do
+    step_pair = StepPair.new(@group, "foo") do
+      def hello_world
+        "Hello, world!"
+      end
+    end
+    step_pair.should respond_to(:hello_world)
+    step_pair.hello_world.should == "Hello, world!"
+  end
+
+  describe "when #up is called" do
+    it "should create a Step object and pass it the StepPair and the block arg" do
+      step_pair = StepPair.new(@group, "foo") do
+        Step.should_receive(:new).with(self).and_yield # Look weird?  See ./README.txt
+        up {}
+      end
+    end
+
+    it "should put the Step object in its up_step attribute" do
+      step_pair = StepPair.new(@group, "foo") do
+        up {}
+      end
+      step_pair.up_step.should be_kind_of(Step)
+    end
+  end
+
+  describe "when #down is called" do
+    it "should create a Step object and pass it the StepPair and the block arg" do
+      step_pair = StepPair.new(@group, "foo") do
+        Step.should_receive(:new).with(self).and_yield # Look weird?  See ./README.txt
+        down {}
+      end
+    end
+
+    it "should put the Step object in its down_step attribute" do
+      step_pair = StepPair.new(@group, "foo") do
+        down {}
+      end
+      step_pair.down_step.should be_kind_of(Step)
+    end
+  end
+
+  describe :valid? do
+    it "should return false if up_step is nil" do
+      step_pair = StepPair.new(@group, "foo") do
+      end
+      step_pair.should_not be_valid
+    end
+    it "should return false if up_step is nil and down_step is not nil" do
+      step_pair = StepPair.new(@group, "foo") do
+        down {}
+      end
+      step_pair.should_not be_valid
+    end
+    it "should return false if up_step is not nil and down_step is nil" do
+      step_pair = StepPair.new(@group, "foo") do
+        up {}
+      end
+      step_pair.should_not be_valid
+    end
+    it "should return true if neither up_step and down_step is nil" do
+      step_pair = StepPair.new(@group, "foo") do
+        up {}
+        down {}
+      end
+      step_pair.should be_valid
+    end
+  end
+
+  describe "when #todo is called" do
+    it "should create a Todo object that saves the message" do
+      pair = StepPair.new(@group, 'foo') { todo 'bar' }
+      pair.todos.map(&:message).should == ['bar']
+    end
+
+    it "should create a Todo object that saves the location of the #todo call" do
+      pair = StepPair.new(@group, 'foo') { todo 'bar' }; line_num = __LINE__
+      pair.todos.first.location.should == [__FILE__, line_num].join(':')
+    end
+  end
+
+  it "should have a unix_name property that consists of the regular name with characters sanitized" do
+    pair = StepPair.new(@group, "This be a test, matey!  ARRR!!") {}
+    pair.unix_name.should == 'this_be_a_test_matey_arrr'
+  end
+end

data/spec/unit/step_spec.rb

@@ -0,0 +1,154 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include Sqrbl
+
+describe Step do
+  before(:each) do
+    @pair = mock('StepPair')
+  end
+
+  it "should evaluate the block in its own context" do
+    step = Step.new(@pair, :skip_block_evaluation => true) do
+      hello_world()
+    end
+    step.should_receive(:hello_world)
+    step.send(:evaluate_block!)
+  end
+
+  it "should delegate method_missing calls back to the step_pair object" do
+    @pair.should_receive(:goodbye_world)
+    step = Step.new(@pair) do
+      goodbye_world()
+    end
+  end
+
+  it "methods defined in the step's block should become available as methods on the Step instance" do
+    step = Step.new(@pair) do
+      def hello_world
+        "Hello, world!"
+      end
+    end
+    step.should respond_to(:hello_world)
+    step.hello_world.should == "Hello, world!"
+  end
+
+  describe "when #todo is called" do
+    it "should create a Todo object that saves the message" do
+      step = Step.new(@pair) { todo 'foo' }
+      step.todos.map(&:message).should == ['foo']
+    end
+
+    it "should create a Todo object that saves the location of the #todo call" do
+      step = Step.new(@pair) { todo 'foo' }; line_num = __LINE__
+      step.todos.first.location.should == [__FILE__, line_num].join(':')
+    end
+
+    it "should prepend its argument with '--> todo ([file], line [line #]):' and put it in #output" do
+      line_num = 0
+      step = Step.new(@pair) do
+        todo 'Fix a terrible issue'; line_num = __LINE__
+      end
+
+      step.output.should =~ /^--> todo \(.*\)\:/i
+      step.output.should include(__FILE__)
+      step.output.should =~ Regexp.new("line #{line_num}")
+      step.output.should include('Fix a terrible issue')
+    end
+  end
+
+  describe "when #comment is called" do
+    it "should prepend its argument with '-- ' and put it in #output" do
+      message = "Here's something you should probably be aware of."
+      step = Step.new(@pair) { comment(message) }
+      step.output.should =~ Regexp.new('^-- ' + message)
+    end
+  end
+
+  describe "when #block_comment is called" do
+    it "should surround its argument with /* and */ on newlines and put the whole thing in #output" do
+      message = "Here's something you should probably be aware of."
+      step = Step.new(@pair) { block_comment { message } }
+      step.output.should =~ /^\/\*/
+      step.output.should =~ Regexp.new('^    ' + message)
+      step.output.should =~ /^\*\//
+    end
+
+    describe "and given a string with extra spaces (as, e.g., a heredoc)" do
+      it "should unindent the argument before putting it in #output" do
+        step = Step.new(@pair) do
+          block_comment do 
+            <<-EOF
+              Foo.
+              Bar.
+              Baz.
+            EOF
+          end
+        end
+        step.output.should =~ /^    Foo./
+        step.output.should =~ /^    Bar./
+        step.output.should =~ /^    Baz./
+      end
+    end
+  end
+
+  describe "when #warning is called" do
+    it "should create a Todo object with type=:warning that saves the message" do
+      step = Step.new(@pair) { warning 'Danger, Will Robinson!' }
+      step.todos.map(&:type).should == [:warning]
+      step.todos.map(&:message).should == ['Danger, Will Robinson!']
+    end
+
+    it "should write a giant ASCII warning to #output" do
+      line_num = 0
+      step = Step.new(@pair) do
+        warning 'Danger, Will Robinson!'; line_num = __LINE__
+      end
+      step.output.should include(Step::GiantWarningSeparator)
+      step.output.should include(Step::GiantWarningText)
+      step.output.should include('Danger, Will Robinson!')
+      step.output.should =~ Regexp.new("line #{line_num}")
+    end
+  end
+
+  describe "when #action is called with a string and a block" do
+    before(:each) do
+      @step = Step.new(@pair) do
+        action "Do something" do
+          <<-EOF
+            Hello world!
+          EOF
+        end
+      end
+    end
+
+    it "should treat the string as a comment" do
+      @step.output.should =~ /^-- Do something/
+    end
+
+    it "should unindent the return value from the block and put it in #output" do
+      @step.output.should =~ /^Hello world!/
+    end
+  end
+
+  describe "#insert_into" do
+    it "should produce an INSERT INTO fragment" do
+      @step = Step.new(@pair) {}
+      insert_fragment = @step.insert_into 'new_widgets', {
+        :name     => 'widget_name',
+        :part_num => 'CONCAT("X_", part_number)',
+        :note     => '"Imported from old_widgets"',
+      }
+      # puts '<pre>%s</pre>' % insert_fragment
+
+      insert_fragment.should include('new_widgets')
+
+      insert_fragment.should =~ /^\s*name/
+      insert_fragment.should =~ /^\s*part_num/
+      insert_fragment.should =~ /^\s*note/
+
+      insert_fragment.should include('widget_name AS name')
+      insert_fragment.should include('CONCAT("X_", part_number) AS part_num')
+      insert_fragment.should include('"Imported from old_widgets" AS note')
+    end
+  end
+end

data/tasks/ann.rake

@@ -0,0 +1,80 @@
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+  desc "Send an email announcement"
+  task :email => ['ann:prereqs', PROJ.ann.file] do
+    ann = PROJ.ann
+    from = ann.email[:from] || Array(PROJ.authors).first || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF

data/tasks/bones.rake

@@ -0,0 +1,20 @@
+
+if HAVE_BONES
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if t.application.top_level_tasks.length == 2
+      t.application.top_level_tasks.pop
+    end
+
+    if atr then Bones::Debug.show_attr(PROJ, atr)
+    else Bones::Debug.show PROJ end
+  end
+
+end  # namespace :bones
+
+end  # HAVE_BONES
+
+# EOF