monster_remote 0.0.1 → 0.1.0

data/lib/monster/remote/wrappers/net_ftp.rb

@@ -4,84 +4,140 @@ module Monster
   module Remote
     module Wrappers
 
-      class MonsterRemoteNetFTPWrapper < StandardError; end
-      class NetFTPPermissionDenied < MonsterRemoteNetFTPWrapper; end
-
       class NetFTP
 
-        def initialize(provider = Net::FTP)
-          @provider = provider
-          @filters = []
-          @nslt = {}
+        def initialize(driver=Net::FTP)
+          @driver = driver
         end
 
-        def open(host, port, user, pass)
-          @provider.open(host) do |ftp|
-            @ftp = ftp
-            @ftp.connect(host, port)
-            @ftp.login(user, pass)
-            yield(self, ftp)
+        def open(host, user, password, port, &block)
+          ftp = @driver.new
+          ftp.connect(host, port)
+          ftp.login(user, password)
+          if block
+            block.call(NetFTPHandler.new(ftp), ftp)
           end
+          ftp.close
         end
 
-        def copy_dir(local_dir, remote_dir)
-          create_if_not_exists(remote_dir)
-          local_structure = filter(Dir.entries(local_dir))
-          local_structure.each do |entry|
-            local_path = File.join(local_dir, entry)
-            remote_path = File.join(remote_dir, entry)
-            copy(local_path, remote_path)
+      end# NetFTP
+
+      class NetFTPHandler
+
+        def initialize(ftp)
+          @ftp = ftp
+        end
+
+        def create_dir(dir)
+          pwd = @ftp.pwd
+
+          dirs = dirs_in_path(dir)
+          root_dir_name = dirs.shift
+
+          create_and_chdir(root_dir_name)
+
+          if dirs.size > 0
+            dirs.each do |dir|
+              create_and_chdir(dir)
+            end
           end
+
+          @ftp.chdir(pwd)
         end
 
-        def add_filter(filter)
-          @filters ||= []
-          @filters << filter
+        def remove_dir(dir)
+          pwd = @ftp.pwd
+          dirs = dirs_in_path(dir)
+          final_dir = dirs.pop
+          dirs.each { |dir| @ftp.chdir(dir) }
+          empty_and_remove_dir(final_dir)
+          while(final_dir = dirs.pop)
+            @ftp.chdir("..")
+            empty_and_remove_dir(final_dir)
+          end
+          @ftp.chdir(pwd)
         end
 
-        private
-        def copy(from, to)
-          if(Dir.exists?(from))
-            copy_dir(from, to)
+        def copy_file(from, to)
+          if (dirs = dirs_in_path(to)).size > 1
+            file = dirs.pop
+            create_dir(dirs.join("/"))
+
+            pwd = @ftp.pwd
+            dirs.each { |dir| @ftp.chdir(dir) }
+            @ftp.putbinaryfile(from, file)
+            @ftp.chdir(pwd)
           else
-            copy_file(from, to)
+            @ftp.putbinaryfile(from, to)
           end
         end
 
-        def copy_file(from, to)
-          @ftp.putbinaryfile(from, to)
+        def remove_file(file)
+          @ftp.delete(file)
         end
 
-        def filter(dir_structure)
-          if(@filters.empty?)
-            @filters << ContentNameBasedFilter.new.reject([".", ".."])
+        private
+
+        def entry_from_regex_on_path(regex, path)
+          (matcher = regex.match(path)) && matcher[2].strip
+        end
+
+        def empty_dir(dir)
+          pwd = @ftp.pwd
+          @ftp.chdir(dir)
+          res = @ftp.list;
+          res.shift
+
+          res.each do |item|
+            if dir = entry_from_regex_on_path(/(^d.*)(\s.*)/i, item)
+              remove_dir(dir)
+            end
+
+            if file = entry_from_regex_on_path(/(^-.*)(\s.*)/i, item)
+              remove_file(file)
+            end
           end
 
-          allowed = dir_structure
-          @filters.each do |f|
-            allowed = f.filter(allowed)
+          @ftp.chdir(pwd)
+        end
+
+        def empty_and_remove_dir(dir)
+          empty_dir(dir)
+          if(@ftp.nlst.include?(dir))
+            @ftp.rmdir(dir)
           end
