gluey 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2fde00ea1efaad06ddc4780ae8cd89ba0608d2c3
+  data.tar.gz: d51d6124fbecf62a1bab250a7e8f62e0f9fda44d
+SHA512:
+  metadata.gz: 8be79aa84654f1e3b1ce3f6e220cb8bd767eef34593503809c06d92ed01c7f024ce1ef2f9878cffc35bff50983557b562e8dcebd1f93822b808297a4a27c083b
+  data.tar.gz: 177013b823b9a1bd66aaa8773e5fc501df265ceef0550afb15547b3962288598a53a5feb1f0cd336e3419f38c5bd1c11045660c3e20e31655131b428c1f8bbba

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gluey.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 doooby
+
+MIT License
+
+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/README.md

@@ -0,0 +1,37 @@
+# Gluey
+
+This is my custom alternative for processing assets in ruby web apps. Firt, there was just dislike in sprockets
+(and their integration into rails), but then i realized it's not that big a deal to write my own caching and processing system.
+This has unlimited abilities, because it's very easy to write custom directives (that headers in assets that you know from
+sprockets). For example, you can precompile handlebars a nd insert them into page's js file as an object (it cannot be easier).
+You can append, prepend, insert (...) other files, merge them into one asset, that you wanth to hit on
+particular http path. There is no docs nor test for now, and probably never will be, but the code should not be hard
+to read, so if you're interested, just digg into the code itself.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gluey'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gluey
+
+## Usage
+
+ look at my nesselsburg2 integration (a repository just next door)
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/gluey/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/gluey.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gluey/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'gluey'
+  spec.version       = Gluey::VERSION
+  spec.authors       = ['doooby']
+  spec.email         = ['zelazk.o@email.cz']
+  spec.summary       = 'Rails\' asset pipelane replacement'
+  spec.description   = %q{Concatenating and processing asset files with possibly complicated dependencies.}
+  # spec.homepage      = ""
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  # 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.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/lib/gluey/dependencies/directory.rb

@@ -0,0 +1,29 @@
+require_relative 'single_file'
+
+module Gluey::Dependencies
+  class Directory < SingleFile
+
+    def initialize(dir, dir_pattern=nil)
+      @dir_pattern = "#{dir}/#{ dir_pattern || '**/*' }"
+      super dir
+    end
+
+    def actualize
+      @files_list = files_list
+      super
+    end
+
+    def changed?
+      @files_list != files_list
+    end
+
+    def exists?
+      Dir.exists? @file
+    end
+
+    def files_list
+      Dir[@dir_pattern]
+    end
+
+  end
+end

data/lib/gluey/dependencies/handlebars_bundle.rb

