yuzu 0.2.1.pre

data/lib/uploader/ftp_service.rb

@@ -0,0 +1,90 @@
+require 'uploader/base'
+require 'uploader/service'
+require 'net/ftp'
+require 'stringio'
+
+module Uploader
+  class FtpService < Service
+
+    def connect!
+      $stderr.puts "Opening a persistent FTP connection to #{@config.host}..."
+
+      @ftp = Net::FTP.new
+      @ftp.passive = true
+      @ftp.connect(@config.host)
+      @ftp.login(@config.username, @config.password)
+    rescue
+      $strerr.puts "Something went wrong with the FTP login."
+    end
+
+    def close!
+      @ftp.close
+    end
+
+    def initialized?
+      not @ftp.nil?
+    end
+
+    def upload(remote_path, contents)
+      raise UploadArgumentError if not remote_path.is_a?(Path)
+
+      if contents.is_a?(File)
+        upload_via_ftp(remote_path, contents)
+
+      elsif contents.is_a?(String)
+        upload_contents_via_ftp(remote_path, contents)
+
+      else
+        raise UnrecognizedContentType
+
+      end
+    end
+
+    def upload_contents_via_ftp(remote_path, contents)
+      file = StringIO.new(contents)
+      upload_via_ftp(remote_path, file, false)
+    end
+
+    def upload_via_ftp(remote_path, file, binary=true)
+      server_path = Path.new(@config.remote_root_path) + remote_path.relative
+
+      $stderr.puts "Opening an FTP connection for #{remote_path}"
+
+      begin
+        attempt_upload!(server_path, file, binary)
+      rescue => e
+        $stderr.puts "FTP Error"
+        $stderr.puts e.message
+
+        create_remote_folder!(server_path)
+        attempt_upload!(server_path, file, binary)
+      end
+    end
+
+    def attempt_upload!(server_path, file, binary)
+      $stderr.puts "Path on server: #{server_path}"
+      if binary
+        file.binmode
+        @ftp.storbinary("STOR #{server_path}", file, Net::FTP::DEFAULT_BLOCKSIZE)
+      else
+        @ftp.storlines("STOR #{server_path}", file)
+      end
+    end
+
+    def create_remote_folder!(server_path)
+      server_path.descend do |path|
+        begin
+          @ftp.mkdir(path)
+        rescue Net::FTPPermError
+          $stderr.puts "Remote folder already exists."
+        rescue
+          # Ok.
+        end
+      end
+    end
+  end
+
+  Service.register(:ftp => FtpService)
+end
+
+

data/lib/uploader/s3_service.rb

