hanami-assets 0.0.0 → 0.2.0

data/lib/hanami/assets/compiler.rb

@@ -0,0 +1,212 @@
+module Hanami
+  module Assets
+    class MissingAsset < Error
+      def initialize(name, sources)
+        sources = sources.map(&:to_s).join(', ')
+        super("Missing asset: `#{ name }' (sources: #{ sources })")
+      end
+    end
+
+    class UnknownAssetEngine < Error
+      def initialize(source)
+        super("No asset engine registered for `#{ ::File.basename(source) }'")
+      end
+    end
+
+    # Assets compiler
+    #
+    # It compiles assets that needs to be preprocessed (eg. Sass or ES6) into
+    # the destination directory.
+    #
+    # Vanilla javascripts or stylesheets are just copied over.
+    #
+    # @since 0.1.0
+    # @api private
+    class Compiler
+      # @since 0.1.0
+      # @api private
+      DEFAULT_PERMISSIONS = 0644
+
+      # @since 0.1.0
+      # @api private
+      COMPILE_PATTERN = '*.*.*'.freeze # Example hello.js.es6
+
+      # @since 0.1.0
+      # @api private
+      EXTENSIONS = {'.js' => true, '.css' => true}.freeze
+
+      # @since 0.1.0
+      # @api private
+      SASS_CACHE_LOCATION = Pathname(Hanami.respond_to?(:root) ?
+                                     Hanami.root : Dir.pwd).join('tmp', 'sass-cache')
+
+      # Compile the given asset
+      #
+      # @param configuration [Hanami::Assets::Configuration] the application
+      #   configuration associated with the given asset
+      #
+      # @param name [String] the asset path
+      #
+      # @since 0.1.0
+      # @api private
+      def self.compile(configuration, name)
+        return unless configuration.compile
+
+        require 'tilt'
+        require 'hanami/assets/cache'
+        new(configuration, name).compile
+      end
+
+      # Assets cache
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see Hanami::Assets::Cache
+      def self.cache
+        @@cache ||= Assets::Cache.new
+      end
+
+      # Return a new instance
+      #
+      # @param configuration [Hanami::Assets::Configuration] the application
+      #   configuration associated with the given asset
+      #
+      # @param name [String] the asset path
+      #
+      # @return [Hanami::Assets::Compiler] a new instance
+      #
+      # @since 0.1.0
+      # @api private
+      def initialize(configuration, name)
+        @configuration = configuration
+        @name          = Pathname.new(name)
+      end
+
+      # Compile the asset
+      #
+      # @raise [Hanami::Assets::MissingAsset] if the asset can't be found in
+      #   sources
+      #
+      # @since 0.1.0
+      # @api private
+      def compile
+        raise MissingAsset.new(@name, @configuration.sources) unless exist?
+        return unless fresh?
+
+        if compile?
+          compile!
+        else
+          copy!
+        end
+
+        cache!
+      end
+
+      private
+
+      # @since 0.1.0
+      # @api private
+      def source
+        @source ||= begin
+          @name.absolute? ? @name :
+            @configuration.find(@name)
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      def destination
+        @destination ||= @configuration.destination_directory.join(basename)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def basename
+        result = ::File.basename(@name)
+
+        if compile?
+          result.scan(/\A[[[:alnum:]][\-\_]]*\.[[\w]]*/).first || result
+        else
+          result
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      def exist?
+        !source.nil? &&
+          source.exist?
+      end
+
+      # @since 0.1.0
+      # @api private
+      def fresh?
+        !destination.exist? ||
+          cache.fresh?(source)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def compile?
+        @compile ||= ::File.fnmatch(COMPILE_PATTERN, source.to_s) &&
+          !EXTENSIONS[::File.extname(source.to_s)]
+      end
+
+      # @since 0.1.0
+      # @api private
+      def compile!
+        # NOTE `:load_paths' is useful only for Sass engine, to make `@include' directive to work.
+        # For now we don't want to maintan a specialized Compiler version for Sass.
+        #
+        # If in the future other precompilers will need special treatment,
+        # we can consider to maintain several specialized versions in order to
+        # don't add a perf tax to all the other preprocessors who "just work".
+        #
+        # Example: if Less "just works", we can keep it in the general `Compiler',
+        # but have a `SassCompiler` if it requires more than `:load_paths'.
+        #
+        # NOTE: We need another option to pass for Sass: `:cache_location'.
+        #
+        # This is needed to don't create a `.sass-cache' directory at the root of the project,
+        # but to have it under `tmp/sass-cache'.
+        write { Tilt.new(source, nil, load_paths: @configuration.sources.to_a, cache_location: sass_cache_location).render }
+      rescue RuntimeError
+        raise UnknownAssetEngine.new(source)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def copy!
+        write { source.read }
+      end
+
+      # @since 0.1.0
+      # @api private
+      def cache!
+        cache.store(source)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def write
+        destination.dirname.mkpath
+        destination.open(File::WRONLY|File::CREAT, DEFAULT_PERMISSIONS) do |file|
+          file.write(yield)
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      def cache
+        self.class.cache
+      end
+
+      # @since 0.1.0
+      # @api private
+      def sass_cache_location
+        SASS_CACHE_LOCATION
+      end
+    end
+  end
+end

