frank 1.0.9 → 1.0.10

data/lib/frank/publish/ftptls.rb

@@ -0,0 +1,80 @@
+require 'frank/publish/base'
+require 'net/ftptls'
+
+module Frank
+  module Publish
+
+    class FTPTLS < Base
+
+      def initialize(options, &block)
+        super(options)
+        instance_eval(&block) if block_given?
+
+        @port ||= 21
+        @remote_path = remote_path.sub(/^\~\//, '').sub(/^\//, '')
+      end
+
+      private
+
+      ##
+      # Establishes a connection to the remote server
+      #
+      # Note:
+      # Since the FTP port is defined as a constant in the Net::FTP class, and
+      # might be required to change by the user, we dynamically remove and
+      # re-add the constant with the provided port value
+      def connection
+        if Net::FTPTLS.const_defined?(:FTP_PORT)
+          Net::FTPTLS.send(:remove_const, :FTP_PORT)
+        end; Net::FTPTLS.send(:const_set, :FTP_PORT, port)
+
+        Net::FTPTLS.open(hostname, username, password) do |ftp|
+          ftp.passive = true
+          yield ftp
+        end
+      end
+
+      ##
+      # Transfers the archived file to the specified remote server
+      def transfer!
+        connection do |ftp|
+          directories.each do |dir|
+            create_remote_path(File.join(remote_path, dir), ftp)
+          end
+
+          files_to_transfer.each do |file|
+            ok_message "Uploading #{file}", "    - "
+            ftp.put(
+              File.join(local_path, file),
+              File.join(remote_path, file)
+            )
+          end
+        end
+      end
+
+      ##
+      # Creates (if they don't exist yet) all the directories on the remote
+      # server in order to upload the backup file. Net::FTP does not support
+      # paths to directories that don't yet exist when creating new
+      # directories. Instead, we split the parts up in to an array (for each
+      # '/') and loop through that to create the directories one by one.
+      # Net::FTP raises an exception when the directory it's trying to create
+      # already exists, so we have rescue it
+      def create_remote_path(remote_path, ftp)
+        path_parts = []
+        remote_path.split('/').each do |path_part|
+          path_parts << path_part
+          begin
+            dir = path_parts.join('/')
+            ftp.mkdir(dir) unless dir.empty?
+          rescue Net::FTPPermError;
+          end
+        end
+      end
+
+
+    end
+
+
+  end
+end

data/lib/frank/publish/scp.rb

@@ -0,0 +1,37 @@
+require 'frank/publish/base'
+require 'net/ssh'
+require 'net/scp'
+
+
+module Frank
+  module Publish
+    class SCP < Base
+
+      def initialize(options, &block)
+        super(options)
+        instance_eval(&block) if block_given?
+
+        @port ||= 22
+      end
+
+
+      def connection
+        Net::SCP.start(hostname, username, :password => password) do |scp|
+          yield scp
+        end
+      end
+
+      def transfer!
+        connection do |scp|
+          old_name = ''
+          scp.upload! local_path, remote_path do |ch, name|
+            if old_name != name
+              ok_message "Uploading #{name}", "    - "
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/frank/publish/sftp.rb

@@ -0,0 +1,37 @@
+require 'frank/publish/base'
+require 'net/ssh'
+require 'net/sftp'
+
+
+module Frank
+  module Publish
+    class SFTP < Base
+
+      def initialize(options, &block)
+        super(options)
+        instance_eval(&block) if block_given?
+
+        @port ||= 22
+      end
+
+
+      def connection
+        Net::SFTP.start(hostname, username, :password => password) do |scp|
+          yield scp
+        end
+      end
+
+      def transfer!
+        connection do |scp|
+          old_name = ''
+          scp.upload! local_path, remote_path do |ch, name|
+            if old_name != name
+              ok_message "Uploading #{name}", "    - "
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/frank/publish/shell_scp.rb

@@ -0,0 +1,29 @@
+module Frank
+  module Publish
+
+    #TODO
+
+    class ShellSCP
+
+
+      def self.shell_copy(local_dir, remote_dir, options)
+
+        host = []
+        command = ["scp "]
+        command << "-P #{options[:port]} " if options[:port]
+        command << "-r #{local_dir}/* "
+        host << "#{options[:username]}" if options[:username]
+        host << ":#{options[:password]}" if options[:password]
+        host << "@#{options[:host]}:#{remote_dir}"
+
+        shell_command = "#{command.join('')}#{host.join('')}"
+        system(shell_command)
+
+      end
+
+
+    end
+
+
+  end
+end

data/lib/frank/settings.rb

@@ -43,6 +43,7 @@ module Frank
       @publish.path = nil
       @publish.username = nil
       @publish.password = nil
+      @publish.mode = nil
 
       # setup folders
       @static_folder = "static"

data/lib/frank/version.rb

@@ -1,3 +1,3 @@
 module Frank
-  VERSION = '1.0.9'
+  VERSION = '1.0.10'
 end

data/lib/template/setup.rb

@@ -53,7 +53,8 @@ Frank.export.path = "exported"
 #  Publish settings:
 #
 #  Frank can publish your exported project to
-#  a server. All you have to do is tell Frank what host, path, and username.
+#  a remote server via scp (default) or ftp. All you have to do is tell Frank what host, path, and username.
+#  Depending on the chosen mode, you may need to install net-scp or net-sftp.
 #  If you have ssh keys setup there is no need for a password.
 #  Just uncomment the Publish settings below and
 #  make the appropriate changes.
@@ -63,6 +64,8 @@ Frank.export.path = "exported"
 #  Frank.publish.username = 'me'
 #  Frank.publish.password = 'secret'
 #  Frank.publish.port = 22
+#  Frank.publish.mode = :scp (or :ftp, :ftptls, :sftp)  #no ftptls in ruby 1.9
+#
 #
 
 # ----------------------

data/spec/base_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/helper'
+require File.dirname(__FILE__) + '/spec_helper'
 
 describe Frank::Base do
   include Rack::Test::Methods
@@ -26,14 +26,14 @@ describe Frank::Base do
     get '/'
 
     last_response.should be_ok
-    last_response.body.should == "<div id='p'>/</div>\n<div id='layout'>\n  <h1>hello worlds</h1>\n  <h2>/</h2>\n</div>\n"
+    last_response.body.strip.should == "<div id='p'>/</div>\n<div id='layout'>\n  <h1>hello worlds</h1>\n  <h2>/</h2>\n</div>"
   end
 
   it 'renders a page and uses a helper' do
     get '/helper_test'
 
     last_response.should be_ok
-    last_response.body.should == "<div id='p'>/helper_test</div>\n<div id='layout'>\n  <h1>hello from helper</h1>\n</div>\n"
+    last_response.body.strip.should == "<div id='p'>/helper_test</div>\n<div id='layout'>\n  <h1>hello from helper</h1>\n</div>"
   end
 
   it 'renders a nested template given a request' do
@@ -51,7 +51,7 @@ describe Frank::Base do
   end
 
   it 'renders a 404 page if template not found' do
-    get '/not_here.css'
+    capture_stdout { get '/not_here.css' }
 
     last_response.should_not be_ok
     last_response.content_type.should == 'text/html'
@@ -68,7 +68,7 @@ describe Frank::Base do
   it 'stubs out a project' do
     out = capture_stdout { Frank.stub('stubbed') }
     Dir.entries('stubbed').should == Dir.entries(File.join(LIBDIR, 'template'))
-    response = "\nFrank is...\n - \e[32mCreating\e[0m your project 'stubbed'\n - \e[32mCopying\e[0m Frank template\n\n \e[32mCongratulations, 'stubbed' is ready to go!\e[0m\n"
+    response = "\nFrank is...\n - \e[32mCreating\e[0m your project 'stubbed'\n - \e[32mCopying\e[0m default Frank template\n\n \e[32mCongratulations, 'stubbed' is ready to go!\e[0m\n"
     out.string.should == response
   end
 

data/spec/compile_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/helper'
+require File.dirname(__FILE__) + '/spec_helper'
 
 describe Frank::Compile do
   include Rack::Test::Methods
@@ -14,6 +14,8 @@ describe Frank::Compile do
       end
 
       it 'creates the default export dir' do
+        Frank.bootstrap(proj_dir)
+
         Dir.chdir proj_dir do
           frank 'export'
 

data/spec/publish/base_spec.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+require 'frank/publish/base'
+
+
+describe Frank::Publish::Base do
+
+  let(:publisher) do
+    Frank::Publish::Base.new(Frank.publish)
+  end
+
+  before(:all) do
+    Frank.bootstrap(File.join(File.dirname(__FILE__), '..', 'template'))
+  end
+
+  describe '#initialize' do
+
+    it 'should set the correct values' do
+      publisher.username.should == 'test'
+      publisher.password.should == 'secret'
+      publisher.hostname.should == 'example.com'
+      publisher.remote_path.should == '/remote/path'
+    end
+
+    it 'should set the local export path' do
+      publisher.local_path =~ /\/tmp\/frank-publish-template-\d+\//
+    end
+
+  end
+
+  describe '#permform!' do
+
+    before do
+      publisher.stubs(:export!)
+      publisher.stubs(:transfer!)
+      publisher.stubs(:cleanup!)
+    end
+
+    it 'call export, transfer, cleanup ins that order' do
+      publisher.expects(:export!)
+      publisher.expects(:transfer!)
+      publisher.expects(:cleanup!)
+
+      publisher.perform!
+    end
+
+  end
+
+  describe '#files_to_transfer' do
+
+    it 'should list empty directories if export does not exists' do
+      publisher.send(:files_to_transfer).should be_empty
+    end
+
+    it 'should list all files' do
+      publisher.send(:export!)
+      publisher.send(:files_to_transfer).should have(26).elements
+      publisher.send(:files_to_transfer).should include("500.html")
+      publisher.send(:files_to_transfer).should_not include("files")
+    end
+
+    it 'should not list hidden files beginning with .' do
+      publisher.send(:export!)
+      publisher.send(:files_to_transfer).each do |elem|
+        elem.should_not =~ /^\./
+      end
+    end
+
+    after do
+      publisher.send(:cleanup!)
+    end
+
+  end
+
+  describe '#directories' do
+
+    it 'should list empty directories if export does not exists' do
+      publisher.send(:directories).should be_empty
+    end
+
+    it 'should list all directories' do
+      publisher.send(:export!)
+      publisher.send(:directories).should include("files", "nested", "nested/deeper", "stylesheets")
+    end
+
+    it 'should not list . or ..' do
+      publisher.send(:export!)
+      publisher.send(:directories).should_not include('.', '..')
+    end
+
+    after do
+      publisher.send(:cleanup!)
+    end
+
+  end
+
+  describe '#export!' do
+
+    it 'should export the project to the tmp folder' do
+      publisher.send(:export!)
+
+      publisher.local_path.should =~ /\/tmp\/frank-publish-template-\d+/
+      File.exist?(publisher.local_path).should be_true
+    end
+
+    after do
+      publisher.send(:cleanup!)
+    end
+
+  end
+
+  describe '#cleanup!' do
+
+    it 'should not leave the export folder in the tmp folder' do
+      publisher.send(:export!)
+      publisher.send(:cleanup!)
+
+      publisher.local_path.should =~ /\/tmp\/frank-publish-template-\d+/
+      File.exist?(publisher.local_path).should_not be_true
+    end
+
+  end
+
+end

data/spec/publish/ftp_spec.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+require 'frank/publish/ftp'
+
+describe Frank::Publish::FTP do
+
+  let(:publisher) do
+    Frank::Publish::FTP.new(Frank.publish) do |ftp|
+      ftp.username = 'my_username'
+      ftp.password = 'my_password'
+      ftp.hostname = 'ftp.example.com'
+      ftp.local_path = '/local/path'
+      ftp.remote_path = '/remote/path'
+    end
+  end
+
+  before(:all) do
+    Frank.bootstrap(File.join(File.dirname(__FILE__), 'template'))
+  end
+
+  describe '#initialize' do
+    it 'should set the correct values' do
+      publisher.username.should == 'my_username'
+      publisher.password.should == 'my_password'
+      publisher.hostname.should == 'ftp.example.com'
+      publisher.port.should == 21
+      publisher.local_path.should == '/local/path'
+      publisher.remote_path.should == 'remote/path'
+
+    end
+
+    it 'should remove any preceeding tilde and slash from the path' do
+      publisher = Frank::Publish::FTP.new(Frank.publish) do |ftp|
+        ftp.remote_path = '~/my_backups/path'
+      end
+      publisher.remote_path.should == 'my_backups/path'
+    end
+
+    context 'when setting configuration defaults' do
+
+
+    end # context 'when setting configuration defaults'
+
+  end # describe '#initialize'
+
+  describe '#connection' do
+    let(:connection) { mock }
+
+    it 'should yield a connection to the remote server' do
+      Net::FTP.expects(:open).with(
+        'ftp.example.com', 'my_username', 'my_password'
+      ).yields(connection)
+
+      connection.expects(:passive=).with(true)
+
+      publisher.send(:connection) do |ftp|
+        ftp.should be(connection)
+      end
+    end
+
+    it 'should set the Net::FTP_PORT constant' do
+      publisher.port = 40
+      Net::FTP.expects(:const_defined?).with(:FTP_PORT).returns(true)
+      Net::FTP.expects(:send).with(:remove_const, :FTP_PORT)
+      Net::FTP.expects(:send).with(:const_set, :FTP_PORT, 40)
+
+      Net::FTP.expects(:open)
+      publisher.send(:connection)
+    end
+
+  end # describe '#connection'
+
+  describe '#transfer!' do
+    let(:connection) { mock }
+    let(:package) { mock }
+    let(:files) { ["file1", "file2", "subdir1/file3", "subdir2/file4"] }
+    let(:dirs) { ["subdir1", "subdir2"] }
+    let(:s) { sequence '' }
+
+    before do
+      publisher.stubs(:connection).yields(connection)
+      publisher.stubs(:files_to_transfer).returns(files)
+      publisher.stubs(:directories).returns(dirs)
+    end
+
+    it 'should transfer the files' do
+
+
+      # connection.expects(:chdir).in_sequence(s).with('remote/path')
+
+      #publisher.expects(:directories).in_sequence(s)
+
+      publisher.expects(:create_remote_path).in_sequence(s).with('remote/path/subdir1', connection)
+      publisher.expects(:create_remote_path).in_sequence(s).with('remote/path/subdir2', connection)
+
+      connection.expects(:put).in_sequence(s).with(
+        File.join('/local/path', 'file1'),
+        File.join('remote/path', 'file1')
+      )
+
+      connection.expects(:put).in_sequence(s).with(
+        File.join('/local/path', 'file2'),
+        File.join('remote/path', 'file2')
+      )
+
+      connection.expects(:put).in_sequence(s).with(
+        File.join('/local/path', 'subdir1/file3'),
+        File.join('remote/path', 'subdir1/file3')
+      )
+
+      connection.expects(:put).in_sequence(s).with(
+        File.join('/local/path', 'subdir2/file4'),
+        File.join('remote/path', 'subdir2/file4')
+      )
+
+      publisher.send(:transfer!)
+    end
+  end # describe '#transfer!'
+
+
+  describe '#create_remote_path' do
+    let(:connection) { mock }
+    let(:remote_path) { 'remote/folder/another_folder' }
+    let(:s) { sequence '' }
+
+    context 'while properly creating remote directories one by one' do
+      it 'should rescue any FTPPermErrors and continue' do
+        connection.expects(:mkdir).in_sequence(s).
+          with("remote").raises(Net::FTPPermError)
+        connection.expects(:mkdir).in_sequence(s).
+          with("remote/folder")
+        connection.expects(:mkdir).in_sequence(s).
+          with("remote/folder/another_folder")
+
+        expect do
+          publisher.send(:create_remote_path, remote_path, connection)
+        end.not_to raise_error
+      end
+    end
+  end
+
+end