spark_engine 1.0.0

data/lib/spark_engine/middleware.rb

@@ -0,0 +1,72 @@
+require 'action_dispatch/middleware/static'
+
+module SparkEngine
+  class Application < Rails::Application
+    initializer "static assets" do |app|
+      app.middleware.insert_before(::ActionDispatch::Static, ::ActionDispatch::Static, "#{root}/public")
+    end
+  end
+
+  class StaticAssets
+
+    # Rails 5 middleware patch
+    if SparkEngine.rails5?
+
+      def initialize(app, path, index: 'index', headers: {}, engine_name: nil)
+        @app = app
+        @engine_name = engine_name
+        @file_handler = ActionDispatch::FileHandler.new(path, index: index, headers: headers)
+      end
+
+      def call(env)
+        req = Rack::Request.new env
+        prefix = File.join Application.config.assets.prefix, @engine_name
+
+        if req.get? || req.head?
+          path = req.path_info.chomp('/'.freeze)
+
+          if path.start_with? prefix
+            path = path.remove /\A#{prefix}\//
+
+            if match = @file_handler.match?(path)
+              req.path_info = match
+              return @file_handler.serve(req)
+            end
+          end
+        end
+
+        @app.call(req.env)
+      end
+
+    # Rails 4 middleware patch
+    else
+
+      def initialize(app, path, cache_control=nil, engine_name: nil)
+        @app = app
+        @engine_name = engine_name
+        @file_handler = ::ActionDispatch::FileHandler.new(path, cache_control)
+      end
+
+      def call(env)
+        prefix = File.join Application.config.assets.prefix, @engine_name
+
+        case env['REQUEST_METHOD']
+        when 'GET', 'HEAD'
+          path = env['PATH_INFO'].chomp('/')
+
+          if path.start_with? prefix
+            path = path.remove /\A#{prefix}\//
+
+            if match = @file_handler.match?(path)
+              env["PATH_INFO"] = match
+              return @file_handler.call(env)
+            end
+          end
+        end
+
+        @app.call(env)
+      end
+    end
+  end
+
+end

data/lib/spark_engine/plugin/assets/asset.rb

