capucine 0.1.7 → 0.2.0

data/content/templates/cmd_help.erb

@@ -1,44 +1,35 @@
-    Capucine - <%= config %> 
+    Capucine - <%= config %>
     Usage:
 
         Configure your preferences in capucine.yaml
 
-        $ capucine [option]
-  
-    Options:
+        $ capucine [command]
 
-        new  [name]                   -    Create a new project 
-                                           If not name specified, this will create the folder : capucine/
+    Commands:
 
+        new  [name]                   -    Create a new project
+                                           If not name specified, this will create the folder : capucine/
         init                          -    Initialize a project in current folder (simply add a capucine.yaml file)
-      
         compile [path/to/config]      -    Compile .sass, .coffee, .erb files (just once)
-                              
         watch [path/to/config]        -    Compile .sass, .coffee, .erb files (run the watcher).
-
         help                          -    Print this message
 
     Shortcuts:
 
         n = new
-
         i = init
-
         c = compile
-
         w = watch
-
         h = help
 
     Informations:
-    
+
         Github         -  https://github.com/damln/Capucine
         Documentation  -  http://capucine.dln.name
-        Twitter        -  @wearecapucine ( http://twitter.com/wearecapucine )
-      
+
     Author:
 
         Name           - Damian Le Nouaillle
         Site           - http://dln.name
         Twitter        - @damln ( http://twitter.com/damln )
-      
+

data/lib/capucine.rb

@@ -1,14 +1,73 @@
-require 'settings.rb'
+%w{settings coffeescript compass-sass incloudr tools}.each {|lib| require "#{lib}.rb"}
 
 module Capucine
-  
-  def new
-    @settings = Capucine::Settings.new
-  end
-  
-  def settings
-    @settings
+  class Main
+
+    attr_accessor :settings
+    attr_accessor :coffee
+    attr_accessor :sass
+    attr_accessor :incloudr
+    attr_accessor :tools
+
+    def initialize
+      self.settings = Capucine::Settings.new
+      self.tools = Capucine::Tools.new(self)
+      self.sass = Capucine::CompassSass.new(self)
+      self.coffee = Capucine::CoffeeScript.new(self)
+      self.incloudr = Capucine::Incloudr.new(self)
+      return self
+    end
+
+    def run_command(command)
+      # command = ['c', '/path/to/file.yaml']
+      # command = ['c:sass', '/path/to/file.yaml']
+      # ...
+
+      run = command[0].to_s.split(':') # Rake like capucine compile:sass
+      config_or_name = command[1] # second part (the capucine.yaml file or template name/url)
+
+      main = run[0] # c, w, compile, watch, new, init
+      run.shift # all, coffee, sass or incloudr | sinatra, wordpress, etc ...
+      scope = run # all, coffee, sass or incloudr | sinatra, wordpress, etc ...
+
+      if %w{i init}.include?(main)
+        self.tools.init(scope[0], config_or_name)
+
+      elsif %w{n new}.include?(main)
+        self.tools.new_project(scope[0], config_or_name)
+        self.tools.compile
+
+      elsif %w{c compile}.include?(main)
+        self.settings.set_user_config_file(config_or_name)
+        self.tools.compile(scope[0])
+
+      elsif %w{j js}.include?(main)
+        self.settings.set_user_config_file(config_or_name)
+        self.tools.js(scope, config_or_name)
+
+      elsif %w{w watch}.include?(main)
+        self.settings.set_user_config_file(config_or_name)
+        self.tools.watch(scope[0])
+
+      elsif %w{cl clean}.include?(main)
+        self.settings.set_user_config_file(config_or_name)
+        self.tools.clean
+
+      elsif %w{u update}.include?(main)
+        self.settings.set_user_config_file(config_or_name)
+        self.tools.update
+
+      else
+        self.help
+      end
+
+      return self
+    end
+
+    def help
+      puts 'HELP'
+    end
+
   end
 
-  module_function :new, :settings
 end

data/lib/cdnjs.rb

@@ -0,0 +1,71 @@
+require 'open-uri'
+require 'json'
+
+module Capucine
+  class CDNJS
+    attr_accessor :result
+
+    @@cdnjsroot_github = 'https://raw.github.com/cdnjs/cdnjs/master/ajax/libs/'
+    @@cdnjsroot = 'http://cdnjs.cloudflare.com/ajax/libs/'
+    @@cdnjs = 'http://www.cdnjs.com/packages.json'
+
+
+    def initialize(lib_name, version = nil, content = true)
+
+      return false unless lib_name
+      @result = {}
+
+      cdnjs_url_pkg = "#{@@cdnjsroot_github}#{lib_name}/package.json"
+      raw_content = nil
+
+      begin
+        distant = open(cdnjs_url_pkg).read
+      rescue => e
+        @result[:error] = e; return
+      end
+      content = JSON.parse(distant)
+
+      version = version || content['version']
+      version = version.to_s
+
+      filename = content['filename']
+
+      raw_file_url = "#{@@cdnjsroot}#{lib_name}/#{version}/#{filename}"
+
+      if content
+        begin
+          raw_content = open(raw_file_url).read
+        rescue => e
+          @result[:error] = e; return
+        end
+      end
+
+      @result = {
+        :lib => lib_name,
+        :version => version,
+        :file_url => raw_file_url,
+        :content => raw_content,
+        :response => content,
+      }
+
+    end
+
+    def self.get_all
+      content = JSON.parse open(@@cdnjs).read
+      return content['packages']
+    end
+
+    def self.search(query)
+      results = []
+
+      self.get_all.each do |lib|
+        if lib['name'] =~ /#{query}/
+          results.push(lib)
+        end
+      end
+      return results
+    end
+
+
+  end
+end

data/lib/coffeescript.rb

@@ -1,38 +1,54 @@
 module Capucine
-  class Coffee
+  class CoffeeScript
     require 'packr'
     require 'coffee-script'
-    require 'fssm'
 
-    def self.compile_dir input, output
-      settings = Capucine.settings
+    def initialize(capucine)
+      @cap = capucine
+    end
+
+    def run_once(file = nil)
+
+      unless file
+        files = Dir.glob(File.join @cap.settings.working_dir, @cap.settings.conf['coffeescript_output_dir'], '*')
+        FileUtils.rm_r files
+        self.compile_dir @cap.settings.conf['coffeescript_files_dir'], @cap.settings.conf['coffeescript_output_dir']
+      else
+        self.compile_dir file, @cap.settings.conf['coffeescript_output_dir']
+      end
+
+      puts "[coffee] - Compiled"
+    end
+
+    def compile_dir(input, output)
 
       if File.extname(input) == '.coffee'
         coffee_files = input
       else
-        coffee_files = File.join settings.working_dir, input, "**/**.coffee"
+        coffee_files = File.join @cap.settings.working_dir, input, "**/**.coffee"
       end
 
       Dir.glob(coffee_files).each do |file_coffee_o|
 
         file_coffee = File.expand_path file_coffee_o
-        base_in_dir = File.join settings.working_dir, input
+        base_in_dir = File.join @cap.settings.working_dir, input
+
+        relative_path = file_coffee.gsub(File.join(@cap.settings.working_dir, @cap.settings.conf['coffeescript_files_dir'] ),'')
 
-        relative_path = file_coffee.gsub(File.join(Capucine.settings.working_dir, Capucine.settings.config['coffeescript_files_dir'] ),'')
         relative_path = relative_path.gsub(/\.coffee$/, '.js')
         relative_path_min = relative_path.gsub(/\.js$/, '.min.js')
 
-        file_out = File.join settings.working_dir, output, relative_path
-        file_out_min = File.join settings.working_dir, output, relative_path_min
+        file_out = File.join @cap.settings.working_dir, output, relative_path
+        file_out_min = File.join @cap.settings.working_dir, output, relative_path_min
 
         relative_coffee_file = file_coffee.gsub(base_in_dir, '')
 
-        opts = {:bare => settings.config['coffeescript_bare']}
+        opts = {:bare => @cap.settings.conf['coffeescript_bare']}
         coffee_output_min = ""
 
         error = false
         begin
-          coffee_output = CoffeeScript.compile(File.read(file_coffee), opts)
+          coffee_output = ::CoffeeScript.compile(File.read(file_coffee), opts)
         rescue Exception => e
           error = true
           message = "#{e.message}"
@@ -57,37 +73,26 @@ module Capucine
 
     end
 
-    def self.run_once file = nil
-      settings = Capucine.settings
 
-      unless file
-        files = Dir.glob(File.join settings.working_dir, settings.config['coffeescript_output_dir'], '*')
-        FileUtils.rm_r files
-        self.compile_dir settings.config['coffeescript_files_dir'], settings.config['coffeescript_output_dir']
+    def run_watch
+      require 'fssm'
 
-      else
-        self.compile_dir file, settings.config['coffeescript_output_dir']
-      end
+      files_to_lookat = File.join @cap.settings.working_dir, @cap.settings.conf['coffeescript_files_dir']
+      js_generated_dir = File.join @cap.settings.working_dir, @cap.settings.conf['coffeescript_output_dir']
 
-      puts "[coffee] - Compiled"
-    end
-
-    def self.proc_watch
-      settings = Capucine.settings
-
-      files_to_lookat = File.join settings.working_dir, settings.config['coffeescript_files_dir']
-      js_generated_dir = File.join settings.working_dir, settings.config['coffeescript_output_dir']
+      coffee = @cap.coffee
 
       coffee_thread = Thread.new {
+
         FSSM.monitor(files_to_lookat, :directories => true) do
           update do |b, r|
             file = File.join b, r
-            Capucine::Coffee.run_once file if File.extname(r) == '.coffee'
+            coffee.run_once file if File.extname(r) == '.coffee' # COFFEE
           end
 
           create do |b, r|
             file = File.join b, r
-            Capucine::Coffee.run_once file if File.extname(r) == '.coffee'
+            coffee.run_once file if File.extname(r) == '.coffee' # COFFEE
           end
 
           delete do |b, r|
@@ -116,6 +121,7 @@ module Capucine
 
       return coffee_thread
 
+
     end
 
   end

data/lib/compass-sass.rb

@@ -1,7 +1,21 @@
 module Capucine
   class CompassSass
+    attr_accessor :tmp_config
 
-    def self.update_plugins gems
+    def initialize(capucine)
+      @cap = capucine
+    end
+
+    def run_once
+      self.update_config
+      self.import_css if @cap.settings.conf['sass_import_css']
+
+      command = "compile --quiet --config \"#{@tmp_config}\" \"#{@cap.settings.working_dir}\""
+      self.exec_compass(command)
+      puts "[compass] - Compiled"
+    end
+
+    def update_plugins gems
       return if not gems
       gems.each do |plugin|
         begin
@@ -12,20 +26,25 @@ module Capucine
       end
     end
 
-    def self.update_config
-      settings = Capucine.settings
-      template_file = File.join settings.gem_content_dir, 'templates', 'compass_config.erb'
-      output_file = File.join settings.working_dir, '.compass.rb'
+    def update_config
+      require 'tempfile'
+      require 'digest/md5'
+
+      template_file = File.join @cap.settings.content_dir, 'templates', 'compass_config.erb'
 
-      settings.config['compass_plugins_list'] = []
+      md5 = Digest::MD5.hexdigest(@cap.settings.working_dir.to_s)
+      tmp = Tempfile.new('capucine_'+md5)
+      @tmp_config = tmp.path
+
+      @cap.settings.conf['compass_plugins_list'] = []
       plugins_gems = []
 
-      plugins = settings.config['compass_plugins']
+      plugins = @cap.settings.conf['compass_plugins']
 
       if plugins.size > 0
         plugins.each do |p|
           p = p.split('|')
-          settings.config['compass_plugins_list'].push p[0]
+          @cap.settings.conf['compass_plugins_list'].push p[0]
           if p[1]
             plugins_gems.push p[1]
           else
@@ -35,75 +54,54 @@ module Capucine
         end
       end
 
-      config_ = settings.config
-      result = Capucine::Tools.render_template template_file, config_
+      result = @cap.tools.render_template template_file, @cap.settings.conf
 
-      f = File.open(output_file, 'w')
+      f = File.open(@tmp_config, 'w')
       f.write(result)
       f.close
 
       self.update_plugins plugins_gems
-    end
 
-    # def self.load_my_functions
-    #   rb_files = Dir.glob "#{Capucine.settings.working_dir}/#{Capucine.settings.config['compass_compass_files_dir']}/**/**.rb"
-    #
-    #   rb_files.each do |file|
-    #     require "#{file}"
-    #   end
-    #
-    # end
+      return tmp.path
+    end
 
-    def self.import_css
+    def import_css
 
-      s = Capucine.settings
-      import_dir = File.join s.working_dir, s.config['sass_import_css_dir']
-      output_dir= File.join s.working_dir, s.config['sass_import_output_dir']
+      import_dir = File.join @cap.settings.working_dir, @cap.settings.conf['sass_import_css_dir']
+      output_dir= File.join @cap.settings.working_dir, @cap.settings.conf['sass_import_output_dir']
 
       Dir.mkdir(import_dir) if not File.directory?(import_dir)
       Dir.mkdir(output_dir) if not File.directory?(output_dir)
 
-      formats = s.config['sass_import_formats'].split
+      formats = @cap.settings.conf['sass_import_formats'].split
       from_format = formats[0]
       to_format = formats[2]
 
       command = "sass-convert -R --from #{from_format} --to #{to_format} \"#{import_dir}\" \"#{output_dir}\""
       system(command)
-      Capucine::Tools.archive_file import_dir
+      @cap.tools.archive_file import_dir
 
     end
 
-    def self.run_once
-      self.update_config
-      # self.load_my_functions
-      self.import_css if Capucine.settings.config['sass_import_css']
-      config = File.join Capucine.settings.working_dir, '.compass.rb'
-      command = "compass compile --quiet --config \"#{config}\" \"#{Capucine.settings.working_dir}\""
-      system(command)
-      puts "[compass] - Compiled"
+    def exec_compass compass_args, system = true
+      if not system
+        require 'compass'
+        require 'compass/exec'
+        return Compass::Exec::SubCommandUI.new(compass_args).run!
+      else
+        return system("compass #{compass_args}")
+      end
     end
 
-    # def self.export_path
-    #   require 'compass'
-    #   require 'rubygems'
-    #   path_compass = Gem.loaded_specs['compass'].full_gem_path
-    #   ENV['PATH'] = "#{path_compass}:#{Capucine.settings.gem_dir}:#{ENV['PATH']}"
-    # end
+    def run_watch
+      conf = self.update_config
+      self.import_css if @cap.settings.conf['sass_import_css']
 
-    def self.proc_watch
-      self.update_config
-      config_file = File.join Capucine.settings.working_dir, '.compass.rb'
-      compass_args = ['watch', '--config', config_file, Capucine.settings.working_dir]
-      proc_watch = Thread.new {
-        self.exec_compass compass_args
-      }
-      return proc_watch
-    end
+      compass_args = ['watch', '--config', conf, @cap.settings.working_dir]
+      compass_args = compass_args.join(' ')
 
-    def self.exec_compass compass_args
-      require 'compass'
-      require 'compass/exec'
-      Compass::Exec::SubCommandUI.new(compass_args).run!
+      proc_watch = Thread.new { self.exec_compass compass_args }
+      return proc_watch
     end
 
   end

data/lib/incloudr.rb

@@ -1,50 +1,64 @@
 module Capucine
   class Incloudr
+
+    require 'cdnjs.rb'
+    require 'npm.rb'
+
     require 'open-uri'
     require 'fileutils'
-    require 'json'
     require 'packr'
 
-    @@noderoot = 'http://registry.npmjs.org/'
-    @@cdnjsroot = 'https://raw.github.com/cdnjs/cdnjs/master/ajax/libs/'
-    @@cdnjs = 'http://www.cdnjs.com/packages.json'
+    def initialize(capucine)
+      @cap = capucine
+    end
 
-    def self.run_once
-      files = Capucine.settings.config['incloudr_libs']
+    def run_once
+      files = @cap.settings.conf['incloudr_libs']
       return false if files.length == 0
-      dir = File.join(Capucine.settings.working_dir, Capucine.settings.config['incloudr_output_dir'])
+
+      dir = File.join(@cap.settings.working_dir, @cap.settings.conf['incloudr_output_dir'])
       FileUtils.rm_r dir if File.exist?(dir)
       FileUtils.mkdir_p dir
 
       @file = nil
+
       files.each {|file| self.pack file}
       puts "[incloudr] - Packaged"
     end
 
-    def self.pack file
+    def pack file
+
       @file = file
 
-      if @file.kind_of? String # CDNJS
-        @file = {}
-        @file['name'] = file
-        @file['type'] = 'cdnjs'
-      else
-        @file['type'] = 'npm' unless @file['source'] # NPM
-      end
+      @file['version'] = @file['version'].to_s if @file['version']
+      @file['type'] = @file['type'] || 'cdnjs'
+      @file['type'] = 'url' if @file['source']
 
-      @file['type'] = @file['type'] || 'url' # URL
+      name = @file['file_name'] || @file['name']
 
-      @output = File.join(Capucine.settings.working_dir, Capucine.settings.config['incloudr_output_dir'], @file['name'].gsub(/$/, '.js'))
-      @output_min = File.join(Capucine.settings.working_dir, Capucine.settings.config['incloudr_output_dir'], @file['name'].gsub(/$/, '.min.js'))
+      @dir = @cap.settings.working_dir
+      @conf = @cap.settings.conf
+
+      @output = File.join(@dir, @conf['incloudr_output_dir'], name.gsub(/$/, '.js'))
+      @output_min = File.join(@dir, @conf['incloudr_output_dir'], name.gsub(/$/, '.min.js'))
 
       self.cdnjs if @file['type'] == 'cdnjs'
       self.url if @file['type'] == 'url'
-      # self.npm(file) if type == 'npm'
+      # self.npm if @file['type'] == 'npm'
     end
 
+    def url raw_content = nil
+      if not raw_content
+        begin
+          content = open(@file['source']).read
+        rescue => e
+          puts "Error"
+          return e
+        end
+      else
+        content = raw_content
+      end
 
-    def self.url raw_content = nil
-      content = raw_content || open(@file['source']).read
       content_min = ""
       content_min << Packr.pack(content)
 
@@ -57,34 +71,21 @@ module Capucine
       f2.close
     end
 
+    def cdnjs
+      api = Capucine::CDNJS.new(@file['name'], @file['version'], content = false)
 
-    def self.cdnjs
-      cdnjs_url_pkg = "#{@@cdnjsroot}#{@file['name']}/package.json"
-      content = JSON.parse open(cdnjs_url_pkg).read
-      version = @file['version'] || content['version']
-      filename = content['filename']
-      raw_file_url = "#{@@cdnjsroot}#{@file['name']}/#{version}/#{filename}"
-      raw_content = open(raw_file_url).read
-      self.url raw_content
+      if not api.result[:error]
+        self.url api.result[:content]
+      else
+        puts "Error on #{@file['name']}"
+      end
     end
 
-    def self.npm file
-      # infos = JSON.parse open("#{@@noderoot}#{file['name']}").read
-      # version = file['version'] || infos['dist-tags']['lastest']
-      # lib = infos['versions'][version]
-      # tarball_url = lib['dist']['tarball']
-
-      # tarball = open(tarball_url).read
-
-      # p version
+    def npm
+      # TODO !
 
     end
 
-    def self.list
-      content = JSON.parse open(@@cdnjs).read
-      packages = content['packages']
-      packages.each {|p| puts "#{p['name']}\n"}
-    end
 
   end
 end

data/lib/npm.rb

@@ -0,0 +1,21 @@
+require 'open-uri'
+require 'zlib'
+require 'fileutils'
+require 'json'
+require 'packr'
+
+module Capucine
+  class NPM
+    @@noderoot = 'http://registry.npmjs.org/'
+
+    def initialise(lib_name)
+      infos = JSON.parse open("#{@@noderoot}#{file['name']}").read
+      version = file['version'] || infos['dist-tags']['lastest']
+      lib = infos['versions'][version]
+      tarball_url = lib['dist']['tarball']
+
+      # tarball = open(tarball_url).read
+
+    end
+  end
+end