tipsy 0.0.2 → 0.0.3

data/lib/tipsy/view.rb

@@ -1,78 +1,24 @@
+require 'tipsy/handler/all'
 require 'tilt'
-require 'tipsy/helpers'
 require 'hike'
 
 module Tipsy
-  ##
-  # Handles rendering of templates and layouts
-  # 
-  class View
-
-    attr_reader :content_type
-    attr_reader :file
-    attr_reader :request
-    attr_reader :trail
-    attr_reader :view_path
-    
-    def initialize(path, request)            
-      @request      = request
-      @content_type = 'text/html'
-      @trail        = Hike::Trail.new(File.join(Tipsy.root, 'views'))      
-      @view_path    = path
-      @template     = nil      
-      trail.append_path('.')
-      trail.append_extensions '.erb','.html', '.json', '.xml'      
-    end
-    
-    def render
-      unless template.nil?
-        handler  = Tilt[template] || Tilt::ErubisTemplate
-        tilt     = handler.new(template, nil, :outvar => '@_output_buffer')
-        context  = Context.new(request, template, trail)
-        contents = unless layout.nil?
-          wrapped  = Tilt.new(layout, nil, :outvar => '@_output_buffer')
-          contents = wrapped.render(context) do |*args|
-            tilt.render(context, *args)
-          end
-        else
-          tilt.render(context)
-        end
-        return contents
-      end      
-      nil
-    end
-    
-    private
-    
-    def template
-      @template ||= (trail.find(view_path) || trail.find(File.join(view_path, "index")))
-    end
-    
-    def layout
-      @layout ||= (trail.find(File.join(view_path, '_layout')) || trail.find('_layout'))
-    end
-    
-    ##
-    # A rendering context. This class is the context all views are stemmed from.
-    # 
-    class Context
-      include Tipsy::Helpers
-      attr_reader :request, :root, :template_file_name, :view_trail
-      
-      def initialize(req, tpl, trail)
-        @request            = req
-        @root               = Tipsy.root
-        @template_file_name = tpl
-        @view_trail         = trail
-        __initialize_helpers
+  module View 
+    class << self
+      def register_handler(klass, ext)
+        Tilt.register(klass, ext)
       end
     end
     
+    class TemplateMissing < ::StandardError; end
+    class LayoutMissing < ::StandardError; end
+    
   end
 end
 
-begin
-  require 'erubis'
-  Tilt.prefer Tilt::ErubisTemplate, 'erb'
-rescue LoadError
-end
+require 'tipsy/helpers'
+require 'tipsy/view/base'
+require 'tipsy/view/context'
+require 'tipsy/view/path'
+
+Tipsy::View.register_handler(Tipsy::Handler::ErbHandler, 'erb')

data/lib/tipsy.rb

@@ -1,84 +1,47 @@
-require "tipsy/version"
 require "active_support/all"
-require 'optparse'
-require 'ostruct'
+require "tipsy/version"
 
 module Tipsy
-
-  autoload :Application,  'tipsy/application'
-  autoload :Server,       'tipsy/server'
-  autoload :Responder,    'tipsy/handler'
-  autoload :Helpers,      'tipsy/helpers'  
-  autoload :Builder,      'tipsy/builder'
-  autoload :Logger,       'tipsy/logger'
-  autoload :View,         'tipsy/view'
   
-  module Compressors
-    autoload :CssCompressor, 'tipsy/compressors/css'
-    autoload :JavascriptCompressor, 'tipsy/compressors/javascript'
+  module Handler    
+    autoload :AssetHandler,    'tipsy/handler/asset'
+    autoload :StaticHandler,   'tipsy/handler/static'
+    autoload :SassHandler,     'tipsy/handler/sass'
+    autoload :PhpHandler,      'tipsy/handler/php'
+    autoload :ErbHandler,      'tipsy/handler/erb'
   end
   
-  module Sass
-    autoload :Template, 'tipsy/sass/template'
+  module Runners
+    autoload :Generator, 'tipsy/runners/generator'
+    autoload :Compiler,  'tipsy/runners/compiler'
+    autoload :Deployer,  'tipey/runners/deployer'
   end
   
