syntaxer 0.4.0 → 0.5.0

data/features/support/env.rb

@@ -1,3 +1,7 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+pp File.join(File.dirname(__FILE__), '..', 'lib')
 require 'aruba/cucumber'
 require 'fileutils'
-require "git"
+require "git"
+require 'syntaxer'
+require 'cucumber/rspec/doubles' 

data/lib/syntaxer.rb

@@ -5,22 +5,28 @@ require "forwardable"
 require "git"
 require "rainbow"
 require 'progress_bar'
+require 'highline'
+require "highline/import"
 require File.join(%w{syntaxer reader})
 require File.join(%w{syntaxer file_status})
 require File.join(%w{syntaxer checker})
+require File.join(%w{syntaxer runner})
 require File.join(%w{syntaxer repository})
 require File.join(%w{syntaxer language_definition})
 require File.join(%w{syntaxer printer})
 require File.join(%w{syntaxer progress_bar})
+require File.join(%w{syntaxer wizzard})
+require File.join(%w{syntaxer writer})
 
 require File.join(%w{syntaxer railtie}) if defined?(Rails)
 
 module Syntaxer
   DEFAULT_FILES_MASK = "**/*"
   SYNTAXER_RULES_FILE = File.join(File.dirname(__FILE__), "..", "syntaxer_rules.dist.rb")
+  SYNTAXER_CONFIG_FILE_NAME = "syntaxer.rb"
   
   class << self
-    attr_reader :reader, :repository, :root_path, :results, :warnings, :hook
+    attr_reader :reader, :repository, :root_path, :results, :warnings, :hook, :jslint
     
     def configure
       yield(self) if block_given?
@@ -38,17 +44,27 @@ module Syntaxer
     
     def check_syntax(options = {})
       @root_path = options[:root_path]
-      Printer.quite = options[:quite] || false
-      Printer.loud = options[:loud] || false
       @warnings = options[:warnings]
       @hook = options[:hook]
+      @jslint = options[:jslint]
+      Printer.quite = options[:quite] || false
+      Printer.loud = options[:loud] || false
       
       @reader = Reader::DSLReader.load(options[:config_file])
+
+      if @jslint # if jslint option passed set from command line we have to add new rule with indicated dir
+        rule = LanguageDefinition.new(:javascript, %w{js}, nil, [@jslint+"*", @jslint+"**/*"], nil, nil, nil, true, true)
+        rule.exec_rule = Runner.javascript.call
+        @reader.add_rule rule
+      end
+
       @repository = Repository.factory(@root_path, options[:repository]) if options[:repository]
-      
+
+      $stdmyout = StringIO.new
       checker = Checker.process(self)
       Printer.print_result checker
-      exit(1) unless checker.error_files.empty?
+
+      exit(1) unless checker.error_files.empty? && $stdmyout.string.empty?
     end
 
     # This method generate and put hook to .git/hooks
@@ -63,20 +79,37 @@ module Syntaxer
       @root_path = options[:root_path]
       raise ArgumentError, 'Indicate repository type' unless options.include?(:repository)
       raise ArgumentError, "SVN is temporarily not supported" if options[:repository].to_sym == :svn
-      
-      repo = Repository.factory(@root_path, options[:repository])
+
       hook_file = "#{@root_path}/.git/hooks/pre-commit"
-      hook_string = "syntaxer -r git --hook"
-      hook_string += " -c config/syntaxer.rb" if options[:rails]
+      hook_string = 'syntaxer '
+      
+      if options[:restore] && File.exist?(File.join(@root_path,'.syntaxer'))
+        hook_string += File.open(File.join(@root_path,'.syntaxer')).read
+      else
+        repo = Repository.factory(@root_path, options[:repository])
+        hook_string += "-r git --hook"
+        hook_string += " -c config/syntaxer.rb" if options[:rails]
+        hook_string += " -c #{options[:config_file]}" unless options[:config_file].nil?
+      end
       
       File.open(hook_file, 'w') do |f|
         f.puts hook_string
       end
       File.chmod(0755, hook_file)
+
+      # save syntaxer options
+      File.open(File.join(options[:root_path],'.syntaxer'), 'w') do |f|
+        f.write(hook_string.gsub('syntaxer ',''))
+      end
+
     rescue Exception => e
       puts e.message.color(:red)
       raise e
     end
+
+    def wizzard(options)
+      Wizzard.start
+    end
     
   end
 end

data/lib/syntaxer/checker.rb

@@ -1,8 +1,9 @@
 require 'set'
 require "observer"
+require 'thread'
 module Syntaxer
   class Checker
