hanami-assets 0.0.0 → 0.2.0

data/bin/hanami-assets

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'pathname'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: hanami-assets --config=path/to/config.rb"
+
+  opts.on("-c", "--config FILE", "Path to config") do |c|
+    options[:config] = c
+  end
+end.parse!
+
+config = options.fetch(:config) { raise ArgumentError.new("You must specify a configuration file") }
+config = Pathname.new(config)
+config.exist? or raise ArgumentError.new("Cannot find configuration file: #{ config }")
+
+require 'hanami/assets'
+load config
+
+Hanami::Assets.deploy

data/hanami-assets.gemspec

@@ -4,20 +4,34 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'hanami/assets/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "hanami-assets"
+  spec.name          = 'hanami-assets'
   spec.version       = Hanami::Assets::VERSION
-  spec.authors       = ["Luca Guidi"]
-  spec.email         = ["me@lucaguidi.com"]
+  spec.authors       = ['Luca Guidi', 'Trung Lê', 'Alfonso Uceda']
+  spec.email         = ['me@lucaguidi.com', 'trung.le@ruby-journal.com', 'uceda73@gmail.com']
+  spec.summary       = %q{Assets management}
+  spec.description   = %q{Assets management for Ruby web applications}
+  spec.homepage      = 'http://hanamirb.org'
+  spec.license       = 'MIT'
 
-  spec.summary       = %q{The web, with simplicity}
-  spec.description   = %q{Hanami is a web framework for Ruby}
-  spec.homepage      = "http://hanamirb.org"
+  spec.files         = `git ls-files -- lib/* bin/* CHANGELOG.md LICENSE.md README.md hanami-assets.gemspec`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.0.0'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency 'hanami-utils',    '~> 0.7'
+  spec.add_runtime_dependency 'hanami-helpers',  '~> 0.3'
+  spec.add_runtime_dependency 'tilt',            '~> 2.0', '>= 2.0.2'
 
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'bundler',          '~> 1.6'
+  spec.add_development_dependency 'rake',             '~> 10'
+  spec.add_development_dependency 'minitest',         '~> 5'
+
+  spec.add_development_dependency 'yui-compressor',   '~> 0.12'
+  spec.add_development_dependency 'uglifier',         '~> 2.7'
+  spec.add_development_dependency 'closure-compiler', '~> 1.1'
+  spec.add_development_dependency 'sass',             '~> 3.4'
+
+  spec.add_development_dependency 'coffee-script',    '~> 2.3'
+  spec.add_development_dependency 'babel-transpiler', '~> 0.7'
 end

data/lib/hanami/assets.rb

@@ -1,7 +1,158 @@
-require "hanami/assets/version"
+require 'thread'
+require 'hanami/utils/class_attribute'
 
 module Hanami
+  # Assets management for Ruby web applications
+  #
+  # @since 0.1.0
   module Assets