-  mattr_accessor :root
-  mattr_accessor :logger
-  mattr_accessor :env
-  mattr_accessor :sprockets
-  mattr_accessor :compass
-  
-  def self.logger
-    @logger ||= Tipsy::Logger.new($stdout)
-  end
-    
-  def self.run_command(args, stdin)    
-    args   = [args].flatten    
-    to_run = args.first
-    to_run = case to_run
-    when nil then 'run'
-    when 'new' then 'create'
-    when 'serve' || 's' then 'run'
-    else to_run
-    end
-    
-    args.shift
-    parse_options!    
-    Tipsy::Application.send(:"#{to_run}", *args)    
-    
+  module Utils
+    autoload :System,     'tipsy/utils/system'
+    autoload :SystemTest, 'tipsy/utils/system_test'
+    autoload :Logger,     'tipsy/utils/logger'
   end
   
-  def self.options
-    @@options ||= OpenStruct.new({
-      :port         => 4000,
-      :host         => '0.0.0.0',
-      :assets       => OpenStruct.new({ :paths => [], :precompile => [] }),
-      :build_path   => File.join(Tipsy.root, 'build'),
-      :public_path  => File.join(Tipsy.root, 'public'),
-      :asset_path   => File.join(Tipsy.root, 'public', 'assets')
-    })
+  module Compressors
+    autoload :JavascriptCompressor, 'tipsy/compressors/javascript_compressor'
+    autoload :CssCompressor,        'tipsy/compressors/css_compressor'
   end
   
-  private
-  
-  def self.parse_options!    
+  class << self    
+    def env
+      @env ||= ENV['TIPSY_ENV'] || 'development'
+    end
     
-    op = OptionParser.new do |opts|
-      opts.banner = "Usage: tipsy [cmd] [options]"
-      opts.separator ""
-      opts.separator "Options:"
-      opts.on("-p", "--port", "Run the server on a specified port ( default: 4000 )") do |port|
-        options.port = port
-      end
-      opts.on("-a", "--address", "Run the server on a specified address ( default: 0.0.0.0 )") do |host|
-        options.host = host
-      end
-      opts.on_tail("--version", "Show version") do
-        puts Tipsy::VERSION
-        exit 0
-      end
+    def root
+      @root ||= ENV['TIPSY_ROOT']
     end
     
+    def logger
+      @logger ||= Tipsy::Utils::Logger.new($stdout)
+    end    
   end
-  
+
 end
+
+require 'tipsy/site'

data/test/helpers/tag_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+require 'tipsy/helpers'
+
+class TagTest < ActiveSupport::TestCase
+
+  include Tipsy::Helpers::Tag
+  include Tipsy::Helpers::AssetPaths
+  include Tipsy::Helpers::AssetTags
+  
+  def setup
+    @output_buffer = ""
+  end
+
+  test "Single tags should be rendered with attributes" do
+    tag(:img, { src: "some/source.jpg" }).should  == '<img src="some/source.jpg" />'
+  end
+  
+  test "The image_tag renders an img tag" do
+    image_tag("something.jpg").should == '<img alt="something.jpg" src="/assets/something.jpg" />'
+  end
+
+end

