slinky 0.2.1 → 0.4.0

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -4,13 +4,18 @@ gem "eventmachine", ">= 0.12.0"
 gem "eventmachine_httpserver", ">= 0.2.0"
 gem "rainbow", ">= 1.1.1"
 gem "haml", ">= 3.0.0"
-#gem "sass", ">= 4.0.0"
+gem "sass", ">= 3.1.1"
 gem "coffee-script", ">= 2.2.0"
+gem "mime-types", ">= 1.16"
+gem "yui-compressor", ">= 0.9.6"
 
 group :development do
-  gem "bacon", ">= 0"
+  gem "rspec", "~> 2.3.0"
   gem "yard", "~> 0.6.0"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.5.2"
-  gem "rcov", ">= 0"
+  gem 'cover_me', '>= 1.0.0.rc6'
+  gem "fakefs"
+  gem "em-http-request"
+#  gem "em-synchrony", ">= 0"
 end

data/README.md

@@ -1,9 +1,87 @@
 #Slinky
 
-Slinky is a static file server designed to make development of static
-web sites and applications simpler. Simply run slinky in the home
-directory of your app and it will serve while compiling things like
-SASS, HAML and CoffeeScript on the fly.
+Slinky helps you write rich web applications using compiled web
+languages like SASS, HAML and CoffeeScript. The slinky server
+transparently compiles resources as they're requested, leaving you to
+worry about your code, not how to compile it.
 