data/lib/hanami/assets/compressors/abstract.rb

@@ -0,0 +1,119 @@
+require 'hanami/utils/string'
+require 'hanami/utils/class'
+
+module Hanami
+  module Assets
+    module Compressors
+      # Unknown compressor error
+      #
+      # It's raised when trying to load an unknown compressor.
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see Hanami::Assets::Configuration#javascript_compressor
+      # @see Hanami::Assets::Configuration#stylesheet_compressor
+      # @see Hanami::Assets::Compressors::Abstract#for
+      class UnknownCompressorError < Error
+        # @since 0.1.0
+        # @api private
+        def initialize(type, engine_name)
+          super("Unknown #{ type } compressor: :#{ engine_name }")
+        end
+      end
+
+      # Abstract base class for compressors.
+      #
+      # Don't use this class directly, but please use subclasses instead.
+      #
+      # @since 0.1.0
+      # @api private
+      class Abstract
+        # Compress the given asset
+        #
+        # @param filename [String, Pathname] the absolute path to the asset
+        #
+        # @return [String] the compressed asset
+        #
+        # @since 0.1.0
+        # @api private
+        def compress(filename)
+          compressor.compress(
+            read(filename)
+          )
+        end
+
+        protected
+        # @since 0.1.0
+        # @api private
+        attr_reader :compressor
+
+        # Read the contents of given filename
+        #
+        # @param filename [String, Pathname] the absolute path to the asset
+        #
+        # @return [String] the contents of asset
+        #
+        # @since 0.1.0
+        # @api private
+        def read(filename)
+          ::File.read(filename)
+        end
+
+        private
+
+        # Factory for compressors.
+        #
+        # It loads a compressor for the given name.
+        #
+        # @abstract Please use this method from the subclasses
+        #
+        # @param engine_name [Symbol,String,NilClass,#compress] the name of the
+        #   engine to load or an instance of an engine
+        #
+        # @return [Hanami::Assets::Compressors::Abstract] returns a concrete
+        #   implementation of a compressor
+        #
+        # @raise [Hanami::Assets::Compressors::UnknownCompressorError] when the
+        #   given name refers to an unknown compressor engine
+        #
+        # @since 0.1.0
+        # @api private
+        def self.for(engine_name)
+          case engine_name
+          when Symbol, String
+            load_engine(name, engine_name)
+          when nil
+            require 'hanami/assets/compressors/null_compressor'
+            NullCompressor.new
+          else
+            engine_name
+          end
+        end
+
+        # Load the compressor for the given type and engine name.
+        #
+        # @param type [String] asset type (eg. "Javascript" or "Stylesheet")
+        # @param engine_name [Symbol,String] the name of the engine to load (eg. `:yui`)
+        #
+        # @return [Hanami::Assets::Compress::Abstract] returns a concrete
+        #   implementation of a compressor
+        #
+        # @since 0.1.0
+        # @api private
+        def self.load_engine(type, engine_name)
+          type = Utils::String.new(type).demodulize
+
+          require "hanami/assets/compressors/#{ engine_name }_#{ type.underscore }"
+          Utils::Class.load!("#{ Utils::String.new(engine_name).classify }#{ type }", Hanami::Assets::Compressors).new
+        rescue LoadError
+          raise UnknownCompressorError.new(type, engine_name)
+        end
+
+        class << self
+          private :for, :load_engine
+        end
+      end
+    end
+  end
+end