@@ -0,0 +1,135 @@
+require 'helpers/system_checks'
+require 'uploader/base'
+require 'uploader/service'
+require 'uploader/suppressor'
+
+module Uploader
+  class S3Service < Service
+
+    def connect!
+      # TODO S3 may not work yet.
+
+      if not SystemChecks.gem_available?('aws/s3')
+        $stderr.puts %Q{\nThe Amazon S3 service requires the aws-s3 gem (vers >= 0.6.2), which is 
+not required by default. Run 'gem install aws-s3' to install it.\n\n}
+        raise LoadError
+      end
+
+      @bucket_name = @config.bucket
+      access_key = ENV[@config.access_key]
+      secret_key = ENV[@config.secret_key]
+
+      $stderr.puts "Connecting to AWS..."
+
+      @suppressor.shutup!
+
+      unless AWS::S3::Base.connected?
+        options = {
+            :access_key_id => access_key,
+            :secret_access_key => secret_key,
+            :use_ssl => true,
+            :port => 443
+          }
+
+        if @config.use_proxy
+          options.update({
+            :proxy => {
+              :host => @config.proxy['host'],
+              :port => @config.proxy['port']
+              }
+            })
+        end
+
+        AWS::S3::Base.establish_connection!(options)
+        @suppressor.ok
+
+      else
+        @suppressor.ok
+        $stderr.puts "AWS already connected."
+      end
+
+      @s3_bucket = AWS::S3::Bucket.find(@bucket_name)
+    end
+
+    def close!
+      AWS::S3::Base.disconnect!
+    end
+
+    def upload(remote_path, contents)
+      raise UploadArgumentError if not remote_path.is_a?(Path)
+
+      if contents.is_a?(File)
+        contents_to_upload = contents.read
+
+      elsif contents.is_a?(String)
+        contents = contents
+
+      else
+        raise UnrecognizedContentType
+
+      end
+
+      upload_contents_to_s3(local_path, contents_to_upload)
+    end
+
+    def upload_contents_to_s3(remote_path, contents, mime_type=nil)
+      $stderr.puts "Attempting to upload #{remote_path} to S3"
+
+      destination = Path.new(@config.remote_root_path) + remote_path
+
+      @suppressor.shutup!
+
+      # Prepare the object.
+      object = @s3_bucket.new_object
+      object.key = destination
+      object.value = contents
+
+      # Store the object first...
+      object.store
+
+      #if not mime_type.blank?
+      #  #object.content_type = mime_type
+      #  #object.store
+      #else
+      #  ext = File.extname(local_path)
+      #  if content_types.keys.include? ext
+      #    #object.content_type = content_types[ext]
+      #    #object.store
+      #  end
+      #end
+
+      # ... then set the ACLs.
+      public_read_grant = AWS::S3::ACL::Grant.grant(:public_read)
+      object.acl.grants << public_read_grant
+      object.acl(object.acl)
+
+      @suppressor.ok
+
+      if @s3_bucket.objects.include?(object)
+        $stderr.puts "Successfully uploaded #{local_path} to S3!"
+      else
+        $stderr.puts "Something went wrong uploading #{local_path} to S3."
+      end
+    rescue => detail
+      $stderr.puts "Uploader#upload_contents_to_s3 exception."
+      $stderr.puts detail.message
+    end
+
+    def self.content_types
+      {
+        ".png" => "image/png",
+        ".jpg" => "image/jpeg",
+        ".jpeg" => "image/jpeg",
+        ".pdf" => "application/pdf",
+        ".jar" => "application/java-archive",
+        ".txt" => "text/plain",
+        ".html" => "text/html",
+        ".css" => "text/css",
+        ".js" => "text/javascript"
+      }
+    end
+
+  end
+  Service.register(:s3 => S3Service)
+end
+

data/lib/uploader/service.rb

@@ -0,0 +1,57 @@
+require 'helpers/path'
+require 'helpers/system_checks'
+
+
+module Uploader
+  class UnrecognizedContentType < Exception; end
+  class ServiceNotConnected < Exception; end
+  class UploadArgumentError < Exception; end
+
+  class Service
+    include Helpers
+
+    def initialize(config)
+      @config = config
+    end
+
+    # Called to connect to remote services like FTP and S3.
+    def connect!
+    end
+
+    # Perform the upload operation to this service.
+    #
+    # @param [Path] remote_path The relative path to upload. This is prefixed by "remote_root_path"
+    #   set in the uploader Config. You can set remote_root_path to "" if you want complete control
+    #   over the path.
+    # @param [File, String] contents The contents to upload into the remote file
+    #   destination.
+    # @return nothing
+    def upload(remote_path, contents)
+    end
+
+    # Closes the service connection, if required.
+    def close!
+    end
+
+    def initialized?
+      false
+    end
+
+    @@services = {}
+
+    def self.services
+      @@services
+    end
+
+    # Returns whether this service appears in the Service class's registry.
+    def self.is_registered?(service)
+      @@services.keys.include?(service)
+    end
+
+    # Registers the Service in the registry, so clients of the service can access it by name.
+    def self.register(kwds={})
+      @@services.update(kwds)
+    end
+  end
+
+end

data/lib/uploader/suppressor.rb

@@ -0,0 +1,25 @@
+# Haml and AWS put out a lot of junk. Redirect stdout and stderr to /dev/null to suppress these
+# useless warnings, then restore stdout and stderr at the end.
+class Suppressor
+  def initialize
+    @hole = File.new('/dev/null', 'w')
+    @orig_stdout = $stdout
+    @orig_stderr = $stderr
+  end
+  
+  # Redirect stdout to /dev/null
+  def shutup!
+    $stdout = @hole
+    $stderr = @hole
+  end
+  
+  # Restore stdout and stderr
+  def ok
+    $stdout = @orig_stdout
+    $stderr = @orig_stderr
+  end
+  
+  def close!
+    @hole.close
+  end
+end

