linner-hc 1.0.0

data/lib/linner/cache.rb

@@ -0,0 +1,19 @@
+module Linner
+  class Cache < Hash
+    def miss? ns, path
+      asset = Asset.new path
+      if self["#{ns}:#{path}"] and self["#{ns}:#{path}"].mtime == asset.mtime
+        false
+      else
+        self["#{ns}:#{path}"] = asset
+      end
+    end
+
+    def expire_by paths
+      is_include_partial_styles = paths.any? do |path|
+        Asset.new(path).stylesheet? and File.basename(path).start_with? "_"
+      end
+      self.reject! {|k, v| v.stylesheet?} if is_include_partial_styles
+    end
+  end
+end

data/lib/linner/command.rb

@@ -0,0 +1,133 @@
+require "thor"
+require "listen"
+
+module Linner
+  class Command < Thor
+    include Thor::Actions
+    map "-v" => :version
+
+    def self.source_root
+      File.dirname(__FILE__)
+    end
+
+    desc "version", "show version"
+    def version
+      puts Linner::VERSION
+    end
+
+    desc "check", "check dependencies"
+    method_option :environment,
+                  type: :string,
+                  default: "development",
+                  aliases: "-e",
+                  desc: "Watch the choosen environment"
+    def check
+      env.merge_with_environment(options[:environment])
+      message = Linner::Bundler.new(env).check
+      puts (message.first ? "🍵 :" : "👻 :") + message.last
+    end
+
+    desc "install", "install dependencies"
+    method_option :environment,
+                  type: :string,
+                  default: "development",
+                  aliases: "-e",
+                  desc: "Watch the choosen environment"
+    def install
+      begin
+        env.merge_with_environment(options[:environment])
+        Linner::Bundler.new(env).perform
+      rescue
+        puts "👻 : Install failed!"
+        puts $!
+        return
+      end
+      puts "🍵 : Perfect installed all bundles!"
+    end
+
+    desc "build", "build assets"
+    method_option :strict,
+                  type: :boolean,
+                  default: false,
+                  aliases: "-s",
+                  desc: "Use strict mode to replace revisiton."
+    method_option :environment,
+                  type: :string,
+                  default: "production",
+                  aliases: "-e",
+                  desc: "Build the choosen environment"
+    def build
+      Linner.compile = true
+      Linner.strict = true if options[:strict]
+      clean
+      env.merge_with_environment(options[:environment])
+      Bundler.new(env).perform
+      perform
+    rescue
+      Notifier.error $!
+    end
+
+    desc "watch", "watch assets"
+    method_option :environment,
+                  type: :string,
+                  default: "development",
+                  aliases: "-e",
+                  desc: "Watch the choosen environment"
+    def watch
+      clean
+      env.merge_with_environment(options[:environment])
+      Bundler.new(env).perform
+      perform
+      watch_for_env
+      watch_for_perform
+      watch_for_reload rescue nil
+      sleep
+    end
+
+    desc "clean", "clean assets"
+    def clean
+      FileUtils.rm_rf Dir.glob("#{env.public_folder}/*")
+    end
+
+    desc "new", "create the skeleton of project"
+    def new(name)
+      directory('templates', name)
+      chmod("#{name}/bin/server", 0755)
+    end
+
+  private
+    def env
+      Linner.env
+    end
+
+    def perform
+      Notifier.profile { Linner.perform }
+    end
+
+    def watch_for_perform
+      Listen.to env.watched_paths do |modified, added, removed|
+        Linner.cache.expire_by(modified + added + removed)
+        perform
+      end
+    end
+
+    def watch_for_reload
+      reactor = Reactor.supervise_as(:reactor).actors.first
+      Listen.to env.public_folder, relative_path: true do |modified, added, removed|
+        reactor.reload_browser(modified + added + removed)
+      end
+    end
+
+    def watch_for_env
+      Listen.to Linner.root, filter: /(config\.yml|Linnerfile)$/ do |modified, added, removed|
+        Linner.env = Environment.new Linner.config_file
+        Bundler.new(env).perform
+      end
+    end
+
+    def exit!
+      Notifier.exit
+      Kernel::exit
+    end
+  end
+end

data/lib/linner/compressor.rb

@@ -0,0 +1,17 @@
+require "uglifier"
+require "cssminify"
+
+module Linner
+  class Compressor
+
+    def self.compress(asset)
+      if asset.javascript? or asset.template?
+        Uglifier.compile asset.content, comments: "none"
+      elsif asset.stylesheet?
+        CSSminify.new.compress asset.content
+      else
+        asset.content
+      end
+    end
+  end
+end

data/lib/linner/environment.rb

