syntaxer 0.1.0

data/lib/syntaxer/printer.rb

@@ -0,0 +1,41 @@
+require "rainbow"
+module Syntaxer
+
+  # Print system messages
+
+  class Printer
+    class << self
+      attr_accessor :quite
+
+      # Print progress in dot notation
+      #
+      # @param [Boolean] (true|false)
+
+      def print_progress succ = true
+        if succ
+          s = '.'.color(:green)
+        else
+          s = 'E'.color(:red)
+        end
+        print s unless @quite
+      end
+
+      # Print error message for each if file
+      #
+      # @param [Array, #each] files
+
+      def print_result files
+        return if @quite
+        puts "\n"
+        puts "Syntax OK".color(:green) if files.empty?
+
+        files.each do |file|
+          puts file.file_name
+          file.errors.each do |error|
+            puts "\t #{error}".color(:red)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/syntaxer/railtie.rb

@@ -0,0 +1,12 @@
+require 'syntaxer'
+
+module Syntaxer
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load "tasks/syntaxer.rake"
+      end
+    end
+  end
+end

data/lib/syntaxer/reader.rb

@@ -0,0 +1,147 @@
+# @author Artyom Kramarenko
+module Syntaxer
+  module Reader
+    class DSLFileNotFoundError < Exception; end
+    class DSLError < Exception; end
+    class DSLSyntaxError < DSLError; end
+        
+    class DSLReader
+
+      attr_reader :rules, :ignored_folders
+      
+      def initialize
+        @rules = LanguageRules.new
+        @ignore_folders = []
+      end
+            
+      class << self
+        
+        # Read files from params and send to {#parse} method to fill in {Syntaxer::LanguageDefinition LanguageDefinition} objects.
+        # 
+        # @param [Array] dsl_files    Files with syntaxer rules and language definitions to be used in syntax checking
+        #
+        # @return [DSLReader] reader object
+        #
+        # @raise [DSLFileNotFoundError] If file with file is not exists
+        def load(*dsl_files)
+          reader = build
+          dsl_files = [dsl_files].flatten
+          dsl_files.each do |file|
+            begin
+              reader.parse(File.read(file))
+            rescue SystemCallError
+              raise ::Syntaxer::Reader::DSLFileNotFoundError, "Error reading syntaxer rules file with path '#{file}'!  Please ensure it exists and that it is accessible."
+            end
+          end
+          reader
+        end
+        
+        def build(skip_default_rules = false, default_rules_file = SYNTAXER_RULES_FILE)
+          reader = new
+          reader.parse(File.read(default_rules_file)) unless skip_default_rules
+          reader
+        end
+      end
+      
+      # Parses a syntaxer DSL specification from the string given.
+      # 
+      # @param [String] dsl_data     Text of actual data to be parsed
+      #
+      # @raise [DSLSyntaxError] If errors occur on parsing
+      # @example
+      #   Syntaxer::Reader::DSLReader.new.parse%|
+      #     syntaxer do
+      #       languages :ruby
+      #         folders 'app/**/*', 'lib/**/*'
+      #       end
+      #     end
+      #   | 
+      def parse(dsl_data)
+        self.instance_eval(dsl_data)
+        @rules << @current_rule
+      rescue SyntaxError, NoMethodError, NameError => e
+        raise DSLSyntaxError, "Illegal DSL syntax: #{e}"
+      end
+      
+      # The top level block executor
+      # 
+      # @yield Description of block
+      #
+      # @example
+      #     syntaxer do
+      #       languages :ruby
+      #         folders 'app/**/*', 'lib/**/*'
+      #       end
+      #     end
+      def syntaxer(&block)
+        self.instance_eval(&block)
+      end
+      
+      # The languages block executor
+      # 
+      # @yield [langs_name] Description of block
+      # @return [nil]
+      #
+      #
+      # @example
+      #    languages :ruby do
+      #      folders 'app/**/*', 'lib/**/*'
+      #    end
+      # @see #syntaxer
+      def languages(*args, &block)
+        args.each do |lang|          
+          @current_rule = @rules.find_or_create(lang)
+          self.instance_eval(&block)
+        end
+      end
+      
+      # Stub for DSL folders method.
+      #
+      # @note This method won't check if files are really exist.
+      #
+      # @param [Array(String)] args   File regexps to be assigned for particular language
+      #
+      # @example
+      #   folders('app/**/*', 'lib/**/*') #=> ['app/**/*', 'lib/**/*']
+      #   folders() # => DEFAULT_FILES_MASK
+      # @return [args]
+      #      
+      # @see #syntaxer
+      def folders(*args)
+        current_rule.folders = (args.empty? ? [DEFAULT_FILES_MASK] : args.flatten)
+      end
+      
+      def extensions(*args)
+        current_rule.extensions = args
+      end
+      
+      def specific_files(*args)
+        current_rule.specific_files = args
+      end
+            
+      def exec_rule(exec_string)
+        current_rule.exec_rule = exec_string    
+      end
+      
+      def ignore_folders(ignore_folders)
+        current_rule.ignore_folders = ignore_folders    
+      end
+      
+      def overall_ignore_folders(*args)
+        @ignored_folders = args
+      end
+      
+      
+      alias_method :ignore, :overall_ignore_folders
+      alias_method :lang, :languages
+      alias_method :f, :folders
+      
+      private
+      def current_rule
+        @current_rule
+      end
+    end #end of class DSLReader
+    
+    
+  end #end of module Reader
+end #end of module Syntaxer