@@ -0,0 +1,163 @@
+module SparkEngine
+  module Assets
+    class AssetType
+      attr_reader :plugin, :base
+
+      def initialize(plugin, base)
+        @base = base
+        @plugin = plugin
+      end
+
+      def find_files
+        if @files
+          @files
+        else
+          files = Dir[File.join(base, "*.#{ext}")].reject do |f|
+            # Filter out partials
+            File.basename(f).start_with?('_')
+          end
+
+          @files = files if SparkEngine.production?
+          files
+        end
+      end
+
+      def filter_files(names)
+
+        # Filter names based on asset file locations
+        find_files.select do |f|
+          names.include? File.basename(f).sub(/(\..+)$/,'')
+        end
+      end
+
+      def versioned(path)
+        File.basename(path).sub(/(\.\w+)$/, '-'+plugin.version+'\1')
+      end
+
+      def local_path(file)
+        destination(file).sub(plugin.root+'/','')
+      end
+
+      def build_success(file)
+        log_success "Built: #{local_path(file)}"
+      end
+
+      def build_failure(file)
+        msg = "\nFAILED TO BUILD"
+        msg += ": #{local_path(file)}" if file
+        log_error msg
+      end
+
+      def log_success( msg )
+        STDOUT.puts msg.to_s.colorize(:green)
+      end
+
+      def log_error( msg )
+        STDERR.puts msg.to_s.colorize(:red)
+      end
+
+      # Determine if an NPM module is installed by checking paths with `npm bin`
+      # Returns path to binary if installed
+    def find_node_module(cmd)
+      require 'open3'
+      (@modules ||= {})[cmd] ||= begin
+
+        local = "$(npm bin)/#{cmd}"
+        global = "$(npm -g bin)/#{cmd}"
+        
+        if Open3.capture3(local)[2].success?
+          local
+        elsif Open3.capture3(global)[2].success?
+          global
+        end
+
+      end
+    end
+
+      def npm_command(cmd)
+        cmd = cmd.split(' ')
+        if path = find_node_module(cmd.shift)
+          system "#{path} #{cmd.join(' ')}"
+        end
+      end
+
+      def destination(path)
+        plugin.asset_path(versioned(path))
+      end
+
+      def url(path)
+        plugin.asset_url(versioned(path))
+      end
+
+      def urls(names=nil)
+        # If names are passed, look at the basename minus
+        # the extension as build files may have
+        # different extensions than sources
+        names = [names].flatten.compact.map do |n|
+          File.basename(n).sub(/(\..+)$/,'')
+        end
+
+        # Return all asset urls if none were specifically chosen
+        if names.empty?
+          find_files.map{ |file| url(file) }
+
+        # Filter files based on name
+        else
+          filter_files(names).map{ |file| url(file) }
+        end
+      end
+
+      def watch
+
+        @throttle = 4
+        @last_build = 0
+        
+        puts "Watching for changes to #{base.sub(plugin.root+'/', '')}...".colorize(:light_yellow)
+
+        Thread.new {
+          listener = Listen.to(base) do |modified, added, removed|
+            change(modified, added, removed)
+          end
+
+          listener.start # not blocking
+          sleep
+        }
+      end
+
+      def change(modified, added, removed)
+        return if (Time.now.to_i - @last_build) < @throttle
+
+        puts "Added: #{file_event(added)}".colorize(:light_green)        unless added.empty?
+        puts "Removed: #{file_event(removed)}".colorize(:light_red)      unless removed.empty?
+        puts "Modified: #{file_event(modified)}".colorize(:light_yellow) unless modified.empty?
+
+        build
+        @last_build = Time.now.to_i
+      end
+
+      def file_event(files)
+        list = files.flat_map { |f| f.sub(base+'/', '') }.join("  \n")
+        list = "  \n#{files}" if 1 < files.size
+
+        list
+      end
+
+      def compress(file)
+        return unless SparkEngine.production?
+
+        mtime = File.mtime(file)
+        gz_file = "#{file}.gz"
+        return if File.exist?(gz_file) && File.mtime(gz_file) >= mtime
+
+        File.open(gz_file, "wb") do |dest|
+          gz = Zlib::GzipWriter.new(dest, Zlib::BEST_COMPRESSION)
+          gz.mtime = mtime.to_i
+          IO.copy_stream(open(file), gz)
+          gz.close
+        end
+
+        File.utime(mtime, mtime, gz_file)
+      end
+    end
+  end
+end

data/lib/spark_engine/plugin/assets/javascripts.rb

