wake-assets 0.2.0

data/README.md

@@ -0,0 +1,126 @@
+# Wake::Assets
+
+This module helps you render links to assets managed using
+[wake](http://github.com/jcoglan/wake). It's easy to set up and works with any
+Ruby web framework.
+
+
+## Installation
+
+```
+$ gem install wake-assets
+```
+
+
+## Usage
+
+These examples are based on the [wake example build
+config](https://github.com/jcoglan/wake#usage).
+
+#### At boot time
+
+When your app boots, create an instance of `Wake::Assets` and keep this object
+around through the lifetime of the app process. For example, in Rails:
+
+```ruby
+require 'wake/assets'
+
+dev = Rails.env.development?
+
+$wake = Wake::Assets.new(
+  :wake    => File.expand_path('node_modules/.bin/wake', Rails.root),
+  :root    => File.expand_path('public', Rails.root),
+  :mode    => dev ? :sources : :targets,
+  :monitor => dev
+)
+```
+
+The options are:
+
+* `:wake` - the path to your `wake` executable
+* `:root` - the document root of your application
+* `:mode` - `:sources` if you want to render links to source files, `:targets`
+  if you want optimised files
+* `:monitor` - whether to monitor the filesystem for changes, recommended in
+  development but not in production
+
+#### At request time
+
+On each request, create a renderer from your `Assets` instance. In Rails, you
+might do this with a helper:
+
+```ruby
+module AssetsHelper
+  CONFIG_PATH = File.expand_path('package.json', Rails.root)
+  ASSET_HOSTS = JSON.parse(File.read(CONFIG_PATH))['wake']['css']['hosts']
+
+  def assets
+    @assets ||= $wake.renderer(
+      :builds => {
+        'css'        => request.ssl? ? 'ssl' : 'min',
+        'javascript' => 'min',
+        'binary'     => 'min'
+      },
+      :hosts  => ASSET_HOSTS[Rails.env][request.ssl? ? 'https' : 'http'],
+      :inline => false
+    )
+  end
+end
+```
+
+The options are:
+
+* `:builds` - which build to use for each asset type, the default for each is
+  `min`
+* `:hosts` - the set of asset hosts to use for rendering links, the default is
+  an empty list
+* `:inline` - whether to render assets inline so the browser does not make
+  additional requests for them, default is `false`
+
+#### In your templates
+
+With this helper in place, you can render links to JavaScript, CSS and images:
+
+```ruby
+assets.include_js 'scripts.js'
+# => '<script type="text/javascript" src="/assets/scripts-bb210c6.js"></script>'
+
+assets.include_css 'style.css'
+# => '<link rel="stylesheet" type="text/css" href="/assets/styles-5a2ceb1.css">'
+
+assets.include_image 'logo.png', :html => {:alt => 'Logo'}
+# => '<img src="/assets/logo-2fa8d38.png" alt="Logo">'
+```
+
+You can pass the `:inline` option to any of these to override the per-request
+`:inline` setting:
+
+```ruby
+assets.include_js 'scripts.js', :inline => true
+# => '<script type="text/javascript">alert("Hello, world!")</script>'
+```
+
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2013 James Coglan, Songkick
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the 'Software'), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/lib/wake.rb

@@ -0,0 +1,6 @@
+module Wake
+  root = File.expand_path('../wake', __FILE__)
+  autoload :Assets, root + '/assets'
+  autoload :Renderer, root + '/renderer'
+end
+

data/lib/wake/assets.rb

@@ -0,0 +1,148 @@
+require 'base64'
+require 'erb'
+require 'json'
+require 'listen'
+require 'mime/types'
+require 'pathname'
+require 'set'
+
+module Wake
+  class Assets
+
+    DEFAULT_BUILD = 'min'
+    DEFAULT_MODE  = :targets
+    DEFAULT_WAKE  = './node_modules/wake/bin/wake'
+    CACHE_FILE    = '.wake.json'
+    MANIFEST      = '.manifest.json'
+    PACKAGE_FILE  = 'package.json'
+    WAKE_FILE     = 'wake.json'
+    CONFIG_FILES  = Set.new([CACHE_FILE, MANIFEST, PACKAGE_FILE, WAKE_FILE])
+
+    CSS = 'css'
+    JS  = 'javascript'
+    IMG = 'binary'
+
+    class InvalidReference < StandardError
+    end
+
+    autoload :Renderer, File.expand_path('../assets/renderer', __FILE__)
+
+    def initialize(options)
+      @pwd      = File.expand_path(options.fetch(:pwd, Dir.pwd))
+      @wake     = options.fetch(:wake, File.expand_path(DEFAULT_WAKE, @pwd))
+      @root     = Pathname.new(File.expand_path(options.fetch(:root, @pwd)))
+      @mode     = options.fetch(:mode, DEFAULT_MODE)
+      @manifest = new_manifest_cache
+      @paths    = new_path_cache
+
+      system(@wake, '--cache')
+      read_config
+
+      return unless options[:monitor]
+
+      listener = Listen.to(@pwd).change do |modified, added, removed|
+        all = (modified + added + removed).map &File.method(:basename)
+        system(@wake, '--cache') if (added.any? or removed.any?) and not all.include?(CACHE_FILE)
+        update! if (CONFIG_FILES & all).any?
+      end
+      listener.force_polling(true)
+      listener.start
+    end
+
+    def deployment?
+      @mode == :targets
+    end
+
+    def paths_for(group, names, options = {})
+      build = options.fetch(:build, DEFAULT_BUILD)
+      unless @config[group].fetch('builds', {}).has_key?(build)
+        build = DEFAULT_BUILD
+      end
+      names.map { |name| @paths[group][name][build] }.flatten
+    end
+
+    def relative(path)
+      '/' + Pathname.new(path).relative_path_from(@root).to_s
+    end
+
+    def renderer(options = {})
+      Renderer.new(self, options)
+    end
+
+  private
+
+    def find_paths_for(group, name, build)
+      absolute_paths = begin
+        cache = @cache[group][name]
+        if @mode.to_s == 'sources'
+          cache.fetch('sources')
+        else
+          [cache.fetch('targets').fetch(build)]
+        end
+      rescue
+        nil
+      end
+
+      if absolute_paths.nil?
+        raise InvalidReference, "Could not find assets, group: #{group}, name: #{name}, build: #{build}"
+      end
+
+      absolute_paths.map do |path|
+        basename = File.basename(path)
+        dirname  = File.dirname(path)
+        manifest = File.join(dirname, MANIFEST)
+
+        File.join(dirname, @manifest[manifest].fetch(basename, basename))
+      end
+    end
+
+    def new_manifest_cache
+      Hash.new do |hash, path|
+        hash[path] = File.file?(path) ? JSON.parse(File.read(path)) : {}
+      end
+    end
+
+    def new_path_cache
+      Hash.new do |h, group|
+        h[group] = Hash.new do |i, name|
+          i[name] = Hash.new do |j, build|
+            j[build] = find_paths_for(group, name, build)
+          end
+        end
+      end
+    end
+
+    def read_config
+      cache   = File.join(@pwd, CACHE_FILE)
+      wake    = File.join(@pwd, WAKE_FILE)
+      package = File.join(@pwd, PACKAGE_FILE)
+
+      @config = if File.file?(wake)
+                  JSON.parse(File.read(wake))
+                elsif File.file?(package)
+                  JSON.parse(File.read(package))['wake']
+                else
+                  {}
+                end
+
+      @cache = JSON.parse(File.read(cache))
+    end
+
+    def update!
+      paths = new_path_cache
+      read_config
+
+      @paths.each do |group, a|
+        a.each do |name, b|
+          b.each do |build, files|
+            paths[group][name][build]
+          end
+        end
+      end
+      @manifest = new_manifest_cache
+      @paths    = paths
+    end
+
+  end
+end
+

data/lib/wake/assets/renderer.rb

@@ -0,0 +1,100 @@
+module Wake
+  class Assets
+    class Renderer
+
+      def initialize(assets, options)
+        @assets = assets
+        @builds = options.fetch(:builds, {})
+        @hosts  = options.fetch(:hosts, [])
+        @inline = options[:inline]
+      end
+
+      def include_css(*names)
+        names, options = extract_options(names)
+
+        tags = if options.fetch(:inline, @inline)
+                 paths_for(CSS, names, options).map do |path|
+                   %Q{#{tag :style, options, :type => 'text/css'}#{File.read path}</style>}
+                 end
+               else
+                 urls_for(CSS, names, options).map do |url|
+                   tag :link, options, :rel => 'stylesheet', :type => 'text/css', :href => url
+                 end
+               end
+
+        html_safe(tags * '')
+      end
+
+      def include_image(*names)
+        names, options = extract_options(names)
+
+        tags = if options.fetch(:inline, @inline)
+                 paths_for(IMG, names, options).map do |path|
+                   base64 = Base64.strict_encode64(File.read(path))
+                   mime   = MIME::Types.type_for(path).first
+                   tag :img, options, :src => "data:#{mime};base64,#{base64}"
+                 end
+               else
+                 urls_for(IMG, names, options).map { |url| tag :img, options, :src => url }
+               end
+
+        html_safe(tags * '')
+      end
+
+      def include_js(*names)
+        names, options = extract_options(names)
+
+        tags = if options.fetch(:inline, @inline)
+                 paths_for(JS, names, options).map do |path|
+                   %Q{#{tag :script, options, :type => 'text/javascript'}#{File.read path}</script>}
+                 end
+               else
+                 urls_for(JS, names, options).map do |url|
+                   %Q{#{tag :script, options, :type => 'text/javascript', :src => url}</script>}
+                 end
+               end
+
+        html_safe(tags * '')
+      end
+
+      def paths_for(type, names, options = {})
+        @assets.paths_for(type, names, {:build => @builds[type]}.merge(options))
+      end
+
+      def urls_for(type, names, options = {})
+        paths = paths_for(type, names, options).map { |p| @assets.relative(p) }
+
+        return paths unless @hosts.any?
+
+        paths.map do |path|
+          @hosts[path.hash % @hosts.size].gsub(/\/*$/, '') + path
+        end
+      end
+
+    private
+
+      def extract_options(names)
+        [names.grep(String), names.grep(Hash).first || {}]
+      end
+
+      def h(string)
+        ERB::Util.html_escape(string)
+      end
+
+      def html_safe(string)
+        if defined? ActiveSupport
+          ActiveSupport::SafeBuffer.new(string)
+        else
+          string
+        end
+      end
+
+      def tag(name, options, attrs)
+        attrs = attrs.merge(options.fetch(:html, {}))
+        "<#{name} #{ attrs.map { |k,v| %Q{#{k}="#{h v.to_s}"} }.join(' ') }>"
+      end
+
+    end
+  end
+end
+

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: wake-assets
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- James Coglan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: jcoglan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/wake.rb
+- lib/wake/assets.rb
+- lib/wake/assets/renderer.rb
+homepage: http://github.com/jcoglan/wake-assets
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+- --markup
+- markdown
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Renders links to assets managed by wake
+test_files: []