-    # Your code goes here...
+    # Base error for Hanami::Assets
+    #
+    # All the errors defined in this framework MUST inherit from it.
+    #
+    # @since 0.1.0
+    class Error < ::StandardError
+    end
+
+    require 'hanami/assets/version'
+    require 'hanami/assets/configuration'
+    require 'hanami/assets/config/global_sources'
+    require 'hanami/assets/helpers'
+
+    include Utils::ClassAttribute
+
+    # Configuration
+    #
+    # @since 0.1.0
+    # @api private
+    class_attribute :configuration
+    self.configuration = Configuration.new
+
+    # Configure framework
+    #
+    # @param blk [Proc] configuration code block
+    #
+    # @return self
+    #
+    # @since 0.1.0
+    #
+    # @see Hanami::Assets::Configuration
+    def self.configure(&blk)
+      configuration.instance_eval(&blk)
+      self
+    end
+
+    # Prepare assets for deploys
+    #
+    # @since 0.1.0
+    def self.deploy
+      require 'hanami/assets/precompiler'
+      require 'hanami/assets/bundler'
+
+      Precompiler.new(configuration, duplicates).run
+      Bundler.new(configuration,     duplicates).run
+    end
+
+    # Preload the framework
+    #
+    # This MUST be used in production mode
+    #
+    # @since 0.1.0
+    #
+    # @example Direct Invocation
+    #   require 'hanami/assets'
+    #
+    #   Hanami::Assets.load!
+    #
+    # @example Load Via Configuration Block
+    #   require 'hanami/assets'
+    #
+    #   Hanami::Assets.configure do
+    #     # ...
+    #   end.load!
+    def self.load!
+      configuration.load!
+    end
+
+    # Global assets sources
+    #
+    # This is designed for third party integration gems with frontend frameworks
+    # like Bootstrap, Ember.js or React.
+    #
+    # Developers can maintain gems that ship static assets for these frameworks
+    # and make them available to Hanami::Assets.
+    #
+    # @return [Hanami::Assets::Config::GlobalSources]
+    #
+    # @since 0.1.0
+    #
+    # @example Ember.js Integration
+    #   # lib/hanami/emberjs.rb (third party gem)
+    #   require 'hanami/assets'
+    #
+    #   Hanami::Assets.sources << '/path/to/emberjs/assets'
+    def self.sources
+      synchronize do
+        @@sources ||= Config::GlobalSources.new
+      end
+    end
+
+    # Duplicate the framework and generate modules for the target application
+    #
+    # @param mod [Module] the Ruby namespace of the application
+    # @param blk [Proc] an optional block to configure the framework
+    #
+    # @return [Module] a copy of Hanami::Assets
+    #
+    # @since 0.1.0
+    #
+    # @see Hanami::Assets#dupe
+    # @see Hanami::Assets::Configuration
+    def self.duplicate(mod, &blk)
+      dupe.tap do |duplicated|
+        duplicated.configure(&blk) if block_given?
+        duplicates << duplicated
+      end
+    end
+
+    # Duplicate Hanami::Assets in order to create a new separated instance
+    # of the framework.
+    #
+    # The new instance of the framework will be completely decoupled from the
+    # original. It will inherit the configuration, but all the changes that
+    # happen after the duplication, won't be reflected on the other copies.
+    #
+    # @return [Module] a copy of Hanami::Assets
+    #
+    # @since 0.1.0
+    # @api private
+    def self.dupe
+      dup.tap do |duplicated|
+        duplicated.configuration = configuration.duplicate
+      end
+    end
+
+    # Keep track of duplicated frameworks
+    #
+    # @return [Array] a collection of duplicated frameworks
+    #
+    # @since 0.1.0
+    # @api private
+    #
+    # @see Hanami::Assets#duplicate
+    # @see Hanami::Assets#dupe
+    def self.duplicates
+      synchronize do
+        @@duplicates ||= Array.new
+      end
+    end
+
+    private
+
+    # @since 0.1.0
+    # @api private
+    def self.synchronize(&blk)
+      Mutex.new.synchronize(&blk)
+    end
   end
 end

data/lib/hanami/assets/bundler.rb

