tipsy 0.0.2 → 0.0.3

data/lib/tipsy/handler/sass.rb

@@ -0,0 +1,36 @@
+require 'tilt'
+require 'sass/engine'
+require 'tipsy/handler/sass/resolver'
+require 'tipsy/handler/sass/importer'
+
+module Tipsy
+  module Handler
+    class SassHandler < ::Tilt::ScssTemplate
+      self.default_mime_type = 'text/css'
+      
+      def prepare; end;
+
+      def evaluate(scope, locals, &block)
+        ::Sass::Engine.new(data, sass_engine_options(scope)).render
+      end
+      
+      private
+      
+      def sass_engine_options(scope)
+        options = {
+          :filename   => eval_file,
+          :line       => line,
+          :syntax     => :scss,
+          :importer   => Importer.new(scope)
+        }
+        begin
+          require 'compass'
+          options.reverse_merge!(::Compass.sass_engine_options)
+        rescue LoadError
+        end
+        ensure options
+      end
+      
+    end
+  end
+end

data/lib/tipsy/handler/static.rb

@@ -0,0 +1,30 @@
+require 'rack'
+
+module Tipsy
+  module Handler
+    ##
+    # Handles serving/delivering static files from the 
+    # /public directory.
+    # 
+    class StaticHandler    
+      attr_reader :app, :try_files, :static
+
+      def initialize(app, options)
+        @app       = app
+        @try_files = ['', *options.delete(:try)]      
+        @static    = ::Rack::Static.new(lambda { [404, {}, []] }, options)
+      end
+
+      def call(env)
+        pathinfo = env['PATH_INFO']
+        found    = nil
+        try_files.each do |path|
+          response = static.call(env.merge!({ 'PATH_INFO' => pathinfo + path }))
+          break if 404 != response[0] && found = response
+        end
+        found or app.call(env.merge!('PATH_INFO' => pathinfo))
+      end      
+    end
+    
+  end
+end

data/lib/tipsy/helpers/asset_paths.rb

@@ -6,13 +6,41 @@ module Tipsy
       
       def asset_path(path)
         return path if path.match(/^https?:/) || Pathname.new(path).absolute?
-        "/" << File.join('assets', path)
+        "/" << path_for_asset_type(path)
       end
       
       def path_with_ext(path, ext)
         return path if path.match(/^https?:/) || path.ends_with?(".#{ext}")
         [path, ext].join('.')
       end
+      
+      private
+      
+      def path_for_asset_type(path)
+        result = if is_javascript?(path)
+          File.join(Tipsy::Site.javascripts_path, path)
+          elsif is_css?(path)
+            File.join(Tipsy::Site.css_path, path)
+          elsif is_image?(path)
+            File.join(Tipsy::Site.images_path, path)
+          else 
+            File.join(Tipsy::Site.asset_path, path)
+        end
+        result = (Pathname.new(result).absolute? ? result.sub("/",'') : result)
+        result
+      end
+      
+      def is_image?(path)
+        !!(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.bmp'].detect{ |p| path.ends_with?(p) })
+      end
+      
+      def is_css?(path)
+        path.ends_with?('.css')
+      end
+      
+      def is_javascript?(path)
+        path.ends_with?(".js")
+      end
     
     end
   end

data/lib/tipsy/helpers/asset_tags.rb

@@ -23,7 +23,7 @@ module Tipsy
         }).stringify_keys!
         
         files.map{ |file| 
-          content_tag('link', '', { 'href' => asset_path(path_with_ext(file, 'css')), 'rel' => "stylesheet" }.merge!(html_attrs))
+          tag('link', { 'href' => asset_path(path_with_ext(file, 'css')), 'rel' => "stylesheet" }.merge!(html_attrs))
         }.join("\n")
       end
       

data/lib/tipsy/helpers/capture.rb

@@ -5,51 +5,22 @@ module Tipsy
       def content_for(name, content = nil, &block)
         content ||= capture(&block) if block_given?
         instance_variable_set("@_#{name}", content) if content
-        instance_variable_get("@_#{name}") unless content
-      end
-
-      def capture(&block)
-        buffer = ""
-        orig_buffer, @_output_buffer = @_output_buffer, buffer
-        yield
-        buffer
-        ensure
-          @_output_buffer = orig_buffer
+        instance_variable_get("@_#{name}").to_s unless content
       end
       
