vitrine 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91d23457bb272e611a621e15a4ec00427d6d7460
-  data.tar.gz: e45473b0d4cefc4b9c740c8e7650345e970268f1
+  metadata.gz: ad38905bb36040591304042eb96301dd54844848
+  data.tar.gz: df1a08482625e54ba47255a640913d288898a79b
 SHA512:
-  metadata.gz: 48c138e91489e1c1fe73b96e578721cadb15437e3fedc412ec3d3c290993a7b4e787ecb218cb0b51811e6f6e00738de8a31680a7cfce622508df58da4efe825c
-  data.tar.gz: d022f069dd5f28900b2f4919c340ed3fc665c2ffce1214b34db2be9c61cd1693c039e4eee996b9474d0363da56c60f70931093c88fb7fd89264a4a459232c2d9
+  metadata.gz: 104b112da1f12d430e449d1ecc59ed80ff07045c9f8141ee91c3be7f6dba79570b3108c674702d638ab7ca3a61a17c9435a89c651960a63a679b05bd9ae7f619
+  data.tar.gz: 89d843fd806e0f41b95e438ba3cdef583cdb7d1ea105405f99c18a8a393862a6a70fbcb491f5f43db897b0604866b2e026f4d4549893033ca16879b20a68a428

data/README.md

@@ -67,12 +67,18 @@ Vitrine will `etag` all the precompiled assets for faster reloading.
 
 At this point the best way to bake a Vitrine site is to crawl it externally, but we are going to implement
 baking at some point. The idea is that you will end up upgrading the site to either a Node app or a Ruby app
-with it's own +config.ru+ - if after that point you still wish to use Vitrine, you can use it like a Rack
+with it's own `config.ru` - if after that point you still wish to use Vitrine, you can use it like a Rack
 middleware.
 
 ## Using as a middleware
 
-Most actions in Vitrine will fall through to 404, so `Vitrine::App` can be used with `Rack::Cascade`
+Most actions in Vitrine will fall through to 404, so `Vitrine::App` can be used as a middleware handler.
+Put Vitrine into your application stack and it will complement your main application very nicely. But don't
+forget to set `:root` - like so:
+
+    use Vitrine::App.new do | vitrine |
+      vitrine.settings.set :root => File.dirname(__FILE__)
+    end
 
 ## Contributing to vitrine
  

data/bin/vitrine

@@ -1,5 +1,20 @@
 #!/usr/bin/env ruby
-
 lib = File.dirname(__FILE__) + '/../lib'
-require lib + '/vitrine'
-Vitrine.run
+require lib + '/server'
+require 'optparse'
+
+options = {}
+
+op = OptionParser.new
+op.banner = "Usage: cd ~/sites/my-glorious-app; vitrine -p 9292"
+op.on("-p", "--port NUMBER", Integer, "Run on the specified port (default is 4000)") do | port |
+  options[:port] = port
+end
+
+op.on("-r", "--root DIR", String, "Override the root directory (defaults to CWD)") do | rootdir |
+  options[:root] = rootdir
+end
+
+op.parse!
+
+Vitrine::Server.start(options)

data/lib/server.rb