-    include Open3
+    # include Open3
     include Observable
     extend Forwardable
 
@@ -43,20 +44,14 @@ module Syntaxer
         notify_observers({:rule => rule})
       else
         if @syntaxer.warnings && rule.name == :ruby
-          rule.exec_rule = rule.exec_rule.gsub(/(-\S+)\s/,'\1w ')
+          rule.exec_rule.exec_rule = rule.exec_rule.exec_rule.gsub(/(-\S+)\s/,'\1w ')
         end
-        errors = run_exec_rule(rule, file)
+        errors = rule.exec_rule.run(file)
         FileStatus.build(file, errors)
         notify_observers({:file_status => errors.empty?})
       end
     end
 
-    def run_exec_rule rule, file
-      popen3(rule.exec_rule.gsub('%filename%', file)) do |stdin, stdout, stderr, wait_thr|
-        stderr.read.split("\n")
-      end
-    end
-         
   end
 
   # Check status of files in repository
@@ -64,7 +59,27 @@ module Syntaxer
   class RepoChecker < Checker
 
     def initialize syntaxer
-      super syntaxer, syntaxer.repository.changed_and_added_files.length
+      @syntaxer = syntaxer
+      count_of_files = 0
+      @rule_files = {}
+      @deferred_process = []
+      syntaxer.reader.rules.each do |rule|
+        @rule_files[rule.name] = {}
+        @rule_files[rule.name][:rule] = rule
+        @rule_files[rule.name][:files] = []
+        rule.extensions.each do |ext|
+          files.each do |file|
+            if File.extname(file).gsub(/\./,'') == ext || \
+              (!rule.specific_files.nil? && !@rule_files[rule.name][:files].include?(file) && rule.specific_files.include?(file))
+              
+              @rule_files[rule.name][:files].push(file)
+              count_of_files += 1 if !rule.deferred # skip these files
+            end
+          end
+        end
+      end
+      
+      super syntaxer, count_of_files 
     end
 
     # Check syntax in repository directory
@@ -72,28 +87,19 @@ module Syntaxer
     # @see Checker#process
 
     def process
-      checked_files = Set.new
-      rule_files = {}
-      
-      @reader.rules.each do |rule|
-        rule_files[rule.name] = {}
-        rule_files[rule.name][:rule] = rule
-        rule_files[rule.name][:files] = []
-        rule.extensions.each do |ext|
-          files.each do |file|
-            if File.extname(file).gsub(/\./,'') == ext || \
-              (!rule.specific_files.nil? && !rule_files[rule.name][:files].include?(file) && rule.specific_files.include?(file))
-              rule_files[rule.name][:files].push(file)
-            end
+      @rule_files.each do |rule_name, rule|
+        if rule[:rule].deferred
+          @deferred_process << rule
+        else
+          rule[:files].each do |file|
+            full_path = File.join(@syntaxer.root_path,file)
+            check(rule[:rule], full_path)
           end
         end
       end
 
-      rule_files.each do |rule_name, rule|
-        rule[:files].each do |file|
-          full_path = File.join(@syntaxer.root_path,file)
-          check(rule[:rule], full_path)
-        end
+      @deferred_process.each do |rule|
+        rule[:rule].exec_rule.run(@syntaxer.root_path, rule[:files])
       end
 
       self
@@ -116,13 +122,21 @@ module Syntaxer
     # @see Checker#process
 
     def process
+      @deferred_process = []
       @reader.rules.each do |rule|
-        # check if executor exists
-        rule.files_list(@syntaxer.root_path).each do |file|
-          check(rule, file)
+        if rule.deferred
+          @deferred_process << rule
+        else
+          rule.files_list(@syntaxer.root_path).each do |file|
+            check(rule, file)
+          end
         end
       end
       
+      @deferred_process.each do |rule|
+        rule.exec_rule.run(@syntaxer.root_path, rule.files_list(@syntaxer.root_path))
+      end
+      
       self
     end
 

data/lib/syntaxer/language_definition.rb

@@ -1,7 +1,7 @@
 module Syntaxer
   class LanguageDefinitionException < Exception; end
     
-  LanguageDefinition = Struct.new(:name, :extensions, :specific_files, :folders, :ignore_folders, :exec_rule, :executor, :exec_existence) do
+  LanguageDefinition = Struct.new(:name, :extensions, :specific_files, :folders, :ignore_folders, :exec_rule, :executor, :exec_existence, :deferred) do
     def initialize(*args)
       super(*args)
       raise LanguageDefinitionException.new "name can't be blank" unless self.name     

data/lib/syntaxer/printer.rb

