tipsy 0.0.2 → 0.0.3

data/lib/tipsy/server.rb

@@ -1,134 +1,76 @@
 require 'rack'
-require 'sprockets'
 require 'hike'
 
-module Tipsy
-  
+module Tipsy  
+  ##
+  # Rack server implementation.
+  # Tipsy::Server will run any Rack::Builder compatable format. If thin or mongrel
+  # are availble, they will be used first, and in that order, with a fallback to webrick.
+  # 
   class Server
+    attr_reader :request, :response
     
-    attr_reader :request
-    attr_reader :response
-    
-    def self.init!
-      Rack::Builder.new {
-        use Rack::CommonLogger
-        use Rack::ShowStatus
-        use Rack::ShowExceptions
-        use Tipsy::StaticFile, :root => Tipsy.options.public_path, :urls => %w[/]
-        run Rack::Cascade.new([
-        	Rack::URLMap.new({ "/#{File.basename(Tipsy.options.asset_path)}" => Tipsy::AssetHandler.new }),
-        	Tipsy::Server.new        	
-        ])
-      }      
+    class << self    
+      ##
+      # Run the Rack::Builder application
+      # @param [run] Rack::Builder An instance of Rack::Builder
+      # 
+      def run!(app, options)
+        begin
+          handler = Rack::Handler.get('thin')
+          handler.run app, options do |server|
+            puts "Running Tipsy with Thin (#{Thin::VERSION::STRING})."
+          end
+          exit(0)
+        rescue LoadError
+          begin
+            handler = Rack::Handler.get('mongrel')
+            handler.run app, options do |server|
+              puts "Running Tipsy with Mongrel (#{Mongrel::Const::MONGREL_VERSION})."
+            end
+            exit(0)
+          rescue LoadError
+            handler = Rack::Handler.get('webrick')
+            handler.run app, server_opts do |server|
+              puts "Running Tipsy with Webrick. To use Mongrel or Thin (recommended), add them to your Gemfile"
+              trap("INT"){ server.shutdown }
+            end
+          end
+        end
+      end
     end
-      
+    
     def initialize      
       @last_update = Time.now      
     end
     
     def call(env)      
       @request  = Request.new(env)