-      def render(options = {})
-        options.symbolize_keys!
-        assert_valid_keys!(options, :template, :partial, :collection, :locals)
-        
-        if template = options.delete(:template)
-          _render_template(template, options)
-        elsif template = options.delete(:partial)
-          _render_template(template, options, true)
-        else
-          raise 'Render requires a :template or :partial option.'
-        end
+      def content_for?(name)
+        !instance_variable_get("@_#{name}").nil?
       end
-      
-      private
-      
-      def _render_template(name, options = {}, partial = false)
-        to_render = ( partial === true ? "_#{name}" : name )
-        to_render = view_trail.find(to_render)
-        unless to_render.nil?
-          local_vars = options.delete(:locals) || {}
-          results = Tilt[to_render].new(to_render, nil)
-          return results.render(self, local_vars)
-        end
-        raise "Missing #{ partial ? 'partial' : 'template' } #{name}."
-      end
-      
-      def assert_valid_keys!(hash, *keys)
-        left = hash.keys.reject{ |k| keys.include?(k) }
-        unless left.empty?
-          raise 'Invalid keys for hash: #{left.join(", ")}'
-        end
+
+      def capture(*args)
+        buffer ||= ""
+        @output_buffer, old_buffer = buffer, @output_buffer
+        yield
+        @output_buffer
+      ensure
+        @output_buffer = old_buffer
       end
       
-    end      
+    end          
   end
 end

data/lib/tipsy/helpers/rendering.rb

@@ -0,0 +1,46 @@
+module Tipsy
+  module Helpers
+    module Rendering
+      
+      def render(options = {})
+        options.symbolize_keys!
+        assert_valid_keys!(options, :template, :partial, :collection, :locals)
+        
+        if template = options.delete(:template)
+          render_inline_template(template, options)
+        elsif template = options.delete(:partial)
+          render_inline_template(template, options, true)
+        else
+          raise 'Render requires a :template or :partial option.'
+        end
+      end
+      
+      private
+      
+      def render_inline_template(path, options = {}, partial = false) 
+        
+        to_render   = File.basename(path)
+        to_render   = "_#{to_render}" if partial
+        render_path = Pathname.new(path)
+        render_path = render_path.absolute? ? render_path : lookup_context.locate_relative(render_path.dirname, to_render)
+        
+        unless render_path.nil?
+          local_vars = options.delete(:locals) || {}
+          results    = Tilt[render_path].new(render_path, nil)
+          return results.render(self, local_vars)
+        end
+        
+        raise "Missing #{ partial ? 'partial' : 'template' } #{to_render}."
+        
+      end
+      
+      def assert_valid_keys!(hash, *keys)
+        left = hash.keys.reject{ |k| keys.include?(k) }
+        unless left.empty?
+          raise 'Invalid keys for hash: #{left.join(", ")}'
+        end
+      end
+      
+    end
+  end
+end

data/lib/tipsy/helpers/sass.rb

@@ -5,27 +5,38 @@ module Tipsy
     module Sass
 
       def asset_path(asset, kind)
-        ::Sass::Script::String.new(public_path(asset.value, kind.value), true)
+        ::Sass::Script::String.new(public_path(asset, kind), true)
       end
 
       def asset_url(asset, kind)