@@ -0,0 +1,173 @@
+require 'digest'
+require 'fileutils'
+require 'json'
+
+module Hanami
+  module Assets
+    # Bundle assets from a single application.
+    #
+    # @since 0.1.0
+    # @api private
+    class Bundler
+      # @since 0.1.0
+      # @api private
+      DEFAULT_PERMISSIONS = 0644
+
+      # @since 0.1.0
+      # @api private
+      JAVASCRIPT_EXT      = '.js'.freeze
+
+      # @since 0.1.0
+      # @api private
+      STYLESHEET_EXT      = '.css'.freeze
+
+      # @since 0.1.0
+      # @api private
+      WILDCARD_EXT        = '.*'.freeze
+
+      # @since 0.1.0
+      # @api private
+      URL_SEPARATOR       = '/'.freeze
+
+      # @since 0.1.0
+      # @api private
+      URL_REPLACEMENT     = ''.freeze
+
+      # Return a new instance
+      #
+      # @param configuration [Hanami::Assets::Configuration] a single application configuration
+      #
+      # @param duplicates [Array<Hanami::Assets>] the duplicated frameworks
+      #   (one for each application)
+      #
+      # @return [Hanami::Assets::Bundler] a new instance
+      #
+      # @since 0.1.0
+      # @api private
+      def initialize(configuration, duplicates)
+        @manifest       = Hash.new
+        @configuration  = configuration
+        @configurations = if duplicates.empty?
+                            [@configuration]
+                          else
+                            duplicates.map(&:configuration)
+                          end
+      end
+
+      # Start the process.
+      #
+      # For each asset contained in the sources and third party gems, it will:
+      #
+      #   * Compress
+      #   * Create a checksum version
+      #
+      # At the end it will generate a digest manifest
+      #
+      # @see Hanami::Assets::Configuration#digest
+      # @see Hanami::Assets::Configuration#manifest
+      # @see Hanami::Assets::Configuration#manifest_path
+      def run
+        assets.each do |asset|
+          next if ::File.directory?(asset)
+
+          compress(asset)
+          checksum(asset)
+        end
+
+        generate_manifest
+      end
+
+      private
+
+      # @since 0.1.0
+      # @api private
+      def assets
+        Dir.glob("#{ public_directory }#{ ::File::SEPARATOR }**#{ ::File::SEPARATOR }*")
+      end
+
+      # @since 0.1.0
+      # @api private
+      def compress(asset)
+        case File.extname(asset)
+        when JAVASCRIPT_EXT then _compress(compressor(:js, asset),  asset)
+        when STYLESHEET_EXT then _compress(compressor(:css, asset), asset)
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      def checksum(asset)
+        digest        = Digest::MD5.file(asset)
+        filename, ext = ::File.basename(asset, WILDCARD_EXT), ::File.extname(asset)
+        directory     = ::File.dirname(asset)
+        target        = [directory, "#{ filename }-#{ digest }#{ ext }"].join(::File::SEPARATOR)
+
+        FileUtils.cp(asset, target)
+        _set_permissions(target)
+
+        store_manifest(asset, target)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def generate_manifest
+        _write(@configuration.manifest_path, JSON.dump(@manifest))
+      end
+
+      # @since 0.1.0
+      # @api private
+      def store_manifest(asset, target)
+        @manifest[_convert_to_url(::File.expand_path(asset))] = _convert_to_url(::File.expand_path(target))
+      end
+
+      # @since 0.1.0
+      # @api private
+      def compressor(type, asset)
+        _configuration_for(asset).__send__(:"#{ type }_compressor")
+      end
+
+      # @since 0.1.0
+      # @api private
+      def _compress(compressor, asset)
+        _write(asset, compressor.compress(asset))
+      rescue => e
+        warn "Skipping compression of: `#{ asset }'\nReason: #{ e }\n\t#{ e.backtrace.join("\n\t") }\n\n"
+      end
+
+      # @since 0.1.0
+      # @api private
+      def _convert_to_url(path)
+        path.sub(public_directory.to_s, URL_REPLACEMENT).
+          gsub(File::SEPARATOR, URL_SEPARATOR)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def _write(path, content)
+        Pathname.new(path).dirname.mkpath
+        ::File.write(path, content)
+
+        _set_permissions(path)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def _set_permissions(path)
+        ::File.chmod(DEFAULT_PERMISSIONS, path)
+      end
+
+      def _configuration_for(asset)
+        url = _convert_to_url(asset)
+
+        @configurations.find {|config| url.start_with?(config.prefix) } ||
+          @configuration
+      end
+
+      # @since 0.1.0
+      # @api private
+      def public_directory
+        @configuration.public_directory
+      end
+    end
+  end
+end

data/lib/hanami/assets/cache.rb

@@ -0,0 +1,58 @@
+require 'thread'
+
+module Hanami
+  module Assets
+    # Store assets references when compile mode is on.
+    #
+    # This is expecially useful in development mode, where we want to compile
+    # only the assets that were changed from last browser refresh.
+    #
+    # @since 0.1.0
+    # @api private
+    class Cache
+      # Return a new instance
+      #
+      # @return [Hanami::Assets::Cache] a new instance
+      def initialize
+        @data  = Hash.new{|h,k| h[k] = 0 }
+        @mutex = Mutex.new
+      end
+
+      # Check if the given file is fresh or changed from last check.
+      #
+      # @param file [String,Pathname] the file path
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.1.0
+      # @api private
+      def fresh?(file)
+        @mutex.synchronize do
+          @data[file.to_s] < mtime(file)
+        end
+      end
+
+      # Store the given file reference
+      #
+      # @param file [String,Pathname] the file path
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.1.0
+      # @api private
+      def store(file)
+        @mutex.synchronize do
+          @data[file.to_s] = mtime(file)
+        end
+      end
+
+      private
+
+      # @since 0.1.0
+      # @api private
+      def mtime(file)
+        file.mtime.utc.to_i
+      end
+    end
+  end
+end