-      @response = Response.new
-      path      = request.path_info.to_s.sub(/^\//, '')
-      view      = Tipsy::View.new(path, request)
-      content   = view.render
-      content.nil? ? not_found : finish(content)
-    end
-    
-    private
-    
-    def finish(content)
-      [ 200, { 'Content-Type' => 'text/html' }, [content] ]
-    end
-    
-    def not_found
-      [ 400, { 'Content-Type' => 'text/html' }, [] ]
-    end
-    
-  end
-  
-  class AssetHandler < Sprockets::Environment    
-    def initialize
-      Sprockets.register_engine '.scss', Tipsy::Sass::Template
-      
-       super(Tipsy.root) do |env|
-        env.static_root    = Tipsy.options.asset_path
-        #env.css_compressor = Tipsy::Compressors::CssCompressor.new
-        # begin
-        #   require 'uglifier'          
-        #   env.js_compressor = Uglifier
-        # rescue LoadError
-        #   env.js_compressor = Tipsy::Compressors::JavascriptCompressor.new
-        # end
-      end 
-      Tipsy.sprockets = self
-      configure_paths!
-      self
-    end
-    
-    private
-    
-    def configure_paths!
-      require 'compass'
-      require 'sass/plugin'
-      
-      append_path "assets/javascripts"
-      append_path "assets/images"
-      append_path "assets/stylesheets"
-      
-      compass_config = ::Compass::Configuration::Data.new("project")
-      compass_config.project_type   = :rails
-      compass_config.project_path   = Tipsy.root
-      compass_config.extensions_dir = Tipsy.root
-      compass_config.sass_dir       = File.join("assets", "stylesheets")            
-      
-      ::Sass::Plugin.engine_options.merge!(Compass.sass_engine_options)
-      
-      Tipsy.options.assets.paths |= self.paths
-      
-    end
-    
-  end
-  
-  # From the rack/contrib TryStatic class
-  class StaticFile
-    attr_reader :app, :try_files, :static
-    
-    def initialize(app, options)
-      @app       = app
-      @try_files = ['', *options.delete(:try)]
-      @static    = ::Rack::Static.new(lambda { [404, {}, []] }, options)
+      @response = Response.new      
+      result    = Tipsy::View::Base.new(@request, @response)
+      result.render.to_a
     end
 
-    def call(env)
-      orig_path = env['PATH_INFO']
-      found = nil
-      try_files.each do |path|
-        resp = static.call(env.merge!({'PATH_INFO' => orig_path + path}))
-        break if 404 != resp[0] && found = resp
-      end
-      found or app.call(env.merge!('PATH_INFO' => orig_path))
+    ##
+    # Subclass Rack::Request to create a rails-like params hash.
+    class Request < Rack::Request
+      def params
+        @params ||= begin
+          hash = HashWithIndifferentAccess.new.update(Rack::Utils.parse_nested_query(query_string))
+          post_params = form_data? ? Rack::Utils.parse_nested_query(body.read) : {}
+          hash.update(post_params) unless post_params.empty?
+          hash
+        end
+      end    
     end
-  end
     
-  
-  class Request < Rack::Request    
-    # Hash access to params
-    def params
-      @params ||= begin
-        hash = HashWithIndifferentAccess.new.update(Rack::Utils.parse_nested_query(query_string))
-        post_params = form_data? ? Rack::Utils.parse_nested_query(body.read) : {}
-        hash.update(post_params) unless post_params.empty?
-        hash
+    ##
+    # Ensure proper body output
+    class Response < Rack::Response
+      def body=(value)
+        value.respond_to?(:each) ? super(value) : super([value])
       end
-    end    
-  end
-
-  class Response < Rack::Response
-    def body=(value)
-      value.respond_to?(:each) ? super(value) : super([value])
     end
   end
   
-end
-
+end

data/lib/tipsy/site.rb

@@ -0,0 +1,88 @@
+require 'active_support/configurable'
+
+module Tipsy
+  
+  class Site
+    include ActiveSupport::Configurable
+    config_accessor :asset_path, :compile_to, :css_path, :javascripts_path, :images_path, :fonts_path,
+                    :public_path, :load_paths, :compile_to, :compile
+    ##
+    # Site configuration options
+    # 
+    # General:
+    # port: The port in which the server should run
+    # address: The address on which the server should run
+    # public_path: Path to the public files/assets
+    # 
+    # Assets:
+    # asset_path: The path in which assets should be preserved
+    # assets.paths: Paths in which sprockets will look for assets    
+    # assets.javascripts_path: Path in which javascript files should be served. Helper methods will use this path
+    # assets.images_path: Path in which image assets should be served. Helper methods will use this path
+    # assets.css_path: Path in which stylesheets should be served. Helper methods will use this path
+    # 
+    # Compiling:
+    # compile_path: The directory in which the site will be compiled
+    # compile.preserve: An array of files or directories that will be preserved when the compile folder is rebuilt.
+    
+    config.port       = 4000
+    config.address    = '0.0.0.0'
+    
+    config.public_path       = File.join(Tipsy.root, 'public')
+    config.load_paths        = ::ActiveSupport::OrderedOptions.new( 'assets' => [] )
+    config.asset_path        = '/assets'
+    config.images_path       = asset_path
+    config.fonts_path        = "/fonts"
+    config.javascripts_path  = asset_path
+    config.css_path          = asset_path
+    config.compile_to        = File.join(Tipsy.root, 'compiled')
+    
+    config.compile           = ::ActiveSupport::OrderedOptions.new
+    config.compile.assets    = ['screen.css', 'site.js']
+    config.compile.preserve  = [".svn", ".gitignore", ".git"]
+    config.compile.skip      = []
+    
+    
+    config.compile.enable_rewrite = true
+    config.compile.rewrite_mode   = :htaccess
+
+    def self.configure!
+      @_callbacks = { :before => [], :after => [] }
+      local_config = File.join(Tipsy.root, 'config.rb')
+      if File.exists?(local_config)
+        class_eval(File.open(local_config).readlines.join("\n"))
+      end
+      
+    end
+    
+    ##
+    # Callback support
+    # 
+    [:compile].each do |callback|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def self.before_#{callback}(&block)
+          if block_given?
+            @_callbacks[:before] << block
+          else
+            @_callbacks[:before].each(&:call)
+          end
+        end
+
+        def self.after_#{callback}(&block)
+          if block_given?
+            @_callbacks[:after] << block
+          else
+            @_callbacks[:after].each(&:call)
+          end
+        end
+      METHOD
+    end
+    
+    
+    def initialize
+      @_callbacks = {}
+    end
+          
+  end
+  
+end

data/lib/tipsy/utils/logger.rb

@@ -0,0 +1,47 @@
+module Tipsy
+  module Utils
+    class Logger      
+      COLORS = { :clear => 0, :red => 31, :green => 32, :yellow => 33 }    
+      attr_reader :stdout
+
+      def initialize(o)
+        @stdout = o
+      end
+      
+      def print(msg)
+        puts msg
+      end
+      
+      def action(name, action)
+        print colorize(:green, (name.rjust(12, ' ') << " "), :clear, action)
+      end
+
+      def info(msg)
+        print msg unless Tipsy.env.eql?("test")
+      end
+
+      def warn(msg)
+        print colorize(:yellow, "Warning: ", :clear, msg)
+      end
+
+      def error
+        print colorize(:red, "Error: ", :clear, msg)
+      end
+      
+      private
+      
+      def colorize(*args)
+        output = args.inject([]) do |arr, option|
+          unless option.is_a?(Symbol) && COLORS[option]
+            arr << option
+          else
+            arr << "\e[#{COLORS[option]}m"
+          end
+          arr
+        end
+        output.push("\e[0m").join("")
+      end
+
+    end
+  end
+end

data/lib/tipsy/utils/system.rb

@@ -0,0 +1,115 @@
+require 'find'
+require 'pathname'
+require 'fileutils'
+
+module Tipsy
+  module Utils
+    module System
+      extend ActiveSupport::Concern
+      
+      def excludes
+        @_excludes ||= ['.svn', '.git', '.gitignore', '.sass-cache', 'config.erb', '.rb', '.DS_Store']
+      end
+
+      def excluded?(file, against = nil)
+        against ||= excludes
+        return true if file.to_s == '.' || file.to_s == '..' || against.include?(file)
+        check = ::Pathname.new(file)
+        return true if against.include?(check.basename.to_s)
+        !against.detect do |exc| 
+          (check.basename == exc || check.extname == exc)
+        end.nil?
+      end
+
+      ##
+      # Copies from one location to another
+      # 
+      def copy_file(source, destination)
+        return true if skip_file?(source)
+        log_action("create", destination)
+        ::FileUtils.cp(source, destination)
+      end
+
+      ##
+      # Makes a matching folder in destination from source
+      #
+      def copy_folder(dirname)
+        return true if skip_path?(dirname)
+        log_action("create", dirname)
+        ::FileUtils.mkdir(dirname)
+      end
+
+      ##
+      # Basic alias
+      # 
+      def mkdir_p(path)
+        return true if ::File.exists?(path)
+        log_action("create", path)
+        ::FileUtils.mkdir_p(path)
+      end
+      
+      def make_file(path, content)
+        ::File.new(path, 'w').puts(content)
+      end
+      
+      def rm_rf(path)
+        log_action('delete', path)
+        ::FileUtils.rm_rf(path)
+      end
+      
+      def unlink(file)
+        log_action('delete', file)
+        ::File.unlink(file)
+      end
+      
+      def empty_dir?(path)
+        ::Dir.entries(path).reject do |ent| 
+          ent == "." || ent == ".." || ent == path
+        end.empty?
+      end
+
+      ##
+      # Iterate through a file tree and process each file and folder.
+      # 
+      def copy_tree(src, dest)
+        ::Dir.foreach(src) do |file|
+          next if excluded?(file)
+          source       = ::File.join(src, file)
+          destination  = ::File.join(dest, file)
+
+          if ::File.directory?(source)
+            copy_folder(destination)
+            copy_tree(source, destination)
+          else
+            copy_file(source, destination)
+          end
+        end
+      end
+      
+      # Override in specific runner as necessary
+      # Allows more fine-grained control per directory.
+      def skip_path?(dirname)
+        false
+      end
+      
+      # Override in specific runner as necessary. 
+      # Allows more fine-grained control per file.
+      def skip_file?(filename)
+        false
+      end
+      
+      ##
+      # Collect the entire tree of files and folders and yield to a block
+      def enumerate_tree(path, &block)
+        ::Find.find(path) do |path|
+          yield path
+        end
+      end
+      
+      def log_action(name, action)
+        ::Tipsy.logger.action(name, action)
+      end
+      
+    end
+  end
+end

data/lib/tipsy/utils/system_test.rb

@@ -0,0 +1,103 @@
+require 'find'
+require 'pathname'
+require 'fileutils'
+
+module Tipsy
+  module Utils
+    ##
+    # Overrides file and directory methods for the test environment
+    module SystemTest
+      attr_reader :deletions, :creations
+      
+      extend ActiveSupport::Concern
+      include System
+      
+      ##
+      # Copies from one location to another
+      # 
+      def copy_file(source, destination)
+        return true if skip_file?(source)
+        set_created(destination)
+      end
+
+      ##
+      # Makes a matching folder in destination from source
+      #
+      def copy_folder(dirname)
+        return true if skip_path?(dirname)
+        log_action("create", dirname)
+        set_created(dirname)
+      end
+
+      ##
+      # Basic alias
+      # 
+      def mkdir_p(path)
+        return true if ::File.exists?(path)
+        log_action("create", path)
+        set_created(path)
+      end
+      
+      def make_file(path, content)
+        set_created(path)
+      end
+      
+      def rm_rf(path)
+        log_action('delete', path)
+        set_deleted(path)
+      end
+      
+      def unlink(file)
+        log_action('delete', file)
+        set_deleted(file)
+      end
+      
+      def empty_dir?(path)
+        ::Dir.entries(path).reject do |ent| 
+          ent == "." || ent == ".." || ent == path || was_deleted?(File.join(path, ent))
+        end.empty?
+      end
+
+      ##
+      # Iterate through a file tree and process each file and folder.
+      # 
+      def copy_tree(src, dest)
+        ::Dir.foreach(src) do |file|
+          next if excluded?(file)
+          source       = ::File.join(src, file)
+          destination  = ::File.join(dest, file)
+
+          if ::File.directory?(source)
+            copy_folder(destination)
+            copy_tree(source, destination)
+          else
+            copy_file(source, destination)
+          end
+        end
+      end
+     
+      
+      def log_action(name, action)
+      end
+      
+      def was_deleted?(path)
+        (@deletions ||= []).include?(path)
+      end
+      
+      def was_created?(path)
+        (@creations ||= []).include?(path)
+      end
+      
+      private
+      
+      def set_created(path)
+        (@creations ||= []) << path
+      end
+      
+      def set_deleted(path)
+        (@deletions ||= []) << path
+      end
+      
+    end
+  end
+end

data/lib/tipsy/version.rb

@@ -1,3 +1,3 @@
 module Tipsy
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/tipsy/view/base.rb

@@ -0,0 +1,55 @@
+module Tipsy
+  module View
+    class Base
+      
+      attr_reader :lookup_context, :request, :response, :view_context, :template
+      
+      def initialize(request, response)
+        @request  = request
+        @response = response
+        @lookup_context = Tipsy::View::Path.new        
+      end
+      
+      def render
+        
+        @template     = lookup_context.locate_template(current_path)
+        
+        if template.nil?
+          return generate_response(nil)
+        end
+        
+        @view_context = Tipsy::View::Context.new(request, lookup_context, File.dirname(template), lookup_context)
+        
+        handler  = Tilt[template]
+        tilt     = handler.new(template, nil, :outvar => '@output_buffer')      
+        result   = tilt.render(view_context)
+        
+        unless view_context.layout == false
+          layout = lookup_context.locate_layout(view_context.layout) 
+          raise Tipsy::View::LayoutMissing.new("Missing layout '#{view_context.layout}'") and return if layout.nil?
+          wrapped = Tilt[layout].new(layout, nil, :outvar => '@output_buffer')          
+          result  = wrapped.render(view_context) do |*args|
+            result
+          end
+        end
+        
+        generate_response(result)
+        
+      end
+      
+      private
+      
+      def current_path
+        @_current_path ||= request.path_info.to_s.sub(/^\//, '')
+      end
+      
+      def generate_response(content)
+        response.status = ( content.nil? ? 404 : 200)
+        response.headers['content-type'] = "text/html"
+        response.body = content
+        response
+      end
+      
+    end
+  end
+end

data/lib/tipsy/view/context.rb

@@ -0,0 +1,28 @@
+module Tipsy
+  module View
+    ##
+    # All views are rendered within a context object. This object handles
+    # transitioning data between templates and layouts.
+    # 
+    class Context
+      include Tipsy::Helpers
+      attr_reader :request, :template, :layout, :virtual_path, :lookup_context
+      
+      def initialize(request, template, path, lookup)
+        @request        = request
+        @layout         = 'default'
+        @template       = template
+        @virtual_path   = path
+        @lookup_context = lookup
+        @output_buffer  = nil
+      end
+      
+      def layout(set = nil)
+        @layout = set unless set.nil?
+        @layout
+      end
+
+    end
+    
+  end
+end

data/lib/tipsy/view/path.rb

@@ -0,0 +1,44 @@
+require 'hike'
+
+module Tipsy
+  module View
+    class Path < ::Hike::Trail
+      
+      def initialize
+        super(Tipsy.root)
+        append_path('.')
+        append_extensions '.erb','.html', '.json', '.xml'
+      end
+      
+      def locate_template(view_path)
+        with_temporary_scope('views') do
+          @_template ||= (find(view_path) || find(File.join(view_path, "index")))
+        end
+      end
+      
+      def locate_layout(name)
+        with_temporary_scope('layouts') do
+          @_layout ||= find(name)
+        end
+      end
+      
+      def locate_relative(path, name)
+        with_temporary_scope("views", path) do
+          find(name)
+        end
+      end
+      
+      private 
+      
+      def with_temporary_scope(*new_scope)
+        old_paths = @paths
+        new_scope = [Tipsy.root, new_scope].flatten
+        append_path(File.join(*new_scope))
+        yield
+      ensure
+        @paths = old_paths
+      end
+      
+    end
+  end
+end