data/lib/syntaxer/repository.rb

@@ -0,0 +1,80 @@
+module Syntaxer
+  class RepositoryError < Exception; end
+  class GitRepositoryError < RepositoryError; end
+  class SvnRepositoryError < RepositoryError; end
+  
+  class Repository
+    
+    def self.factory(root_path, type_of_repository)
+      case type_of_repository.to_sym
+      when :git then Git.new(root_path)
+      when :svn then Svn.new(root_path)
+      end
+    end
+    
+  end
+
+  
+  class Git
+    require "git"
+        
+    def initialize(repo_path)
+      @repository = ::Git.open(Dir.new(repo_path))
+    rescue ArgumentError => ex
+        raise GitRepositoryError, "The path you specified is not a git repository: '#{File.expand_path(repo_path)}'"
+    end
+
+    # Returns list of files what have been changed
+    #
+    # @return [Array]
+
+    def changed_files
+      @repository.chdir do
+        @changed ||= @repository.status.changed.keys
+      end
+    end
+
+    # Returns list of files what have been added
+    #
+    # @return [Array]
+    
+    def added_files
+      @repository.chdir do
+        @added ||= @repository.status.added.keys
+      end
+    end
+
+    # Aggregates added and changed files in one array
+    #
+    # @return [Array]
+    
+    def changed_and_added_files
+      changed_files + added_files
+    rescue
+      []
+    end
+=begin
+    private
+    def check_repo repository
+      @logs = @repository.log
+      @logs.first
+    rescue ::Git::GitExecuteError => e
+      puts "\nRepository is empty. There are no any revision.".color(:red)
+      raise e
+      exit 1
+    end
+=end
+  end
+  
+  
+  class Svn
+    def initialize
+      raise "TDB"    
+    end
+    
+    def changed_files_list
+      raise "TDB"      
+    end
+  end
+
+end

data/lib/syntaxer/version.rb

@@ -0,0 +1,3 @@
+module Syntaxer
+  VERSION = "0.0.1" unless defined? Syntaxer::VERSION
+end

data/lib/syntaxer.rb