@@ -0,0 +1,76 @@
+require_relative 'vitrine'
+require 'rack-livereload'
+
+module Vitrine::Server
+  DEFAULTS = { root: Dir.getwd, port: 4000, :address => '127.0.0.1' }
+  
+  def self.check_dirs_present!(options)
+    views = options[:root] + '/views'
+    unless File.exist?(views) and File.directory?(views)
+      $stderr.puts "WARNING: `views' directory not found under the current tree, you might want to create it"
+    end
+    
+    public_folder = options[:root] + '/public'
+    unless File.exist?(public_folder) and File.directory?(public_folder)
+      $stderr.puts "ERROR: `public' directory not found under the current tree, you should create it. Vitrine won't run without it"
+      exit 1
+    end
+  end
+  
+  # Builds the Rack application with all the wrappers
+  def self.build_app(options)
+    Rack::Builder.new do
+      use Rack::ShowStatus
+      use Rack::ShowExceptions
+  
+      guardfile_path = options[:root] + '/Guardfile'
+      if File.exist?(guardfile_path)
+        $stderr.puts "Attaching LiveReload via Guardfile at #{guardfile_path.inspect}"
+        # Assume livereload is engaged
+        use Rack::LiveReload
+      else
+        $stderr.puts "No Guardfile found, so there won't be any livereload injection"
+      end
+  
+      vitrine = Vitrine::App.new
+      vitrine.settings.set :root, options[:root]
+      run vitrine
+    end
+  end
+  
+  # Pick a server handler engine and run the passed
+  # app on it, honoring the passed options
+  def self.start_server(app, options)
+    begin
+      # Try Thin
+      thin = Rack::Handler.get('thin')
+      thin.run app, :Port => options[:port], :Host => options[:address] do |server|
+        puts "Thin #{Thin::VERSION::STRING} available at http://#{options[:address]}:#{options[:port]}"
+      end
+    rescue LoadError
+      begin
+        # Then Mongrel
+        mongrel = Rack::Handler.get('mongrel')
+        mongrel.run app, :Port => options[:port], :Host => options[:address] do |server|
+          puts "Mongrel #{Mongrel::Const::MONGREL_VERSION} available at http://#{options[:address]}:#{options[:port]}"
+        end
+      rescue LoadError
+        # Then WEBrick
+        puts "Install Mongrel or Thin for better performance."
+        webrick = Rack::Handler.get('webrick')
+        webrick.run app, :Port => options[:port], :Host => options[:address] do |server|
+          trap("INT") { server.shutdown }
+        end
+      end
+    end
+  end
+  
+  # Run the server, largely stolen from Serve
+  def self.start(passed_options = {})
+    options = DEFAULTS.merge(passed_options)
+    check_dirs_present!(options)
+    
+    app = build_app(options)
+    start_server(app, options)
+  end
+end

data/lib/sourcemaps.rb

@@ -2,14 +2,14 @@ require 'pathname'
 require 'json'
 
 module Vitrine
-  def self.build_coffeescript_source_map_body(full_coffeescript_file_path, public_dir_path)
+  def self.build_coffeescript_source_map_body(full_coffeescript_file_path, public_folder_path)
     
     script = File.read(full_coffeescript_file_path)
     
     # We need to feed paths ON THE SERVER so that the browser can connect the coffee file, the map and the JS file
     # - specify coffee source file explicitly (see http://coffeescript.org/documentation/docs/sourcemap.html#section-8)
     # The paths need to be slash-prepended (server-absolute)
-    relative_path = '/' + Pathname.new(full_coffeescript_file_path).relative_path_from(Pathname.new(public_dir_path)).to_s
+    relative_path = '/' + Pathname.new(full_coffeescript_file_path).relative_path_from(Pathname.new(public_folder_path)).to_s
     relative_js_path = '/' + relative_path.gsub(/\.coffee$/, '.js')
     
     options = {sourceMap: true}

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Vitrine
-  VERSION = '0.0.11'
+  VERSION = '0.0.12'
 end

data/lib/vitrine.rb

@@ -8,71 +8,6 @@ require_relative 'version'
 require_relative 'atomic_write'
 require_relative 'sourcemaps'
 