@@ -29,8 +29,6 @@ module Syntaxer
         return if @quite
         if args.include?(:file_status)
           @mode == :hook ? @@bar.increment!(args[:file_status]) : @@bar.increment!
-          # @@bar.increment!(args[:file_status]) if @mode == :hook
-          # @@bar.increment! unless @mode == :hook
         end
         true
       end
@@ -42,19 +40,21 @@ module Syntaxer
       def print_result checker
         return if @quite
         puts "\n"
-        puts "Syntax OK".color(:green) if checker.error_files.empty?
+        puts "Syntax OK".color(:green) if checker.error_files.empty? && $stdmyout.string.empty?
 
         @loud ? (files = checker.all_files) : (files = checker.error_files)
         files.each do |file|
           print_message(file)
         end
-
+        
         unless @@not_exists_rules.empty?
           puts "\n"
           @@not_exists_rules.each do |rule|
             puts (NON_EXISTENT_RULE_MESSAGE % [rule.executor, rule.name]).color(:yellow)
           end
         end
+        
+        $stderr.puts("\nErrors:"+"\n\t"+$stdmyout.string.color(:red)) unless $stdmyout.string.empty?
       end
 
       def print_message filestatus

data/lib/syntaxer/railtie.rb

@@ -4,9 +4,18 @@ module Syntaxer
   if defined? Rails::Railtie
     require 'rails'
     class Railtie < Rails::Railtie
+      
       rake_tasks do
         load "tasks/syntaxer.rake"
       end
+
+      initializer "syntaxer.initialize" do |app|
+        if app.root.join('.syntaxer').exist? && !app.root.join('.git/hooks/pre-commit').exist? && Rails.env.development?
+          Syntaxer.make_hook({:root_path => app.root, :repository => :git, :rails => true, :restore => true})
+          puts "Syntaxer hook restored.".color(:green)
+        end
+      end
+
     end
   end
 end

data/lib/syntaxer/reader.rb

@@ -14,9 +14,18 @@ module Syntaxer
         @ignore_folders = []
       end
 
+      def add_rule rule
+        @rules << rule
+        self
+      end
+
       def files_count syntaxer
         @rules.map{ |rule|
-          rule.files_list(syntaxer.root_path).length
+          if rule.deferred
+            0 # skip such files
+          else
+            rule.files_list(syntaxer.root_path).length
+          end
         }.inject(:+)
       end
             
@@ -123,11 +132,25 @@ module Syntaxer
       def specific_files(*args)
         current_rule.specific_files = args
       end
-            
+
+      # Create exec rule for language. It may be console string and
+      # ruby method
+      #
+      # @param [String|Proc]
       def exec_rule(exec_string)
-        current_rule.executor = exec_string.scan(/\w+/).first
-        current_rule.exec_existence = system("which #{current_rule.executor} > /dev/null")
-        current_rule.exec_rule = exec_string    
+        # if it is string create default console runner
+        if !exec_string.respond_to?(:call) || exec_string.is_a?(String)
+          current_rule.executor = exec_string.scan(/\w+/).first
+          current_rule.exec_existence = system("which #{current_rule.executor} > /dev/null")
+          exec_rule = Syntaxer::Runner.default(exec_string)
+          current_rule.deferred = false
+        else
+          # if it is proc call it and pass current rule
+          current_rule.exec_existence = true
+          current_rule.deferred = true # we have run it after all console checkers
+          exec_rule = exec_string.call
+        end
+        current_rule.exec_rule = exec_rule
       end
       
       def ignore_folders(ignore_folders)

data/lib/syntaxer/runner.rb

@@ -0,0 +1,57 @@
+require 'jslint'
+
+module Syntaxer
+  class Runner
+    include Open3
+
+    attr_accessor :exec_rule, :language
+
+    def initialize exec_rule = nil
+      @exec_rule = exec_rule
+    end
+
+    class << self
+      def javascript
+        lambda do
+          c = Syntaxer::Runner.new
+          c.language = 'javascript' # it is using for backward compatibility
+          c.extend(Runners::Javascript)
+          c
+        end
+      end
+
+      def default exec_rule
+        c = self.new(exec_rule)
+        c.extend(Runners::Default)
+        c
+      end
+    end
+  end
+
+  module Runners
+    
+    module Default
+      def run file
+        result = Open3.popen3(@exec_rule.gsub('%filename%', file)) do |stdin, stdout, stderr, wait_thr|
+          stderr.read.split("\n")
+        end
+        result
+      end
+    end
+
+    module Javascript
+      def run(root, files = [])
+        puts ''
+        JSLint::Lint.new(
+                         :paths => files,
+                         :config_path => 'config/jslint.yml'
+                         ).run
+        []
+      rescue JSLint::LintCheckFailure
+        $stdmyout.puts "jslint checking failed"
+      end
+    end
+
+  end
+
+end