@@ -0,0 +1,74 @@
+require "rake"
+require "open3"
+require "forwardable"
+require "git"
+require File.join(%w{syntaxer reader})
+require File.join(%w{syntaxer file_status})
+require File.join(%w{syntaxer checker})
+require File.join(%w{syntaxer repository})
+require File.join(%w{syntaxer language_definition})
+require File.join(%w{syntaxer version})
+require File.join(%w{syntaxer printer})
+
+module Syntaxer
+  DEFAULT_FILES_MASK = "**/*"
+  SYNTAXER_RULES_FILE = File.join(File.dirname(__FILE__), "..", "syntaxer_rules.dist.rb")
+  
+  class << self
+    attr_reader :reader, :repository, :root_path, :result, :verbose
+    
+    def configure
+      yield(self) if block_given?
+    end
+     
+    # Main method to be used for syntax checking. 
+    # 
+    # @return [Boolean]
+    #  
+    # @param [Hash] options the options to perform syntax checking
+    # @option options [String] :root_path (Dir.getwd) The starting point, which will be used for all relative path's
+    # @option options [String] :languages (:all) Type of languages to be used in checking
+    # @option options [String] :repository (git|svn) Type of repository
+    # @option options [String] :config_file(SYNTAXER_RULES_FILE) File with syntax rules and language definitions
+    
+    def check_syntax(options = {})
+      @root_path = options[:root_path]
+      Printer.quite = options[:quite] || false
+      @reader = Reader::DSLReader.load(options[:config_file])
+      @repository = Repository.factory(@root_path, options[:repository]) if options[:repository]
+      
+      Checker.process(self)
+      error_files = Checker.error_files
+      Printer.print_result error_files
+      exit(1) unless error_files.empty?
+    end
+
+    # This method generate and put hook to .git/hooks
+    #
+    # @return [Nil]
+    #
+    # @see Syntaxer#check_syntax
+    # @raise ArgumentError if no repository indicated
+    # @raise ArgumentError if SVN is indicated. SVN is not supported yet.
+
+    def make_hook(options)
+      @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"
+      File.open(hook_file, 'w') do |f|
+        f.puts "syntaxer -r git" # #{@root_path}"
+      end
+      File.chmod(0755, hook_file)
+    rescue Exception => e
+      puts e.message.color(:red)
+      raise e
+    end
+    
+  end
+end
+# 
+# Syntaxer.configure do |config|
+#   config.root = File.expand_path(File.dirname(__FILE__) + '../..')
+# end

data/rails/init.rb

@@ -0,0 +1,5 @@
+require 'syntaxer/railtie'
+
+Syntaxer.configure do |syntaxer|
+  syntaxer.root = Rails.root
+end

data/spec/checker_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Syntaxer::Checker" do
+
+  context "Syntaxer::PlainChecker" do
+    
+    before(:each) do
+      reader = mock('Reader')
+      reader.stub!(:rules).and_return([Syntaxer::LanguageDefinition.new(:ruby, ["rb.example", "rake"], ["Rakefile", "Thorfile"], ["**/*"], nil, "ruby -wc %filename%")])
+      Syntaxer.should_receive(:reader).and_return(reader)
+      Syntaxer.stub!(:root_path).and_return(fixtures_path(:ruby))
+
+      Syntaxer::Printer.stub!(:print_result)
+      Syntaxer::Printer.stub!(:print_progress)
+    end
+    
+    subject {Syntaxer::PlainChecker.new(Syntaxer)}
+    
+    it {should respond_to(:error_files)}
+    it {should respond_to(:fine_files)}
+
+    it "should return correct error_files " do
+      subject.process
+      subject.fine_files.size.should == 1      
+      subject.error_files.size.should == 1
+    end
+    
+    it "should send to FileStatus" do
+      Syntaxer::FileStatus.should_receive(:build).twice
+      subject.process      
+    end
+  end
+  
+  # it "fails" do
+  #   fail "hey buddy, you should probably rename this file and start specing for real"
+  # end
+
+  context "Syntaxer::RepoChecker" do
+
+    before(:all) do
+      Syntaxer::Printer.stub!(:print_result)
+      Syntaxer::Printer.stub!(:print_progress)
+    end
+    
+    before(:each) do
+      @repo_dir = create_temp_ruby_project
+      make_initial_commit(@repo_dir)
+      add_file_to_repo(:ruby, @repo_dir, "correct.rb.example")
+      add_file_to_repo(:ruby, @repo_dir, "wrong.rb.example")
+      make_git_add(@repo_dir)
+
+      reader = mock('Reader')
+      reader.stub!(:rules).and_return([Syntaxer::LanguageDefinition.new(:ruby, ["rb.example", "rake"], ["Rakefile", "Thorfile"], ["**/*"], nil, "ruby -wc %filename%")])
+      Syntaxer.should_receive(:reader).and_return(reader)
+      Syntaxer.stub!(:root_path).and_return(@repo_dir)
+      repo = Syntaxer::Repository.factory(@repo_dir, :git)
+      Syntaxer.stub!(:repository).and_return(repo)
+    end
+    
+    subject {Syntaxer::RepoChecker.new(Syntaxer)}
+
+    it "should return correct error_files" do
+      subject.process
+      subject.fine_files.size.should_not eql(0)
+      subject.error_files.size.should_not eql(0)
+    end
+
+    it "should send to FileStatus" do
+      Syntaxer::FileStatus.should_receive(:build).twice
+      subject.process      
+    end
+
+    after(:each) do
+      FileUtils.rm_rf(@repo_dir)
+    end
+
+  end
+  
+
+end

