tipsy 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+.rvmrc
+.sass-cache/*

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'facades', :path => '/_Work/gems/facades'
+gem 'thin'

data/README.md

@@ -0,0 +1,10 @@
+= Tipsy
+
+Tipsy is a small Rack-based server inspired by gems like StaticMatic and Serve. Its purpose is to aid development of static sites by providing 
+Rails-esque style templating and helpers. Various template types are supported via the Tilt gem, and assets are served via Sprockets, essentially giving you 
+a miniture Rails "view-only" environment. 
+
+=== Notes
+
+Tipsy was developed for personal/internal use but feature/pull requests are gladly accepted. It is not designed to function in any kind of production 
+environment. When ready to upload files to a production environment, build the project and upload the result.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/tipsy

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'rubygems'
+require 'bundler'
+Bundler.require
+
+require 'tipsy'
+Tipsy.root = File.expand_path('.')
+Tipsy.run_command(ARGV, STDIN)

data/config.ru

@@ -0,0 +1,26 @@
+#\ -p 4000
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Missing dependencies. Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'tipsy'
+require 'sprockets'
+
+# Setup the root path and initialize.
+Tipsy.root = ::File.dirname(__FILE__) + "/test/root"
+use Rack::CommonLogger
+use Rack::ShowStatus
+use Rack::ShowExceptions
+run Rack::Cascade.new([
+	Rack::URLMap.new({ "/assets" => Tipsy::AssetHandler.new }),
+	Tipsy::Server.new,
+	Rack::Directory.new(Tipsy.root + '/public')
+])

data/lib/tipsy/application.rb

@@ -0,0 +1,88 @@
+require 'rack'
+require 'tipsy/server'
+
+module Tipsy
+  class Application
+    
+    class_attribute :config, :instance_writer => false    
+    attr_reader :app
+        
+    def self.create(name = nil)
+      raise "Missing project name for 'tipsy new'" unless name
+      Tipsy::Generator.create_project!(name)
+    end
+    
+    def self.build
+      Tipsy::Builder.new(self.config.build_path)
+    end
+    
+    def self.initialize!
+      self.config = Tipsy.options
+      begin
+        require File.join(Tipsy.root, 'config.rb')
+      rescue LoadError
+        puts "To configure additional settings, create a config.rb in your root path. (#{Tipsy.root})"
+      end
+    end
+    
+    def self.run
+      initialize!
+      self.new
+    end
+    
+    def initialize
+      
+      @app = 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        	
+        ])
+      }
+      
+      puts "Tipsy #{Tipsy::VERSION} running on #{config.address}:#{config.port}"
+      
+      begin run_thin
+      rescue LoadError
+        begin run_mongrel
+        rescue LoadError
+          run_webrick
+        end
+      end      
+    end
+    
+    private
+
+    def server_opts
+      { :Port => config.port, :Host => config.address }
+    end
+    
+    def run_thin
+      handler = Rack::Handler.get('thin')
+      handler.run app, server_opts do |server|
+        puts "Running Tipsy with Thin (#{Thin::VERSION::STRING})."
+      end
+      exit(0)
+    end
+    
+    def run_mongrel
+      handler = Rack::Handler.get('mongrel')
+      handler.run app, server_opts do |server|
+        puts "Running Tipsy with Mongrel (#{Mongrel::Const::MONGREL_VERSION})."
+      end
+      exit(0)
+    end
+    
+    def run_webrick
+      handler = Rack::Handler.get('webrick')
+      handler.run app, server_opts do |server|
+        puts "Running Tipsy with Webrick. To use Mongrel or Thin, add them to your Gemfile"
+        trap("INT"){ server.shutdown }
+      end
+    end
+    
+  end
+end

data/lib/tipsy/builder.rb

@@ -0,0 +1,13 @@
+require 'active_support/inflector'
+
+module Tipsy
+  class Builder
+    
+    attr_reader :build_path
+    
+    def initialize(path)
+      @build_path = path
+    end
+    
+  end
+end

data/lib/tipsy/generator.rb

@@ -0,0 +1,53 @@
+require 'tilt'
+
+module Tipsy
+  class Generator
+    
+    attr_reader :project_class, :dest_path, :source_path
+    
+    def self.create_project!(name)
+      self.new(File.join(Tipsy.root, name.underscore), name.camelize)
+    end
+    
+    def initialize(dir, klass)
+      Tipsy.root     = dir
+      @project_class = klass
+      
+      @dest_path   = dir
+      @source_path = File.join(File.dirname(__FILE__), 'project')
+      generate!
+    end
+
+    def generate!
+      FileUtils.mkdir(dest_path) unless File.exists?(dest_path)
+      copy_source(source_path, dest_path)
+      config = Tilt.new(File.join(source_path, 'config.erb'), nil)
+      config = config.render(Object.new, {
+        :classname => @project_class,
+        :root      => dest_path
+      })
+      File.open(File.join(dest_path, 'config.rb'), 'w'){ |io| io.write(config) }
+    end
+    
+    private
+    
+    def copy_source(src, dest)
+      
+      Dir.foreach(src) do |file|
+        next if file == '.' || file == '..' || file == 'config.erb'
+        
+        source = File.join(src, file)
+        copyto = File.join(dest, file)
+      
+        if File.directory?(source)
+          FileUtils.mkdir(copyto)
+          copy_source(source, copyto)
+        else
+          FileUtils.cp(source, copyto)
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/tipsy/helpers/capture.rb

@@ -0,0 +1,22 @@
+module Tipsy
+  module Helpers
+    module Capture
+  
+      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
+      end
+      
+    end      
+  end
+end

data/lib/tipsy/helpers/tag.rb

@@ -0,0 +1,30 @@
+module Tipsy
+  module Helpers
+    
+    module Tag
+      include Capture
+      
+      def tag(name, html_attrs = {}, open = false)
+        "<#{name}#{make_attributes(html_attrs)}#{open ? ">" : " />"}"
+      end
+      
+      def content_tag(name, content = nil, html_attrs = {}, &block)
+        buffer = "<#{name}#{make_attributes(html_attrs)}>"
+        content = capture(&block) if block_given?
+        "<#{name}#{make_attributes(html_attrs)}>#{content}</#{name}>"
+      end
+      
+      private
+      
+      def make_attributes(hash)
+        attrs = []
+        hash.each_pair do |key, value|
+          attrs << "#{key}=#{value.inspect}"
+        end
+        (attrs.empty? ? "" : " #{attrs.join(" ")}")
+      end
+      
+    end
+    
+  end
+end

data/lib/tipsy/helpers.rb

@@ -0,0 +1,9 @@
+require 'tipsy/helpers/capture'
+require 'tipsy/helpers/tag'
+
+module Tipsy
+  module Helpers
+    include Capture
+    include Tag    
+  end
+end

data/lib/tipsy/logger.rb

@@ -0,0 +1,11 @@
+require 'logger'
+
+module Tipsy
+  class Logger < ::Logger
+    
+    def initialize
+      super($stdout)
+    end
+    
+  end
+end

data/lib/tipsy/project/config.erb

@@ -0,0 +1,16 @@
+class <%= classname %> < Tipsy::Application
+
+	# Configure assets to be precompiled
+	config.assets << "site.js"
+	config.assets << "screen.css"
+	
+	# The path where build files will go when compiled
+	# config.build_path = <%= File.join(root, 'build') %>
+	
+	# The path where public files exist (default root/public)
+	# config.public_path = <%= File.join(root, 'public') %>
+	
+	# The path where assets will be stored on build (default public_path/assets)
+	# config.asset_path = <%= File.join(root, 'assets') %>
+	
+end

data/lib/tipsy/project/helpers/site_helper.rb

@@ -0,0 +1,4 @@
+module SiteHelper
+  # Add your helper methods here. You may also add additional helpers to your helpers folder.
+  # Helpers should use Rails style naming conventions (site_helper.rb = SiteHelper)
+end

data/lib/tipsy/project/views/_layout.html.erb

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+	<meta charset="utf-8"/>
+	<title></title>
+	<meta name="keywords" content=""/>
+	<meta name="description" content=""/>
+	<!--[if lte IE 8]> 
+	<![endif]-->
+	<!--[if IE 8]> 
+	<![endif]-->
+</head>
+<body>
+	<%= yield %>
+</body>
+</html>

data/lib/tipsy/server.rb

@@ -0,0 +1,91 @@
+require 'rack'
+require 'sprockets'
+require 'hike'
+require 'sass'
+
+module Tipsy
+  
+  class Server
+    
+    attr_reader :request
+    attr_reader :response
+      
+    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
+      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"
+      self
+    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)
+    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))
+    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
+      end
+    end    
+  end
+
+  class Response < Rack::Response
+    def body=(value)
+      value.respond_to?(:each) ? super(value) : super([value])
+    end
+  end
+  
+end
+

data/lib/tipsy/version.rb

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

data/lib/tipsy/view.rb

@@ -0,0 +1,64 @@
+require 'tilt'
+require 'tipsy/helpers'
+require 'hike'
+
+module Tipsy
+  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?
+        tilt     = Tilt.new(template, nil, :outvar => '@_output_buffer')
+        context  = Context.new(request)
+        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
+  
+    class Context
+      include Tipsy::Helpers            
+      
+      attr_accessor :request, :content, :root
+      
+      def initialize(req)
+        @request = req, @root = Tipsy.root
+        super
+      end
+      
+    end
+    
+  end
+end

data/lib/tipsy.rb

@@ -0,0 +1,72 @@
+require "tipsy/version"
+require "active_support/all"
+require 'optparse'
+require 'ostruct'
+
+module Tipsy
+
+  autoload :Application,  'tipsy/application'
+  autoload :Server,       'tipsy/server'
+  autoload :Responder,    'tipsy/handler'
+  autoload :View,         'tipsy/view'
+  autoload :Helpers,      'tipsy/helpers'
+  
+  autoload :Builder,      'tipsy/builder'
+  autoload :Generator,    'tipsy/generator'
+
+  mattr_accessor :root
+  mattr_accessor :logger
+  mattr_accessor :env
+  mattr_accessor :sprockets
+  mattr_accessor :compass
+    
+  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
+
+    options.port        = 4000
+    options.host        = '0.0.0.0'
+    options.assets      = []
+    options.build_path  = File.join(Tipsy.root, 'build')
+    options.public_path = File.join(Tipsy.root, 'public')
+    options.asset_path  = File.join(options.public_path, 'assets')
+    
+    parse_options!
+    Tipsy::Application.send(:"#{to_run}", *args)    
+  end
+  
+  def self.options
+    @@options ||= OpenStruct.new
+  end
+  
+  private
+  
+  def self.parse_options!    
+    
+    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
+    end
+    
+  end
+  
+end

data/test/root/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+.rvmrc
+.sass-cache/*

data/test/root/assets/stylesheets/screen.css.scss

@@ -0,0 +1,3 @@
+//= require_self
+body{ background:black; }
+p{ font-size:10px; }

data/test/root/config.rb

@@ -0,0 +1,6 @@
+class TestRoot < Tipsy::Application
+
+  # Configure assets that should be precompiled
+  config.assets << "application.js"
+  
+end

data/test/root/views/_layout.html.erb

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+	<meta charset="utf-8"/>
+	<title></title>
+	<meta name="keywords" content=""/>
+	<meta name="description" content=""/>
+	<!--[if lte IE 8]> 
+	<![endif]-->
+	<!--[if IE 8]> 
+	<![endif]-->
+</head>
+<body>
+	<p> I wrap the <%= yield %> in a layout</p>
+	<p>I'm a var set in the view: <%= @poop %></p>	
+	<p>Some bold text set in the view: <%= content_for(:text) %></p>
+</body>
+</html>

data/test/root/views/index.html.erb

@@ -0,0 +1,3 @@
+<% @poop = 'awesome' %>
+<strong>content</strong>
+<% content_for(:text, "THIS IS SOME BOLD ACTION") %>

data/tipsy.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.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.email       = ["brent@kurbmedia.com"]
+  s.homepage    = ""
+  s.summary     = %q{A mini Rack application server for developing static sites.}
+  s.description = %q{Tipsy is a mini Rack application for working with static websites using Tilt, Compass, and Sprockets.}
+
+  s.rubyforge_project = "tipsy"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  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("tilt", "~> 1.3")
+  s.add_dependency("i18n", "~> 0.5")
+  s.add_dependency("sass", "~> 3.1")
+  s.add_dependency("active_support", ">= 3.0")
+  s.add_dependency('sprockets', '~> 2.0.0.beta.12')
+  
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: tipsy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Brent Kirby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-06 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70334947082500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70334947082500
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &70334947081980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70334947081980
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: &70334947081520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70334947081520
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70334947081020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70334947081020
+- !ruby/object:Gem::Dependency
+  name: sass
+  requirement: &70334947080560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70334947080560
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: &70334947080100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70334947080100
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  requirement: &70334947079640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0.beta.12
+  type: :runtime
+  prerelease: false
+  version_requirements: *70334947079640
+description: Tipsy is a mini Rack application for working with static websites using
+  Tilt, Compass, and Sprockets.
+email:
+- brent@kurbmedia.com
+executables:
+- tipsy
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/tipsy
+- config.ru
+- lib/tipsy.rb
+- lib/tipsy/application.rb
+- lib/tipsy/builder.rb
+- lib/tipsy/generator.rb
+- lib/tipsy/helpers.rb
+- lib/tipsy/helpers/capture.rb
+- lib/tipsy/helpers/tag.rb
+- lib/tipsy/logger.rb
+- lib/tipsy/project/assets/javascripts/site.js
+- lib/tipsy/project/assets/stylesheets/screen.css.scss
+- lib/tipsy/project/config.erb
+- lib/tipsy/project/helpers/site_helper.rb
+- lib/tipsy/project/views/_layout.html.erb
+- lib/tipsy/server.rb
+- lib/tipsy/version.rb
+- lib/tipsy/view.rb
+- test/root/.gitignore
+- test/root/assets/javascripts/test.js
+- test/root/assets/stylesheets/screen.css.scss
+- test/root/config.rb
+- test/root/views/_layout.html.erb
+- test/root/views/index.html.erb
+- tipsy.gemspec
+has_rdoc: true
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: tipsy
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A mini Rack application server for developing static sites.
+test_files:
+- test/root/.gitignore
+- test/root/assets/javascripts/test.js
+- test/root/assets/stylesheets/screen.css.scss
+- test/root/config.rb
+- test/root/views/_layout.html.erb
+- test/root/views/index.html.erb