data/lib/syntaxer/wizzard.rb

@@ -0,0 +1,116 @@
+module Syntaxer
+  class Wizzard
+    # Interactive console wizzard
+    LANG = [:ruby, :haml, :sass, :javascript]
+    FOLDERS_RAILS = {
+      :ruby => ["app/*", "app/**/*", "lib/*", "lib/**/*"],
+      :haml => ["app/views/*", "app/views/**/*"],
+      :sass => ["public/stylesheets/sass/*", "public/stylesheets/sass/**/*"],
+      :javascript => ["public/javascript/*", "public/javascript/**/*"]
+    }
+    DEFAULT_GLOB = ["*/*", "**/*"]
+    FOLDERS = {
+      :ruby => DEFAULT_GLOB,
+      :haml => DEFAULT_GLOB,
+      :sass => DEFAULT_GLOB,
+      :javascript => DEFAULT_GLOB
+    }
+    
+    attr_accessor :options
+
+    def initialize options
+      @options = options
+    end
+
+    def run
+      FileUtils.mkdir_p(@options[:config_path]) if !@options[:config_dir_exists] && @options[:create_config_dir]
+      config_full_path = File.join(@options[:config_path], Syntaxer::SYNTAXER_CONFIG_FILE_NAME)
+      File.open(config_full_path, 'w') do |f|
+        f.write(config)
+      end
+
+      if @options[:git]
+        options = {:root_path => @options[:root_path], :repository => :git, :config_file => File.join(@options[:config_path], Syntaxer::SYNTAXER_CONFIG_FILE_NAME)}
+        options.merge!({:rails => true}) if options[:rails]
+        Syntaxer.make_hook(options)
+      end
+
+      if @options[:rails] && @options[:languages].include?(:javascript)
+        system('rake jslint:copy_config')
+      end
+    end
+
+    def config
+      reader = Reader::DSLReader.build
+      writer = Writer.new(@options[:languages], reader.rules)
+      writer.get_config
+    end
+    
+    class << self
+      
+      def start
+        options = {}
+        options[:root_path] = Dir.getwd
+        rails = false
+        say("Some greeting message. Hello God of this computer! Please answer in couple of question:".color(:green))
+        
+        # ask for the languages to install
+        to_install = []
+        LANG.each do |lang|
+          if agree("Install support of #{lang.to_s.capitalize}? (y/n)".color(:yellow))
+            default_paths = rails? ? FOLDERS_RAILS[lang] : FOLDERS[lang]
+            paths = ask("Paths to check separated by comma (default are #{default_paths.inspect}):".color(:yellow))
+            if paths.empty?
+              paths = default_paths
+            else
+              paths = paths.split(',').map{|l| l.gsub(/\s/,'')}
+            end
+            to_install.push([lang, paths])
+          end
+        end
+
+        options[:languages] = to_install
+
+        # ask for path to save config
+        if rails?
+          say("Rails application detected. Config file saved to config/synaxer.rb".color(:green))
+          rails = true
+          config_path = "config"
+        else
+          config_path = ask("Specify where to save syntaxer's config file (./ by default):".color(:yellow))
+          config_path = '.' if config_path.empty?
+          expanded_config_path = File.expand_path(config_path)
+          options[:config_dir_exists] = FileTest.directory?(expanded_config_path)
+          options[:create_config_dir] = agree("No such directory found #{expanded_config_path}. Create it?".color(:green)) unless options[:config_dir_not_exists]
+        end
+
+        options[:rails] = rails
+        options[:config_path] = config_path
+
+        # trying to detect GIT
+        begin
+          g = ::Git.open(options[:root_path])
+          options[:git] =  agree("Found git repo in #{File.expand_path(options[:root_path])}. Would you like install hook to check syntax before every commit? (y/n)".color(:yellow))
+        rescue
+          options[:git] = false
+        end
+       
+        Wizzard.new(options).run
+        
+        # buy message
+        say("Syntaxer is configured and installed. You can edit config in #{File.join(config_path, Syntaxer::SYNTAXER_CONFIG_FILE_NAME)}".color(:green))
+
+      rescue Interrupt => e
+        # external quit
+        puts "\nBuy"
+      end
+
+      private
+      
+      def rails?
+        FileTest.directory?("config") && FileTest.file?("config/application.rb") && FileTest.file?("config/routes.rb")
+      end
+
+    end
+  end
+end