-module Vitrine
-  DEFAULTS = { root: Dir.getwd, port: 4000, host: '127.0.0.1' }
-  
-  def self.check_dirs_present!
-    views = DEFAULTS[:root] + '/views'
-    unless File.exist?(views) and File.directory?(views)
-      $stderr.puts "WARNING: `views' directory not found under the current tree, you might want to create it"
-    end
-    
-    public_dir = DEFAULTS[:root] + '/public'
-    unless File.exist?(public_dir) and File.directory?(public_dir)
-      $stderr.puts "ERROR: `public' directory not found under the current tree, you should create it. Vitrine won't run without it"
-      exit 1
-    end
-  end
-  
-  # Run the server, largely stolen from Serve
-  def self.run(options = DEFAULTS)
-    check_dirs_present!
-    
-    app = Rack::Builder.new do
-      use Rack::ShowStatus
-      use Rack::ShowExceptions
-      
-      guardfile_path = options[:root] + '/Guardfile'
-      if File.exist?(guardfile_path)
-        $stderr.puts "Attaching LiveReload via Guardfile at #{guardfile_path.inspect}"
-        # Assume livereload is engaged
-        use Rack::LiveReload
-      else
-        $stderr.puts "No Guardfile found, so there won't be any livereload injection"
-      end
-      
-      vitrine = Vitrine::App.new
-      vitrine.settings.set :root, options[:root]
-      run vitrine
-    end
-    
-    begin
-      # Try Thin
-      thin = Rack::Handler.get('thin')
-      thin.run app, :Port => options[:port], :Host => options[:address] do |server|
-        puts "Thin #{Thin::VERSION::STRING} available at http://#{options[:address]}:#{options[:port]}"
-      end
-    rescue LoadError
-      begin
-        # Then Mongrel
-        mongrel = Rack::Handler.get('mongrel')
-        mongrel.run app, :Port => options[:port], :Host => options[:address] do |server|
-          puts "Mongrel #{Mongrel::Const::MONGREL_VERSION} available at http://#{options[:address]}:#{options[:port]}"
-        end
-      rescue LoadError
-        # Then WEBrick
-        puts "Install Mongrel or Thin for better performance."
-        webrick = Rack::Handler.get('webrick')
-        webrick.run app, :Port => options[:port], :Host => options[:address] do |server|
-          trap("INT") { server.shutdown }
-        end
-      end
-    end
-  end
-end
-
-require 'rack-livereload'
-
 # A little idiosyncrastic asset server.
 # Does very simple things:
 # * sensible detector for default pages (they render from Sinatra view templates)
@@ -80,11 +15,13 @@ require 'rack-livereload'
 #  and Vitrine will find them and compile them for you on the spot
 class Vitrine::App < Sinatra::Base
   set :static, true
+  
   set :show_exceptions, false
   set :raise_errors, true
-  set :root, File.expand_path(File.dirname(__FILE__))
-  set :views, lambda { File.join(settings.root, "views") }
-  set :public_dir, lambda { File.join(settings.root, "public") }
+  
+  # Sets whether Vitrine will output messages about dynamic assets
+  set :silent, true
+  set :public_folder, ->{ File.join(settings.root, 'public') }
   
   # For extensionless things try to pick out the related templates
   # from the views directory, and render them with a default layout.
@@ -101,8 +38,11 @@ class Vitrine::App < Sinatra::Base
   
   def render_template_or_static(extensionless_path)
     probable_html = extensionless_path + "/index.html"
-    html_path = File.join(settings.public_dir, probable_html)
+    
+    html_path = File.join(settings.public_folder, probable_html)
     if File.exist? html_path
+      # Might want to investigate...
+      # https://github.com/elitheeli/sinatra-index/blob/master/lib/sinatra-index.rb
       send_file html_path
     else
       render_template(extensionless_path)
@@ -129,15 +69,19 @@ class Vitrine::App < Sinatra::Base
     # Try the first template that has been found
     template_path = possibilites.shift
     
-    # If nothing is found just bail
+    # If nothing is found try downstream or bail
     unless template_path
       err = possible_globs.map{|e| e.inspect }.join(', ')
-      halt 404, "No template found - tried #{err}"
+      if @app
+        return forward
+      else
+        halt 404, "No template found - tried #{err}, and no downstream Rack handler present"
+      end
     end
     
     relative_path = Pathname.new(template_path).relative_path_from(Pathname.new(settings.views))
     