-        ::Sass::Script::String.new(%Q{url(#{public_path(asset.value, kind.value)})})
+        ::Sass::Script::String.new(%Q{url(#{asset_path(asset, kind)})})
       end
 
-      [:image, :font, :video, :audio, :javascript, :stylesheet].each do |asset_class|
+      [:image, :font, :stylesheet].each do |asset_class|
         class_eval %Q{
           def #{asset_class}_path(asset)
-            asset_path(asset, Sass::Script::String.new("#{asset_class}"))
+            asset_path(asset, ::Sass::Script::String.new("#{asset_class}"))
           end
           def #{asset_class}_url(asset)
-            asset_url(asset, Sass::Script::String.new("#{asset_class}"))
+            asset_url(asset, ::Sass::Script::String.new("#{asset_class}"))
           end
         }, __FILE__, __LINE__ - 6
       end
 
     protected
       def public_path(asset, kind)
-        options[:custom][:resolver].public_path(asset, kind.pluralize)
+        
+        check = ::Pathname.new(asset.to_s)
+        return asset.to_s if check.absolute?
+        
+        path = case kind.to_s        
+        when 'stylesheet' || 'css' then Tipsy::Site.css_path
+        when 'javascript' || 'js'  then Tipsy::Site.javascripts_path
+        when 'image' || 'images'  then Tipsy::Site.images_path
+        when 'font'  || 'fonts'    then Tipsy::Site.fonts_path
+        else "/"
+        end
+        path.to_s
       end
     end
   end

data/lib/tipsy/helpers/tag.rb

@@ -1,16 +1,15 @@
 module Tipsy
-  module Helpers
-    
+  module Helpers    
     module Tag
-      include Capture
+      include Tipsy::Helpers::Capture
       
       def tag(name, html_attrs = {}, open = false)
         "<#{name}#{make_attributes(html_attrs)}#{open ? ">" : " />"}"
       end
       
-      def content_tag(name, content = nil, html_attrs = {}, &block)
+      def content_tag(name, content = nil, html_attrs = {}, &capt)
         buffer = "<#{name}#{make_attributes(html_attrs)}>"
-        content = capture(&block) if block_given?
+        content = capture(&capt) if block_given?
         "<#{name}#{make_attributes(html_attrs)}>#{content}</#{name}>"
       end
       
@@ -34,9 +33,7 @@ module Tipsy
           attrs << "#{key}=#{value.inspect}"
         end
         (attrs.empty? ? "" : " #{attrs.join(" ")}")
-      end
-      
-    end
-    
+      end      
+    end    
   end
 end

data/lib/tipsy/helpers.rb

@@ -1,32 +1,29 @@
 require 'active_support/core_ext/array'
-
 require 'tipsy/helpers/asset_paths'
 require 'tipsy/helpers/capture'
 require 'tipsy/helpers/tag'
 require 'tipsy/helpers/asset_tags'
-require 'tipsy/helpers/sass'
+require 'tipsy/helpers/rendering'
 
 module Tipsy
   module Helpers
-    extend ActiveSupport::Concern
     include Capture
     include Tag 
     include AssetPaths
     include AssetTags
+    include Rendering
     
-    module InstanceMethods
-      private
-      
-      def __initialize_helpers
-        module_names = []
-        includes = Dir.glob(File.expand_path(Tipsy.root) << "/helpers/*.rb").inject([]) do |arr, helper|
-          module_names << File.basename(helper, '.rb').classify
-          arr.concat File.open(helper).readlines          
-        end
-        module_names.each{ |mod| includes.concat(["\n include #{mod}"]) }
-        self.class_eval(includes.join("\n"))
-      end
-    end
+    extend ActiveSupport::Concern
     
+    included do
+      module_names = []
+      includes = Dir.glob(File.expand_path(Tipsy.root) << "/helpers/*.rb").inject([]) do |arr, helper|
+        module_names << File.basename(helper, '.rb').classify
+        arr.concat File.open(helper).readlines          
+      end
+      module_names.each{ |mod| includes.concat(["\n include #{mod}"]) }
+      eval(includes.join("\n"), binding)
+    end    
   end
+  
 end

data/lib/tipsy/runner.rb

@@ -0,0 +1,82 @@
+require 'optparse'
+require 'tipsy/site'
+
+module Tipsy
+  class Runner
+    attr_reader :args, :site
+    
+    def initialize(ar, stdin)
+      @args = [ar].flatten    
+      cmd = args.first || "serve"
+      cmd = "serve"  if ['', 'run', 's', 'serve'].include?(cmd)
+      cmd = "create" if cmd == 'new'
+      args.shift
+      Tipsy::Site.configure!
+      @site = Tipsy::Site.new
+      send(:"#{cmd}")
+    end
+    
+    ##
+    # Create an instance of Rack::Builder to serve the "static" site.
+    # @usage From the command line,
+    #  run `tipsy`, `tipsy serve` or simply `tipsy s`
+    # 
+    def serve
+      require 'tipsy/server'
+      require 'tipsy/view'
+      require 'rack'
+      
+      app = Rack::Builder.new {
+        use Rack::Reloader
+        use Rack::ShowStatus
+        use Rack::ShowExceptions
+        use Tipsy::Handler::StaticHandler, :root => Tipsy::Site.config.public_path, :urls => %w[/]
+        run Rack::Cascade.new([
+        	Rack::URLMap.new(Tipsy::Handler::AssetHandler.map!),
+        	Tipsy::Server.new
+        ])
+      }.to_app
+      
+      conf    = Tipsy::Site.config
+      options = {
+        :Host => conf.address,
+        :Port => conf.port
+      }
+      
+      Tipsy::Server.run!(app, options)
+    end
+    
+    ##
+    # Generates a new site in the specified path. 
+    # @usage From the command line, run `tipsy new name_of_site_to_create`
+    #
+    def create
+      Tipsy::Runners::Generator.new(args, @site)
+    end
+    
+    ##
+    # Responsible for compiling the final site for deployment. This process will 
+    # take the following steps:
+    # 
+    # 1. Copy files recursively from /public
+    # 2. Compile javascripts, sprites, and css files into their respective directories within the compile folder
+    # 3. Render all templates and place in their proper directories within the compile folder.
+    # 
+    # @usage From the command line, run `tipsy compile`
+    # 
+    def compile
+      Tipsy::Runners::Compiler.new
+    end
+    
+    
+    ##
+    # Responsible for deploying a compiled site to a production server. 
+    # @usage From the command line, run `tipsy deploy`
+    # 
+    def deploy
+      Tipsy::Runners::Deployer.new
+    end
+    
+  end
+  
+end

data/lib/tipsy/runners/compiler.rb

@@ -0,0 +1,189 @@
+require 'find'
+
+module Tipsy
+  module Runners
+    class Compiler
+      include Tipsy::Utils::System
+      
+      attr_reader :source_path, :dest_path, :scope
+      
+      def initialize
+        @source_path = config.public_path
+        @dest_path   = config.compile_to
+        excluded     = [excludes, config.compile.preserve].flatten.uniq
+        @_excludes   = excluded
+        clean_existing!
+        
+        [:public, :images, :assets, :templates].each do |m|
+          send(:"compile_#{m}!")
+        end
+        
+        cleanup!
+        
+      end
+      
+      def config
+        Tipsy::Site.config
+      end
+      
+      def skip_file?(src)
+        return false unless scope == :clean || scope == :public
+        check = case scope
+        when :clean  then config.compile.preserve
+        when :public then config.compile.skip
+        else []
+        end
+        check.detect{ |path| File.basename(src) == path }
+      end
+      
+      alias :skip_path? :skip_file?
+      
+      private
+      
+      def clean_existing!
+        @scope = :clean
+        return true unless ::File.directory?(dest_path)
+        ::Find.find(dest_path) do |path|
+          next if path == config.compile_to
+          if ::File.directory?(path)
+            if skip_path?(path)
+              ::Find.prune
+            elsif empty_dir?(path)
+              rm_rf(path)
+              ::Find.prune
+            else
+              next
+            end
+          elsif ::File.exists?(path)
+            unlink(path) unless skip_file?(path)
+          end
+        end
+
+        Dir["#{dest_path}/**/**"].select{ |path| File.directory?(path) }.each do |dir|
+          next if config.compile_to == dir
+          rm_rf(dir) if empty_dir?(dir)
+        end
+        
+      end
+      
+      def compile_public!
+        @scope = :public
+        log_action("copy", "public files")
+        copy_tree(source_path, dest_path)
+      end
+      
+      def compile_images!
+        @scope = :images
+        log_action("compile", "images")      
+        image_path = File.join(dest_path, config.images_path)
+        mkdir_p image_path
+        copy_tree(File.join(Tipsy.root, 'assets', 'images'), image_path)
+      end
+      
+      def compile_assets!
+        @scope = :assets
+        log_action('compile', 'assets')
+        handler = Tipsy::Handler::AssetHandler.new
+        handler.prepare_compiler
+
+        config.compile.assets.each do |file|
+          handler.each_logical_path do |path|
+            should_compile = path.is_a?(Regexp) ? file.match(path) : File.fnmatch(file.to_s, path)
+            next unless should_compile?
+
+            if asset = handler.find_asset(path)
+              log_action("compile", asset.logical_path)            
+              writepath = build_asset_path(asset, file)
+              asset.write_to(writepath)
+            end
+            
+          end
+        end
+      end
+      
+      def compile_templates!
+        dirs = ::Dir[::File.join(Tipsy.root, "views") << "/**/**"].reject do |dir|
+          dir == '.' || dir == ".." || dir[0] == "." || !::File.directory?(dir)
+        end
+        dirs = dirs.reject do |dir|
+          # Skip folders that only have partials or all files/dirs excluded
+          ::Dir.entries(dir).reject{ |f| f.to_s[0] == "_" || excluded?(f) }.empty?
+        end.push(File.join(Tipsy.root, "views"))
+
+        view_path  = ::File.join(Tipsy.root, "views")
+
+        dirs.each do |path|          
+          templates_in_path(path).each do |tpl|
+            next if ::File.directory?(File.join(path, tpl))
+            
+            route    = ::Pathname.new(path.gsub("#{Tipsy.root}/views", ""))
+            route    = "/" if route.blank?
+            route    = "/#{route.to_s}" unless route.absolute?
+            route    = File.join(route.to_s, tpl.split(".").first) unless tpl.to_s.match(/^index/i)
+            request  = MockRequest.new(route.to_s)
+            view     = Tipsy::View::Base.new(request, MockResponse.new)            
+
+            compiled = view.render
+            next if view.template.nil?
+            proper_name = proper_template_name(view.template)
+            
+            if ::File.directory?(File.join(view_path, request.path))
+              write_to = ::File.join(request.path, proper_name)
+            else
+              write_to = "#{request.path}#{::File.extname(proper_template_name(view.template))}"
+            end
+            
+            log_action("render", request.path)
+            mkdir_p ::File.join(config.compile_to, write_to)
+            make_file(::File.join(config.compile_to, write_to), compiled)
+          end
+        end
+      end
+      
+      def cleanup!
+        wipe = { :files => [".DS_Store"], :dirs => [".sass-cache"] }
+        enumerate_tree(dest_path) do |path|
+          wipe[:files].each do|file| 
+            ::File.unlink(path) if ::File.basename(path) == file
+          end
+          wipe[:dirs].each do |dir|
+            ::FileUtils.rm_rf(path) if ::File.basename(path) == dir
+          end
+        end
+      end
+      
+      class MockRequest
+        attr_reader :path_info, :path
+        def initialize(p)
+          @path_info, @path = p, p
+        end
+      end
+      
+      class MockResponse
+        attr_accessor :status, :body, :headers
+        def initialize
+          @headers = {}
+        end
+      end
+      
+      private
+      
+      def templates_in_path(path)
+        ::Dir.entries(path).reject{ |file| file[0] == "_" || ::File.directory?(file) }
+      end
+      
+      def proper_template_name(tpl)
+        ::File.basename(tpl).gsub(/(md|haml|erb|rb|slim)/i, "").gsub(/\.$/, '')        
+      end
+      
+      def build_asset_path(asset, file)
+        base =  (file.to_s.match(/\.js$/i) ? :javascripts_path : (file.to_s.match(/\.css$/i) ? :css_path : :images_path))
+        base = config.send(base)
+        path = File.expand_path(File.join(config.compile_to, base))
+        mkdir_p(path) unless File.directory?(path)
+        File.join(path, asset.logical_path)
+      end
+      
+    end
+  end
+end

data/lib/tipsy/runners/deployer.rb

@@ -0,0 +1,7 @@
+module Tipsy
+  module Runners
+    class Deployer
+      
+    end
+  end
+end

data/lib/tipsy/runners/generator.rb

@@ -0,0 +1,24 @@
+module Tipsy
+  module Runners
+    class Generator      
+      attr_reader :site_name, :site, :source_path, :dest_path
+      
+      include Tipsy::Utils::System
+      
+      def initialize(args, site)
+        @site_name, @site = args.first, site
+        @source_path = File.expand_path("../../../templates/site", __FILE__)
+        @dest_path   = File.join(Tipsy.root, site_name)
+        ensure_destination
+        copy_tree(source_path, dest_path)
+      end
+      
+      private
+      
+      def ensure_destination
+        ::FileUtils.mkdir(dest_path) unless ::File.exists?(dest_path) && ::File.directory?(dest_path)
+      end
+      
+    end
+  end
+end