tipsy 0.0.1 → 0.0.2

data/lib/tipsy/helpers/asset_tags.rb

@@ -0,0 +1,32 @@
+module Tipsy
+  module Helpers
+    module AssetTags
+      
+      def image_tag(src, html_attrs = {})
+        html_attrs.stringify_keys!
+        html_attrs.reverse_merge!('alt' => File.basename(src))
+        tag(:img, html_attrs.merge('src' => asset_path(src)))
+      end
+      
+      def javascript_include_tag(*files)        
+        html_attrs = files.extract_options!
+        html_attrs.stringify_keys!
+        files.map{ |file| 
+          content_tag('script', '', {'src' => asset_path(path_with_ext(file, 'js'))}.merge!(html_attrs))
+        }.join("\n")
+      end
+      
+      def stylesheet_link_tag(*files)        
+        html_attrs = files.extract_options!
+        html_attrs.reverse_merge!({          
+          :media => "screen"
+        }).stringify_keys!
+        
+        files.map{ |file| 
+          content_tag('link', '', { 'href' => asset_path(path_with_ext(file, 'css')), 'rel' => "stylesheet" }.merge!(html_attrs))
+        }.join("\n")
+      end
+      
+    end
+  end
+end

data/lib/tipsy/helpers/capture.rb

@@ -17,6 +17,39 @@ module Tipsy
           @_output_buffer = orig_buffer
       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
+      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
+      end
+      
     end      
   end
 end

data/lib/tipsy/helpers/sass.rb