@@ -0,0 +1,76 @@
+require "yaml"
+
+module Linner
+  class Environment
+
+    def initialize(path)
+      @env ||= (YAML::load(File.read path) || Hash.new)
+      merge_with_convension
+    end
+
+    %w(app test vendor public).each do |method|
+      define_method("#{method}_folder") do
+        @env["paths"][method]
+      end
+    end
+
+    def paths
+      groups.map { |group| group["paths"] }.flatten.uniq
+    end
+
+    def watched_paths
+      [app_folder, vendor_folder, test_folder].select do |path|
+        File.exist? path
+      end
+    end
+
+    %w(revision notification).each do |method|
+      define_method("#{method}") do
+        @env[method]
+      end
+    end
+
+    def manifest
+      revision["manifest"]
+    end
+
+    def bundles
+      @env["bundles"] || []
+    end
+
+    def sprites
+      @env["sprites"] || {}
+    end
+
+    def modules_ignored
+      Dir.glob(@env["modules"]["ignored"])
+    end
+
+    def wrapper
+      @env["modules"]["wrapper"]
+    end
+
+    def definition
+      File.join public_folder, @env["modules"]["definition"]
+    end
+
+    def groups
+      @env["groups"].values
+    end
+
+    def environments
+      @env["environments"] || {}
+    end
+
+    def merge_with_environment(environment)
+      return @env unless picked = environments[environment]
+      @env = @env.rmerge!(picked)
+    end
+
+    private
+    def merge_with_convension
+      convension = YAML::load File.read(File.join File.dirname(__FILE__), "../../vendor", "config.default.yml")
+      @env = convension.rmerge!(@env)
+    end
+  end
+end

data/lib/linner/helper.rb