data/test/runner/compiler_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class CompilerTest < ActiveSupport::TestCase
+  attr_reader :compiler
+  
+  def setup
+    Tipsy::Runners::Compiler.send(:include, Tipsy::Utils::SystemTest)
+    @compiler = Tipsy::Runners::Compiler.new
+    Tipsy::Site.configure!
+  end
+  
+  test "Ensure source path is set" do
+    compiler.source_path.should == Tipsy::Site.config.public_path    
+  end
+  
+  test "Ensure destination path is set" do
+    compiler.dest_path.should == Tipsy::Site.config.compile_to
+  end
+  
+  test "An option exists to skip specific files and folders on compile" do
+    compiler.excludes.include?('.git').should == true
+    compiler.excludes.include?('.svn').should == true
+  end
+  
+  test "Ensure skipped directory is not removed" do
+    compiler.was_deleted?(File.join(Tipsy::Site.compile_to, ".svn")).should == false
+  end
+  
+  test "Ensure un-skipped files are removed" do
+    compiler.was_deleted?(File.join(Tipsy::Site.compile_to, "sub-path-with-skip", "fake.txt")).should == true
+  end
+  
+  test "Ensure un-skipped files in folders are removed" do
+    compiler.was_deleted?(File.join(Tipsy::Site.compile_to, "sub-path", "fake.txt")).should == true
+  end
+  
+  test "Ensure un-skipped directories are removed" do
+    compiler.was_deleted?(File.join(Tipsy::Site.compile_to, "sub-path")).should == true
+  end
+  
+  test "Ensure templates are created" do
+    compiler.was_created?(File.join(Tipsy::Site.compile_to, "sub", "page.html")).should == true
+  end
+  
+  test "Ensure index templates are created" do
+    compiler.was_created?(File.join(Tipsy::Site.compile_to, "sub", "tertiary", "index.html")).should == true
+  end
+  
+end

data/test/test_helper.rb

@@ -1,33 +1,172 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require "rack/test"
-require "test/unit"
-require "minitest/unit"
-require "turn"
-require "tipsy"
-require 'matchy'
-
-module Tipsy
-  module Test
-    
-    def self.app
-      @app ||= Tipsy::Server.init!
+require 'rubygems'
+require 'bundler/setup'
+
+ENV['TIPSY_ROOT'] ||= File.join(File.dirname(__FILE__), "root")
+ENV['TIPSY_ENV'] = "test"
+
+Bundler.require
+require 'rubygems'
+require 'colored'
+require 'active_support/all'
+require 'fileutils'
+require 'ostruct'
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'test/unit'
+
+require 'tipsy'
+
+require 'rspec/core'
+require 'rspec/expectations'
+
+Tipsy::Site.configure!
+
+module MiniTest
+  class SpecRunner < Unit
+  
+    def before_suites
+      super if defined?(super)
+    end
+
+    def after_suites
+      super if defined?(super)
     end
   
-    module Helpers
+    def status(io = nil)
+      io ||= @@out
+      return io.puts ("%d tests, %d failures" % [assertion_count, failures]).green unless (failures.to_i > 0 || errors.to_i > 0)
+      format = "%d tests, %d assertions, %d failures, %d skipped/pending"
+      io.puts (format % [test_count, assertion_count, (failures + errors), skips]).red
+    end
+    
+    def pad(str, size = 2)
+      " " * size + ("%5s" % str)
+    end
+
+    def puke klass, meth, e  
       
-      def to_html(string)
-        string.strip
+      meth_title = meth.to_s.gsub("_", " ").capitalize
+      make_fail  = lambda{ |k, m, msg, loc|
+        ["#{k} #{m}", pad("Failure/Error: #{msg}", 5).red, pad("#{loc}", 5)].join("\n")
+      }
+      make_bt    = lambda{ | bt | 
+        bt.map{ |line| "\e[90m# #{line}\e[0m" }.join("\n")        
+      }
+      
+      msg   = case e
+        when MiniTest::Skip
+          @skips += 1
+          result  = :skip 
+          message = pad("(skipped/pending)", 6).yellow
+          "Pending: #{klass} #{meth}\n #{pad(location e)}]"
+        when MiniTest::Assertion
+          @failures += 1
+          result  = :fail
+          message = pad("#{e.message}", 6).red
+        when defined?(RSpec::Expectations) && RSpec::Expectations::ExpectationNotMetError
+          @failures += 1
+          result  = :fail
+          message = pad("#{e.message}", 6).red
+        else
+          @errors += 1
+          result  = :error
+          message = pad("#{e.class}: #{e.message}\n", 6)
       end
       