data/lib/hanami/assets/compressors/builtin_javascript.rb

@@ -0,0 +1,36 @@
+require 'hanami/assets/compressors/javascript'
+require_relative './jsmin'
+
+module Hanami
+  module Assets
+    module Compressors
+      # Builtin compressor for stylesheet
+      #
+      # This is a port of jsmin
+      # Copyright (c) 2002 Douglas Crockford  (www.crockford.com)
+      #
+      # This Ruby port was implemented by Ryan Grove (@rgrove) as work for
+      # <tt>jsmin</tt> gem.
+      #
+      # Copyright (c) 2008-2012 Ryan Grove
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see https://github.com/sbecker/asset_packager
+      class BuiltinJavascript < Javascript
+        def initialize
+          @compressor = JSMin
+        end
+
+        # @since 0.1.0
+        # @api private
+        def compress(filename)
+          compressor.minify(
+            read(filename)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hanami/assets/compressors/builtin_stylesheet.rb

@@ -0,0 +1,57 @@
+require 'hanami/assets/compressors/stylesheet'
+
+module Hanami
+  module Assets
+    module Compressors
+      # Builtin compressor for stylesheet
+      #
+      # This is a basic algorithm based on Scott Becker (@sbecker) work on
+      # <tt>asset_packager</tt> gem.
+      #
+      # Copyright (c) 2006-2008 Scott Becker
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see https://github.com/sbecker/asset_packager
+      class BuiltinStylesheet < Stylesheet
+        # @since 0.1.0
+        # @api private
+        SPACE_REPLACEMENT                = " ".freeze
+
+        # @since 0.1.0
+        # @api private
+        COMMENTS_REPLACEMENT             = "".freeze
+
+        # @since 0.1.0
+        # @api private
+        LINE_BREAKS_REPLACEMENT          = "}\n".freeze
+
+        # @since 0.1.0
+        # @api private
+        LAST_BREAK_REPLACEMENT           = "".freeze
+
+        # @since 0.1.0
+        # @api private
+        INSIDE_LEFT_BRACKET_REPLACEMENT  = " {".freeze
+
+        # @since 0.1.0
+        # @api private
+        INSIDE_RIGHT_BRACKET_REPLACEMENT = "}".freeze
+
+        # @since 0.1.0
+        # @api private
+        def compress(filename)
+          result = read(filename)
+          result.gsub!(/\s+/,            SPACE_REPLACEMENT)                # collapse space
+          result.gsub!(/\/\*(.*?)\*\/ /, COMMENTS_REPLACEMENT)             # remove comments - caution, might want to remove this if using css hacks
+          result.gsub!(/\} /,            LINE_BREAKS_REPLACEMENT)          # add line breaks
+          result.gsub!(/\n$/,            LAST_BREAK_REPLACEMENT)           # remove last break
+          result.gsub!(/ \{ /,           INSIDE_LEFT_BRACKET_REPLACEMENT)  # trim inside brackets
+          result.gsub!(/; \}/,           INSIDE_RIGHT_BRACKET_REPLACEMENT) # trim inside brackets
+          result
+        end
+      end
+    end
+  end
+end

data/lib/hanami/assets/compressors/closure_javascript.rb

@@ -0,0 +1,25 @@
+require 'hanami/assets/compressors/javascript'
+require 'closure-compiler'
+
+module Hanami
+  module Assets
+    module Compressors
+      # Google Closure Compiler for JavaScript
+      #
+      # Depends on <tt>closure-compiler</tt> gem
+      #
+      # @see https://developers.google.com/closure/compiler
+      # @see https://rubygems.org/gems/closure-compiler
+      #
+      # @since 0.1.0
+      # @api private
+      class ClosureJavascript < Javascript
+        # @since 0.1.0
+        # @api private
+        def initialize
+          @compressor = Closure::Compiler.new
+        end
+      end
+    end
+  end
+end