data/spec/fixtures/haml/correct.html.haml

@@ -0,0 +1,4 @@
+- pretty_dialog :title => "Confirm Delete", :style => "display:none;", :id => "interview_confirm_delete_dialog" do |d|
+  %p.center Are you sure you want to delete this interview from your list?
+  = d.button :ok, :text => "Yes"
+  = d.button :cancel, :class => "cancel", :text => "No"

data/spec/fixtures/haml/wrong.html.haml

@@ -0,0 +1,4 @@
+- pretty_dialog :title => "Confirm Delete", :style => "display:none;", :id => "interview_confirm_delete_dialog" do |d|
+%p.center Are you sure you want to delete this interview from your list?
+= d.button :ok, :text => "Yes"
+= d.button :cancel, :class => "cancel", :text => "No"

data/spec/fixtures/ruby/correct.rb.example

@@ -0,0 +1,5 @@
+class A
+  def some_method
+    puts "Do nothing"
+  end
+end

data/spec/fixtures/ruby/wrong.rb.example

@@ -0,0 +1,2 @@
+cals A
+end

data/spec/fixtures/syntaxer_rules.rb

@@ -0,0 +1,13 @@
+syntaxer do
+
+  languages :ruby do
+    folders 'app/controllers/**/*'
+  end
+  
+  languages :haml do
+    folders 'app/views/**/*'  
+  end
+
+  #ignore_folders "app/models/**" # this folders will be deleted from all languages
+  
+end

data/spec/fixtures/syntaxer_rules_git.rb

@@ -0,0 +1,7 @@
+syntaxer do
+
+  languages :ruby do
+    folders '**/*'
+  end
+  
+end

data/spec/language_rules_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "LanguageRules" do
+  before(:each) do
+    @rules = Syntaxer::LanguageRules.new
+  end
+  
+  it "should raise exception if obj is not LanguageDefinition instance" do
+    lambda do 
+       @rules << "a"
+    end.should raise_exception(Syntaxer::LanguageDefinitionException)
+  end
+  
+  it "should not raise if LanguageDefinition object added" do
+    lambda do 
+       @rules << Syntaxer::LanguageDefinition.new(:ruby)
+    end.should_not raise_exception(Syntaxer::LanguageDefinitionException)
+  end
+  
+  context "LanguageDefinition" do
+    it "should not create w/o name" do
+      lambda do 
+         Syntaxer::LanguageDefinition.new
+      end.should raise_exception(Syntaxer::LanguageDefinitionException)
+    end    
+  end
+  
+  context "LanguageDefinition" do
+    it "#file_list should return correct file list based on rules" do
+      correct_array = Rake::FileList.new(File.dirname(__FILE__) + '/fixtures/ruby/*')
+      ld = Syntaxer::LanguageDefinition.new(:ruby, ["rb.example", "rake"], ["Rakefile", "Thorfile"], ["**/*"], nil, "`ruby -wc %filename%`")
+      ld.files_list(File.dirname(__FILE__) + '/fixtures/').should == correct_array
+    end
+  end
+  
+end

data/spec/printer_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Syntaxer" do
+  context "::Printer" do
+    
+    before(:each) do
+    end
+
+    subject{Syntaxer::Printer}
+
+    it "should be quite if passed --quite option" do
+      IO.should_not_receive(:print)
+      IO.should_not_receive(:puts)
+
+      subject.quite = true
+      subject.print_progress true
+      subject.print_result ['a','b']
+    end
+  end
+end