-    # $stderr.puts "-> #{extensionless_path.inspect} : Rendering via template #{relative_path.to_s.inspect}"
+    log "-> #{extensionless_path.inspect} : Rendering via template #{relative_path.to_s.inspect}"
     
     locals = {}
     # Auto-pick the template engine out of the extension
@@ -153,6 +97,7 @@ class Vitrine::App < Sinatra::Base
       # TODO: has no handling for .sass
       scss_source_path = File.join(settings.root, 'public', "#{basename}.scss")
       mtime_cache(scss_source_path) do
+        # TODO: Examine http://sass-lang.com/documentation/file.SASS_REFERENCE.html
         Sass.compile_file(scss_source_path, cache_location: '/tmp/vitrine/sass-cache')
       end
     rescue Errno::ENOENT # Missing SCSS
@@ -218,7 +163,7 @@ class Vitrine::App < Sinatra::Base
     else
       yield.tap do | body |
         Vitrine.atomic_write(p) do |f|
-          # $stderr.puts "---> Recompiling #{path} for #{request.path_info}"
+          log "---> Recompiling #{path} for #{request.path_info}"
           f.write body
         end
         etag File.mtime(p)
@@ -231,4 +176,7 @@ class Vitrine::App < Sinatra::Base
     layouts.any? ? :layout : false
   end
   
+  def log(msg)
+    $stderr.puts(msg) unless settings.silent?
+  end
 end

data/test/helper.rb

@@ -9,3 +9,34 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'vitrine'
+
+module VitrineTesting
+  
+  # Wrap the test run in mktimpdir where we will store our temp application
+  def run(runner)
+    Dir.mktmpdir("vitrine-tests") do | dir_path |
+      @tempdir = dir_path
+      super
+    end
+  ensure
+    @tempdir = nil
+  end
+  
+  def temporary_app_dir
+    raise "Not within a tempdir block" unless @tempdir
+    @tempdir
+  end
+  
+  # Write a file out into 'public', creating the subdir tree
+  def write_public(name)
+    location = FileUtils.mkdir_p(File.dirname(File.join(@tempdir, 'public', name)))
+    File.open(File.join(@tempdir, 'public', name), 'w') do | f |
+      yield f
+    end
+  end
+  
+  # Return the vitrine default Vitrine app
+  def app
+    Vitrine::App.new.tap { |a| a.settings.set :root, @tempdir }
+  end
+end

data/test/test_vitrine.rb

@@ -1,28 +1,7 @@
 require 'helper'
 
 class TestVitrine < Test::Unit::TestCase
-  include Rack::Test::Methods
-  
-  # Wrap the test run in mktimpdir where we will store our temp application
-  def run(runner)
-    Dir.mktmpdir("vitrine-tests") do | dir_path |
-      @tempdir = dir_path
-      super
-    end
-  end
-  
-  def write_public(name)
-    FileUtils.mkdir_p @tempdir + '/public'
-    File.open(File.join(@tempdir, 'public', name), 'w') do | f |
-      yield f
-    end
-  end
-  
-  def app
-    vitrine = Vitrine::App.new
-    vitrine.settings.set :root, @tempdir
-    vitrine
-  end
+  include Rack::Test::Methods, VitrineTesting
   
   def test_fetch_index_without_index_should_404
     get '/'
@@ -72,15 +51,15 @@ class TestVitrine < Test::Unit::TestCase
     assert last_response.ok?, "Should have fetched the index.html"
   end
   
-#  def test_fetches_index_in_subdirectory_if_present
-#    write_public 'items/index.html' do | f |
-#      f.write 'this just in'
-#    end
-#    
-#    get '/items'
-#    assert last_response.ok?, "Should have responded with 404 since there is no template"
-#    assert_equal 'this just in', last_response.body
-#  end
+  def test_fetches_index_in_subdirectory_if_present
+    write_public 'items/index.html' do | f |
+      f.write 'this just in'
+    end
+    
+    get '/items'
+    assert last_response.ok?, "Should have responded with 404 since there is no template"
+    assert_equal 'this just in', last_response.body
+  end
 
   def test_passes_coffeescript_as_raw_file
     write_public 'nice.coffee' do | f |
