contao 0.4.2 → 0.5.0

data/lib/contao/coffeescript_compiler.rb

@@ -1,58 +0,0 @@
-require 'coffee_script'
-require 'contao/compiler'
-require 'fileutils'
-
-module TechnoGate
-  module Contao
-    class CoffeescriptCompiler < Compiler
-
-      def initialize(options = {})
-        super
-      end
-
-      def clean
-        FileUtils.rm_rf output_path.to_s if File.exists?(output_path)
-
-        super
-      end
-
-      protected
-
-      def input_from_config_path
-        Application.config.javascripts_path
-      end
-
-      def output_from_config_path
-        Contao.expandify("tmp/compiled_javascript")
-      end
-
-      def compiler_name
-        :coffeescript
-      end
-
-      # Compile assets
-      #
-      # This method compiled coffeescripts from
-      # Application.config.javascripts_path into
-      # Contao.root.join('tmp/compiled_javascript')
-      def compile_assets
-        input_path.each do |src_path|
-          Dir["#{Contao.expandify(src_path)}/**/*.coffee"].sort.each do |file|
-            dest = compute_destination_filename(src_path, file)
-            FileUtils.mkdir_p File.dirname(dest)
-            File.open(dest, 'w') do |f|
-              f.write ::CoffeeScript.compile(File.read(file))
-            end
-          end
-        end
-      end
-
-      def compute_destination_filename(src_path, file)
-        dest = "#{output_path}/#{src_path.gsub('/', '_')}/"
-        dest << file.gsub(/.*#{Regexp.escape src_path}\//, '').gsub(/\.coffee$/, '')
-        dest << '.js' unless File.extname(dest) == '.js'
-        dest
-      end
-    end
-  end
-end

data/lib/contao/compiler.rb

@@ -1,128 +0,0 @@
-require 'active_support/core_ext/string/inflections'
-require 'json'
-
-module TechnoGate
-  module Contao
-    class Compiler
-      attr_accessor :options
-
-      def initialize(options = {})
-        @options = options
-        @manifest_path = assets_public_path.join('manifest.json')
-      end
-
-      # Compile assets
-      def compile
-        prepare_folders
-        compile_assets
-        create_hashed_assets if Contao.env == :production
-        generate_manifest
-        notify
-
-        self
-      end
-
-      def self.compile
-        new.compile
-      end
-
-      def clean
-        FileUtils.rm_rf Contao.expandify(Application.config.assets_public_path)
-      end
-
-      def self.clean
-        new.clean
-      end
-
-      protected
-      def assets_public_path
-        Contao.expandify(Contao::Application.config.assets_public_path)
-      end
-
-      def input_from_config_path
-        raise "Child class must define this"
-      end
-
-      def input_from_options
-        @options[:input][compiler_name] rescue nil
-      end
-
-      def input_path
-        input_from_options || input_from_config_path
-      end
-
-      def output_from_config_path
-        raise "Child class must define this"
-      end
-
-      def output_from_options
-        @options[:output][compiler_name] rescue nil
-      end
-
-      def output_path
-        output_from_options || output_from_config_path
-      end
-
-      # Prepare folders
-      def prepare_folders
-        FileUtils.mkdir_p assets_public_path
-      end
-
-      def compile_assets
-      end
-
-      def create_hashed_assets
-      end
-
-      def notify
-        klass_name = self.class.to_s.split('::').last
-
-        Notifier.notify("#{klass_name.underscore.humanize} finished successfully.", title: klass_name)
-      end
-
-      # Create a diges for a given file
-      #
-      # This method creates a digested file for a given file path
-      #
-      # @param [Pathname | String] file_path
-      def create_digest_for_file(file_path)
-        digest = Digest::MD5.hexdigest File.read(file_path)
-        digested_file_path = "#{file_path.to_s.chomp(File.extname(file_path))}-#{digest}#{File.extname(file_path)}"
-        FileUtils.cp file_path, digested_file_path
-
-        digested_file_path
-      end
-
-      # This method generates a manifest of all generated files
-      # so it can be parsed and processed by the PHP application
-      #
-      # This method is expected to be overridden
-      def generate_manifest
-      end
-
-      def generate_manifest_for(key, extension)
-        manifest = JSON.parse(File.read(@manifest_path)) rescue {}
-        manifest[key] = []
-
-        all_files      = Dir["#{assets_public_path}/**/*.#{extension}"]
-        digested_files = all_files.select {|f| f =~ /^.+-[0-9a-f]{32}\.#{extension}$/}
-        non_digested_files = all_files - digested_files
-
-        if Contao.env == :production
-          files = digested_files
-        else
-          files = non_digested_files
-        end
-
-        files.each do |file|
-          file.slice! "#{assets_public_path}/"
-          manifest[key] << file
-        end
-
-        File.open(@manifest_path, 'w') do |f|
-          f.write(manifest.to_json)
-        end
-      end
-    end
-  end
-end

data/lib/contao/javascript_compiler.rb

@@ -1,77 +0,0 @@
-require 'contao/compiler'
-require 'fileutils'
-require 'uglifier'
-
-module TechnoGate
-  module Contao
-    class JavascriptCompiler < Compiler
-
-      def initialize(options = {})
-        super
-      end
-
-      protected
-
-      def compiler_name
-        :javascript
-      end
-
-      def input_from_config_path
-        Application.config.javascripts_path
-      end
-
-      def output_from_config_path
-        Contao.expandify(Application.config.assets_public_path)
-      end
-
-      # Compile assets
-      #
-      # This method compiles javascripts from
-      # Application.config.javascripts_path into
-      # Application.config.assets_public_path/application.js and it uglifies
-      # only if the environment is equal to :production
-      def compile_assets
-        tmp_app_js = Contao.root.join('tmp/application.js')
-        FileUtils.mkdir_p File.dirname(tmp_app_js)
-
-        File.open(tmp_app_js, 'w') do |compressed|
-          javascripts_path.each do |src_path|
-            Dir["#{Contao.expandify(src_path)}/**/*.js"].sort.each do |f|
-              if TechnoGate::Contao.env == :production
-                compressed.write(Uglifier.new.compile(File.read(f)))
-              else
-                compressed.write("// #{f}\n")
-                compressed.write(File.read(f))
-                compressed.write("\n")
-              end
-            end
-          end
-        end
-
-        FileUtils.mv tmp_app_js, application_js_path
-      end
-
-      # Generate source folders give the exact source and the folder
-      # under tmp/compiled_javascript on which CoffeeScript compiler
-      # adds javascript files to.
-      def javascripts_path
-        input_path.map do |path|
-          ["tmp/compiled_javascript/#{path.gsub('/', '_')}", path]
-        end.flatten
-      end
-
-      # This function creates a hashed version of the assets
-      def create_hashed_assets
-        create_digest_for_file(Contao.expandify(Contao::Application.config.assets_public_path).join("application.js"))
-      end
-
-      def application_js_path
-        Pathname(output_from_config_path).join("application.js")
-      end
-
-      def generate_manifest
-        generate_manifest_for("javascripts", "js")
-      end
-    end
-  end
-end

data/lib/contao/stylesheet_compiler.rb

@@ -1,56 +0,0 @@
-require 'contao/compiler'
-require 'compass'
-require 'compass/commands'
-
-module TechnoGate
-  module Contao
-    class StylesheetCompiler < Compiler
-
-      def initialize(options = {})
-        super
-      end
-
-      def clean
-        @cleaner ||= Compass::Commands::CleanProject.new(
-          Contao.root,
-          configuration_file: Contao.root.join('config', 'compass.rb')
-        )
-
-        @cleaner.execute
-
-        super
-      end
-
-      protected
-      def compiler_name
-        :stylesheet
-      end
-
-      # This class can't be told where to get assets from or where to compile to
-      # unless I figure out how to configure the UpdateProject without a file
-      def input_from_config_path
-      end
-      def output_from_config_path
-      end
-
-      def compile_assets
-        @updater ||= Compass::Commands::UpdateProject.new(
-          Contao.root,
-          configuration_file: Contao.root.join('config', 'compass.rb')
-        )
-
-        @updater.execute
-      end
-
-      def create_hashed_assets
-        Dir["#{Contao.expandify(Contao::Application.config.assets_public_path)}/**/*.css"].each do |file|
-          create_digest_for_file Pathname(file).expand_path
-        end
-      end
-
-      def generate_manifest
-        generate_manifest_for("stylesheets", "css")
-      end
-    end
-  end
-end

data/lib/contao/tasks/assets.rake

@@ -1,22 +0,0 @@
-namespace :assets do
-  desc "Compile javascript"
-  task :javascript do
-    TechnoGate::Contao::CoffeescriptCompiler.compile
-    TechnoGate::Contao::JavascriptCompiler.compile
-  end
-
-  desc "Compile stylesheet"
-  task :stylesheet do
-    TechnoGate::Contao::StylesheetCompiler.compile
-  end
-
-  desc "Clean assets"
-  task :clean do
-    TechnoGate::Contao::StylesheetCompiler.clean
-    TechnoGate::Contao::CoffeescriptCompiler.clean
-    TechnoGate::Contao::JavascriptCompiler.clean
-  end
-
-  desc "Precompile assets"
-  task :precompile => [:clean, :stylesheet, :javascript]
-end

data/lib/contao/tasks/jasmine.rake

@@ -1,8 +0,0 @@
-begin
-  require 'jasmine'
-  load 'jasmine/tasks/jasmine.rake'
-rescue LoadError
-  task :jasmine do
-    abort "Jasmine is not available. In order to run jasmine, you must: (sudo) gem install jasmine"
-  end
-end

data/lib/guard/assets.rb

@@ -1,117 +0,0 @@
-require 'guard'
-require 'guard/guard'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/object/try'
-
-module Guard
-  class Assets < ::Guard::Guard
-    # Initialize a Guard.
-    # @param [Array<Guard::Watcher>] watchers the Guard file watchers
-    # @param [Hash] options the custom Guard options
-    def initialize(watchers = [], options = {})
-      super
-
-      @options   = options
-      @compilers = instantiate_compilers
-    end
-
-    # Call once when Guard starts. Please override initialize method to init stuff.
-    # @raise [:task_has_failed] when start has failed
-    def start
-      run_all
-    end
-
-    # Called when just `enter` is pressed
-    # This method should be principally used for long action like running all specs/tests/...
-    # @raise [:task_has_failed] when run_all has failed
-    def run_all
-      @compilers.each do |compiler|
-        compiler.clean
-      end
-
-      call_compilers
-    end
-
-    # Called on file(s) modifications that the Guard watches.
-    # @param [Array<String>] paths the changes files or paths
-    # @raise [:task_has_failed] when run_on_changes has failed
-    def run_on_changes(paths)
-      compile(paths)
-    end
-
-    # Called on file(s) deletions that the Guard watches.
-    # @param [Array<String>] paths the deleted files or paths
-    # @raise [:task_has_failed] when run_on_changes has failed
-    def run_on_removals(paths)
-      compile(paths)
-    end
-
-    protected
-    def instantiate_compilers
-      @options.merge!(compilers: [:stylesheet, :coffeescript, :javascript]) unless @options[:compilers]
-
-      sort_compilers(@options[:compilers]).map(&:to_s).map do |compiler|
-        self.instance_variable_set(
-          "@#{compiler}_compiler",
-          "::TechnoGate::Contao::#{compiler.camelize}Compiler".constantize.new(@options)
-        )
-
-        self.instance_variable_get "@#{compiler}_compiler"
-      end
-    end
-
-    def sort_compilers(unsorted_compilers)
-      compilers = []
-      compilers << :stylesheet  if unsorted_compilers.include? :stylesheet
-      compilers << :coffeescript if unsorted_compilers.include? :coffeescript
-      compilers << :javascript  if unsorted_compilers.include? :javascript
-
-      compilers
-    end
-
-    def compile(paths)
-      coffeescript = javascript = stylesheet = false
-
-      paths.each do |path|
-        coffeescript = true if !coffeescript && is_coffeescript?(path)
-        javascript = true if !javascript && is_javascript?(path)
-        stylesheet = true if !stylesheet && is_stylesheet?(path)
-      end
-
-      compilers = @compilers.clone
-      compilers.delete(:stylesheet) unless stylesheet
-      compilers.delete(:javascript) unless javascript
-      compilers.delete(:coffeescript) unless coffeescript
-
-      call_compilers compilers
-    end
-
-    def call_compilers(compilers = @compilers)
-      compilers.each do |compiler|
-        compiler.compile
-      end
-    end
-
-    def is_coffeescript?(path)
-      file_in_path?(path, TechnoGate::Contao::Application.config.javascripts_path) && File.extname(path) == '.coffee'
-    end
-
-    def is_javascript?(path)
-      file_in_path?(path, TechnoGate::Contao::Application.config.javascripts_path) && File.extname(path) == '.js'
-    end
-
-    def is_stylesheet?(path)
-      file_in_path?(path, TechnoGate::Contao::Application.config.stylesheets_path)
-    end
-
-    def file_in_path?(file, paths)
-      paths = [paths] if paths.is_a?(String)
-
-      paths.each do |path|
-        return true if file.start_with?(path)
-      end
-
-      false
-    end
-  end
-end