yuzu 0.2.1.pre

data/lib/helpers/string.rb

@@ -0,0 +1,35 @@
+
+unless String.method_defined?(:titlecase)
+
+  class String
+    def titlecase
+      self.downcase.spacify.split(" ").collect {|str| str.capitalize}.join(" ")
+    end
+
+    def titleize
+      titlecase
+    end
+
+    def spacify
+      self.gsub("-", " ").gsub("_", " ")
+    end
+
+    def dasherize
+      self.gsub(" ", "-").gsub("_", "-")
+    end
+
+    def underline
+      self.gsub(/\W/, "_")
+    end
+
+    def includes_one_of?(arr)
+      tr = false
+      arr.each do |el|
+        tr ||= self.include?(el)
+      end
+      tr
+    end
+  end
+
+end
+

data/lib/helpers/system_checks.rb

@@ -0,0 +1,10 @@
+module SystemChecks
+  module_function
+  def gem_available?(name)
+     Gem::Specification.find_by_name(name)
+  rescue Gem::LoadError
+     false
+  rescue
+     Gem.available?(name)
+  end
+end

data/lib/helpers/url.rb

@@ -0,0 +1,64 @@
+# Url holds an abstraction for web URLs, closely tied to the Path objects. This aids in translating
+# on-disk paths to URLs for links.
+module Helpers
+
+  class Url
+    # Create a new Url object.
+    #
+    # @param [String, Path] url_path The root path of the Url, from the file system, with the
+    #   appropriate extension in place ideally.
+    # @param [String] prefix A prefix to add to the front of the url. This usually consists of the
+    #   root common path on the server like http://domain.com/blah
+    def initialize(url_path, prefix=nil)
+      if url_path.is_a?(Path)
+        @path = url_path
+
+      elsif url_path.is_a?(String)
+        @path = Path.new(url_path)
+
+      elsif url_path.is_a?(Url)
+        @path = url_path.path
+
+      else
+        raise "Url must be initialized with a String, Url, or Path instance."
+
+      end
+
+      @prefix = prefix
+    end
+
+    attr_accessor :path
+
+    def + (other)
+      if other.is_a?(String)
+        Url.new(@path + other, prefix=@prefix)
+
+      elsif other.is_a?(Url)
+        Url.new(@path + other.path.relative, prefix=@prefix)
+
+      elsif other.is_a?(Path)
+        Url.new(@path + other.relative_path, prefix=@prefix)
+
+      else
+        raise "Url + accepts String, Path, and Url instances."
+
+      end
+    end
+
+    def to_s
+      full
+    end
+
+    def full(new_extension=nil)
+      new_extension.nil? ? join(@prefix, @path) : join(@prefix, @path.with_extension(new_extension))
+    end
+
+    # Join a set of paths together
+    def join(prefix, path, suffix=nil)
+      root = prefix.nil? ? path.relative : prefix + "/" + path.relative
+      suffix.nil? ? root : root + "/" + suffix
+    end
+  end
+
+end
+

data/lib/html/base.rb