@@ -108,6 +87,24 @@ class TestVitrine < Test::Unit::TestCase
       'Should include the reference to the source map'
   end
   
+  def test_compiles_coffeescript_sourcemap
+    
+    FileUtils.mkdir_p File.join(@tempdir, 'public', 'js')
+    
+    write_public 'js/nice.coffee' do | f |
+      f.puts 'alert "rockage!"'
+    end
+    
+    # Sourcemap will only ever get requested AFTER the corresponding JS file
+    get '/js/nice.js'
+    assert last_response.ok?
+    
+    get '/js/nice.js.map'
+    ref = {"version"=>3, "file"=>"", "sourceRoot"=>"", "sources"=>["/js/nice.coffee"], 
+      "names"=>[], "mappings"=>"AAAA;CAAA,CAAA,GAAA,KAAA;CAAA"}
+    assert_equal ref, JSON.parse(last_response.body)
+  end
+  
   def test_sends_vanilla_js_if_its_present
     write_public 'vanilla.js' do | f |
       f.puts 'vanilla();'

data/test/test_vitrine_in_rack_stack.rb

@@ -0,0 +1,35 @@
+require 'helper'
+require 'rack/lobster'
+
+class TestVitrineInRackStack < Test::Unit::TestCase
+  include Rack::Test::Methods, VitrineTesting
+  
+  def app
+    td = temporary_app_dir
+    outer = Rack::Builder.new do
+      use Vitrine::App do | v | 
+        v.settings.set root: td 
+      end
+      map "/lobster" do
+        run Rack::Lobster.new
+      end
+    end
+    outer.to_app
+  end
+  
+  def test_lobster
+    get '/lobster'
+    assert last_response.ok?
+    assert_match /Lobstericious/, last_response.body, "Should have forwarded to downstream Lobster"
+  end
+  
+  def test_fetch_js
+    write_public('hello.coffee') do | f |
+      f << 'window.alert("Hello Coffee")'
+    end
+    
+    get '/hello.js'
+    assert last_response.ok?
+    assert_include last_response.body, 'window.alert("Hello Coffee")', "Should include the JS fragment"
+  end
+end

data/vitrine.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "vitrine"
-  s.version = "0.0.11"
+  s.version = "0.0.12"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Julik Tarkhanov"]
-  s.date = "2013-11-25"
+  s.date = "2013-12-19"
   s.description = " Serves ERB templates with live CoffeeScript and SASS "
   s.email = "me@julik.nl"
   s.executables = ["vitrine"]
@@ -26,11 +26,13 @@ Gem::Specification.new do |s|
     "Rakefile",
     "bin/vitrine",
     "lib/atomic_write.rb",
+    "lib/server.rb",
     "lib/sourcemaps.rb",
     "lib/version.rb",
     "lib/vitrine.rb",
     "test/helper.rb",
     "test/test_vitrine.rb",
+    "test/test_vitrine_in_rack_stack.rb",
     "vitrine.gemspec"
   ]
   s.homepage = "http://github.com/julik/vitrine"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vitrine
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-25 00:00:00.000000000 Z
+date: 2013-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -223,11 +223,13 @@ files:
 - Rakefile
 - bin/vitrine
 - lib/atomic_write.rb
+- lib/server.rb
 - lib/sourcemaps.rb
 - lib/version.rb
 - lib/vitrine.rb
 - test/helper.rb
 - test/test_vitrine.rb
+- test/test_vitrine_in_rack_stack.rb
 - vitrine.gemspec
 homepage: http://github.com/julik/vitrine
 licenses: