webmake 1.1.0

data/lib/ftp.rb

@@ -0,0 +1,175 @@
+require 'net/ftp'
+require 'net/sftp'
+
+class Ftp
+
+  def initialize(config)
+    @config = config
+    connect
+  end
+
+  def connect
+    if @config["sftp"]
+      @connection = Net::SFTP.start(@config["host"], @config["username"], :password => @config["password"])
+    else
+      @connection = Net::FTP.new(@config["host"])
+      @connection.login(@config["username"], @config["password"])
+    end
+
+    true
+  rescue
+    false
+  end
+
+  def close
+    @connection.close unless @config["sftp"]
+    true
+  end
+
+  def connected?
+    ! @connection.nil?
+  end
+
+  def list(dir)
+    if @config["sftp"]
+      files = []
+      @connection.dir.foreach(dir) do |entry|
+       permissions = entry.longname.split(" ")[0]
+        files << [entry.name, !entry.longname.starts_with("d"), permissions_from_string(permissions)] unless [".", ".."].include? entry.name
+      end
+      files
+    else
+      @connection.chdir(dir)
+      list = []
+      @connection.ls("-a").each do |file|
+        if file.size() > 8
+          filename = ""
+          filehold = file.split(" ")[8..-1] # get filename or directory name
+          filehold.each {|name_segment| filename += " #{name_segment}" }
+          filename.lstrip!
+
+          # if this is a directory a d or ASCII 100 will be the first character
+          # 45 means its just a file
+          # anything else is garbage
+          unless [".", ".."].include? filename
+            if file[0] == 45
+              list << [filename, true]
+            elsif file[0] == 100
+              list << [filename, false]
+            end 
+          end
+        end
+      end
+
+      list
+    end
+  rescue
+    []
+  end
+
+  def publish(path, create_dirs_on_failure = true)
+    remote_path = prepare_remote_path(path)
+
+    if @config["sftp"]
+      @connection.upload!(path, remote_path)
+    else
+      @connection.put(path, remote_path)
+    end
+
+    true
+  rescue
+    if create_dirs_on_failure
+      create_directories(remote_path)
+      return publish(path, false)
+    end
+    
+    false
+  end
+
+  def create_directories(path)
+    segments = File.dirname(path).gsub(/^\/?(.+?)\/?$/, "\\1").split("/")
+
+    dir = ""
+    dir = "/" if path[0, 1] == "/"
+
+    segments.each do |segment|
+      dir << "#{segment}/"
+
+      begin
+        @connection.mkdir(dir)
+      rescue
+        # This dir already exist, move on.
+      end
+    end
+  end
+
+  def create_dir(path)
+    path = prepare_remote_path(path)
+
+    create_directories(path)
+    @connection.mkdir(path)
+    true
+  rescue
+    false
+  end
+
+  def delete_file(path)
+    path = prepare_remote_path(path) unless path.match(/^#{Regexp.escape(@config["root"])}/)
+
+    if @config["sftp"]
+      @connection.remove!(path)
+      true
+    else
+      @connection.delete(path)
+      true
+    end
+  rescue
+    false
+  end
+
+  def delete_dir(path)
+    path = prepare_remote_path(path) unless path.match(/^#{Regexp.escape(@config["root"])}/)
+
+    if @config["sftp"]
+      @connection.dir.entries(path).each do |entry|
+        next if entry.name == '.' or entry.name == '..'
+
+        child_path = File.join(path, entry.name)
+
+        if @connection.stat!(child_path).directory?
+          delete_dir(child_path) 
+        else
+          delete_file(child_path)
+        end
+      end
+
+      @connection.rmdir!(path)
+      true
+    else
+      file_list = list(path)
+
+      file_list.each do |thefile|
+        filename = thefile[0]
+        # Files are True
+        if thefile[1]
+          delete_file(File.join(path, filename))
+        else
+          if filename != "." and filename != ".."
+            delete_dir(File.join(path, filename))
+          end
+        end
+      end
+
+      @connection.rmdir(path)
+      true
+    end
+  rescue
+    false
+  end
+
+  def prepare_remote_path(local_path)
+    path = local_path.gsub(/^#{Regexp.escape(Dir.pwd)}\//, "")
+    File.join(@config["root"], path)
+  end
+
+end

data/lib/wake.rb

@@ -0,0 +1,149 @@
+require 'rubygems'
+require 'find'
+require 'yaml'
+require "#{File.expand_path("..", __FILE__)}/ftp"
+require 'fileutils'
+
+module Wake
+
+  def self.public_methods
+    ['help', 'init', 'sync', 'set_synced']
+  end
+
+  # ----------------------------------------------------------------------
+  # Callable methods
+  # ----------------------------------------------------------------------
+
+  def self.help(e = nil)
+    puts "Wake only has three basic commands."
+    puts "  init - Initializes a new Wake project and creates a sample Wakefile."
+    puts "  sync - Publishes any changes in the filetree (including deletes)."
+    puts "  set_synced - Set the project as synchronized without publishing changes."
+  end
+
+  def self.init(e = nil)
+    config_file = File.join(Dir.pwd, "Wakefile")
+    release_dir = File.join(Dir.pwd, ".wake")
+
+    FileUtils.mkdir release_dir unless File.exists? release_dir
+
+    unless File.exists? config_file
+      wakefile_sample = File.expand_path("..", __FILE__)+"/../sample/Wakefile"
+      FileUtils.cp wakefile_sample, Dir.pwd
+    end
+  end
+
+  def self.set_synced(environment = "development")
+    self.get_tree_diff(environment)
+    puts "Environment #{environment} is now set as synced."
+  end
+
+  def self.sync(environment = "development")
+    config_file = File.join(Dir.pwd, "Wakefile")
+
+    unless File.exists? config_file
+      puts "This project has no Wakefile."
+      return
+    end
+
+    config = YAML::load(File.open(config_file).read)
+
+    unless config.has_key? environment
+      puts "#{environment.capitalize} environment is not defined in Wakefile."
+    end
+
+    synchronize(environment, config[environment])
+  end
+
+  def self.synchronize(environment, config)
+    diff_tree = self.get_tree_diff(environment)
+
+    ftp = Ftp.new(config)
+    diff_tree.each do |filename, stats|
+      if stats[:is_dir]
+        ftp.delete_dir(filename) if stats[:status] == :delete
+        ftp.create_dir(filename) if stats[:status] == :publish
+      else
+        ftp.delete_file(filename) if stats[:status] == :delete
+        ftp.publish(filename) if stats[:status] == :publish
+      end
+    end
+  end
+
+  # ----------------------------------------------------------------------
+  # "Private" methods
+  # ----------------------------------------------------------------------
+
+  def self.get_tree_diff(environment)
+    old_tree = self.get_old_tree(environment)
+    current_tree = self.get_current_tree
+
+    last_release = self.get_last_release_date(environment)
+
+    diff_tree = {}
+
+    # Find out if any files have been added or updated since the last release.
+    current_tree.each do |filename, is_dir|
+      if File.ctime(filename) > last_release
+        diff_tree[filename] = {
+          :is_dir => is_dir,
+          :status => :publish
+        }
+      end
+    end
+
+    # Find out if any files have been removed since the last release.
+    old_tree.each do |filename, is_dir|
+      unless current_tree.has_key? filename
+        diff_tree[filename] = {
+          :is_dir => is_dir,
+          :status => :delete
+        }
+      end
+    end
+
+    self.write_tree(environment, current_tree)
+
+    diff_tree
+  end
+
+  def self.get_last_release_date(environment)
+    tree_file = File.join(Dir.pwd, ".wake/#{environment}")
+
+    if File.exists? tree_file
+      return File.ctime tree_file
+    end
+
+    Time.at(0)
+  end
+
+  def self.get_old_tree(environment)
+    tree = {}
+
+    tree_file = File.join(Dir.pwd, ".wake/#{environment}")
+    if File.exists? tree_file
+      tree = YAML::load(File.open(tree_file).read)
+    end
+
+    tree
+  end
+
+  def self.get_current_tree
+    tree = {}
+
+    path = Dir.pwd
+    Find.find(path) do |file|
+      tree[file] = File.directory? file unless (file == path or file.match(/(Wakefile|\.wake)/))
+    end
+
+    tree
+  end
+
+  def self.write_tree(environment, tree)
+    tree_file = File.join(Dir.pwd, ".wake/#{environment}")
+    File.open(tree_file, 'w') do |f|
+      f.write YAML::dump(tree)
+    end
+  end
+
+end

data/sample/Wakefile

@@ -0,0 +1,20 @@
+development:
+  sftp: false
+  host: "ftp.example.com"
+  username: "dev"
+  password: "dev"
+  root: "/var/www/dev/"
+
+test:
+  sftp: false
+  host: "ftp.example.com"
+  username: "test"
+  password: "test"
+  root: "/var/www/test/"
+
+production:
+  sftp: true
+  host: "sftp.example.com"
+  username: "prod"
+  password: "prod"
+  root: "/var/www/production/"

data/wake

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require "#{File.expand_path("..", __FILE__)}/lib/wake"
+
+unless ARGV[0].nil?
+  command = ARGV[0]
+
+  if Wake.public_methods.include? command
+    environment = "development"
+    environment = ARGV[1] if ["development", "test", "production"].include? ARGV[1]
+
+    Wake.send(command, environment)
+  else
+    puts "Wake does not respond to \"#{command}\". Run \"wake help\" for more information."
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: webmake
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 1
+  - 1
+  - 0
+  version: 1.1.0
+platform: ruby
+authors: 
+- Christoffer Lejdborg
+autorequire: 
+bindir: .
+cert_chain: []
+
+date: 2011-01-21 00:00:00 +01:00
+default_executable: wake
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: net-sftp
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 0
+        - 5
+        version: 2.0.5
+  type: :runtime
+  version_requirements: *id002
+description: Wake is a very simplistic synchronisation tool for web applications. You can set up three envioronments (test, development and production) and use wither FTP or SFTP to sync your sites.
+email: hello@9muses.se
+executables: 
+- wake
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ftp.rb
+- lib/wake.rb
+- sample/Wakefile
+- ./wake
+has_rdoc: true
+homepage: http://github.com/Lejdborg/Wake
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: FTP/SFTP sync tool.
+test_files: []
+