-To get it, just `gem install slinky`. Note that this is unstable, not well 
-tested, and hardly feature-complete. It may, however, be useful.
+Once your ready for production, the slinky builder will compile all of
+your sources and concatenate and minify your javascript and css,
+leaving you a directory that's ready to be pushed to your servers.
+
+## Quickstart
+
+```
+$ gem install slinky
+$ cd ~/my/awesome/project
+$ slinky start
+[hardcore web development action]
+$ slinky build
+$ scp -r build/ myserver.com/var/www/project
+````
+## But tell me more!
+
+Slinky currently supports three languages for compilation, SASS/SCSS,
+HAML and CoffeeScript, but it's simple to add support for others (and
+please submit a pull request when you do!). Slinky also has a few
+tricks of its own for managing the complexity of modern web
+development.
+
+### Script & style management
+
+Slinky can manage all of your javascript and css files if you want it
+to, serving them up individually during development and concatenating
+and minifying them for production. To support this, Slinky recognizes
+`slinky_scripts` in your HTML/Haml files. For example, when Slinky
+sees this:
+
+```haml
+!!!5
+%html
+  %head
+    slinky_scripts
+    slinky_styles
+  %body
+    %h1 Hello, world!
+```
+
+it will compile the HAML to HTML and replace slinky_styles with the
+appropriate HTML.
+
+### Specifying order
+
+But what if your scripts or styles depend on being included in the
+page in a particular order? For this, we need the `slinky_require`
+directive.
+
+For example, consider the case of two coffeescript files, A.coffee and
+B.coffee. A includes a class definition that B depends upon, so we
+want to make sure that A comes before B in the concatenation order. We
+can solve this simply using `slinky_require(script)`
+
+File A.coffee:
+
+```coffeescript
+class A
+  hello: (thing) -> "Hello, " + thing
+```
+
+File B.coffee:
+
+```coffeescript
+slinky_require("A.coffee")
+alert (new A).hello("world")
+```
+We can also do this in CSS/SASS/SCSS:
+
+```sass
+/* slinky_require("reset.css")
+a
+  color: red
+```
+
+### And coming up next...
+
+* Support for more languages
+* Built in proxy-server to allow connections to web services
+* More control over behavior

data/Rakefile

@@ -22,20 +22,32 @@ Jeweler::Tasks.new do |gem|
 end
 Jeweler::RubygemsDotOrgTasks.new
 
-require 'rake/testtask'
-Rake::TestTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.verbose = true
+namespace :cover_me do
+  task :report do
+    require 'cover_me'
+    # CoverMe.config do |c|
+    #   # where is your project's root:
+    #   c.project.root = Dir.pwd
+      
+    #   # what files are you interested in coverage for:
+    #   c.file_pattern = /(#{CoverMe.config.project.root}\/lib\/.+\.rb)/i
+    # end
+    CoverMe.complete!
+  end
 end
 
-require 'rcov/rcovtask'
-Rcov::RcovTask.new do |spec|
-  spec.libs << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.verbose = true
+# task :spec do
+#   Rake::Task['cover_me:report'].invoke
+# end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
+
+
 task :default => :spec
 
 require 'yard'

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.4.0

data/bin/slinky

@@ -5,4 +5,4 @@ root = File.expand_path(File.dirname(__FILE__))
 #require "#{root}/../lib/slinky"
 require 'slinky'
 
-Slinky::Runner.run
+Slinky::Runner.new(ARGV).run

data/lib/slinky/builder.rb

@@ -0,0 +1,8 @@
+module Slinky
+  class Builder
+    def self.build dir, build_dir
+      manifest = Manifest.new(dir, :build_to => build_dir, :devel => false)
+      manifest.build
+    end
+  end
+end

data/lib/slinky/compiled_file.rb

@@ -2,62 +2,80 @@ module Slinky
   # Stores information about compiled files, including location,
   # source file and last modified time
   class CompiledFile
-    attr_reader :source, :last_compiled
-
+    attr_accessor :source, :print_name, :output_path
+    attr_reader :last_compiled, :output_ext
+    
     # Creates a new CompiledFile, compiling the provided source file
     # with the provided compiler class.
     def initialize source, compiler, output_ext
+      super source
       @source = source
       @compiler = compiler
       @last_compiled = Time.new(0)
       @output_ext = output_ext
     end
 
+    def build path
+      compiler_compile path, EM::DefaultDeferrable
+    end
+
     # Compiles the source file to a temporary location
     def compile &cb
-      path = @path || tmp_path
+      path = @output_path || tmp_path
       @last_compiled = Time.now
       if @compiler.respond_to? :compile
         compiler_compile path, cb
       else
-        compiler_command path, cb
+        compile_failed "invalid compiler"
+        cb.call @output_path, nil, nil, "invalid compiler"
+        # compiler_command path, cb
       end
     end
 
     def compiler_compile path, cb
       begin
-        out = @compiler.compile @source
+        out = File.open @source do |f|
+          @compiler.compile f.read, @source
+        end
+        
         compile_succeeded
-        @path = path
         File.open(path, "w+") do |f|
           f.write out
         end
-      rescue
+      rescue Exception
         compile_failed $!
+        path = nil
       end
-      cb.call @path, nil, nil, $! 
+      cb.call((path ? path.to_s : nil), nil, nil, $!)
     end
 
-    def command path, cb
-      command = @compiler.command @source, path
+    # def compiler_command path, cb
+    #   #NOTE: This currently won't strip out compiler directives, so
+    #   #use at own risk. Ideally all compilers would have ruby version
+    #   #so we don't have to use this
+    #   command = @compiler.command @source, path
 
-      EM.system3 command do |stdout, stderr, status|
-        if status.exitstatus != 0
-          compile_failed stderr.strip
-        else
-          compile_succeeded
-          @path = path
-        end
-        cb.call(@path, status, stdout, stderr)
-      end
+    #   EM.system3 command do |stdout, stderr, status|
+    #     if status.exitstatus != 0
+    #       compile_failed stderr.strip
+    #     else
+    #       compile_succeeded
+    #       @output_path = path
+    #     end
+    #     cb.call(@output_path, status, stdout, stderr)
+    #   end
+    # end
+
+    def name
+      @print_name || @source
     end
 
     def compile_succeeded
-      puts "Compiled #{@source}".foreground(:green)
+      $stdout.puts "Compiled #{name}".foreground(:green)
     end
 
     def compile_failed e
-      $stderr.write "Failed on #{@source}: #{e}\n".foreground(:red)
+      $stderr.puts "Failed on #{name}: #{e}".foreground(:red)
     end
 
     # Calls the supplied callback with the path of the compiled file,
@@ -66,7 +84,7 @@ module Slinky
       if needs_update?
         compile &cb
       else
-        cb.call @path, nil, nil, nil
+        cb.call @output_path, nil, nil, nil
       end
     end
 
@@ -74,7 +92,7 @@ module Slinky
     # compiled.
     def needs_update?
       return true if @compiler.to_s.match "SassCompiler"
-      File.new(source).mtime > @last_compiled
+      File.new(source).mtime > @last_compiled rescue true
     end
 
     private

data/lib/slinky/compilers/coffee-compiler.rb

@@ -2,12 +2,11 @@ require 'coffee-script'
 
 module Slinky
   module CoffeeCompiler
-    Server.register_compiler self,
+    Compilers.register_compiler self,
     :inputs => ["coffee"],
     :outputs => ["js"]
 
-    def CoffeeCompiler::compile file
-      s = File.read(file)
+    def CoffeeCompiler::compile s, file
       CoffeeScript::compile(s)
     end
   end

data/lib/slinky/compilers/haml-compiler.rb

@@ -2,14 +2,20 @@ require 'haml'
 
 module Slinky
   module HamlCompiler
-    Server.register_compiler self,
+    Compilers.register_compiler self,
     :inputs => ["haml"],
     :outputs => ["html"]
 
-    def HamlCompiler::compile file
-      s = File.read(file)
+    def HamlCompiler::compile s, file
       haml_engine = Haml::Engine.new(s)
       haml_engine.render
-    end    
+    end
+
+    # escape should return a string that can be inserted into the
+    # document in such a way that after compilation the string will be
+    # intact in the final output.
+    def HamlCompiler::escape s
+      s
+    end
   end
 end

data/lib/slinky/compilers/sass-compiler.rb

@@ -2,12 +2,11 @@ require 'sass'
 
 module Slinky
   module SassCompiler
-    Server.register_compiler self,
+    Compilers.register_compiler self,
       :inputs => ["sass", "scss"],
       :outputs => ["css"]
 
-    def SassCompiler::compile file
-      s = File.read(file)
+    def SassCompiler::compile s, file
       sass_engine = Sass::Engine.new(s, :load_paths => [File.dirname(file)])
       sass_engine.render
     end

data/lib/slinky/compilers.rb

@@ -0,0 +1,72 @@
+module Slinky
+  EXTENSION_REGEX = /(.+)\.(\w+)/
+  
+  class Compilers
+    @compilers = []
+    @compilers_by_ext = {}
+    @compilers_by_input = {}
+
+    class << self
+      def register_compiler klass, options
+        options[:klass] = klass
+        @compilers << options
+        options[:outputs].each do |output|
+          @compilers_by_ext[output] ||= []
+          @compilers_by_ext[output] << options
+        end
+        options[:inputs].each do |input|
+          @compilers_by_input[input] = options
+        end
+      end
+
+      # Produces a CompiledFile for an input file if the file needs to
+      # be compiled, or nil otherwise. Note that path is the path of
+      # the compiled file, so script.js not script.coffee.
+      def cfile_for_request path
+        _, file, extension = path.match(EXTENSION_REGEX).to_a
+
+        compilers = @compilers_by_ext
+
+        # if there's a file extension and we have a compiler that
+        # outputs that kind of file, look for an input with the same
+        # name and an extension in our list
+        if extension && extension != "" && compilers[extension]
+          files_by_ext = {}
+          # find possible source files
+          Dir.glob("#{file}.*").each do |f|
+            _, _, ext = f.match(EXTENSION_REGEX).to_a
+            files_by_ext[ext] = f
+          end
+
+          cfile = nil
+          # find a compiler that outputs the request kind of file and
+          # which has an input file type that exists on the file system
+          compilers[extension].each do |c|
+            c[:inputs].each do |i|
+              if files_by_ext[i]
+                cfile = CompiledFile.new files_by_ext[i], c[:klass], extension
+                break
+              end
+            end
+            break if cfile
+          end
+          cfile
+        else
+          nil
+        end
+      end
+
+      # Like cfile_for_request, but for the actual file to be compiled
+      # (so script.coffee, not script.js).
+      def cfile_for_file path
+        _, file, ext = path.match(EXTENSION_REGEX).to_a
+
+        if ext && ext != "" && compiler = @compilers_by_input[ext]
+          CompiledFile.new path, compiler[:klass], compiler[:outputs].first
+        else
+          nil
+        end
+      end
+    end
+  end
+end