-          allowed
         end
 
-        def create_remote_dir(dir)
-          dirname = File.dirname(dir)
-          dir_content = @nslt[dirname] || @ftp.nlst(dirname)
-          dir_exists = dir_content.include? dir
-          @ftp.mkdir(dir) unless dir_exists
+        def create_and_chdir(dir)
+          create_dir_if_not_exists(dir)
+          @ftp.chdir(dir)
+        end
+
+        def dirs_in_path(dir)
+          dirs_in_path = dir.gsub(/\.*\/$/, "").split("/")
         end
 
-        def create_if_not_exists(dir)
+        def is_new_dir?(dir)
+          is_new_dir = true
           begin
-            create_remote_dir(dir)
-          rescue Net::FTPPermError => e
-            denied = NetFTPPermissionDenied.new(e)
-            raise denied, e.message
+            is_new_dir = @ftp.nlst(dir).empty?
+          rescue Net::FTPTempError => e
+            is_unexpected_error = !e.message.include?("450")
+            if is_unexpected_error
+              raise(e, e.message, caller)
+            end
+            is_new_dir = !e.message.include?("No files found")
           end
+          return is_new_dir
         end
 
-      end # NetFTP
+        def create_dir_if_not_exists(dir)
+          if is_new_dir?(dir)
+            @ftp.mkdir(dir)
+          end
+        end
+      end# NetFTPHandler
 
-    end
-  end
-end
+    end# Wrappers
+  end# Remote
+end# Monster

data/lib/monster/remote.rb

@@ -1,3 +1,15 @@
-require 'monster/remote/sync'
 require 'monster/remote/wrappers/net_ftp'
-require 'monster/remote/content_name_based_filter'
+require 'monster/remote/filters/filter'
+require 'monster/remote/filters/name_based_filter'
+require 'monster/remote/configuration'
+require 'monster/remote/sync'
+require 'monster/remote/cli'
+
+module Monster
+  module Remote
+
+    class MissingProtocolWrapperError < StandardError; end
+    class MissingLocalDirError < StandardError; end
+    class MissingRemoteDirError < StandardError; end
+  end
+end

data/lib/monster_remote.rb

@@ -0,0 +1,8 @@
+module Monster
+  module Remote
+    VERSION = "0.1.0"
+    NAME = File.basename(__FILE__)
+  end
+end
+
+require 'monster/remote'

data/monster_remote.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name        = "monster_remote"
+  s.version     = "0.1.0"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ricardo Valeriano"]
+  s.email       = ["ricardo.valeriano@gmail.com"]
+  s.homepage    = "http://github.com/ricardovaleriano/monster_remote"
+  s.summary     = "Publish your jekyll blog via ftp easy as pie"
+  s.description = "This gem allow you publish your jekyll static site via FTP, easy as pie."
+
+  s.required_rubygems_version = ">= 0"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fakefs"
+
+	s.require_path = 'lib'
+	
+  s.files         = ["Gemfile", "LICENSE", "README.md", "Rakefile", "bin/monster_remote", "lib/monster/remote.rb", "lib/monster/remote/cli.rb", "lib/monster/remote/configuration.rb", "lib/monster/remote/filters/filter.rb", "lib/monster/remote/filters/name_based_filter.rb", "lib/monster/remote/sync.rb", "lib/monster/remote/wrappers/net_ftp.rb", "lib/monster_remote.rb", "monster_remote.gemspec", "spec/monster/remote/cli_spec.rb", "spec/monster/remote/configuration_spec.rb", "spec/monster/remote/filters/filter_spec.rb", "spec/monster/remote/filters/name_based_filter_spec.rb", "spec/monster/remote/sync_spec.rb", "spec/monster/remote/wrappers/net_ftp_spec.rb", "spec/spec_helper.rb"]
+  s.test_files    = ["spec/monster/remote/cli_spec.rb", "spec/monster/remote/configuration_spec.rb", "spec/monster/remote/filters/filter_spec.rb", "spec/monster/remote/filters/name_based_filter_spec.rb", "spec/monster/remote/sync_spec.rb", "spec/monster/remote/wrappers/net_ftp_spec.rb", "spec/spec_helper.rb"]
+
+	
+  s.executables  = ["monster_remote"]
+	
+end

