mbj-assets 0.0.3

data/lib/assets/evaluator.rb

@@ -0,0 +1,67 @@
+module Assets
+
+  # Rule evaluator
+  class Evaluator
+    include Adamantium, Concord.new(:rule)
+
+    # Return asset
+    #
+    # @return [Asset]
+    #
+    # @api private
+    #
+    def asset
+      rule = self.rule
+      Asset.new(
+        :name       => rule.name,
+        :mime       => rule.mime,
+        :created_at => Time.now,
+        :body       => body,
+        :size       => size,
+        :sha1       => sha1
+      )
+    end
+
+    # Return sha1 hexdigest of body
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def sha1
+      Digest::SHA1.hexdigest(body)
+    end
+
+    # Return body
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def body
+      rule.body
+    end
+    memoize :body
+
+    # Return size in bytes
+    #
+    # @return [Fixnum]
+    #
+    # @api private
+    #
+    def size
+      body.bytesize
+    end
+
+    # Return mime
+    #
+    # @return [Mime]
+    #
+    # @api private
+    #
+    def mime
+      rule.mime
+    end
+
+  end
+end

data/lib/assets/handler.rb

@@ -0,0 +1,39 @@
+module Assets
+  # Asset request handler
+  class Handler
+    include Adamantium, Concord.new(:environment, :prefix)
+
+    # Instantiate object
+    #
+    # @param [Environment] environment
+    # @param [String] prefix
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.new(environment, prefix = '')
+      super(environment, Regexp.compile(%r(\A#{Regexp.escape(prefix)})))
+    end
+
+    # Call handler
+    #
+    # @param [Application] application
+    # @param [Request] request
+    #
+    # @return [Response]
+    #
+    # @api private
+    #
+    def call(_application, request)
+      name = request.path_info.gsub(prefix, '')
+      asset = environment.get(name)
+      if asset
+        Responder.run(request, asset)
+      else
+        Responder::NOT_FOUND
+      end
+    end
+
+  end
+end

data/lib/assets/mime.rb

@@ -0,0 +1,81 @@
+module Assets
+  class Mime
+    include Adamantium, Concord.new(:extname, :content_type)
+
+    REGISTRY = {}
+
+    # Return extname
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    attr_reader :extname
+
+    # Return content type
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    attr_reader :content_type
+
+    # Return mime for extname
+    #
+    # @param [String] extname
+    #
+    # @return [Mime]
+    #
+    # @api private
+    #
+    def self.extname(extname)
+      REGISTRY.fetch(extname)
+    end
+
+    # Return mime name
+    #
+    # @param [String] name
+    #
+    # @return [Mime]
+    #
+    # @api private
+    #
+    def self.from_name(name)
+      extname(::File.extname(name))
+    end
+
+    # Instantiate object 
+    #
+    # @return [Mime]
+    #
+    # @api private
+    #
+    def self.new(*)
+      instance = super
+      REGISTRY[instance.extname]=instance
+      instance
+    end
+
+    private_class_method :new
+
+    JPG          = new('.jpg',    'image/jpg'                               )
+    ICO          = new('.ico',    'image/vnd.microsoft.icon'                )
+    PNG          = new('.png',    'image/png'                               )
+    GIF          = new('.gif',    'image/gif'                               )
+    SVG          = new('.svg',    'image/svg'                               )
+    PDF          = new('.pdf',    'application/pdf'                         )
+    RUBY         = new('.rb',     'application/ruby'                        )
+    TXT          = new('.txt',    'text/plain; charset=UTF-8'               )
+    CSS          = new('.css',    'text/css; charset=UTF-8'                 )
+    JAVASCRIPT   = new('.js',     'application/javascript; charset=UTF-8'   )
+    COFFEESCRIPT = new('.coffee', 'application/coffeescript; charset=UTF-8' )
+    SASS         = new('.sass',   'text/plain; charset=UTF-8'               )
+    HTML         = new('.html',   'text/html; charset=UTF-8'                )
+
+    IMAGES = [
+      JPG, ICO, PNG, SVG, GIF
+    ].freeze
+
+    REGISTRY.freeze
+  end
+end

data/lib/assets/package.rb

@@ -0,0 +1,124 @@
+module Assets
+  class Package
+    include Concord::Public.new(:repository, :contents)
+
+    # Return rules for mime type
+    #
+    # @return [Enumerable<Rule>]
+    #
+    # @api private
+    #
+    def mime(mime)
+      contents.fetch(mime, [])
+    end
+
+    # Return image rules
+    #
+    # @return [Enumerable<Rule>]
+    #
+    # @api private
+    #
+    def images
+      Mime::IMAGES.each_with_object([]) do |mime, images|
+        images.concat(mime(mime))
+      end
+    end
+
+    class Builder
+
+      # Run builder 
+      #
+      # @param [String] directory
+      #
+      # @return [Package]
+      #
+      # @api private
+      #
+      def self.run(directory)
+        repository = Repository::Directory.new(directory)
+        builder = new(repository)
+        yield builder
+        Package.new(repository, builder.contents)
+      end
+
+      # Initialize object
+      #
+      # @param [Repository] repository
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(repository)
+        @repository = repository
+        @contents = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      # Return contents
+      #
+      # @return [Hash]
+      #
+      # @api private
+      #
+      attr_reader :contents
+
+      # Return repository
+      #
+      # @return [Repository]
+      #
+      # @api private
+      #
+      attr_reader :repository
+
+      # Add compile
+      #
+      # @param [String] name
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def compile(name)
+        append(repository.compile(name))
+      end
+
+      # Add static file
+      #
+      # @param [String] name
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def file(name)
+        append(repository.file(name))
+      end
+
+      # Perform glob
+      #
+      # @param [String] pattern
+      #
+      # @return [Enumerable<String>]
+      #
+      # @api private
+      #
+      def glob(pattern)
+        repository.glob(pattern)
+      end
+
+      # Append rule
+      #
+      # @param [Rule] rule
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def append(rule)
+        @contents[rule.mime] << rule
+        self
+      end
+    end
+  end
+end
+

data/lib/assets/repository.rb

@@ -0,0 +1,61 @@
+module Assets
+
+  # Abstract base class for asset repositories
+  class Repository
+
+    # Physical directory repository
+    class Directory
+      include Concord.new(:root)
+
+      # Build a file rule
+      #
+      # @param [#to_s] name
+      #
+      # @return [Rule::File]
+      #
+      # @api private
+      #
+      def file(name)
+        Rule::File.new(name.to_s, path(name))
+      end
+
+      # Return names matching pattern 
+      #
+      # @param [String] pattern
+      #
+      # @return [Enumerable<String>]
+      #
+      # @api private
+      #
+      def glob(pattern)
+        root = self.root
+        Pathname.glob(root.join(pattern)).map do |match|
+          match.relative_path_from(root).to_s
+        end
+      end
+
+      # Return path for name
+      #
+      # @param [String] name
+      #
+      # @return [Pathname]
+      #
+      # @api private
+      #
+      def path(name)
+        root.join(name)
+      end
+
+      # Build a compile rule
+      #
+      # @return [Rule::Compile::Sass]
+      #
+      # @api private
+      #
+      def compile(name)
+        Rule::Compile.build(file(name))
+      end
+
+    end
+  end
+end

data/lib/assets/responder.rb

@@ -0,0 +1,133 @@
+module Assets
+  # Abstract base class for asset responders
+  class Responder
+    include AbstractType, Concord.new(:asset)
+
+    HEADERS   = IceNine.deep_freeze('Cache-Control' => 'max-age=120, must-revalidate')
+    NOT_FOUND = Response.build(
+      Response::Status::NOT_FOUND,
+      HEADERS.merge('Content-Type' => Assets::Mime::TXT.content_type),
+      'Not Found'
+    )
+
+    # Call responder
+    #
+    # @param [Object] asset
+    #
+    # @return [Response]
+    #
+    # @api private
+    #
+    def self.call(asset)
+      new(asset).response
+    end
+
+    # Run responder
+    #
+    # @param [Request] request
+    # @param [Asset] asset
+    #
+    # @return [Response] response
+    #
+    # @api private
+    #
+    def self.run(request, asset)
+      timestamp = request.if_modified_since
+
+      responder =
+        if timestamp && asset.fresh_at?(timestamp)
+          NotModified
+        else
+          New
+        end
+
+      responder.call(asset)
+    end
+
+    # Return response
+    #
+    # @return [Response]
+    #
+    # @api private
+    #
+    def response
+      Response.new(status, headers, body)
+    end
+
+  private
+
+    # Return status code
+    #
+    # @return [Fixnum]
+    #
+    # @api private
+    #
+    def status
+      self.class::STATUS
+    end
+
+    # Return headers
+    #
+    # @return [Hash]
+    #
+    # @api private
+    #
+    def headers
+      HEADERS.merge('Last-Modified' => asset.created_at.httpdate)
+    end
+
+    # Return content type header value
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def content_type
+      asset.mime.content_type
+    end
+
+    # Not modified responder
+    class NotModified < self
+      STATUS = Response::Status::NOT_MODIFIED
+
+    private
+
+      # Return body
+      #
+      # @return [nil]
+      #
+      # @api private
+      #
+      def body; end
+
+    end
+
+    # New asset responder
+    class New < self
+      STATUS = Response::Status::OK
+
+    private
+
+      # Return headers
+      #
+      # @return [Hash]
+      #
+      # @api private
+      #
+      def headers
+        super.merge('Content-Type' => content_type)
+      end
+
+      # Return body
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def body
+        asset.body
+      end
+
+    end
+  end
+end

data/lib/assets/rule/compile/css.rb

@@ -0,0 +1,28 @@
+module Assets
+  class Rule
+    class Compile
+      # Abstract base class for compilers that compile to css
+      class Css < self
+
+        MIME = Mime::CSS
+
+        # Compiler for sass
+        class Sass < self
+          handle(Mime::SASS)
+
+          # Return body
+          #
+          # @return [String]
+          #
+          # @api private
+          #
+          def body
+            ::Sass.compile(input.body, :syntax => :sass)
+          end
+
+        end # Sass
+
+      end # Css
+    end # Compile
+  end # Rule
+end # Assets

data/lib/assets/rule/compile/javascript/coffescript.rb

@@ -0,0 +1,24 @@
+module Assets
+  class Rule
+    class Compile
+      class Javascript
+
+        # Compiler for sass
+        class Coffescript < self
+          handle(Mime::COFFEESCRIPT)
+
+          # Return body
+          #
+          # @return [String]
+          #
+          # @api private
+          #
+          def body
+            ::CoffeeScript.compile(input.body)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/assets/rule/compile/javascript.rb

@@ -0,0 +1,12 @@
+module Assets
+  class Rule
+    class Compile
+      # Base class for compilers that compile to javascript
+      class Javascript < self
+
+        MIME = Mime::JAVASCRIPT
+
+      end
+    end
+  end
+end

data/lib/assets/rule/compile.rb

@@ -0,0 +1,99 @@
+module Assets
+  class Rule 
+    class Compile < self
+      include Concord.new(:input)
+
+      # Return name
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def name
+        input.name
+      end
+
+      # Return updated at
+      #
+      # @return [Time]
+      #
+      # @api private
+      #
+      def updated_at
+        input.updated_at
+      end
+
+      # Return target name
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def target_name
+        regexp = %r(#{Regexp.escape(input.extname)}\z)
+        name.gsub(regexp, mime.extname)
+      end
+      memoize :target_name
+
+      # Return registry
+      #
+      # @return [Hash]
+      #
+      # @api private
+      #
+      def self.registry
+        @registry ||= {}
+      end
+
+      # protected_class_method :registry
+      singleton_class.send(:protected, :registry)
+
+      # Register handler
+      #
+      # @param [Mime] mime
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.handle(mime)
+        Compile.registry[mime]=self
+      end
+      private_class_method :handle
+
+      # Build compiler rule
+      #
+      # @param [Rule::File] rule
+      #
+      # @return [Rule::Compile]
+      #
+      # @api private
+      #
+      def self.build(rule)
+        builder = Compile.registry.fetch(rule.mime)
+        compiler = builder.new(rule)
+        Rename.new(compiler.target_name, compiler)
+      end
+
+      # Return mime type
+      #
+      # @return [Mime]
+      #
+      # @api private
+      #
+      def mime
+        self.class.mime
+      end
+
+      # Return mime type
+      #
+      # @return [Mime]
+      #
+      # @api private
+      #
+      def self.mime
+        self::MIME
+      end
+    end
+  end
+end