@@ -0,0 +1,83 @@
+module SparkEngine
+  module Assets
+    class Javascripts < AssetType
+      def ext
+        "js"
+      end
+
+      def asset_tag(*args)
+        javascript_include_tag(args)
+      end
+
+      def cache_file(name=nil)
+        SparkEngine.rails_path("tmp/cache/assets/.browserify-cache-#{name}.json")
+      end
+
+      # Find all asset files matching array of names
+      def filter_files(names)
+        [find_files, plugin.svgs.build_paths].flatten.select do |f|
+          names.include? File.basename(f).sub(/(\..+)$/,'')
+        end
+      end
+
+      def build
+        files = find_files
+        FileUtils.mkdir_p(File.dirname(cache_file)) if !files.empty?
+
+        if Open3.capture3("npm ls browserify-incremental")[1].empty?
+          files.each do |file|
+
+            dest = destination(file)
+
+            FileUtils.rm(dest) if File.exists?(dest)
+
+            response = Open3.capture3(build_command(file))
+
+            # If the file exists and is not empty (a failed build is empty)
+            if File.exist?(dest) && !File.read(dest).strip.empty?
+              compress(dest) if SparkEngine.production?
+              build_success file
+            else
+              build_failure file
+
+              response = response.map { |l| l.to_s.split("\n") }.flatten
+
+              response.each do |line|
+                if !line.empty? &&                      # Don't print empty lines
+                   !line.match(/node_modules/i) &&      # Ignore stack traces from installed modules
+                   !line.match(/pid (\d+?) exit/i) &&   # Ignore pid exit stack line
+                   !line.match(/\[BABEL\] Note:/i)      # Notices from Bable are noisy
+                  log_error line.gsub(plugin.root+'/','')
+                end
+              end
+
+              puts ""
+            end
+          end
+        else
+          log_error "JS BUILD FAILED: browserifyinc NPM module not found.\n" << "Please add browserifyinc to your package.json and run `npm install`"
+          abort
+        end
+      end
+
+      def npm_path( cmd )
+        File.join SparkEngine.gem_path, "node_modules/.bin", cmd
+      end
+
+      def build_command(file)
+        dest = destination(file).sub(/\.js$/,'')
+        options = "--standalone #{plugin.name} -o #{dest}.js -d"
+
+        cmd = if SparkEngine.production?
+          npm_path "browserify #{file} #{options} -t"
+        else
+          npm_path "browserifyinc --cachefile #{cache_file(File.basename(dest))} #{file} #{options}"
+        end
+        puts "Running: #{cmd}"
+
+        cmd
+
+      end
+    end
+  end
+end

data/lib/spark_engine/plugin/assets/stylesheets.rb

