assette 0.0.0

data/lib/assette/file.rb

@@ -0,0 +1,176 @@
+class Assette::File < ::File
+  extend Forwardable
+  
+  def text
+    @text || (dependencies && @text)
+  end
+  
+  def extension
+    m = path.match(/\.(\w+)$/)
+    m[1] if m
+  end
+  
+  def reader_class
+    if klass = Assette::Reader::ALL[extension]
+      klass
+    else
+      raise "Can't find reader class Assette::Reader::#{extension.capitalize}"
+    end
+  end
+  
+  def target_class
+    return @target_class if @target_class
+    ex = reader_class.outputs
+    
+    raise(Exception, "Define @outputs for #{reader_class.class}") unless ex
+    
+    if @target_class = Assette::Reader::ALL[ex.to_s]
+      @target_class
+    else
+      raise "Can't find reader class Assette::Reader::#{ex.capitalize}"
+    end
+  end
+  
+  def mime_type
+    @mime_type ||= MIME::Types.type_for(path).first
+  end
+  
+  def comment_str
+    target_class.comment_str
+  end
+  
+  def code
+    reader_class.new(self).compile
+  end
+  
+  def all_code_array
+    dep = Assette::CompiledFile.new(self)
+    
+    if !templates.empty?
+      set = Assette::TemplateSet.new(templates)
+      
+      dep << set.compile
+    end
+    
+    dependencies.each {|d| dep.add_dependency(d)}
+    
+    dep.add_dependency(self)
+    
+    dep
+  end
+  
+  def all_code
+    all_code_array.join("\n")
+  end
+  
+  def dirname
+    File.dirname(path)
+  end
+  
+  def filename
+    path.gsub(dirname,'').gsub(/^\//,'')
+  end
+  
+  def puts *args
+    STDOUT.puts *args
+  end
+  
+  def == other
+    if other.instance_of?(self.class)
+      other.path == path
+    else
+      super
+    end
+  end
+  
+  def read
+    @read ||= super
+  end
+  
+  def dependencies
+    return @dependencies if @dependencies
+    
+    @dependencies = []
+    
+    read_config do |l|
+      m = l.match /@require(?:s)?\s+([\w\.\/-]+)/
+      next unless m
+      
+      p = ::File.expand_path(::File.join(dirname,m[1]))
+      
+      # Check for _filename if filename doesn't exist
+      unless ::File.exist?(p)
+        p2 = p.gsub /(.*\/)?(.+)/, '\1_\2'
+        if ::File.exist?(p2)
+          p = p2
+        else
+          raise "Cannot find dependancy #{p} or #{p2} as required in #{path}"
+        end
+      end
+      
+      f = Assette::File.open(p)
+      
+      @dependencies << f
+      f.dependencies.each do |d|
+        @dependencies << d unless @dependencies.include?(d)
+      end
+      
+    end
+    
+    @dependencies
+  end
+  
+  def templates
+    return @templates if @templates
+    
+    @templates = []
+    
+    read_config do |line|
+      m = line.match /@template(?:s)?\s+(\w+)/
+      next unless m
+      
+      @templates << m[1]
+    end
+    
+    dependencies.each do |dep|
+      dep.templates.each do |template|
+        @templates << template unless @templates.include?(template)
+      end
+    end
+    
+    @templates
+  end
+  
+  def read_config
+    started = nil
+    @text = read
+    @text.each_line do |l|
+      next unless started ||= (l =~ /#{Assette::CONFIG_WRAPPER}/)
+      break if l =~ /\/#{Assette::CONFIG_WRAPPER}/
+      
+      yield(l)
+    end
+  end
+  
+  class << self
+    
+    def all_code_for *args
+      start = Time.now
+      f = open(*args)
+      code = f.all_code
+      code << "\n"
+      code << f.comment_str % "Time taken to generate: #{Time.now-start}s"
+    end
+    
+    def rack_resp_if_exists path
+      return unless File.exist?(path)
+      start = Time.now
+      f = open(path)
+      code = f.all_code_array
+      code << "\n"
+      code << f.comment_str % "Time taken to generate: #{Time.now-start}s"
+    end
+    
+  end
+  
+end

data/lib/assette/reader.rb

@@ -0,0 +1,96 @@
+module Assette
+  module Reader
+    extend self
+    OUTPUTS = Hash.new {|h,k| h[k] = []}
+    ALL = {}
+    
+    def possible_targets path
+      match = path.match(/(.+\.)([a-z]+)$/i)
+      return [] unless match
+      file = match[1]
+      ext = match[2]
+      
+      OUTPUTS[ext.to_sym].collect { |cla| file + cla.extension }
+    end
+    
+    class Base
+      attr_reader :file
+      def initialize(file)
+        @file = file
+      end
+      
+      def text
+        @file.text
+      end
+      
+      def compile
+        raise Exception, "You must implement the compile method for #{self.class.inspect}"
+      end
+      
+      class << self
+        
+        # Gets called twice currenlty, once on Class.new(Reader::Base)
+        # and once on the subclassing. Gotta fix that
+        def inherited subclass
+          return if subclass == Assette::Reader::Base || subclass.inspect =~ /#<Class/
+          
+          if outputs
+            Assette::Reader::OUTPUTS[outputs] |= [subclass]
+          end
+          
+          subclass.set_extension
+        end
+        
+        def extension
+          if m = self.inspect.match(/::(\w+)$/i)
+            m[1].downcase
+          end
+        end
+        
+        def outputs
+          
+        end
+        
+        def set_outputs val
+          raise ArgumentError, 'must set outputs to a symbol' unless val.is_a?(Symbol)
+          
+          instance_eval <<-RUBY
+          def outputs
+            #{val.inspect}
+          end
+          RUBY
+          val
+        end
+        
+        def set_extension val = nil
+          if val
+            raise ArgumentError, 'must set extension to a symbol' unless val.is_a?(Symbol)
+            instance_eval <<-RUBY
+            def extension
+              #{val.inspect}
+            end
+            RUBY
+          end
+          
+          if ex = extension
+            Assette::Reader::ALL[ex] = self
+          end
+        end
+        
+        def mime_type
+          @mime_type ||= MIME::Types.type_for("test.#{extension}").first
+        end
+        
+      end
+    
+    end
+    
+  end
+  
+  def self.Reader(type)
+    c = Class.new(Reader::Base)
+    c.set_outputs(type)
+    c
+  end
+  
+end

data/lib/assette/readers.rb

@@ -0,0 +1,4 @@
+fname = File.join(File.dirname(__FILE__),'readers','*.rb')
+Dir[fname].each do |f|
+  require f
+end

data/lib/assette/readers/coffee.rb

@@ -0,0 +1,31 @@
+require 'open3'
+
+class Assette::Reader::Coffee < Assette::Reader(:js)
+  
+  def compile
+    self.class.compile_str text
+  end
+  
+  class << self
+    
+    def compile_str text
+      out = nil
+
+      Open3.popen3('coffee -sc') do |stdin, stdout, stderr|
+        stdin.puts(text)
+        stdin.close_write
+        out = stdout.read
+      end
+
+      out
+    end
+    
+    def comment_str
+      '#'
+    end
+
+    def comment_str_end
+      ''
+    end
+  end
+end

data/lib/assette/readers/css.rb

@@ -0,0 +1,14 @@
+class Assette::Reader::Css < Assette::Reader(:css)
+  
+  def compile
+    @file.text
+  end
+  
+  class << self
+    
+    def comment_str
+      @comment_str ||= '/* %s */'
+    end
+    
+  end
+end

data/lib/assette/readers/js.rb

@@ -0,0 +1,13 @@
+class Assette::Reader::Js < Assette::Reader(:js)
+  
+  def compile
+    @file.text
+  end
+  
+  class << self
+    
+    def comment_str
+      @comment_str ||= "// %s"
+    end
+  end
+end

data/lib/assette/readers/sass.rb

@@ -0,0 +1,18 @@
+require 'haml'
+require 'sass'
+class Assette::Reader::Sass < Assette::Reader(:css)
+  
+  def compile
+    engine = ::Sass::Engine.new(text,options)
+    engine.to_css
+  end
+  
+private
+  
+  def options
+    {
+      :syndtax => :sass,
+      :load_paths => [File.expand_path(@file.dirname)]|Assette.config.file_paths
+    }
+  end
+end

data/lib/assette/readers/scss.rb

@@ -0,0 +1,9 @@
+class Assette::Reader::Scss < Assette::Reader::Sass
+  
+private
+
+  def options
+    super.merge :syntax => :scss
+  end
+  
+end

data/lib/assette/server.rb

@@ -0,0 +1,83 @@
+module Assette
+  # Methods for finding files are ugly, should fix someday
+  class Server
+    attr_reader :path
+    def initialize(path)
+      @path = path
+      Assette.config.asset_path
+    end
+    
+    def find_compiled_file
+      f = nil
+      Assette.config.file_paths.each do |p|
+        
+        Assette::Reader.possible_targets(File.join(p,path)).each do |pp|
+          f = Assette::File.rack_resp_if_exists( pp )
+          break if f
+        end
+        
+        break if f
+      end
+      f
+    end
+    
+    def path_extension
+      m = path.match(/\.(\w+)$/)
+      m[1] if m
+    end
+    
+    def has_registered_reader?
+      !Assette::Reader::OUTPUTS[path_extension.to_sym].empty?
+    end
+    
+    def path_mime_type
+      @path_mime_type ||= MIME::Types.type_for(path).first
+    end
+    
+    def content_type
+      path_mime_type ? path_mime_type.content_type : 'text/plain'
+    end
+    
+    def find_file
+      f = nil
+      
+      Assette.config.file_paths.each do |p|
+        new_path = File.join(p,path)
+        if File.exist?(new_path)
+          f = File.open(new_path)
+          # add in grabbing index.html files if no extension provided
+        end
+        
+        break if f
+      end
+      
+      f
+    end
+    
+    def rack_resp
+      
+      if has_registered_reader? && (f = find_compiled_file)
+        [200,{"Content-Type" => f.content_type},f]
+      elsif (f = find_file) && path_mime_type
+        puts content_type
+        [200,{"Content-Type" => content_type},f]
+      else
+        [404,{"Content-Type" => "text/plain"},["File Not Found"]]
+      end
+    end
+    
+    class << self
+      
+      def call(env)
+        s = new(env["PATH_INFO"])
+        
+        s.rack_resp
+      # rescue => e
+      #   [500,{"Content-Type" => "text/plain"},[e.inspect]]
+      end
+      
+    end
+    
+  end
+  
+end