tipsy 0.0.1 → 0.0.2

data/Gemfile

@@ -3,3 +3,12 @@ gemspec
 
 gem 'facades', :path => '/_Work/gems/facades'
 gem 'thin'
+
+group :test do
+  gem 'jnunemaker-matchy', '~> 0.4.0', :require => 'matchy'
+  gem 'shoulda',           '~> 2.11'
+  gem 'mocha',             '~> 0.9.12'
+  gem 'rack-test'
+  gem 'turn'
+  gem 'minitest'
+end

data/README.md

@@ -1,10 +1,10 @@
-= Tipsy
+# 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
+### 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

@@ -1 +1,11 @@
+require 'rake'
 require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs      << 'lib' << 'test'
+  test.pattern   = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/bin/tipsy

@@ -1,10 +1,21 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-require 'rubygems'
-require 'bundler'
-Bundler.require
+libdir = File.dirname(__FILE__) + '/../lib'
+if File.file?(libdir + '/tipsy/version.rb')
+  $LOAD_PATH.unshift(libdir)
+end
+
+begin
+  require 'tipsy'
+rescue LoadError
+  require 'rubygems'
+  retry
+end
+
+if File.exists?(File.join(File.expand_path('.'), 'Gemfile'))
+  require 'bundler/setup'
+  Bundler.require(:default)
+end
 
-require 'tipsy'
 Tipsy.root = File.expand_path('.')
 Tipsy.run_command(ARGV, STDIN)

data/lib/tipsy.rb

@@ -8,17 +8,29 @@ 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'
-  autoload :Helpers,      'tipsy/helpers'
   
-  autoload :Builder,      'tipsy/builder'
-  autoload :Generator,    'tipsy/generator'
-
+  module Compressors
+    autoload :CssCompressor, 'tipsy/compressors/css'
+    autoload :JavascriptCompressor, 'tipsy/compressors/javascript'
+  end
+  
+  module Sass
+    autoload :Template, 'tipsy/sass/template'
+  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    
@@ -31,20 +43,20 @@ module Tipsy
     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!
+    parse_options!    
     Tipsy::Application.send(:"#{to_run}", *args)    
+    
   end
   
   def self.options
-    @@options ||= OpenStruct.new
+    @@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')
+    })
   end
   
   private

data/lib/tipsy/application.rb

@@ -1,6 +1,9 @@
 require 'rack'
-require 'tipsy/server'
 
+##
+# Base class for all applications. Handles configuration of options, 
+# and processing of command line arguments.
+# 
 module Tipsy
   class Application
     
@@ -9,11 +12,15 @@ module Tipsy
         
     def self.create(name = nil)
       raise "Missing project name for 'tipsy new'" unless name
-      Tipsy::Generator.create_project!(name)
+      Tipsy::Builder.build!(:project, name)
     end
     
     def self.build
-      Tipsy::Builder.new(self.config.build_path)
+      Tipsy::Builder.build!(:export)
+    end
+    
+    def self.deploy
+      Tipsy::Builder.build!(:remote)
     end
     
     def self.initialize!
@@ -31,19 +38,10 @@ module Tipsy
     end
     
     def initialize
+      require 'tipsy/helpers/sass'
+      @app = Tipsy::Server.init!
       
-      @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}"
+      Tipsy.logger.info("Tipsy #{Tipsy::VERSION} running on #{config.address}:#{config.port}")
       
       begin run_thin
       rescue LoadError
@@ -79,7 +77,7 @@ module Tipsy
     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"
+        puts "Running Tipsy with Webrick. To use Mongrel or Thin (recommended), add them to your Gemfile"
         trap("INT"){ server.shutdown }
       end
     end

data/lib/tipsy/builder.rb

@@ -1,12 +1,25 @@
 require 'active_support/inflector'
 
+##
+# Handles building source files into a final project, for 
+# either deployment or output to a directory
+# 
 module Tipsy
-  class Builder
+  module Builder
     
-    attr_reader :build_path
+    autoload :Base,           'tipsy/builders/base'
+    autoload :ProjectBuilder, 'tipsy/builders/project'
+    autoload :ExportBuilder,  'tipsy/builders/local'
+    autoload :RemoteBuilder,  'tipsy/builders/remote'
     
-    def initialize(path)
-      @build_path = path
+    def self.build!(type = :project, *args)
+      handler = case type
+        when :project then ProjectBuilder.new(*args)
+        when :export  then ExportBuilder.new(*args)
+        when :remote  then RemoteBuilder.new(*args)
+        else raise 'No builder specified'
+      end
+      handler.build!
     end
     
   end

data/lib/tipsy/builders/base.rb