data/spec/monster/remote/cli_spec.rb

@@ -0,0 +1,237 @@
+module Monster
+  module Remote
+
+    describe CLI do
+
+      module ::Kernel
+        def rescuing_exit
+          yield
+          rescue SystemExit
+        end
+      end
+
+      def executable
+        File.join(File.expand_path("../../../../", __FILE__), "bin/monster_remote")
+      end
+
+      before(:all) do
+        @current_dir = Dir.pwd
+        @net_ftp = Monster::Remote::Wrappers::NetFTP
+      end
+
+      before do
+        @syncer = double("sync contract").as_null_object
+        @syncer.stub(:new).and_return(@syncer)
+        @out = double("out contract").as_null_object
+        @in = double("in contract").as_null_object
+        @password = "123"
+        @in.stub(:gets).and_return(@password)
+        @wrapper = double("fake wrapper").as_null_object
+
+        @cli = CLI.new(@syncer, @out, @in)
+      end
+
+      it "-v returns the version" do
+        rescuing_exit { @cli.run(["-v"]) == Monster::Remote::VERSION }
+      end
+
+      context "-p (wait for passowrd)" do
+
+        it "calls #print with 'password:' on the output" do
+          rescuing_exit do
+            @out.should_receive(:print).with("password:")
+            @cli.run(["-p"])
+          end
+        end
+
+        it "calls #gets on the input" do
+          rescuing_exit do
+            @in.should_receive(:gets)
+            @cli.run(["-p"])
+          end
+        end
+
+      end# wait for password
+
+      context "using the 'sync' interface" do
+
+        before do
+          @dirname = File.basename(@current_dir)
+          Monster::Remote::Wrappers::NetFTP = @wrapper
+        end
+
+        it "--ftp -p awaits for password even if another flags/options" do
+          rescuing_exit do 
+            @in.should_receive(:gets)
+            @cli.run(["--ftp", "-p"])
+          end
+        end
+
+        it "--ftp and ::new parameters" do
+          @syncer.should_receive(:new).with(@wrapper, @current_dir, @dirname, nil)
+          rescuing_exit do
+            @cli.run(["--ftp"])
+          end
+        end
+
+        it "uses NetFTP as default wrapper" do
+          @syncer.should_receive(:new).with(@wrapper, @current_dir, @dirname, nil)
+          rescuing_exit do
+            @cli.run(["-p"])
+          end
+        end
+
+        it "--verbose turn on the syncer verbosity" do
+          out = STDOUT.clone
+          STDOUT = double("omg my own stdout")
+          @syncer.should_receive(:new).with(@wrapper, @current_dir, @dirname, STDOUT)
+          rescuing_exit do
+            @cli.run(["--verbose"])
+          end
+          STDOUT = out
+        end
+
+        it "-l allow configure the local dir" do
+          local_dir = "opa/lele"
+          @syncer.should_receive(:new).with(@wrapper, local_dir, File.basename(local_dir), nil)
+          rescuing_exit do
+            @cli.run(["-l", local_dir])
+          end
+        end
+
+        it "-r allow specify the remote dir" do
+          remote = "test/omg/gogo"
+          @syncer.should_receive(:new).with(@wrapper, @current_dir, remote, nil)
+          rescuing_exit do
+            @cli.run(["-r", remote])
+          end
+        end
+
+        it "start sync with default configurations" do
+          @syncer.should_receive(:start).with(nil, nil, "localhost", 21)
+          rescuing_exit do
+            @cli.run
+          end
+        end
+
+        it "-H allow specify the server host" do
+          host = "borba"
+          @syncer.should_receive(:start).with(nil, nil, host, 21)
+          rescuing_exit do
+            @cli.run(["-H", host])
+          end
+        end
+
+        it "-P allow specify the host port" do
+          host = "borba"
+          port = "portalhes"
+          @syncer.should_receive(:start).with(nil, nil, host, port)
+          rescuing_exit do
+            @cli.run(["-H", host, "-P", port])
+          end
+        end
+
+        it "-u specify the user" do
+          user = "omg-my-user"
+          @syncer.should_receive(:start).with(user, nil, "localhost", 21)
+          rescuing_exit do
+            @cli.run(["-u", user])
+          end
+        end
+
+        it "-p specify the password" do
+          user = "omg-my-user"
+          @syncer.should_receive(:start).with(user, @password, "localhost", 21)
+          rescuing_exit do
+            @cli.run(["-u", user, "-p"])
+          end
+        end
+
+      end# sync
+
+      context "using configs from config file" do
+        before(:all) do
+          FileUtils.mkdir_p(spec_tmp) unless File.directory?(spec_tmp)
+          @file = File.join(spec_tmp, "_config.yml")
+          @pwd = Dir.pwd
+
+          Dir.chdir(spec_tmp)
+          file_content = "
+monster:
+  remote:
+    host: host
+    port: 333
+    user: user
+    pass: false
+    local_dir: local
+    remote_dir: remote
+"
+          File.open(@file, "w") do |f|
+            f.write(file_content)
+          end
+        end
+
+        it "calls #start with configs from file" do
+          @syncer.should_receive(:start).with("user", nil, "host", 333)
+          rescuing_exit do
+            @cli.run
+          end
+        end
+
+        it "calls ::new with configs from file" do
+          Monster::Remote::Wrappers::NetFTP = @wrapper
+          @syncer.should_receive(:new).with(@wrapper, "local", "remote", nil)
+          rescuing_exit do
+            @cli.run
+          end
+        end
+
+        it "command line options should override configs" do
+          @syncer.should_receive(:start).with("omg_my_user", nil, "monster", 333)
+          rescuing_exit do
+            @cli.run(["-u", "omg_my_user", "-H", "monster"])
+          end
+        end
+
+        it "should wait for password if configs says so" do
+          file_content = "
+monster:
+  remote:
+    host: host
+    port: 333
+    user: user
+    pass: true
+    local_dir: local
+    remote_dir:
+"
+          File.open(@file, "w") do |f|
+            f.write(file_content)
+          end
+          @syncer.should_receive(:start).with("user", @password, "host", 333)
+          rescuing_exit do
+            @cli.run
+          end
+        end
+
+        after(:all) do
+          FileUtils.rm_rf(spec_tmp) if File.directory?(spec_tmp)
+          Dir.chdir(@pwd)
+        end
+
+      end# _config.yml
+
+      context "executable" do
+
+        it "-v returns the version" do
+          `#{executable} -v`.strip.should == Monster::Remote::VERSION
+        end# -v
+
+      end# executable
+
+      after(:all) do
+        Monster::Remote::Wrappers::NetFTP = @net_ftp
+      end
+
+    end# CLI
+  end
+end

data/spec/monster/remote/configuration_spec.rb

@@ -0,0 +1,124 @@
+module Monster
+  module Remote
+
+    describe Configuration do
+      def minimal_config_file(host="host")
+"monster:
+  remote:
+    host: #{host}
+"
+      end
+
+      def path_to(file="o_m_g.yml")
+        File.join(spec_tmp, file)
+      end
+
+      before(:all) do
+        FileUtils.mkdir_p(spec_tmp)
+        @file_content = minimal_config_file << "
+    port: 333
+    user: user
+    pass: true
+    local_dir: local
+    remote_dir:
+"
+      end
+
+      it "ignores the abscence of config file" do
+        lambda { Configuration.new }.should_not raise_error
+      end
+
+      context "specific file on the constructor, properties" do
+
+        before(:all) do
+          @file = "o_m_g.yml"
+          File.open(path_to(@file), "w") do |f|
+            f.write(@file_content)
+          end
+          @conf = Configuration.new(path_to(@file))
+        end
+
+        it "#host" do
+          @conf.host.should == "host"
+        end
+
+        it "#port" do
+          @conf.port.should == 333
+        end
+
+        it "#user" do
+          @conf.user.should == "user"
+        end
+
+        it "#password_required?" do
+          @conf.password_required?.should be_true
+        end
+
+        it "#local_dir" do
+          @conf.local_dir.should == "local"
+        end
+
+        it "#remote_dir" do
+          @conf.remote_dir.should be_nil
+        end
+
+        after(:all) do
+          FileUtils.rm(path_to(@file)) if File.exists?(path_to(@file))
+        end
+
+      end# specific file
+
+      context "uses _config.yml as default configuration" do
+
+        before(:all) do
+          @pwd = Dir.pwd
+          Dir.chdir(spec_tmp)
+          @file = "_config.yml"
+          File.open(path_to(@file), "w") do |f|
+            f.write(minimal_config_file("borba"))
+          end
+          @conf = Configuration.new
+        end
+
+        it "gets configs from _config.yml by default" do
+          @conf.host.should == "borba"
+        end
+
+        after(:all) do
+          FileUtils.rm(@file)
+          Dir.chdir(@pwd)
+        end
+
+      end# defaults to _config.yml
+
+      context "uses .monster.yml as fallback for _config.yml" do
+
+        before(:all) do
+          @pwd = Dir.pwd
+          Dir.chdir(spec_tmp)
+          @file = ".monster.yml"
+          File.open(path_to(@file), "w") do |f|
+            f.write(minimal_config_file("lacatumba"))
+          end
+          @conf = Configuration.new
+        end
+
+        it "gets configs from .monster.yml" do
+          @conf.host.should == "lacatumba"
+        end
+
+        after(:all) do
+          FileUtils.rm(@file)
+          Dir.chdir(@pwd)
+        end
+
+      end
+
+      after(:all) do
+        FileUtils.rm_rf(spec_tmp) if File.exists?(spec_tmp)
+      end
+
+    end# Configuration
+
+  end# Remote
+end# Monpatster