-      def fixture(name)
-        path = File.join(File.expand_path('../fixtures', __FILE__), name)
-        File.read(path).to_s.strip
+      loc = (result == :fail) ? location(e).split("\n") : MiniTest::filter_backtrace(e.backtrace)
+      msg = make_fail.call(klass, meth_title, e.message, make_bt.call(loc)) if result === :fail || result === :error
+      
+      @report << msg
+      result
+    end
+    
+    def _run_anything type
+      suites = TestCase.send "#{type}_suites"
+      return if suites.empty?
+
+      start = Time.now
+      puts "---------------------------------------------------------"
+      puts "Running #{type} suite(s)"
+      puts "---------------------------------------------------------"
+      puts
+      puts
+
+      @test_count, @assertion_count = 0, 0
+      sync = output.respond_to? :"sync=" # stupid emacs
+      old_sync, output.sync = output.sync, true if sync
+      
+      before_suites
+      results = _run_suites suites, type
+
+      @test_count      = results.inject(0) { |sum, (tc, _)| sum + tc }
+      @assertion_count = results.inject(0) { |sum, (_, ac)| sum + ac }
+
+      output.sync = old_sync if sync
+      after_suites
+      
+      t = Time.now - start
+
+      puts
+      puts "Finished in %.5fs" % t
+      puts status
+
+      report.each_with_index do |msg, i|
+        puts "\n%3d) %s" % [i + 1, msg]
       end