@@ -0,0 +1,88 @@
+require 'sass'
+require "autoprefixer-rails"
+
+module SparkEngine
+  module Assets
+    class Stylesheets < AssetType
+
+      def ext
+        "*[ca]ss"
+      end
+
+      def asset_tag(*args)
+        stylesheet_link_tag(args)
+      end
+
+      def build(ext=nil)
+        files = find_files
+        files = files.reject {|f| !f.match(/\.#{ext}/) } if ext
+
+        files.each do |file|
+
+          begin
+            if File.extname(file).match(/\.css/)
+              build_css(file)
+            elsif File.extname(file).match(/\.s[ca]ss/)
+              build_sass(file)
+            end
+
+            puts build_success(file)
+
+          rescue Exception => e
+            build_failure file
+
+            if e.backtrace.is_a? Array
+              log_error "Error in file: #{local_path(e.backtrace[0])}"
+            end
+
+          log_error "  #{e.message}\n" if e.message
+          end
+        end
+      end
+
+      def build_css(file)
+        css = AutoprefixerRails.process(File.read(file)).css
+        File.open(destination(file), 'w') { |io| io.write(css) }
+
+        compress(destination(file))
+      end
+
+      def build_sass(file)
+        style = SparkEngine.production? ? "compressed" : 'nested'
+        dest = destination(file)
+
+        Sass.logger.log_level = :error if SparkEngine.production?
+
+        css = Sass.compile_file(file, style: style)
+        css = AutoprefixerRails.process(css).css
+
+        File.open(dest, 'w') { |io| io.write(css) }
+
+        compress(dest)
+      end
+
+      def data
+        if @data
+          @data
+        else
+          data = {}
+
+          Dir[File.join(base, "**/*.yml")].each do |file|
+            key = file.sub(base+"/", '').sub(/^_/,'').sub('.yml','')
+
+            data[key] = SassParser.parse(file)
+          end
+
+          @data = data if SparkEngine.production?
+          data
+        end
+      end
+
+      # Convert extension
+      def versioned(file)
+        super(file.sub(/(\.css)?\.s[ca]ss$/i,'.css'))
+      end
+    end
+  end
+end
+

data/lib/spark_engine/plugin/assets/svgs.rb

@@ -0,0 +1,79 @@
+module SparkEngine
+  module Assets
+    class Svgs < AssetType
+
+      def initialize(plugin, path)
+
+        require 'esvg'
+
+        @plugin = plugin
+        @base = path
+        @svg = esvg
+      end
+
+      def esvg
+        @svg || Esvg.new({
+          config_file: File.join(plugin.root, 'config', 'esvg.yml'),
+          source: @base,
+          assets: plugin.paths[:javascripts],
+          version: plugin.version,
+          build: plugin.destination,
+          temp: SparkEngine.rails_path('tmp/cache/assets'),
+          filename: '_icons.js',
+          compress: SparkEngine.production?,
+          optimize: true,
+          print: false
+        })
+      end
+
+      def ext
+        "svg"
+      end
+
+      def local_path(path)
+        path = File.expand_path(path)
+
+        # Strip all irrelevant sections of the path
+        path.sub(plugin.paths[:javascripts]+'/', '') # written to assets dir
+            .sub(plugin.root+'/','')                 # writtent to public dir
+      end
+
+      def use(*args)
+        esvg.use(*args)
+      end
+
+      def build_paths
+        esvg.build_paths.map { |file| file.sub("-#{plugin.version}",'') }
+      end
+
+      def build
+        begin
+          esvg.load_files
+
+          return if esvg.symbols.empty?
+
+          if files = esvg.build
+            files.each do |file|
+              puts build_success(file)
+            end
+          else
+            log_error "FAILED TO BUILD SVGs"
+          end
+        rescue Exception => e
+          log_error "\nFAILED TO BUILD SVGs"
+
+          if e.backtrace && e.backtrace.is_a?(Array)
+            log_error "Error in file: #{local_path(e.backtrace.shift)}"
+
+            e.backtrace.each do |line|
+              log_error local_path(line)
+            end
+          end
+
+          log_error("  #{e.message}\n") if e.message
+
+        end
+      end
+    end
+  end
+end

data/lib/spark_engine/plugin.rb

@@ -0,0 +1,191 @@
+module SparkEngine
+  class Plugin
+    attr_reader   :name, :gem, :engine,
+                  :stylesheets, :javascripts, :svgs, :destination
+
+    def initialize(options)
+      @name            = options.delete(:engine).downcase
+      @gem             = Gem.loaded_specs[options.delete(:gem)]
+      config(options)
+      expand_asset_paths
+
+      # Store the gem path for access later when overriding root
+      parent_module.instance_variable_set(:@gem_path, root)
+      parent_module.instance_variable_set(:@spark_plugin_name, name)
+      add_assets
+    end
+
+    def engine_name
+      @engine.name.sub(/::Engine/,'')
+    end
+
+    def create_engine(&block)
+      # Create a new Rails::Engine
+      @engine = parent_module.const_set('Engine', Class.new(Rails::Engine) do
+
+        def spark_plugin_path
+          parent = Object.const_get(self.class.name.sub(/::Engine/,''))
+          Pathname.new parent.instance_variable_get("@gem_path")
+        end
+
+        def config
+          @config ||= Rails::Engine::Configuration.new(spark_plugin_path)
+        end
+
+        engine_name SparkEngine.plugin.name
+
+        require 'spark_engine/middleware'
+
+        initializer "#{name}.static_assets" do |app|
+          if !SparkEngine.rails5? || app.config.public_file_server.enabled
+            app.middleware.insert_after ::ActionDispatch::Static, SparkEngine::StaticAssets, "#{root}/public", engine_name: SparkEngine.plugin.name
+            app.middleware.insert_before ::ActionDispatch::Static, Rack::Deflater
+          end
+        end
+
+      end)
+
+      @engine.instance_eval(&block) if block_given?
+    end
+
+    def parent_module
+      mods = self.class.to_s.split('::')
+      mods.pop
+      Object.const_get(mods.join('::'))
+    end
+
+    def add_assets
+      @javascripts = Assets::Javascripts.new(self, paths[:javascripts])
+      @stylesheets = Assets::Stylesheets.new(self, paths[:stylesheets])
+      @svgs        = Assets::Svgs.new(self, paths[:svgs])
+    end
+
+    def assets(options={})
+      assets = []
+      if options[:select_assets]
+        assets.push @svgs if options[:svg]
+        assets.push @stylesheets if options[:css]
+        assets.push @javascripts if options[:js]
+      else
+        assets = [@svgs, @stylesheets, @javascripts]
+      end
+
+      assets
+    end
+
+    def svgs?
+      @svgs.icons.nil?
+    end
+
+    def build(options={})
+      FileUtils.mkdir_p(asset_path)
+      assets(options).each do |asset|
+        asset.build
+      end
+
+    end
+
+    def watch(options)
+      assets(options).map(&:watch)
+    end
+
+    def asset_root
+      asset_prefix = Rails.application.config.assets.prefix || '/assets'
+      File.join asset_prefix, name
+    end
+
+    def production_root
+      @production_asset_root ||= asset_root
+    end
+
+    def config(options)
+
+      options = {
+        production_asset_root: nil,
+        destination:   "public/",
+        root:          @gem.full_gem_path,
+        version:       @gem.version.to_s,
+        gem_name:      @gem.name,
+        paths: {
+          stylesheets: "app/assets/stylesheets/#{name}",
+          javascripts: "app/assets/javascripts/#{name}",
+          images:      "app/assets/images/#{name}",
+          svgs:        "app/assets/svgs/#{name}",
+        }
+      }.merge(options)
+
+      options.each do |k,v|
+        set_instance(k.to_s,v)
+      end
+    end
+
+    def expand_asset_paths
+      @paths.each do |type, path|
+        @paths[type] = File.join(root, path)
+      end
+      @destination = File.join(root, @destination)
+    end
+
+    def asset_path(file=nil)
+      dest = destination
+      dest = File.join(dest, file) if file
+      dest
+    end
+
+    def asset_url(file=nil)
+
+      path = if SparkEngine.production? && !ENV[name.upcase + '_FORCE_LOCAL_ASSETS']
+        production_root
+      else
+        asset_root
+      end
+
+      path = File.join(path, file) if file
+      path
+    end
+
+    private
+
+    def asset_ext(klass)
+      klass.name.split('::').last.downcase
+    end
+
+    # Find files based on class type and
+    # return an array of Classes for each file
+    def add_files(klass)
+      ext = asset_ext klass
+      find_files(ext).map do |path|
+        klass.new(self, path)
+      end
+    end
+
+    # Find files by class type and extension
+    def find_files(ext)
+      files = Dir[File.join(paths[ext.to_sym], asset_glob(ext))]
+
+      # Filter out partials
+      files.reject { |f| File.basename(f).start_with?('_') }
+    end
+
+    def asset_glob(type)
+      case type
+      when "sass"
+        "*.s[ca]ss"
+      else
+        "*.#{type}"
+      end
+    end
+
+    # Convert configuration into instance variables
+    def set_instance(name, value)
+      instance_variable_set("@#{name}", value)
+
+      instance_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def #{name}
+          @#{name}
+        end
+      EOS
+    end
+
+  end
+end

data/lib/spark_engine/sass/engine.rb

@@ -0,0 +1,21 @@
+require 'spark_engine/sass/importer'
+
+# Taken from https://github.com/chriseppstein/sass-css-importer/blob/master/lib/sass/css_importer/monkey_patches.rb
+# TODO: This feels wrong, surely there must be a better way to handle this
+
+class Sass::Engine
+  alias initialize_without_yaml_importer initialize
+
+  def initialize(template, options={})
+    initialize_without_yaml_importer(template, options)
+
+    yaml_importer = self.options[:load_paths].find {|lp| lp.is_a?(SparkEngine::Importer) }
+
+    unless yaml_importer
+      root        = File.dirname(options[:filename] || ".")
+      plugin_root = SparkEngine.plugin.stylesheets.base
+      self.options[:load_paths] << SparkEngine::Importer.new(root)
+      self.options[:load_paths] << SparkEngine::Importer.new(plugin_root)
+    end
+  end
+end