data/lib/yuzu.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby -wKU
+
+module Yuzu; end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/yuzu')
+

data/lib/yuzu/argparse.rb

@@ -0,0 +1,60 @@
+require 'ostruct'
+require 'optparse'
+require 'version'
+
+module Yuzu::Command
+  HELP_MESSAGE = %Q{
+This is yuzu, a blog-aware, static-website generator and publisher that converts
+a folder of text files and images into an HTML5 website.
+
+Typical Usage
+
+  yuzu [command] [options] [files]
+
+Available Commands
+
+  help                  # Show this help page.
+  help [command]        # Help about the particular command.
+  create                # Creates a new yuzu project in the current folder.
+  preview               # Updates files in the preview folder.
+  publish               # Publishes files to the currently selected remote server.
+  stage                 # Updates files in the staging folder.
+  generate              # Generate new content like posts and thumbnails.
+}
+
+  class ArgParser
+    def self.parse(args)
+      options = OpenStruct.new
+      options.output = :quiet    # :verbose, :debug
+
+      option_parser = \
+      OptionParser.new do |opts|
+        opts.banner = ""
+
+        opts.separator "Options"
+        opts.separator ""
+
+        opts.on("--verbose", "Run showing verbose output.") do
+          options.output = :verbose
+        end
+
+        opts.on_tail("-h", "--help", "Show this help message.") do
+          puts HELP_MESSAGE
+          puts opts
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Show version.") do
+          puts Yuzu::Version::STRING
+          exit
+        end
+      end
+
+      option_parser.parse!(args)
+      options
+
+    end # End self.parse
+  end # End ArgParser
+
+end
+

data/lib/yuzu/command.rb

@@ -0,0 +1,104 @@
+require 'yaml'
+
+require 'commands/base'
+require 'argparse'
+
+require 'helpers/object'
+require 'helpers/string'
+
+# Load all the commands.
+Dir["#{File.dirname(__FILE__)}/commands/*"].each { |c| require c }
+
+
+CONFIG_NOT_FOUND_MESSAGE = \
+%Q{Please run this from the root of your project, in the folder containing
+yuzu.yml or config/yuzu.yml. Or use 'create' to make a new project.}
+
+
+module Yuzu::Command
+
+  def self.run(command_str, args)
+    start = Time.now
+
+    options = ArgParser.parse(args)
+
+    if command_str.nil?
+      exit
+    end
+
+    command_class, method = parse(command_str.downcase)
+    execute(command_class, method, args[1, args.length] || [], options)
+
+    stop = Time.now
+    delta = stop - start
+    if options.output == :verbose
+      $stderr.puts "Yuzu completed in #{delta} seconds."
+    else
+      $stderr.puts
+    end
+  end
+
+  def self.parse(command_str)
+    command, method = command_str.split(':').collect {|part| part.strip}
+    method = method.nil? ? :index : method.to_sym
+
+    return Yuzu::Command.const_get(command.capitalize), method
+  rescue
+    raise InvalidCommand
+  end
+
+  def self.execute(command_class, method, args, parsed_options)
+    if command_class.requires_config?
+      config_hash = load_config
+
+      config = \
+      Yuzu::Core::Config.new(
+        config_hash,
+        command_class.service_override,
+        parsed_options
+      )
+
+      command_instance = command_class.new(args, config)
+      command_instance.send(method)
+
+    else
+      command_instance = command_class.new(args)
+      command_instance.send(method)
+    end
+  rescue => e
+    $stderr.puts e.message
+    $stderr.puts e.backtrace
+    raise CommandFailed
+  end
+
+  def self.load_config
+    config_location = locate_config
+
+    if config_location.nil?
+      $stderr.puts CONFIG_NOT_FOUND_MESSAGE
+      Process.exit!(false)
+    end
+
+    YAML.load_file(config_location)
+  end
+
+  def self.locate_config
+    possible_config_locations.each do |path|
+      if File.exists?(path)
+        return path
+      end
+    end
+    return nil
+  end
+
+  def self.possible_config_locations
+    [
+      File.join(Dir.pwd, "yuzu.yml"),
+      File.join(Dir.pwd, "config", "yuzu.yml")
+    ]
+  end
+
+  class InvalidCommand < RuntimeError; end
+  class CommandFailed  < RuntimeError; end
+end
+