@@ -0,0 +1,64 @@
+module Tipsy
+  module Builder
+    class Base      
+      attr_reader :source_path, :dest_path
+      
+      def excludes
+        @excludes ||= ['.git', '.gitignore', '.sass-cache', 'config.erb', '*.rb', '.', '..']
+      end
+      
+      def build!
+        process_location(source_path, dest_path)
+      end
+      
+      protected
+      
+      def excluded?(file)
+        return true if excludes.include?(file)
+        excludes.detect{ |exc| File.basename(exc).to_s.match(exc) }.nil?
+      end
+      
+      def log_action(action, name)
+        name = name.gsub(dest_path, '').sub(/^\//, '')
+        Tipsy.logger.log_action(action, name)
+      end
+      
+      ##
+      # By default make_file copies from one location to another
+      # Overridden in non-local scenarios
+      # 
+      def make_file(source, destination)
+        log_action("create", destination)
+        FileUtils.cp(source, destination)
+      end
+      
+      ##
+      # By default make_folder makes a matching folder in destination from source
+      # Overridden in non-local scenarios
+      #
+      def make_folder(dirname)
+        log_action("create", dirname)
+        FileUtils.mkdir(dirname)
+      end
+      
+      ##
+      # Iterate through a file tree and process each file and folder.
+      # 
+      def process_location(src, dest)
+        Dir.foreach(src) do |file|
+          next if excluded?(file)
+          source       = File.join(src, file)
+          destination  = File.join(dest, file)
+          
+          if File.directory?(source)
+            make_folder(destination)
+            process_location(source, destination)
+          else
+            make_file(source, destination)
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/tipsy/builders/export.rb

@@ -0,0 +1,16 @@
+module Tipsy
+  module Builder
+    class ExportBuilder < Base
+      
+      def initialize
+        @source_path = Tipsy.root
+        @dest_path   = Tipsy.options.build_path
+      end
+      
+      def build!
+        FileUtils.mkdir(dest_path) unless File.exists?(dest_path) && File.directory?(dest_path)
+      end
+      
+    end
+  end
+end

data/lib/tipsy/builders/project.rb

@@ -0,0 +1,40 @@
+require 'fileutils'
+require 'erb'
+
+module Tipsy
+  module Builder
+    class ProjectBuilder < Base
+      attr_reader :project
+      
+      def initialize(name)
+        @project      = name.camelize
+        @dest_path    = File.join(Tipsy.root, name.underscore)
+        @source_path  = File.expand_path("../../project", __FILE__)        
+      end
+      
+      def build!
+
+        FileUtils.mkdir(dest_path) unless File.exists?(dest_path)
+        super
+        cvars = Conf.new
+        cvars.root      = dest_path
+        cvars.classname = @project              
+        template = File.read(File.join(source_path, 'config.erb'))
+        config   = ERB.new(template).result(cvars.get_binding)
+
+        File.open(File.join(dest_path, 'config.rb'), 'w'){ |io| io.write(config) }
+        log_action('create', File.join(dest_path, 'config.rb'))
+        
+        Tipsy.logger.info("\n   Project #{project} created in #{dest_path}.")
+        Tipsy.logger.info("   Run 'tipsy' from the root folder to start the server.\n\n")
+        
+      end
+      
+      class Conf
+        attr_accessor :classname, :root
+        def get_binding; binding; end
+      end
+      
+    end
+  end
+end

data/lib/tipsy/builders/remote.rb

@@ -0,0 +1,14 @@
+module Tipsy
+  module Builder
+    
+    class RemoteBuilder < Base
+      
+      def initialize
+        @source_path = Tipsy.root
+        @dest_path   = ''
+      end
+      
+    end
+    
+  end
+end

data/lib/tipsy/compressors/css.rb

@@ -0,0 +1,11 @@
+require 'sass'
+
+module Tipsy
+  module Compressors
+    class CssCompressor
+      def compress(css)
+        Sass::Engine.new(css, :syntax => :scss, :cache => false, :read_cache => false, :style => :compressed).render
+      end
+    end
+  end
+end

data/lib/tipsy/compressors/javascript.rb

@@ -0,0 +1,25 @@
+##
+# Interface to Google's Online Closure Compiler. 
+# Uglifier is recommended (gem install uglifier) however to support environments where Node.js
+# is unavailable this can be used as a fallback.
+# 
+require 'net/http'
+require 'uri'
+
+module Tipsy
+  module Compressors
+    # http://closure-compiler.appspot.com/compile
+    class JavascriptCompressor
+      def compress(js)
+        return js if js.to_s.blank?
+        post_data = {
+          'compilation_level' => 'SIMPLE_OPTIMIZATIONS',
+          'js_code'           => js.to_s,
+          'output_format'     => 'text'
+        }
+        request = Net::HTTP.post_form(URI.parse('http://closure-compiler.appspot.com/compile'), post_data)
+        request.body.to_s
+      end
+    end
+  end
+end

data/lib/tipsy/helpers.rb

@@ -1,9 +1,32 @@
+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'
 
 module Tipsy
   module Helpers
+    extend ActiveSupport::Concern
     include Capture
-    include Tag    
+    include Tag 
+    include AssetPaths
+    include AssetTags
+    
+    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
+    
   end
 end

data/lib/tipsy/helpers/asset_paths.rb

@@ -0,0 +1,19 @@
+require 'pathname'
+
+module Tipsy
+  module Helpers
+    module AssetPaths
+      
+      def asset_path(path)
+        return path if path.match(/^https?:/) || Pathname.new(path).absolute?
+        "/" << File.join('assets', path)
+      end
+      
+      def path_with_ext(path, ext)
+        return path if path.match(/^https?:/) || path.ends_with?(".#{ext}")
+        [path, ext].join('.')
+      end
+    
+    end
+  end
+end