data/spec/monster/remote/filters/filter_spec.rb

@@ -0,0 +1,16 @@
+module Monster
+  module Remote
+    module Filters
+
+      describe Filter do
+
+        it "accept a block with rejection logic, the list is passed as argument" do
+          filter = Filter.new
+          filter.reject lambda{ |entries| entries.reject{|entry| entry != "borba"} }
+          filter.filter(["a", "b", "borba"]).should == ["borba"]
+        end
+      end # describe Filter
+    end
+  end
+end
+

data/spec/monster/remote/filters/name_based_filter_spec.rb

@@ -0,0 +1,57 @@
+module Monster
+  module Remote
+    module Filters
+
+      describe NameBasedFilter do
+
+        def create_fake_dirs
+          @all_entries.each do |dir|
+            FileUtils.mkdir_p(File.join(@root_dir, dir))
+          end
+        end
+
+        before(:all) do
+          FakeFS.activate!
+          @root_dir = "/jajaja"
+          @allowed = ["I_CAN_BE_FILE", "ME_CAN"]
+          @forbidden = [".", "..", ".mafagafanho", "borba"]
+          @all_entries = @allowed + @forbidden
+          create_fake_dirs
+        end
+
+        before do
+          @filter = subject
+        end
+
+        it "accepts a dir name and return only allowed entries" do
+          @filter.reject @forbidden
+          @filter.filter(@root_dir).should == @allowed
+        end
+
+        context "#reject, configuring forbbiden names" do
+
+          it "accept string as parameter" do
+            @filter.reject "."
+            @filter.reject ".."
+            @filter.filter(["a", ".", ".."]).should == ["a"]
+          end
+
+          it "or any Enumerable" do
+            rejecting = ["a", "bb", "ccc"]
+            @filter.reject rejecting
+            @filter.filter(rejecting + ["opalhes"]).should == ["opalhes"]
+          end
+
+          it "accept a block with rejection logic, the list is passed as argument" do
+            @filter.reject lambda{ |entries| entries.reject{|entry| entry != "borba"} }
+            @filter.filter(["a", "b", "borba"]).should == ["borba"]
+          end
+        end # #reject
+
+        after(:all) do
+          FakeFS.deactivate!
+        end
+      end # describe ContentNameBasedFilter
+    end
+  end
+end