monster_remote 0.0.1 → 0.1.0

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+group :test do
+  gem "rspec"
+end

data/LICENSE

@@ -11,4 +11,3 @@ distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-

data/README.md

@@ -0,0 +1,141 @@
+Monster Remote (gem: monster_remote)
+====================================
+
+#What is this?
+A gem to help you publish your [jekyll](http://jekyllrb.com) blog via
+ftp (or any other "plugable" remote machine connection provider).
+
+#How is this?
+After install the gem
+
+    gem install monster_remote
+
+A new executable is gonna be at your service: `monster_remote`.
+
+##Syncing
+Enter the jekyll blog root path and type:
+
+    monster_remote [--ftp] -h your_server_address -u your_user_here
+
+The --ftp option is default, you could create you own connection
+provider if you need it.
+
+You will be prompted for your password. To reduce the size of the
+command by configuring some of these informations on your jekyll
+configuration file (or in a .monster.yml file inside your jekyll site):
+
+    monster:
+      remote:
+        host: ftp.some_host.com
+        user: omg_my_user
+        pass: true
+        local_dir: _site
+        remote_dir:
+        verbose: false
+
+Monster will rely on this configurations if you execute it without options.
+But the command line options overrides the configuration file info.
+
+##Filtering specific files
+A filter is an object which `respond_to? :filter`, you can stack
+filters within the synchronization execution. The code to do that
+has to stay on a `monster_config.rb` or a `config.rb`, create
+this file on the root directory of your jekyll site:
+
+```ruby
+# monster_config.rb
+
+Monster::Remote::add_filter(my_filter)
+```
+
+`monster_remote` is shipped with a "name_based_filter", if you want to
+reject specific files or directories based on the name, you could do
+something like these:
+
+```ruby
+# monster_config.rb
+
+my_filter = Monster::Remote::Filters::NameBasedFilter.new
+my_filter.reject /^.*rc/
+my_filter.reject /^not_allowed_dir\//
+
+Monster::Remote::add_filter(my_filter)
+```
+
+Note: the param to `#reject` can be a valid regex, so you could define
+some fine grained rules here. The above example will reject any file
+starting with a "." and ending with "rc", wich is pretty much any
+"classic" configuration file that you have on your directory. Neither
+"not_allowed_dir" gonna be synced. You could provide an array if you prefer:
+
+```ruby
+my_filter.reject [/^.*rc/, /ˆnot_allowed_dir\//]`
+```
+
+Or you could use a string:
+
+```ruby
+my_filter.reject ".my_secret_file"
+```
+
+If you need execute more specific or complex logic, you could use a "raw
+filter". Just provides a block with the logic you need, an array with
+the dir structure will be passed as argument and a filtered array should
+be returned. Just files and dirs on the result array will be synced:
+
+```ruby
+my_custom_filter = Monster::Remote::Filters::Filter.new
+my_custom_filter.reject lambda { |entries|
+  # do whatever you need here, for example:
+  entries.reject do |entry|
+    entry =~ /^.*rc/ || entry =~ /^not_allowed_dir\//
+  end
+}
+
+Monster::Remote::add_filter(my_custom_filter)
+```
+
+Since a filter is an object which `responds_to? :filter` you could
+implement your filter in a class. The `#filter` will receive an array
+with the list of files and dirs in given directory, you need to return a
+new array with only the allowed files and dirs:
+
+```ruby
+class MyOMGFilter
+  def filter(entries)
+    // your logic here
+    return new_filtered_array
+  end
+end
+```
+
+#Protocol Wrappers
+A wrapper is an object with the following methods:
+
+ * `::new(driver=Net::FTP)`
+    - the class from the real connection objects will be generated
+ * `#open(host=nil, user=nil, password=nil, port=nil)`
+    - called when the synchrony starts
+    - if a block is given, it will be yielded and two arguments will be
+      passed to the block:
+        - an object that `responds_to? :create_dir`, and `responds_to?
+          :copy_file`. This object has an internal reference to the real
+          connection
+           - `#create_dir(dir)` - creates a remote dir
+           - `#remove_dir(dir)` - removes a remote dir
+           - `#copy_file(from, to)` - copies a file to the remote location
+           - `#remove_file(file)` - removes a remote file
+        - the real connection object (you can ignore the second argument if you want)
+    - this method close the real connection before returns
+
+Internally a wrapper will use a real "thing" (like the default `Net::FTP`)
+to replicate the local dir structure to the remote dir.
+
+#Programatically Syncing
+The `Monster::Remote::Sync` class has a very well defined interface, and
+you could use this to write your own sync logic if you need:
+
+ * `::new(wrapper, local_dir=nil, remote_dir=nil, verbose=nil)`
+ * `start(user = nil, password = nil, host = "localhost", port = 21)`
+    - calls the wrapper.open method passing a block with instructions to
+      replicate the local configured dir

data/Rakefile

@@ -0,0 +1,12 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+task :default => [:specs]
+task :specs => [:"specs:all"]
+namespace :specs do
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new "all" do |t|
+    t.pattern = "spec/**/*_spec.rb"
+    t.rspec_opts = ['--color', '--format documentation', '--require spec_helper']
+  end
+end

data/bin/monster_remote

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+lib = File.expand_path("../../lib", __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'monster_remote'
+
+begin
+  Monster::Remote::CLI.new.run
+rescue Interrupt => e
+  exit 1
+rescue SystemExit => e
+  exit e.status
+rescue Exception => e
+  raise e
+end
+

data/lib/monster/remote/cli.rb

@@ -0,0 +1,104 @@
+require 'optparse'
+
+module Monster
+  module Remote
+
+    class CLI
+
+      def initialize(syncer=Sync, out=STDOUT, input=STDIN)
+        @syncer = syncer
+        @out = out
+        @in = input
+      end
+
+      def run(args=ARGV)
+        options = parse_options(args)
+
+        show_version if options[:show_version]
+        password = nil
+
+        config = Configuration.new
+        if options[:password] || config.password_required?
+          password = wait_for_password
+        end
+
+        connection_wrapper = options[:wrapper] || Monster::Remote::Wrappers::NetFTP
+        local_dir = options[:local_dir] || config.local_dir || Dir.pwd
+        remote_dir = options[:remote_dir] || config.remote_dir || File.basename(local_dir)
+        out = (options[:verbose] || config.verbose?) ? STDOUT : nil
+        host = options[:host] || config.host || "localhost"
+        port = options[:port] || config.port || 21
+        user = options[:user] || config.user || nil
+
+        sync = @syncer.new(connection_wrapper, local_dir, remote_dir, out)
+        sync.start(user, password, host, port)
+      end
+
+      def show_version
+        @out.puts Monster::Remote::VERSION
+        exit(0)
+      end
+
+      def wait_for_password
+        @out.print "password:"
+
+        system("stty -echo")
+
+        password = @in.gets.strip
+
+        system("stty echo")
+        system("echo \"\"")
+
+        password
+      end
+
+      private
+      def parse_options(args, options={})
+        parser = OptionParser.new do |opts|
+          opts.banner = "monster_remote v#{Monster::Remote::VERSION}"
+          opts.banner << " :: Remote sync your jekyll site :: Usage: monster_remote [options]"
+
+          opts.on "-v", "--version", "Show version" do
+            options[:show_version] = true
+          end
+
+          opts.on "-p", "--password", "Password for connection" do
+            options[:password] = true
+          end
+
+          opts.on "-u", "--user USER", "User for connection" do |user|
+            options[:user] = user
+          end
+
+          opts.on "--ftp", "Transfer with NetFTP wrapper" do
+            options[:wrapper] = Monster::Remote::Wrappers::NetFTP
+          end
+
+          opts.on "--verbose", "Verbose mode" do
+            options[:verbose] = true
+          end
+
+          opts.on "-l", "--local-dir DIR_PATH", "Local dir to replicate" do |dir|
+            options[:local_dir] = dir
+          end
+
+          opts.on "-r", "--remote-dir DIR_PATH", "Remote root dir" do |dir|
+            options[:remote_dir] = dir
+          end
+
+          opts.on "-H", "--host HOST", "Server host" do |host|
+            options[:host] = host
+          end
+
+          opts.on "-P", "--port SERVER_PORT", "Server port" do |port|
+            options[:port] = port
+          end
+        end
+
+        parser.parse!(args)
+        options
+      end
+
+    end # CLI
+  end
+end

data/lib/monster/remote/configuration.rb

@@ -0,0 +1,53 @@
+require 'yaml'
+
+module Monster
+  module Remote
+
+    class Configuration
+
+      def initialize(configuration_file = "_config.yml")
+        unless File.exists?(configuration_file)
+          configuration_file = ".monster.yml"
+        end
+
+        @configs = {}
+
+        begin
+          file_info = YAML::load( File.open(configuration_file) )
+          @configs = file_info && file_info["monster"] && file_info["monster"]["remote"]
+        rescue Errno::ENOENT => e
+        end
+      end
+
+      def password_required?
+        read_config("pass")
+      end
+
+      def verbose?
+        read_config("verbose")
+      end
+
+      private
+      def expected
+        [:host, :port, :user, :local_dir, :remote_dir, :verbose]
+      end
+
+      def respond_to?(method)
+        expected.include? method || super
+      end
+
+      def method_missing(method, *args)
+        if expected.include? method
+          return read_config(method.to_s)
+        end
+        super
+      end
+
+      def read_config(name)
+        @configs && @configs[name]
+      end
+
+    end# Configuration
+
+  end# Remote
+end# Monster

data/lib/monster/remote/filters/filter.rb

@@ -0,0 +1,24 @@
+module Monster
+  module Remote
+
+    class Filter
+
+      def reject(reject_logic)
+        @rejecting ||= []
+        @rejecting << reject_logic
+        self
+      end
+
+      def filter(entries)
+        return [] if entries.nil?
+        allowed = entries
+        @rejecting.each do |logic|
+          allowed = logic.call(allowed)
+        end
+        allowed
+      end
+
+    end # Filter
+  end
+end
+

data/lib/monster/remote/{content_name_based_filter.rb → filters/name_based_filter.rb}

@@ -1,27 +1,24 @@
+require 'monster/remote/filters/filter'
+
 module Monster
   module Remote
 
-    class ContentNameBasedFilter
+    class NameBasedFilter < Filter
 
       def reject(reject_logic)
-        @rejecting ||= []
-        rejections = []
         if reject_logic.respond_to? :call
-          rejections << reject_logic
+          super(reject_logic)
         else
-          rejections = become_block(reject_logic)
+          become_block(reject_logic).each do |rejection|
+            super(rejection)
+          end
         end
-        @rejecting += rejections
         self
       end
 
       def filter(directory)
-        return [] if directory.nil?
-        allowed = become_array(directory)
-        @rejecting.each do |logic|
-          allowed = logic.call(allowed)
-        end
-        allowed
+        dir_structure = become_array(directory)
+        super(dir_structure)
       end
 
       private

data/lib/monster/remote/sync.rb

@@ -3,55 +3,87 @@ module Monster
 
     class Sync
 
-      def self.with
-        Sync.new
+      attr_writer :verbose, :host, :port
+
+      def initialize(wrapper, local_dir=nil, remote_dir=nil, verbose=nil)
+        @wrapper = wrapper
+        local_dir && @local_dir = local_dir
+        remote_dir && @remote_dir = remote_dir
+        verbose && @verbose = verbose
       end
 
-      def start
-        @provider.open(@host, @port || 21, @user, @pass) do |con|
-          con.copy_dir(@local_dir || "./_site", @remote_dir || ".")
+      def start(user = nil, password = nil, host = "localhost", port = 21)
+        @host = host
+        @port = port
+        @user = user || ""
+        @password = password || ""
+
+        @wrapper || raise(MissingProtocolWrapperError)
+        local_dir || raise(MissingLocalDirError)
+        remote_dir || raise(MissingRemoteDirError)
+
+        out("syncing from: #{local_dir} to: #{remote_dir}")
+
+        open(@wrapper) do |wrapper|
+          out("connection openned, using: #{wrapper}")
+          copy_to_remote(wrapper, local_dir)
         end
       end
 
-      def add_filter(filter)
-        @provider.add_filter(filter)
+      private
+      def create_dir(wrapper, local_dir_path, remote_dir_path, entry_path)
+        out("creating dir #{remote_dir_path}")
+        wrapper.create_dir(remote_dir_path)
+        out("diggin into #{local_dir_path}")
+        Dir.entries(local_dir_path).each do |dir|
+          copy_to_remote(wrapper, dir, entry_path)
+        end
       end
 
-      def local_dir(local_dir)
-        @local_dir = local_dir
-        self
+      def copy_file(wrapper, local_file, remote_file)
+        out("coping file to #{remote_file}")
+        wrapper.copy_file(local_file, remote_file)
       end
 
-      def remote_dir(remote_dir)
-        @remote_dir = remote_dir
-        self
-      end
+      def copy_to_remote(wrapper, entry, path=nil)
+        is_dot_dir = entry =~ /^\.$|^\.\.$/
+        out("ignoring dir #{entry}")
+        return if is_dot_dir
+
+        entry_path = path ? File.join(path, entry) : ""
+        local_path = File.join(local_dir, entry_path).gsub(/\.*\/$/, "")
+        remote_path = File.join(remote_dir, entry_path).gsub(/\.*\/$/, "")
 
-      def remote_connection_provider(provider)
-        @provider = provider
-        self
+        if File.directory?(local_path)
+          out("copying #{local_path}")
+          create_dir(wrapper, local_path, remote_path, entry_path)
+        else
+          copy_file(wrapper, local_path, remote_path)
+        end
       end
 
-      def host(host)
-        @host = host
-        self
+      def out(msg)
+        @verbose && @verbose.puts(msg)
       end
 
-      def port(port)
-        @port = port
-        self
+      def local_dir
+        @local_dir
       end
 
-      def user(user)
-        @user = user
-        self
+      def remote_dir
+        @remote_dir
       end
 
-      def pass(pass)
-        @pass = pass
-        self
+      def open(wrapper, &block)
+        begin
+          out("trying to connect using wrapper")
+          wrapper.new.open(@host, @user, @password, @port, &block)
+        rescue Exception => e
+          out("connection failed, #{e.message}")
+          raise e
+        end
       end
-    end # Sync
 
+    end# Sync
   end
 end