@@ -0,0 +1,40 @@
+require 'sass'
+
+module Tipsy
+  module Helpers
+    module Sass
+
+      def asset_path(asset, kind)
+        ::Sass::Script::String.new(public_path(asset.value, kind.value), true)
+      end
+
+      def asset_url(asset, kind)
+        ::Sass::Script::String.new(%Q{url(#{public_path(asset.value, kind.value)})})
+      end
+
+      [:image, :font, :video, :audio, :javascript, :stylesheet].each do |asset_class|
+        class_eval %Q{
+          def #{asset_class}_path(asset)
+            asset_path(asset, Sass::Script::String.new("#{asset_class}"))
+          end
+          def #{asset_class}_url(asset)
+            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)
+      end
+    end
+  end
+end
+
+module Sass
+  module Script
+    module Functions
+      include Tipsy::Helpers::Sass
+    end
+  end
+end

data/lib/tipsy/helpers/tag.rb

@@ -14,6 +14,18 @@ module Tipsy
         "<#{name}#{make_attributes(html_attrs)}>#{content}</#{name}>"
       end
       
+      def link_to(text, path, html_attrs = {})
+        content_tag(:a, text, html_attrs.merge!('href' => path))
+      end
+      
+      def mail_to(addr, text = nil, html_attrs = {})
+        unless text || text.is_a?(Hash)
+          html_attrs = text if text
+          text = addr
+        end
+        link_to(text, "mailto:#{addr}", html_attrs)
+      end
+      
       private
       
       def make_attributes(hash)

data/lib/tipsy/logger.rb

@@ -1,11 +1,62 @@
 require 'logger'
 
 module Tipsy
-  class Logger < ::Logger
+  class Logger
     
-    def initialize
-      super($stdout)
+    COLOR_VALUES = {
+      :clear  => 0,
+      :red    => 31,
+      :green  => 32,
+      :yellow => 33
+    }
+    
+    attr_accessor :cache
+    attr_reader :stdout
+    
+    def initialize(o)
+      @stdout = o
+      @cache  = []
     end
     
+    def append(msg)
+      @cache << msg
+    end
+    
+    def flush!
+      cache.each{ |c| print c }
+    end
+    
+    def log_action(name, action)
+      print colorize(:green, (name.rjust(12, ' ') << " "), :clear, action)
+    end
+    
+    def info(msg)
+      print msg
+    end
+    
+    def warn(msg)
+      print colorize(:yellow, "Warning: ", :clear, msg)
+    end
+    
+    def error
+      print colorize(:red, "Error: ", :clear, msg)
+    end
+    
+    def colorize(*args)
+      output = args.inject([]) do |arr, option|
+        unless option.is_a?(Symbol) && COLOR_VALUES[option]
+          arr << option
+        else
+          arr << "\e[#{COLOR_VALUES[option]}m"
+        end
+        arr
+      end
+      output.push("\e[0m").join("")
+    end
+    
+    def print(msg)
+      puts msg
+    end
+   
   end
 end

data/lib/tipsy/project/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+gem "rack", "~> 1.2"
+gem "tilt", "~> 1.3"
+gem "i18n", "~> 0.5"
+gem "sass", "~> 3.1"
+gem "activesupport", ">= 3.0"
+gem 'sprockets', '~> 2.0.0.beta.12'

data/lib/tipsy/project/config.erb

@@ -1,8 +1,11 @@
 class <%= classname %> < Tipsy::Application
 
 	# Configure assets to be precompiled
-	config.assets << "site.js"
-	config.assets << "screen.css"
+	config.assets.precompile << "site.js"
+	config.assets.precompile << "screen.css"
+	
+	# Add assets to the load path
+	# config.assets.paths << "/some/path"
 	
 	# The path where build files will go when compiled
 	# config.build_path = <%= File.join(root, 'build') %>

data/lib/tipsy/sass/template.rb

@@ -0,0 +1,137 @@
+require 'tilt'
+require 'sass/engine'
+require 'compass'
+
+##
+# Most of this was extracted and modified from the sass-rails plugin, since most of the 
+# Sprockets functionality is the same.
+# 
+module Tipsy
+  module Sass
+    class Template < Tilt::ScssTemplate
+      self.default_mime_type = 'text/css'
+      
+      class Resolver
+        attr_accessor :context        
+        def initialize(context)
+          @context = context
+        end
+        def resolve(path, content_type = :self)
+          options = {}
+          options[:content_type] = content_type unless content_type.nil?
+          context.resolve(path, options)
+        rescue Sprockets::FileNotFound, Sprockets::ContentTypeMismatch
+          nil
+        end
+        def public_path(path, scope)
+          context.asset_paths.compute_public_path(path, scope)
+        end
+        def process(path)
+          context.environment[path].to_s
+        end
+      end
+      
+      
+      class Importer
+        
+        GLOB = /\*|\[.+\]/
+        PARTIAL = /^_/
+        HAS_EXTENSION = /\.css(.s[ac]ss)?$/
+        SASS_EXTENSIONS = {
+              ".css.sass" => :sass,
+              ".css.scss" => :scss,
+              ".sass" => :sass,
+              ".scss" => :scss
+        }            
+        
+        attr_reader :context
+
+        def initialize(context)
+          @context = context
+          @resolver = Resolver.new(context)
+        end
+        
+        def sass_file?(filename)
+          filename = filename.to_s
+          SASS_EXTENSIONS.keys.any?{|ext| filename[ext]}
+        end
+
+        def syntax(filename)
+          filename = filename.to_s
+          SASS_EXTENSIONS.each {|ext, syntax| return syntax if filename[(ext.size+2)..-1][ext]}
+          nil
+        end
+        
+        def render_with_engine(data, pathname, options = {})
+          ::Sass::Engine.new(data, options.merge(:filename => pathname.to_s, :importer => self, :syntax => syntax(pathname)))
+        end
+
+        def resolve(name, base_pathname = nil)
+          name = Pathname.new(name)
+          if base_pathname && base_pathname.to_s.size > 0
+            root = Pathname.new(context.root_path)
+            name = base_pathname.relative_path_from(root).join(name)
+          end
+          partial_name = name.dirname.join("_#{name.basename}")
+          @resolver.resolve(name) || @resolver.resolve(partial_name)
+        end
+        
+        def find_relative(name, base, options)
+          base_pathname = Pathname.new(base)
+          if pathname = resolve(name, base_pathname.dirname)
+            context.depend_on(pathname)
+            if sass_file?(pathname)
+              render_with_engine(pathname.read, pathname)
+            else
+              render_with_engine(@resolver.process(pathname), pathname)
+            end
+          else
+            nil
+          end
+        end
+        
+        def find(name, options)
+          if pathname = resolve(name)
+            context.depend_on(pathname)
+            if sass_file?(pathname)
+              render_with_engine(pathname.read, pathname)
+            else
+              render_with_engine(@resolver.process(pathname), pathname)
+            end
+          else
+            nil
+          end
+        end
+
+        def mtime(name, options)
+          if pathname = resolve_sass_path(name, options)
+            pathname.mtime
+          end
+        end
+
+        def key(name, options)
+          ["Sprockets:" + File.dirname(File.expand_path(name)), File.basename(name)]
+        end
+        
+        def resolve_sass_path(name, options = {}, relative = false)
+          prefix = ( relative === false ? "" : "./" )
+          (context.resolve("#{prefix}#{name}", options) || context.resolve("#{prefix}_#{name}", options))
+        end
+        
+      end
+      
+      def prepare        
+      end
+      
+      def evaluate(scope, locals, &block)
+        ::Sass::Engine.new(data, {
+          :filename   => eval_file,
+          :line       => line,
+          :syntax     => :scss,
+          :importer   => Importer.new(scope)
+        }.reverse_merge!(::Compass.sass_engine_options)).render
+      end
+      
+    end
+  end
+end

data/lib/tipsy/server.rb

@@ -1,7 +1,6 @@
 require 'rack'
 require 'sprockets'
 require 'hike'
-require 'sass'
 
 module Tipsy
   
@@ -9,6 +8,19 @@ module Tipsy
     
     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        	
+        ])
+      }      
+    end
       
     def initialize      
       @last_update = Time.now      
@@ -37,14 +49,45 @@ module Tipsy
   
   class AssetHandler < Sprockets::Environment    
     def initialize
-      super(Tipsy.root) do |env|
-        env.static_root = Tipsy.options.asset_path
-      end
-      self.append_path "assets/javascripts"
-      self.append_path "assets/stylesheets"
-      self.append_path "assets/images"
+      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

data/lib/tipsy/version.rb

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