@@ -0,0 +1,62 @@
+require 'handlebars'
+require_relative 'directory'
+
+module Gluey::Dependencies
+  class Handlebars_bundle < SingleFile
+
+    def initialize(dir, logical_path, context)
+      tmp_dir = "#{context.tmp_path}/.texts_bundle"
+      Dir.mkdir tmp_dir unless Dir.exists? tmp_dir
+      @cache_path = "#{tmp_dir}/#{logical_path.gsub '/', '-'}"
+      Dir.mkdir @cache_path unless Dir.exists? @cache_path
+
+      @dir_dep = ::Gluey::Dependencies::Directory.new(dir, '**/*.hb')
+      @dependencies = []
+      super "#{@cache_path}.hb_bundle"
+    end
+
+    def changed?
+      @dependencies.any?{|d| d.changed?} || @dir_dep.changed? || (File.mtime(@file).to_i != @mtime rescue true)
+    end
+
+    def actualize
+      # remove deleted files
+      @dependencies.delete_if{|dep| !dep.exists? }
+      # add new files
+      new_files = (@dir_dep.files_list - @dependencies.map(&:file)).map do |f|
+        template = f[/#{@dir_dep.file}\/(.+)\.hb$/, 1]
+        ::Gluey::Dependencies::SingleFile.new f, template: template,
+                                                  hb_precompiled: "#{@cache_path}/#{template.gsub '/', '-'}"
+      end
+      @dependencies.concat new_files
+      @dir_dep.actualize
+
+      # re-precompile changed
+      handlebars_context = ::Handlebars::Context.new
+      @dependencies.each do |dep|
+        next if !dep.changed? && File.exists?(dep.data[:hb_precompiled])
+        dep.actualize
+        precompile_output = handlebars_context.precompile File.read(dep.file)
+        File.write dep.data[:hb_precompiled], precompile_output
+      end
+
+      write_bundle
+      @mtime = File.mtime(@file).to_i
+      self
+    end
+
+    private
+
+    def write_bundle
+      File.open @file, 'w' do |f|
+        f.write '{'
+        @dependencies.each_with_index do |dep, i|
+          f.write "#{', ' if i!=0}\"#{dep.data[:template]}\": "
+          f.write File.read(dep.data[:hb_precompiled])
+        end
+        f.write '}'
+      end
+    end
+
+  end
+end

data/lib/gluey/dependencies/single_file.rb

@@ -0,0 +1,29 @@
+module Gluey::Dependencies
+  class SingleFile
+
+    attr_reader :file, :data
+
+    def initialize(file, **data)
+      @file = file
+      @data = data
+    end
+
+    def actualize
+      @mtime = File.mtime(@file).to_i
+      self
+    end
+
+    def changed?
+      File.mtime(@file).to_i != @mtime rescue true
+    end
+
+    def exists?
+      File.exists? @file
+    end
+
+    def ==(other)
+      @file == other.file
+    end
+
+  end
+end

data/lib/gluey/dependencies/texts_bundle.rb

@@ -0,0 +1,62 @@
+require_relative 'directory'
+
+module Gluey::Dependencies
+  class TextsBundle < SingleFile
+    JS_ESCAPE_MAP = {
+        '\\'    => '\\\\',
+        "\r\n"  => '\n',
+        "\n"    => '\n',
+        "\r"    => '\n',
+        '"'     => '\\"',
+        "'"     => "\\'"
+    }
+
+    def initialize(dir, logical_path, context)
+      tmp_dir = "#{context.tmp_path}/.texts_bundle"
+      Dir.mkdir tmp_dir unless Dir.exists? tmp_dir
+      @cache_path = "#{tmp_dir}/#{logical_path.gsub '/', '-'}"
+      Dir.mkdir @cache_path unless Dir.exists? @cache_path
+
+      @dir_dep = ::Gluey::Dependencies::Directory.new(dir, '**/*')
+      @dependencies = []
+      super "#{@cache_path}.texts_bundle"
+    end
+
+    def changed?
+      @dependencies.any?{|d| d.changed?} || @dir_dep.changed? || (File.mtime(@file).to_i != @mtime rescue true)
+    end
+
+    def actualize
+      # remove deleted files
+      @dependencies.delete_if{|dep| !dep.exists? }
+      # add new files
+      new_files = (@dir_dep.files_list - @dependencies.map(&:file)).map do |f|
+        text_name = f[/#{@dir_dep.file}\/(.+)$/, 1]
+        ::Gluey::Dependencies::SingleFile.new f, text_name: text_name
+      end
+      @dependencies.concat new_files
+      @dir_dep.actualize
+      @dependencies.each{|dep| dep.actualize if dep.changed? }
+
+      write_bundle
+      @mtime = File.mtime(@file).to_i
+      self
+    end
+
+    private
+
+    def write_bundle
+      File.open @file, 'w' do |f|
+        f.write '{'
+        @dependencies.each_with_index do |dep, i|
+          f.write "#{', ' if i!=0}\"#{dep.data[:text_name]}\": "
+          text = File.read dep.file
+          text.gsub!(/(\\|\r\n|[\n\r"'])/u){|match| JS_ESCAPE_MAP[match] }
+          f.write "\"#{text}\""
+        end
+        f.write '}'
+      end
+    end
+
+  end
+end

data/lib/gluey/exceptions/file_not_found.rb

@@ -0,0 +1,4 @@
+module Gluey
+  class FileNotFound < StandardError
+  end
+end

data/lib/gluey/exceptions/item_not_listed.rb

@@ -0,0 +1,4 @@
+module Gluey
+  class ItemNotListed < StandardError
+  end
+end

data/lib/gluey/glues/base.rb

@@ -0,0 +1,25 @@
+module Gluey::Glues
+  class Base
+
+    def initialize(context, material)
+      @context = context
+      @material = material
+    end
+
+    def process(base_file, dependecies)
+      read_base_file base_file
+    end
+
+    def read_base_file(file)
+      raw_content = File.read(file)
+      file[-4..-1]=='.erb' ? ERB.new(raw_content).result : raw_content
+    end
+
+  end
+
+  def self.load(name, *addons_names)
+    require_relative name
+    addons_names.flatten.each{|an| require_relative "#{name}/#{an}_addons" }
+  end
+
+end

data/lib/gluey/glues/js_script/handlebars_addons.rb

@@ -0,0 +1,24 @@
+require_relative '../../dependencies/handlebars_bundle'
+
+module Gluey::Glues
+  class JsScript < Script
+
+    def pre_replace_with_handlebars(args)
+      dir = File.expand_path("../#{args[1]}", @base_file)
+      raise "cannot find dir containing handlebars templates for script=#{@base_file}" unless dir && Dir.exists?(dir)
+
+      logical_path = dir[/(?:^#{@context.root_path}\/)?(.+)$/, 1]
+      key = "dep:hb_bundle:#{logical_path}:#{@material.name}"
+      hb_dep = @context.cache[key]
+      unless hb_dep
+        hb_dep = ::Gluey::Dependencies::Handlebars_bundle.new dir, logical_path, @context
+        @context.cache[key] = hb_dep
+      end
+
+      hb_dep.actualize if hb_dep.changed?
+      @dependencies << hb_dep
+      @script.gsub! /"%#{args[0]}%"/, File.read(hb_dep.file)
+    end
+
+  end
+end

data/lib/gluey/glues/js_script.rb

@@ -0,0 +1,53 @@
+require_relative 'script'
+require_relative '../dependencies/texts_bundle'
+
+module Gluey::Glues
+  class JsScript < Script
+
+    def post_strict(_)
+      @output = "'use strict';\n#{@output}"
+    end
+
+    def post_enclose(_)
+      @output = "(function(){\n#{@output}\n}());"
+    end
+
+    def post_strict_mode(_)
+      @output = "'use strict';\n#{@output}"
+    end
+
+    def pre_replace(args)
+      file = find_nested_file(args[1])
+      cached_file, deps = get_nested_piece file
+      @dependencies.concat deps
+      @script.gsub! /"%#{args[0]}%"/, File.read(cached_file)
+    end
+
+    def pre_return(args)
+      @script = "#{@script}\nreturn #{args.first};"
+    end
+
+    def post_return(_)
+      @output = "(function(){\n#{@output}\n}())"
+    end
+
+  end
+
+  def pre_replace_with_texts_bundle(args)
+    dir = File.expand_path("../#{args[1]}", @base_file)
+    raise "cannot find relative path #{args[1]} for script=#{@base_file}" unless dir && Dir.exists?(dir)
+
+    logical_path = dir[/(?:^#{@context.root_path}\/)?(.+)$/, 1]
+    key = "dep:txt_bundle:#{logical_path}:#{@material.name}"
+    hb_dep = @context.cache[key]
+    unless hb_dep
+      hb_dep = ::Gluey::Dependencies::TextsBundle.new dir, logical_path, @context
+      @context.cache[key] = hb_dep
+    end
+
+    hb_dep.actualize if hb_dep.changed?
+    @dependencies << hb_dep
+    @script.gsub! /"%#{args[0]}%"/, File.read(hb_dep.file)
+  end
+
+end

data/lib/gluey/glues/sass.rb

@@ -0,0 +1,26 @@
+require 'sass'
+require_relative '../dependencies/single_file'
+
+module Gluey::Glues
+    class Sass < Base
+
+      def process(base_file, deps)
+        opts = {
+            syntax: @material.file_extension.to_sym,
+            load_paths: [File.expand_path('..', base_file)],
+            cache_store: ::Sass::CacheStores::Filesystem.new("#{@context.tmp_path}/.sass"),
+            filename: base_file,
+            line_comments: true
+        }
+        engine = ::Sass::Engine.new(read_base_file(base_file), opts)
+        output = engine.render
+
+        engine.dependencies.each do |dependency|
+          deps << ::Gluey::Dependencies::SingleFile.new(dependency.options[:filename]).actualize
+        end
+
+        output
+      end
+
+    end
+  end

data/lib/gluey/glues/script.rb

@@ -0,0 +1,84 @@
+require_relative '../dependencies/single_file'
+
+module Gluey::Glues
+  class Script < Base
+
+    PREFIXES = ['//'].map{|p| Regexp.escape(p)}
+    DIRECTIVES_REGEXP = Regexp.compile "\\A(?:\\s*#{PREFIXES.map{|p| "(?:#{p}=.*\\n?)+"}.join '|'})+"
+
+    def process(base_file, deps)
+      @script, @directives = strip_directives read_base_file(base_file)
+      return @script unless @directives
+      @dependencies = deps
+      @output = ''
+      @base_file = base_file
+      @marks = {append_self: ->{ @output += @script }}
+      @directives.each{|args| directive args, :pre }
+      @marks[:append_self].call if @marks[:append_self]
+      @directives.each{|args| directive args, :post }
+      @output
+    end
+
+    def pre_prepend(args)
+      file = find_nested_file(args.first)
+      cached_file, deps = get_nested_piece file
+      @dependencies.concat deps
+      @script = "#{File.read cached_file}#{@script}"
+    end
+
+    def pre_append(args)
+      file = find_nested_file(args.first)
+      cached_file, deps = get_nested_piece file
+      @dependencies.concat deps
+      @script = "#{@script}#{File.read cached_file}"
+    end
+
+    def pre_depend_on(args)
+      file = find_nested_file(args[1])
+      @dependencies << ::Gluey::Dependencies::SingleFile.new(file).actualize
+    end
+
+    private
+
+    def strip_directives(data)
+      script = data
+      directives = data[DIRECTIVES_REGEXP]
+      if directives
+        script = $'
+        directives = directives.split("\n").reject{|dir| dir.empty?}.map do |dir|
+          dir.strip[/(?:#{PREFIXES.join '|'}=)\s*(.+)/, 1].split (' ')
+        end
+      end
+      return script, directives
+    end
+
+    def directive(dir_array, run)
+      method = "#{run}_#{dir_array.first}"
+      send method, dir_array[1..-1] if respond_to? method
+    end
+
+    def find_nested_file(rel_path)
+      file = File.expand_path("../#{rel_path}", @base_file)
+      File.exists?(file) || raise("cannot find '#{rel_path}' from script=#{@base_file}")
+      file
+    end
+
+    def get_nested_piece(file)
+      path = file[/(?:^#{@context.root_path}\/)?(.+)$/, 1]
+      key = "script_piece:#{@material.name}:#{path}"
+      cache_file, dependencies = @context.cache[key]
+      return cache_file, dependencies if cache_file && File.exists?(cache_file) && !dependencies.any?{|dep| dep.changed?}
+
+      glue = self.class.new @context, @material
+      cache_dir = "#{@context.tmp_path}/.script"
+      Dir.mkdir cache_dir unless Dir.exists? cache_dir
+      cache_file = "#{cache_dir}/#{path}.#{@material.name}"
+      dependencies = [::Gluey::Dependencies::SingleFile.new(file).actualize]
+      FileUtils.mkdir_p cache_file[0..(cache_file.rindex('/')-1)]
+      File.write cache_file, glue.process(file, dependencies)
+      @context.cache[key] = [cache_file, dependencies]
+      return cache_file, dependencies
+    end
+
+  end
+end

data/lib/gluey/material.rb

@@ -0,0 +1,74 @@
+require_relative 'exceptions/file_not_found'
+
+class Gluey::Material
+
+  attr_reader :name, :glue
+  attr_accessor :asset, :file_extension, :public_dir
+
+  def initialize(name, glue, context)
+    @name = name.to_sym
+    @glue = glue
+    @context = context
+    @asset = name.to_s
+    @paths = []
+    @items = []
+    yield self if block_given?
+    @file_extension ||= @asset.dup
+  end
+
+  def add_path(path)
+    @paths << path
+  end
+
+  def add_item(declaration)
+    @items << declaration
+  end
+
+  def is_listed?(path, file=nil)
+    @items.any? do |items_declaration|
+      case items_declaration
+        when String
+          path == items_declaration
+        when Regexp
+          path =~ items_declaration
+        when Proc
+          items_declaration[path, file]
+      end
+    end
+  end
+
+  def to_s
+    "Material #{@name}"
+  end
+
+  def find_base_file(path)
+    paths.each do |base_path|
+      p = "#{base_path}/#{path}.#{@file_extension}"; return p if File.exists? p
+      p = "#{p}.erb"; return p if File.exists? p
+      p = "#{base_path}/#{path}/index.#{@file_extension}"; return p if File.exists? p
+      p = "#{p}.erb"; return p if File.exists? p
+      end
+    raise(::Gluey::FileNotFound.new "#{to_s} cannot find base file for #{path}")
+  end
+
+  def list_all_items
+    list = []
+    paths.map do |base_path|
+      glob_path = "#{base_path}/**/*.#{@file_extension}"
+      files = Dir[glob_path] + Dir["#{glob_path}.erb"]
+      files.select do |file|
+        path = file[/^#{base_path}\/(.+)\.#{@file_extension}(?:\.erb)?$/, 1]
+        path.gsub! /\/index$/, ''
+        list << path if is_listed? path, file
+      end
+    end
+    list.uniq
+  end
+
+  private
+
+  def paths
+    @paths.map{|p| "#{@context.root_path}/#{p}"}
+  end
+
+end

data/lib/gluey/tools/local_build.rb

@@ -0,0 +1,86 @@
+require_relative 'tools'
+
+module Gluey::Tools
+
+  def self.build_into_public_dir(workshop, warehouse, public_dir='public/assets', **builders)
+    public_dirs = workshop.materials.values.inject({}) do |h, m|
+      h[m.name] = "#{workshop.root_path}/#{m.public_dir || public_dir}"
+      h
+    end
+
+    built = []
+    move_it = -> (cache_file, file) { FileUtils.mv cache_file, file }
+    self.each_asset_file workshop, warehouse do |cache_file, type, path|
+      file = "#{public_dirs[type]}/#{path}"
+      next if File.exists? file
+      FileUtils.mkdir_p file[0..(file.rindex('/')-1)]
+      (builders[type] || move_it)[cache_file, file]
+      built << file
+      puts "created #{file}"
+    end
+    return built
+  end
+
+  def self.clear_public_dir(workshop, warehouse, versions=2, public_dir='public/assets')
+    public_dirs = workshop.materials.values.inject({}) do |h, m|
+      h[m.name] = "#{workshop.root_path}/#{m.public_dir || public_dir}"
+      h
+    end
+
+    # process existing files into assets
+    eas_regexp = /^#{workshop.root_path}\/(.+)$/
+    assets = public_dirs.values.uniq.map{|dir| Dir["#{dir}/**/*.*.*"]}.flatten.
+        map{|f| Asset.try_create f[eas_regexp, 1]}.compact
+    assets = assets.inject({}){|h, asset| (h[asset.path] ||= []) << asset; h }
+
+    # items not on list
+    on_list = []
+    warehouse.assets.each do |type, mater_assets|
+      mater_assets.each do |_, real_path|
+        file = "#{public_dirs[type]}/#{real_path}"
+        asset = Asset.try_create file[eas_regexp, 1]
+        on_list << asset
+      end
+    end
+    on_list.map! &:path
+    assets.delete_if do |path, asseets_arr|
+      unless on_list.include? path
+        asseets_arr.each do |some_asset|
+          file = "#{workshop.root_path}/#{some_asset.orig_path}"
+          File.delete file
+          puts "deleted unknown #{file}"
+        end
+        true
+      end
+      false
+    end
+
+    # older versions
+    assets.values.select{|arr| arr.length > versions}.
+        map{|arr| arr.sort.slice 0..(-versions-1) }.compact.flatten.each do |old_asset|
+      file = "#{workshop.root_path}/#{old_asset.orig_path}"
+      File.delete file
+      puts "deleted old #{file}"
+    end
+  end
+
+  class Asset < Struct.new(:path, :time_stamp)
+
+    def self.try_create(file)
+      file.match /^([^\.]+)\.(\d+)\.(\w+)$/ do |m|
+        new "#{m[1]}.#{m[3]}", m[2]
+      end
+    end
+
+    def <=>(other)
+      time_stamp <=> other.time_stamp
+    end
+
+    def orig_path
+      ret = path.dup
+      ret.insert ret.rindex('.'), ".#{time_stamp}"
+    end
+
+  end
+
+end

data/lib/gluey/tools/tools.rb

@@ -0,0 +1,19 @@
+require 'gluey/warehouse'
+
+module Gluey::Tools
+
+  def self.each_asset_file(workshop, warehouse)
+    warehouse.assets.each do |type, assets|
+      assets.each do |path, real_path|
+        cache_file = workshop.fetch_file type, path
+        yield cache_file, type, real_path
+      end
+    end
+  end
+
+  def self.create_uglifier_builder(**opts)
+    require 'uglifier'
+    ->(a, b){File.write b, ::Uglifier.new(opts.merge! copyright: :none).compile(File.read a)}
+  end
+
+end

data/lib/gluey/version.rb

@@ -0,0 +1,3 @@
+module Gluey
+  VERSION = '0.2.2'
+end

data/lib/gluey/warehouse.rb

@@ -0,0 +1,50 @@
+require_relative '../gluey'
+require_relative 'exceptions/item_not_listed'
+require 'json'
+
+class Gluey::Warehouse
+
+  attr_reader :assets
+
+  def initialize(root, listing_file='assets/gluey_listing.json')
+    @listing_file = "#{root}/#{listing_file}"
+    read_listing
+  end
+
+  def real_path(asset_type, path)
+    listing = @assets[asset_type]
+    unless listing
+      raise ::Gluey::ItemNotListed.new("Asset type #{asset_type} is not defined! (listing file problem?)")
+    end
+
+    real_path = listing[path]
+    unless real_path
+      raise ::Gluey::ItemNotListed.new("Unknown asset: #{path}, type=#{asset_type}! (listing file problem?)")
+    end
+
+    real_path
+  end
+
+  def read_listing
+    assets = if File.exists? @listing_file
+               JSON.parse File.read(@listing_file) rescue {}
+             else
+               {}
+             end
+    raise "corrupted listing file at #{@listing_file}" unless assets.is_a? Hash
+    @assets = assets.keys.inject({}){|h, asset_type| h[asset_type.to_sym] = assets[asset_type]; h }
+  end
+
+  def write_listing(workshop)
+    @assets = workshop.materials.values.inject({}) do |listing, material|
+      list = material.list_all_items.inject({}) do |h, path|
+        h[path] = workshop.real_path material.name, path
+        h
+      end
+      listing[material.name.to_sym] = list
+      listing
+    end
+    File.write @listing_file, JSON.pretty_generate(@assets)
+  end
+
+end

data/lib/gluey/workshop.rb

@@ -0,0 +1,64 @@
+require_relative '../gluey'
+
+require_relative 'exceptions/item_not_listed'
+
+require_relative 'material'
+require_relative 'glues/base'
+
+class Gluey::Workshop
+
+  attr_reader :root_path, :tmp_path, :materials, :cache
+
+  def initialize(root, tmp_dir='tmp/gluey')
+    @root_path = root
+    @tmp_path = "#{root}/#{tmp_dir}"
+    Dir.mkdir @tmp_path unless Dir.exists? @tmp_path
+    @materials = {}
+    @cache = {}
+  end
+
+  def register_material(name, glue=::Gluey::Glues::Base, &block)
+    name = name.to_sym
+    material = ::Gluey::Material.new name, glue, self, &block
+    @materials[name] = material
+  end
+
+  def fetch_file(material, path)
+    # check cache
+    cache_key = "lump:#{material}:#{path}"
+    file, dependencies = @cache[cache_key]
+    if file && File.exists?(file) && !dependencies.any?{|d| d.changed?}
+      return file
+    end
+
+    # prepare for processing
+    material = @materials[material.to_sym]
+    base_file = material.find_base_file path
+    file = "#{@tmp_path}/#{path}.#{material.asset}"
+    dependencies = [::Gluey::Dependencies::SingleFile.new(base_file).actualize]
+    # process
+    glue = material.glue.new self, material
+    FileUtils.mkdir_p file[0..(file.rindex('/')-1)]
+    File.write file, glue.process(base_file, dependencies)
+
+    # save and return
+    @cache[cache_key] = [file, dependencies]
+    file
+  end
+
+  def real_path(material, path)
+    material = @materials[material.to_sym]
+    file = material.find_base_file path
+    unless material.is_listed? path, file
+      raise ::Gluey::ItemNotListed.new("#{material.to_s} doesn't have enlisted item #{path} (file=#{file}).")
+    end
+    "#{path}.#{File.mtime(file).to_i}.#{material.asset}"
+  end
+
+  def try_real_path(path)
+    path.match /^(.+)\.\d+\.(\w+)$/ do |m|
+      yield m[1], m[2]
+    end
+  end
+
+end

data/lib/gluey.rb

@@ -0,0 +1,2 @@
+
+require_relative 'gluey/version'

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: gluey
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- doooby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Concatenating and processing asset files with possibly complicated dependencies.
+email:
+- zelazk.o@email.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gluey.gemspec
+- lib/gluey.rb
+- lib/gluey/dependencies/directory.rb
+- lib/gluey/dependencies/handlebars_bundle.rb
+- lib/gluey/dependencies/single_file.rb
+- lib/gluey/dependencies/texts_bundle.rb
+- lib/gluey/exceptions/file_not_found.rb
+- lib/gluey/exceptions/item_not_listed.rb
+- lib/gluey/glues/base.rb
+- lib/gluey/glues/js_script.rb
+- lib/gluey/glues/js_script/handlebars_addons.rb
+- lib/gluey/glues/sass.rb
+- lib/gluey/glues/script.rb
+- lib/gluey/material.rb
+- lib/gluey/tools/local_build.rb
+- lib/gluey/tools/tools.rb
+- lib/gluey/version.rb
+- lib/gluey/warehouse.rb
+- lib/gluey/workshop.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Rails' asset pipelane replacement
+test_files: []