+      puts 
+      puts
+      
+      if defined?(MiniTest::Growl)
+        MiniTest::Growl.new(self)
+      end
+
+    end
+
+    def _run_suite suite, type
+      header = "#{type}_suite_header"
+      puts send(header, suite) if respond_to? header
+
+      filter = options[:filter] || '/./'
+      filter = Regexp.new $1 if filter =~ /\/(.*)\//
+      
+      available_suites = suite.send("#{type}_methods").grep(filter)
+      suite_name       = suite.to_s.gsub(/Test$/i, '')
+      
+      print "#{suite_name}\n" unless available_suites.empty?
+      
+      assertions = available_suites.map { |method|
+        inst = suite.new method
+        inst._assertions = 0
+
+        @start_time = Time.now
+        result      = inst.run self
+        repl_hash   = { "_" => " ", ":" => "" }
+        meth_title  = method.to_s.gsub(/\A(#{type.to_s})/, "").strip.gsub(/\A(\W|_)/){ repl_hash[$1] }.strip
+        meth_title  = meth_title.gsub(/\A(#{suite_name})/i, '').strip.gsub("_", " ")
+        
+        # Account for any sort of non-puke callback
+        response = if result.is_a?(Symbol)
+          (result == :skip) ? "#{meth_title} (skipped/pending)".yellow : "[x] : #{meth_title}".red
+        else
+          "[\u221A] : #{meth_title}".green
+        end
+        
+        time = Time.now - @start_time
+
+        print pad(response)
+        print (" (%.2fs) " % time).clear
+        puts
+
+        inst._assertions
+      }
+      
+      puts unless available_suites.empty?
+      return assertions.size, assertions.inject(0) { |sum, n| sum + n }
       
     end
     
-  end
   
+  end
 end
 
-Tipsy.root = File.join(File.dirname(__FILE__), '.', 'root', 'test')
+MiniTest::Unit.runner = MiniTest::SpecRunner.new

data/test/unit/site_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class SiteTest < ActiveSupport::TestCase
+
+  def setup
+    Tipsy::Site.configure!
+  end
+
+  test "before_compile should be a callable class method" do
+    Tipsy::Site.respond_to?(:before_compile).should == true
+  end
+  
+  test "Defined callbacks should be runnable blocks" do
+    check = false
+    Tipsy::Site.before_compile do
+      check = true
+    end
+    Tipsy::Site.before_compile
+    check.should == true
+  end
+  
+
+end

data/test/unit/tipsy_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class TipsyTest < ActiveSupport::TestCase
+
+  test "A root method is defined, defaulting to ENV['TIPSY_ROOT']" do
+    assert_equal Tipsy.root, File.expand_path("../../", __FILE__) << "/root"
+  end
+  
+  test "An env method is defined, defaulting to ENV['TIPSY_ENV']" do
+    assert_equal Tipsy.env, "test"
+  end
+  
+end

data/test/unit/utils/system_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class SystemTest < ActiveSupport::TestCase
+  attr_reader :runner
+  
+  class Runner
+    include Tipsy::Utils::System
+  end
+
+  def setup
+    @runner = Runner.new
+  end
+
+  test "Files can be excluded by extension" do
+    runner.excluded?("/home/someuser/another/something.rb").should == true    
+  end
+  
+  test "Entire directories can be excluded" do
+    runner.excluded?("/home/someuser/another/.svn").should == true    
+  end
+  
+  test "Non-excluded directories should be found" do
+    runner.excluded?("/home/someuser/another/something/").should == false
+  end
+  
+end

data/test/view/base_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+require 'tipsy/view'
+
+class ViewBaseTest < ActiveSupport::TestCase
+  attr_reader :path
+  
+  def setup
+    @path ||= Tipsy::View::Path.new
+  end
+
+  test "It should find a default index template" do
+    path.locate_template('').should_not == nil
+  end
+  
+  test "It should locate templates based on the path" do
+    path.locate_template("page").should_not == nil
+  end  
+  
+  test "Locating the default layout" do
+    path.locate_layout('default').should == expand_path('layouts', 'default.html.erb')
+  end
+  
+  test "Template is found from the URI" do
+    path.locate_template('page').should == expand_path('views', 'page.html.erb')
+  end
+  
+  private
+  
+  def expand_path(*names)
+    names.unshift(Tipsy.root)
+    File.join(*names)
+  end
+
+end

data/test/view/path_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+require 'tipsy/view'
+
+class ViewPathTest < ActiveSupport::TestCase
+  attr_reader :path
+  
+  def setup
+    @path ||= Tipsy::View::Path.new
+  end
+
+  test "The default template should be index" do
+    path.locate_template('').should_not == nil
+  end
+  
+  test "Pages should be found by path" do
+    path.locate_template("page").should_not == nil
+  end  
+  
+  test "The default layout should be found" do
+    path.locate_layout('default').should == expand_path('layouts', 'default.html.erb')
+  end
+  
+  test "Templates should be found by URI if existing" do
+    path.locate_template('page').should == expand_path('views', 'page.html.erb')
+  end
+  
+  private
+  
+  def expand_path(*names)
+    names.unshift(Tipsy.root)
+    File.join(*names)
+  end
+
+end

data/tipsy.gemspec

@@ -3,10 +3,10 @@ $:.push File.expand_path("../lib", __FILE__)
 require "tipsy/version"
 
 Gem::Specification.new do |s|
-  
   s.name        = "tipsy"
   s.version     = Tipsy::VERSION
   s.authors     = ["Brent Kirby"]
+  s.authors     = ["Brent Kirby"]
   s.email       = ["info@kurbmedia.com"]
   s.homepage    = "https://github.com/kurbmedia/tipsy"
   s.summary     = %q{A mini Rack application server for developing static sites.}
@@ -19,13 +19,16 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  s.add_dependency("rack", "~> 1.2")
-  s.add_dependency("rack-test", "~> 0.5")
+  s.add_dependency("rack", "~> 1.3")  
+  s.add_dependency("rack-test", "~> 0.6")
   s.add_dependency("tilt", "~> 1.3")
-  s.add_dependency("i18n", "~> 0.5")
+  s.add_dependency("i18n", "~> 0.6")
   s.add_dependency("sass", "~> 3.1")
-  s.add_dependency("compass", "~> 11.5")
-  s.add_dependency("activesupport", ">= 3.0")
-  s.add_dependency('sprockets', '~> 2.0.0.beta.12')
+  s.add_dependency("activesupport", ">= 3.1")
+  s.add_dependency('sprockets', '~> 2.0')
+  s.add_dependency("hike", "~> 1.2")
+  s.add_dependency("erubis", "~> 2.7")
+    
+  s.add_development_dependency("minitest", "~> 2.5")
   
 end