linner-hc 1.0.0

data/lib/linner.rb

@@ -0,0 +1,261 @@
+require "linner/version"
+require "linner/command"
+require "linner/asset"
+require "linner/cache"
+require "linner/helper"
+require "linner/sprite"
+require "linner/archive"
+require "linner/bundler"
+require "linner/reactor"
+require "linner/wrapper"
+require "linner/template"
+require "linner/notifier"
+require "linner/compressor"
+require "linner/environment"
+
+module Linner
+  extend self
+
+  attr_accessor :env, :compile, :strict
+
+  def root
+    @root ||= Pathname('.').realpath
+  end
+
+  def config_file
+    linner_file = root.join("Linnerfile")
+    config_file = root.join("config.yml")
+    File.exist?(linner_file) ? linner_file : config_file
+  end
+
+  def env
+    @env ||= Environment.new config_file
+  end
+
+  def cache
+    @cache ||= Cache.new
+  end
+
+  def manifest
+    @manifest ||= begin
+      hash = {}
+      copy_assets = []
+      concat_assets = []
+      template_assets = []
+      sprite_assets = []
+      cdn = env.revision["cdn"] || ""
+      prefix = env.revision["prefix"] || ""
+
+      env.groups.each do |config|
+        concat_assets << config["concat"].keys if config["concat"]
+        template_assets << config["template"].keys if config["template"]
+        sprite_assets << config["sprite"].keys if config["sprite"]
+        config["copy"].each do |dest, pattern|
+          copy_assets << Dir.glob(pattern).map do |path|
+            logical_path = Asset.new(path).logical_path
+            dest_path = File.join(dest, logical_path)
+          end
+        end if config["copy"]
+      end
+
+      # revision sprite assets
+      sprite_assets.flatten.each do |dest|
+        name = File.basename(dest).sub /[^.]+\z/, "png"
+        dest = File.join env.sprites["path"], name
+        asset = Asset.new(File.join env.public_folder, dest)
+        hash[prefix + dest] = cdn + prefix + asset.relative_digest_path
+        asset.revision!
+
+        (concat_assets + copy_assets).flatten.each do |file|
+          path = File.join env.public_folder, file
+          next unless Asset.new(path).stylesheet?
+          url = env.sprites["url"] || env.sprites["path"]
+          puts = File.read(path).gsub(File.join(url, File.basename(dest)), File.join(cdn, url, File.basename(asset.relative_digest_path)))
+          File.open(path, "w") { |file| file << puts }
+        end
+      end
+
+      # revision concat template and copy assets
+      (concat_assets + template_assets + copy_assets).flatten.each do |dest|
+        asset = Asset.new(File.join env.public_folder, dest)
+        next unless asset.revable?
+        hash[prefix + dest] = cdn + prefix + asset.relative_digest_path
+        asset.revision!
+      end
+
+      hash
+    end
+  end
+
+  def compile?
+    @compile
+  end
+
+  def strict?
+    @strict
+  end
+
+  def perform(*asset)
+    env.groups.each do |config|
+      precompile(config) if config["precompile"]
+      sprite(config) if config["sprite"]
+    end
+    env.groups.each do |config|
+      copy(config) if config["copy"]
+      compile(config) if config["compile"]
+      concat(config) if config["concat"]
+    end
+    env.groups.each do |config|
+      tar(config) if config["tar"]
+    end
+    revision if compile? and env.revision
+  end
+
+  private
+  def concat(config)
+    config["concat"].each_with_index do |pair, index|
+      dest, pattern, order = pair.first, pair.last, config["order"]||[]
+      matches = Dir.glob(pattern).sort_by(&:downcase).order_by(order)
+      next if matches.select {|path| cache.miss?(dest, path)}.empty?
+      write_asset(dest, matches)
+    end
+  end
+
+  def copy(config)
+    config["copy"].each do |dest, pattern|
+      Dir.glob(pattern).each do |path|
+        asset = Asset.new(path)
+        dest_path = File.join(env.public_folder, dest, asset.logical_path)
+        FileUtils.mkdir_p File.dirname(dest_path)
+        FileUtils.cp_r path, dest_path
+      end
+    end
+  end
+
+  def compile(config)
+    config["compile"].each do |dest, pattern|
+      Dir.glob(pattern).each do |path|
+        next if not cache.miss?(dest, path)
+        asset = Asset.new(path)
+        dest_path = File.join(env.public_folder, dest, asset.logical_path)
+        if asset.javascript? or asset.stylesheet?
+          asset.content
+          asset.compress if compile?
+          dest_path = dest_path.sub(/[^.]+\z/, "js") if asset.javascript?
+          dest_path = dest_path.sub(/[^.]+\z/, "css") if asset.stylesheet?
+          asset.path = dest_path
+          asset.write
+        elsif asset.eruby?
+          base, ext = path.split(".")
+          dest_path = if ext == "erb"
+            dest_path.sub(/[.]+\z/, "html")
+          else
+            dest_path.gsub(File.basename(dest_path), File.basename(dest_path, File.extname(dest_path)))
+          end
+          asset.content(config["context"])
+          asset.path = dest_path
+          asset.write
+        else
+          FileUtils.mkdir_p File.dirname(dest_path)
+          FileUtils.cp_r path, dest_path
+        end
+      end
+    end
+  end
+
+  def precompile(config)
+    config["precompile"].each do |dest, pattern|
+      matches = Dir.glob(pattern).sort_by(&:downcase)
+      next if matches.select { |path| cache.miss?(dest, path) }.empty?
+      write_template(dest, matches)
+    end
+  end
+
+  def sprite(config)
+    config["sprite"].each do |dest, pattern|
+      matches = Dir.glob(pattern).sort_by(&:downcase)
+      next if matches.select { |path| cache.miss?(dest, path) }.empty?
+      paint_sprite(dest, matches)
+    end
+  end
+
+  def tar(config)
+    config["tar"].each do |dest, pattern|
+      path = File.join(env.public_folder, dest)
+      FileUtils.mkdir_p File.dirname(path)
+      Archive.tar(pattern, path)
+    end
+  end
+
+  def revision
+    dump_manifest
+    files = env.revision["files"] || []
+    files.flatten.each do |rev|
+      file = File.join env.public_folder, rev.to_s
+      next if not File.exist?(file)
+      replace_attributes file
+    end
+  end
+
+  def paint_sprite(dest, images)
+    images = images.map do |path|
+      ImageProxy.new(path, ChunkyPNG::Image.from_file(path))
+    end
+    sprite = Sprite.new(images).pack!
+    map = ChunkyPNG::Image.new(sprite.root[:w], sprite.root[:h], ChunkyPNG::Color::TRANSPARENT)
+
+    sprite.images.each do |image|
+      map.compose!(image.image, image.left, image.top)
+    end
+
+    name = File.basename(dest).sub(/[^.]+\z/, "png")
+    path = File.join(env.public_folder, env.sprites["path"], name)
+    FileUtils.mkdir_p File.dirname(path)
+    map.save path
+
+    asset = Asset.new(File.join env.public_folder, dest)
+    asset.content = sprite.generate_style(env.sprites, name)
+    asset.write
+  end
+
+  def write_template(dest, child_assets)
+    asset = Asset.new(File.join env.public_folder, dest)
+    content = child_assets.inject("") {|s, m| s << cache["#{dest}:#{m}"].content}
+    asset.content = Wrapper::Template.definition(content)
+    asset.compress if compile?
+    asset.write
+  end
+
+  def write_asset(dest, child_assets)
+    asset = Asset.new(File.join env.public_folder, dest)
+    definition = (asset.path == env.definition ? Wrapper::Module.definition : "")
+    asset.content = child_assets.inject(definition) {|s, m| s << cache["#{dest}:#{m}"].content}
+    asset.compress if compile?
+    asset.write
+  end
+
+  def replace_attributes file
+    doc = File.read file
+    if strict?
+      doc.gsub!(/(<script.+src=['"])([^"']+)(["'])/) do |m|
+        if p = manifest[$2] then $1 << p << $3 else m end
+      end
+
+      doc.gsub!(/(<link[^\>]+href=['"])([^"']+)(["'])/) do |m|
+        if p = manifest[$2] then $1 << p << $3 else m end
+      end
+    else
+      manifest.each do |k, v|
+        doc.gsub!(k, v)
+      end
+    end
+    File.open(file, "w") {|f| f.write doc}
+  end
+
+  def dump_manifest
+    manifest_file = env.revision["manifest"] || "manifest.yml"
+    File.open(File.join(env.public_folder, manifest_file), "w") do |f|
+      YAML.dump(manifest, f)
+    end
+  end
+end

data/lib/linner/archive.rb

@@ -0,0 +1,53 @@
+require "rubygems/package"
+
+module Linner
+  class Archive
+
+    class << self
+      def tar(glob, dest)
+        archived = StringIO.new
+        Gem::Package::TarWriter.new(archived) do |tar|
+          Dir[glob].each do |file|
+            paths = Linner.env.paths
+            mode = File.stat(file).mode
+            relative_file = file.gsub /^#{paths.join("|")}\/?/, ""
+            if File.directory?(file)
+              tar.mkdir relative_file, mode
+            else
+              tar.add_file relative_file, mode do |tf|
+                File.open(file, "rb") { |f| tf.write f.read }
+              end
+            end
+          end
+        end
+
+        archived.rewind
+
+        Zlib::GzipWriter.open(dest) do |gz|
+          gz.write archived.string
+        end
+      end
+
+      def untar(path, dest)
+        extracted = Gem::Package::TarReader.new Zlib::GzipReader.open(path)
+
+        extracted.rewind
+
+        extracted.each do |entry|
+          file = File.join dest, entry.full_name
+          if entry.directory?
+            FileUtils.mkdir_p file
+          else
+            directory = File.dirname(file)
+            FileUtils.mkdir_p directory unless File.directory?(directory)
+            File.open file, "wb" do |f|
+              f.print entry.read
+            end
+          end
+        end
+
+        extracted.close
+      end
+    end
+  end
+end

data/lib/linner/asset.rb

@@ -0,0 +1,102 @@
+require "digest"
+
+module Linner
+  class Asset
+    class RenderError < StandardError; end
+
+    attr_accessor :path, :content
+
+    def initialize(path)
+      @path = path
+      @mtime = File.mtime(path).to_i if File.exist?(path)
+    end
+
+    def mtime
+      @mtime
+    end
+
+    def extname
+      @extname = File.extname path
+    end
+
+    def digest_path
+      digest = Digest::MD5.hexdigest content
+      path.chomp(extname) << "-#{digest}" << extname
+    end
+
+    def relative_digest_path
+      digest_path.gsub /#{Linner.env.public_folder}/, ""
+    end
+
+    def revable?
+      javascript? or stylesheet?
+    end
+
+    def revision!
+      File.rename path, digest_path
+    end
+
+    def content(context = nil)
+      return @content if @content
+      source = begin
+        File.exist?(path) ? Tilt.new(path, :default_encoding => "UTF-8").render(nil, context) : ""
+      rescue RuntimeError
+        File.read(path, mode: "rb")
+      rescue => e
+        raise RenderError, "#{e.message} in (#{path})"
+      end
+      if wrappable?
+        @content = wrap(source)
+      else
+        @content = source
+      end
+    end
+
+    def wrap(source)
+      if javascript?
+        Wrapper::Module.wrap(logical_path.chomp(File.extname logical_path), source)
+      elsif template?
+        if File.basename(path).start_with?("_")
+          Wrapper::Template.partial_wrap(logical_path.chomp(File.extname logical_path), source)
+        else
+          Wrapper::Template.wrap(logical_path.chomp(File.extname logical_path), source)
+        end
+      end
+    end
+
+    def javascript?
+      Tilt[path] and Tilt[path].default_mime_type == "application/javascript"
+    end
+
+    def stylesheet?
+      Tilt[path] and Tilt[path].default_mime_type == "text/css"
+    end
+
+    def template?
+      Tilt[path] and Tilt[path].default_mime_type == "text/template"
+    end
+
+    def eruby?
+      Tilt[path] and Tilt[path].default_mime_type = "application/x-eruby"
+    end
+
+    def wrappable?
+      !!(self.javascript? and !Linner.env.modules_ignored.include?(@path) or self.template?)
+    end
+
+    def write
+      FileUtils.mkdir_p File.dirname(@path)
+      File.open @path, "w" do |file|
+        file.write @content
+      end
+    end
+
+    def compress
+      @content = Compressor.compress(self)
+    end
+
+    def logical_path
+      @logical_path ||= @path.gsub(/^(#{Linner.env.paths.join("|")})\/?/, "")
+    end
+  end
+end

data/lib/linner/bundler.rb

@@ -0,0 +1,85 @@
+require "uri"
+require "digest"
+require "fileutils"
+require "open-uri"
+
+module Linner
+  class Bundler
+    REPOSITORY = File.expand_path "~/.linner/bundles"
+
+    Bundle = Struct.new(:name, :version, :url) do
+      def path
+        File.join(REPOSITORY, name, version, File.basename(url))
+      end
+    end
+
+    def initialize(env)
+      @bundles = []
+      env.bundles.each do |name, props|
+        @bundles << Bundle.new(name, props["version"], props["url"])
+      end
+      @vendor = Pathname(".").join env.vendor_folder
+    end
+
+    def check
+      return [false, "Bundles didn't exsit!"] unless File.exist? REPOSITORY
+      @bundles.each do |bundle|
+        unless File.exist?(bundle.path) and File.exist?(File.join(@vendor, bundle.name))
+          return [false, "Bundle #{bundle.name} v#{bundle.version} didn't match!"]
+        end
+      end
+      return [true, "Perfect bundled, ready to go!"]
+    end
+
+    def install
+      unless File.exist? REPOSITORY
+        FileUtils.mkdir_p(REPOSITORY)
+      end
+      @bundles.each do |bundle|
+        if bundle.version != "master"
+          next if File.exist?(bundle.path) and File.exist?(File.join(@vendor, bundle.name))
+        end
+        puts "Installing #{bundle.name} #{bundle.version}..."
+        install_to_repository bundle
+        if File.extname(bundle.path) == ".gz"
+          link_and_extract_to_vendor bundle.path, File.join(@vendor, ".pkg", bundle.name, File.basename(bundle.path)), File.join(@vendor, bundle.name)
+        else
+          link_to_vendor bundle.path, File.join(@vendor, bundle.name)
+        end
+      end
+    end
+
+    def perform
+      check and install
+    end
+
+    private
+    def install_to_repository(bundle)
+      FileUtils.mkdir_p File.dirname(bundle.path)
+      begin
+        File.open(bundle.path, "wb") do |dest|
+          if bundle.url =~ URI::regexp
+            open(bundle.url, "r:UTF-8") {|file| dest.write file.read}
+          else
+            dest.write(File.read Pathname(bundle.url).expand_path)
+          end
+        end
+      rescue
+        Notifier.error("Can't fetch bundle #{bundle.name} from #{bundle.url}")
+        Kernel::exit
+      end
+    end
+
+    def link_to_vendor(path, dest)
+      return if File.exist?(dest) and Digest::MD5.file(path).hexdigest == Digest::MD5.file(dest).hexdigest
+      FileUtils.mkdir_p File.dirname(dest)
+      FileUtils.cp path, dest
+    end
+
+    def link_and_extract_to_vendor(path, linked_path, dest)
+      link_to_vendor(path, linked_path)
+      FileUtils.rm_rf Dir.glob("#{dest}/*")
+      Archive.untar(path, dest)
+    end
+  end
+end