@@ -0,0 +1,187 @@
+# Html provides a concise way of programmatically expressing HTML tags and structure.
+#
+# This enables one to express a list like this:
+#
+#     Html::UnorderedList.new << (Html::ListItem.new << "first") + (Html::ListItem.new << "second")
+#
+# which results in:
+#
+#     <ul><li>first</li><li>second</li></ul>
+#
+# The << operator means "contains", and reduces an Html object and a string to another string. So 
+# after the << operation, the tags just obey String semantics.
+#
+# Commonly used nested tags can be composited and deployed as templates multiple times.
+#
+#     title_link = Html::H1.new << Html::Link(:href => "http://mysite.com")
+#     title_link << "My Site"
+#
+# which results in:
+#
+#     <h1><a href="http://mysite.com">My Site</a></h1>
+#
+# This is seemingly more verbose that writing it directly, but it enables you to write HTML without
+# having to do string interpolation and concatenation, and it doesn't imbue Ruby code with a lot of
+# HTML-related strings.
+#
+#     words = %w(hello doctor name continue yesterday tomorrow)
+#     Html::UnorderedList.new << words.collect {|w| Html::ListItem.new(:class => "class-#{w}") << w}.join
+#
+# which will yield:
+#
+#     <ul>
+#       <li class="class-hello">hello</li>
+#       <li class="class-doctor">doctor</li>
+#       <li class="class-name">name</li>
+#       <li class="class-continue">continue</li>
+#       <li class="class-yesterday">yesterday</li>
+#       <li class="class-tomorrow">tomorrow</li>
+#     </ul> 
+
+module Html
+  # The base Html class provides functionality for wrapping HTML tags, e.g. <div>...</div>
+  class Base
+    def initialize(attr={})
+      @attr = attr
+    end
+
+    @tag = "div"
+    def self.tag
+      @tag
+    end
+
+    def tag
+      self.class.tag
+    end
+
+    def attributes
+      @attr.length == 0 ? "" : @attr.collect {|key, value| " #{key.to_s}='#{value}'"}.join
+    end
+
+    def processed_output(contents)
+      "<#{tag}#{attributes}>#{contents}</#{tag}>"
+    end
+
+    def << (other)
+      if other.is_a?(String)
+        processed_output(other)
+      else
+        Composite.new(self, other)
+      end
+    end
+  end
+
+  # Class that sets off the tag by newlines to aid in readability for raw output.
+  class Container < Base
+    def processed_output(contents)
+      "\n<#{tag}#{attributes}>\n#{contents}\n</#{tag}>\n"
+    end
+  end
+
+  class Item < Base
+    def processed_output(contents)
+      "<#{tag}#{attributes}>#{contents}</#{tag}>\n"
+    end
+  end
+
+  # Class for compositing nested tags togther and using them multiple times in different contexts.
+  class Composite
+    def initialize(first, second)
+      @first = first
+      @second = second
+    end
+
+    def << (other)
+      if other.is_a?(String)
+        @first << (@second << other)
+      else
+        Composite.new(self, other)
+      end
+    end
+  end
+
+  # HTML flags are those that don't have a closing tag, e.g. <img href="">
+  class Flag < Base
+    def to_s
+      "<#{tag}#{attributes}>"
+    end
+
+    def << (other)
+      self.to_s + other
+    end
+  end
+
+  # Handler for adding HTML comments inline.
+  class Comment < Base
+    def << (other)
+      "\n<!-- #{other} -->\n"
+    end
+  end
+
+  # Class handler for <div> tags.
+  class Div < Container
+    instance_variable_set(:@tag, "div")
+  end
+
+  # Class handler for <a> links.
+  class Link < Base
+    instance_variable_set(:@tag, "a")
+  end
+
+  # Class handler for <li> list item tags.
+  class ListItem < Item
+    instance_variable_set(:@tag, "li")
+  end
+
+  # Class handler for <ul> unordered lists.
+  class UnorderedList < Container
+    instance_variable_set(:@tag, "ul")
+  end
+
+  # Handler for <ol> ordered lists.
+  class OrderedList < Container
+    instance_variable_set(:@tag, "ol")
+  end
+
+  # Handler for <h1> headers.
+  class H1 < Item
+    instance_variable_set(:@tag, "h1")
+  end
+
+  # Handler for <h2> headers.
+  class H2 < Item
+    instance_variable_set(:@tag, "h2")
+  end
+
+  # Handler for <h3> headers.
+  class H3 < Item
+    instance_variable_set(:@tag, "h3")
+  end
+
+  # Handler for <h4> headers.
+  class H4 < Item
+    instance_variable_set(:@tag, "h4")
+  end
+
+  # Handler for <span> tags.
+  class Span < Base
+    instance_variable_set(:@tag, "span")
+  end
+
+  # Handler for <p> paragraph tags.
+  class Paragraph < Container
+    instance_variable_set(:@tag, "p")
+  end
+
+  # Handler for <img> images.
+  class Image < Flag
+    instance_variable_set(:@tag, "img")
+  end
+
+  # Handler for <br> line breaks.
+  class Break < Flag
+    instance_variable_set(:@tag, "br")
+  end
+
+end
+

data/lib/uploader/base.rb

@@ -0,0 +1,59 @@
+# Require service.rb first.
+require 'uploader/service'
+require 'uploader/suppressor'
+require 'uploader/config'
+
+Dir["#{File.dirname(__FILE__)}/*"].each do |service|
+  require service if service.include?("_service")
+end
+
+
+module Uploader
+  class UnrecognizedService < Exception; end
+
+  class UploadManager
+
+    def initialize(config, service_override=nil)
+      @config = config   # UploaderConfig
+      @service_override = service_override
+      @suppressor = Suppressor.new
+
+      set_service!
+      connect!
+    end
+
+    def set_service!
+      service_name, service_class = get_service
+      service_config_hash = @config.send(service_name).merge({:verbose? => @config.verbose?})
+
+      @service = service_class.new(UploaderConfig.new(service_config_hash))
+    end
+
+    def get_service
+      service_key = (@service_override || @config.connection).to_sym
+
+      if Service.is_registered?(service_key)
+        $stderr.puts "Using service #{service_key}" if @config.verbose?
+
+        return service_key, Service.services[service_key]
+      else
+        raise UnrecognizedService
+      end
+    end
+
+    def connect!
+      @service.connect!
+    end
+
+    def upload(remote_path, contents)
+      @service.upload(remote_path, contents)
+    end
+
+    def close!
+      @service.close!
+      @suppressor.close!
+    end
+  end
+
+end
+

data/lib/uploader/config.rb

@@ -0,0 +1,19 @@
+
+module Uploader
+
+  class UploaderConfig
+    def initialize(config_hash)
+      @config_hash = config_hash
+
+      (class << self; self; end).class_eval do
+        config_hash.each_pair do |key, value|
+          define_method(key) do
+            value
+          end
+        end
+      end
+    end
+  end
+
+end
+

data/lib/uploader/filesystem_service.rb

@@ -0,0 +1,72 @@
+require 'uploader/base'
+require 'uploader/service'
+require 'fileutils'
+
+
+module Uploader
+  GREEN = "\033[32m"
+  ENDC = "\033[0m"
+
+  class FileSystemService < Service
+    def connect!
+    end
+
+    def upload(remote_path, contents)
+      raise UploadArgumentError if not remote_path.is_a?(Path)
+
+      contents_to_upload, binmode = get_upload_contents(contents)
+
+      copy_contents_to_file_system(remote_path, contents_to_upload, binmode)
+    end
+
+    def get_upload_contents(contents)
+      binmode = false
+      if contents.is_a?(File)
+        contents_to_upload = contents.read
+        binmode = true
+
+      elsif contents.is_a?(String)
+        contents_to_upload = contents
+
+      else
+        raise UnrecognizedContentType
+      end
+
+      return contents_to_upload, binmode
+    end
+
+    def copy_contents_to_file_system(remote_path, contents, binary=true)
+      destination = Path.new(@config.destination) + remote_path.relative
+      if @config.verbose?
+        $stderr.puts %Q{Copying #{GREEN}#{remote_path}#{ENDC} to the file system
+      --> #{destination}} 
+      else
+        $stderr.print "."
+      end
+
+      begin
+        f = File.open(destination.absolute, "w+")
+
+      rescue => detail
+        $stderr.puts detail.message
+        $stderr.puts "Attempting to create the path."
+
+        # Assume the directories leading to the file don't exist. Create them.
+        FileUtils::mkdir_p(destination.dirname)
+
+        f = File.open(destination.absolute, "w+")
+      end
+
+      unless f.nil?
+        f.syswrite(contents)
+        f.close
+        $stderr.puts "Done with #{destination.relative}." if @config.verbose?
+      end
+    end
+  end
+
+  Service.register(:filesystem => FileSystemService)
+  Service.register(:stage => FileSystemService)
+  Service.register(:preview => FileSystemService)
+end
+