data/spec/reader_spec.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Syntaxer::Reader::DSLReader" do
+  
+  context "#build" do
+    it "should build from default distr rules files" do
+      @reader = Syntaxer::Reader::DSLReader.build
+      
+      @reader.rules.find(:ruby).should == Syntaxer::LanguageDefinition.new(:ruby, ["rb", "rake"], ["Rakefile", "Thorfile"], ["**/*"], nil, "ruby -wc %filename%")
+      @reader.rules.find(:haml).should == Syntaxer::LanguageDefinition.new(:haml, ["haml"], nil, ["**/*"], nil, "haml -c %filename%")
+      @reader.rules.find(:sass).should == Syntaxer::LanguageDefinition.new(:sass, ["sass"], nil, ["**/*"], nil, "sass -c %filename%")      
+      
+    end
+  end
+  
+  context "#parse" do
+    
+    it "should parse all languages" do
+      reader = Syntaxer::Reader::DSLReader.new
+      
+      reader.parse %|
+        syntaxer do
+          languages :ruby do
+            folders 'app/**/*', 'lib/**/*'
+          end
+          
+          languages :haml do
+            folders 'app/haml/**/*', 'lib/haml/**/*'
+          end
+        end
+      |
+      
+      reader.rules.find(:ruby).folders.should == ['app/**/*', 'lib/**/*']
+      reader.rules.find(:haml).folders.should == ["app/haml/**/*", "lib/haml/**/*"]      
+    end
+    
+    it "should load from file" do
+      reader = Syntaxer::Reader::DSLReader.load(syntaxer_rules_example_file)
+      reader.rules.find(:ruby).folders.should == ["app/controllers/**/*"]
+      reader.rules.find(:haml).folders.should == ["app/views/**/*"]     
+    end
+    
+    it "should do substitution for the same rules" do
+      reader = Syntaxer::Reader::DSLReader.build
+      reader.rules.find(:ruby).folders.should == ["**/*"]
+      
+      reader.parse %|
+        syntaxer do
+          languages :ruby do
+            folders 'app/**/*', 'lib/**/*'
+          end
+        end
+      |
+      
+      reader.rules.find(:ruby).folders.should == ["app/**/*", "lib/**/*"]
+      
+    end
+  end
+  
+  context "raise exceptions" do
+    before(:each) do
+      @reader = Syntaxer::Reader::DSLReader.new      
+    end
+    
+    it "should raise exception if illegal formating of dsl file" do
+      lambda do 
+        @reader.parse %|
+          syntaxer2 do
+          end
+        |
+      end.should raise_exception(Syntaxer::Reader::DSLSyntaxError)
+    end
+  end
+  
+  context "#folders should change current_rule folders attr" do
+    
+    before(:each) do
+      @reader = Syntaxer::Reader::DSLReader.new
+      @current_rule = Syntaxer::LanguageDefinition.new(:name => :ruby)
+      @reader.stub!(:current_rule).and_return(@current_rule)      
+    end
+    
+    it "should return DEFAULT_FILES_MASK if no params given" do
+      @reader.folders()
+      @current_rule.folders.should == [Syntaxer::DEFAULT_FILES_MASK]
+    end
+    
+    it "should return params back" do
+      @reader.folders('app/**/*', 'app/lib/*')
+      @current_rule.folders.should == ['app/**/*', 'app/lib/*']      
+    end
+        
+    it "should change predefined folders" do
+      old_files = "app/libs/bla/*"
+      new_files = ['app/**/*', 'app/lib/*'] 
+      @current_rule.folders = old_files
+      @current_rule.folders.should == old_files   
+      
+      @reader.folders(new_files)
+      @current_rule.folders.should == new_files    
+    end
+  end
+  
+  context "#overall_ignore_folders" do
+    
+    before(:each) do
+      @reader = Syntaxer::Reader::DSLReader.new
+    end
+    
+    it "should return DEFAULT_FILES_MASK if no params given" do
+      @reader.overall_ignore_folders('app/**/*', 'app/lib/*').should == ['app/**/*', 'app/lib/*']
+    end
+    
+    it "should return params back" do
+      @reader.overall_ignore_folders().should == []
+    end   
+  end
+    
+end

data/spec/repository_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Syntaxer::Repository" do
+  context "Git" do
+    it "should not raise exception if there are no any revision" do
+      @repo_dir = create_temp_ruby_project
+      add_file_to_repo(:ruby, @repo_dir, 'wrong.rb.example')
+      lambda{Syntaxer::Git.new(@repo_dir)}.should_not raise_exception
+      FileUtils.rm_rf(@repo_dir)
+    end
+  end
+end