@@ -0,0 +1,39 @@
+module Linner
+  module HashRecursiveMerge
+    def rmerge!(other_hash)
+      merge!(other_hash) do |key, oldval, newval|
+        oldval.class == self.class ? oldval.rmerge!(newval) : newval
+      end
+    end
+  end
+
+  module Order
+    def order_by(ary)
+      ary << "..." if not ary.include? "..."
+      order_ary = ary.inject([[]]) do |a, x|
+        x != "..." ? a.last << x : a<< []; a
+      end
+      order_by_direction(order_ary.first, :before)
+      order_by_direction(order_ary.last, :after)
+      self
+    end
+
+  private
+    def order_by_direction(ary, direction)
+      ary = ary.reverse if direction == :before
+      ary.each do |f|
+        next unless i = self.index {|x| x =~ /#{f}/i}
+        item = self.delete_at i
+        direction == :before ? self.unshift(item) : self.push(item)
+      end
+    end
+  end
+end
+
+class Hash
+  include Linner::HashRecursiveMerge
+end
+
+class Array
+  include Linner::Order
+end

data/lib/linner/notifier.rb

@@ -0,0 +1,24 @@
+require "terminal-notifier"
+
+module Linner
+  class Notifier
+    class << self
+      def profile
+        time = Time.now
+        yield
+        puts "🍜 : Done in #{"%.3f" % (Time.now - time)}s."
+      end
+
+      def error(message)
+        abort message = "👻 : #{message}!"
+        if Linner.env.notification && TerminalNotifier.available?
+          TerminalNotifier.notify message, :title => "Linner"
+        end
+      end
+
+      def exit
+        puts "\r🍵 : Let's take a break!"
+      end
+    end
+  end
+end

data/lib/linner/reactor.rb

@@ -0,0 +1,87 @@
+require "reel"
+require "json"
+
+module Linner
+  class Reactor < Reel::Server::HTTP
+    include Celluloid
+
+    Celluloid.logger = nil
+
+    attr_accessor :clients
+
+    def initialize(host = "127.0.0.1", port = 35729)
+      @clients = []
+      super(host, port, &method(:on_connection))
+    end
+
+    def on_connection(connection)
+      while request = connection.request
+        if request.websocket?
+          connection.detach
+          route_websocket request.websocket
+          return
+        else
+          route_request connection, request
+        end
+      end
+    end
+
+    def route_request(connection, request)
+      if request.url.start_with? "/livereload.js"
+        return connection.respond :ok, {"Content_Type" => 'application/ecmascript'}, File.read(File.join(File.dirname(__FILE__), "../../vendor", "livereload.js"))
+      end
+
+      path = File.join(Linner.environment.public_folder, request.url[1..-1])
+      if File.exist?(path)
+        content_type = case File.extname(path)
+        when '.css' then 'text/css'
+        when '.js' then 'application/ecmascript'
+        when '.gif' then 'image/gif'
+        when '.jpeg', '.jpg' then 'image/jpeg'
+        when '.png' then 'image/png'
+        else; 'text/plain'
+        end
+        return connection.respond :ok, {"Content_Type" => content_type, "Content_Length" => File.size(path)}, File.read(path)
+      end
+
+      connection.respond :not_found, "Not found"
+    end
+
+    def route_websocket(socket)
+      socket << JSON.generate({
+        :command    => 'hello',
+        :protocols  => ['http://livereload.com/protocols/official-7'],
+        :serverName => 'reel-livereload'
+      })
+      if socket.url == "/livereload"
+        @clients << Client.new(socket)
+      else
+        socket.close
+      end
+    end
+
+    def reload_browser(paths = [])
+      paths.each do |path|
+        @clients.each {|c| c.notify_asset_change path }
+      end
+    end
+
+    class Client
+      include Celluloid
+
+      def initialize(socket)
+        @socket = socket
+      end
+
+      def notify_asset_change(path)
+        data = {
+          :path     => path,
+          :command  => 'reload',
+          :liveCSS  => true
+        }
+        @socket << JSON.generate(data)
+      rescue
+      end
+    end
+  end
+end

data/lib/linner/sprite.rb

@@ -0,0 +1,127 @@
+require "chunky_png"
+
+module Linner
+  ImageProxy = Struct.new(:path, :image, :top, :left) do
+    def width
+      image.width
+    end
+
+    def height
+      image.height
+    end
+  end
+
+  class Sprite
+
+    attr_accessor :root, :images
+
+    def initialize(images)
+      @images = images.sort do |a, b|
+        diff = [b.width, b.height].max <=> [a.width, a.height].max
+        diff = [b.width, b.height].min <=> [a.width, a.height].min if diff.zero?
+        diff = b.height <=> a.height if diff.zero?
+        diff = b.width <=> a.width if diff.zero?
+        diff
+      end
+
+      @root = { :x => 0, :y => 0, :w => @images.first.width, :h => @images.first.height}
+    end
+
+    def pack!
+      @images.each do |image|
+        if block = find_block(@root, image)
+          place_image(block, image)
+          split_block(block, image)
+        else
+          @root = expand_root(@root, image)
+          redo
+        end
+      end
+      self
+    end
+
+    def generate_style(config, name)
+      selector = config["selector"] || ".icon-"
+      url = config['url'] || config['path']
+      @images.inject("") do |style, image|
+        logical_path = Asset.new(image.path).logical_path
+        selector_with_pseudo_class = logical_path.chomp(File.extname(logical_path))
+          .gsub("/", "-")
+          .gsub("_active", ".active")
+          .gsub("_hover", ":hover")
+          .gsub("_", "-")
+        style <<
+"#{selector}#{selector_with_pseudo_class} {
+  width: #{image.width}px;
+  height: #{image.height}px;
+  background: url(#{File.join url, name}) -#{image.left}px -#{image.top}px no-repeat;
+}
+"
+      end
+    end
+
+    private
+    def find_block(root, image)
+      if root[:used]
+        find_block(root[:right], image) || find_block(root[:down], image)
+      elsif (image.width <= root[:w]) && (image.height <= root[:h])
+        root
+      end
+    end
+
+    def place_image(block, image)
+      image.top = block[:y]
+      image.left = block[:x]
+    end
+
+    def split_block(block, image)
+      block[:used] = true
+      block[:down] = {:x => block[:x], :y => block[:y] + image.height, :w => block[:w], :h => block[:h] - image.height}
+      block[:right] = {:x => block[:x] + image.width, :y => block[:y], :w => block[:w] - image.width, :h => image.height}
+    end
+
+    def expand_root(root, image)
+      can_expand_down  = (image.width <= root[:w])
+      can_expand_right = (image.height <= root[:h])
+
+      should_expand_down  = can_expand_down  && (root[:w] >= (root[:h] + image.height))
+      should_expand_right = can_expand_right && (root[:h] >= (root[:w] + image.width))
+
+      if should_expand_right
+        expand_right(root, image.width)
+      elsif should_expand_down
+        expand_down(root, image.height)
+      elsif can_expand_right
+        expand_right(root, image.width)
+      elsif can_expand_down
+        expand_down(root, image.height)
+      else
+        raise RuntimeError, "Crashed!"
+      end
+    end
+
+    def expand_right(root, width)
+      Hash[
+        :used  => true,
+        :x     => 0,
+        :y     => 0,
+        :w     => root[:w] + width,
+        :h     => root[:h],
+        :down  => root,
+        :right => { :x => root[:w], :y => 0, :w => width, :h => root[:h] }
+      ]
+    end
+
+    def expand_down(root, height)
+      Hash[
+        :used  => true,
+        :x     => 0,
+        :y     => 0,
+        :w     => root[:w],
+        :h     => root[:h] + height,
+        :down  => { :x => 0, :y => root[:h], :w => root[:w], :h => height },
+        :right => root
+      ]
+    end
+  end # Sprite
+end # Linner