mactag 0.4.0 → 0.5.3

data/lib/mactag/errors.rb

@@ -0,0 +1,32 @@
+module Mactag
+  class MactagError < StandardError
+  end
+
+  class PluginNotFoundError < MactagError
+    attr_reader :plugin
+
+    def initialize(plugin)
+      @plugin = plugin
+    end
+
+    def to_s
+      "Plugin #{plugin.name} not found"
+    end
+  end
+
+  class GemNotFoundError < MactagError
+    attr_reader :gem
+
+    def initialize(gem)
+      @gem = gem
+    end
+
+    def to_s
+      if gem.version
+        "Gem #{gem.name} with version #{gem.version} not found"
+      else
+        "Gem #{gem.name} not found"
+      end
+    end
+  end
+end

data/lib/mactag/tag.rb

@@ -3,5 +3,7 @@ require 'mactag/tag/plugin'
 require 'mactag/tag/gem'
 require 'mactag/tag/rails'
 
-module Tag
+module Mactag
+  module Tag
+  end
 end

data/lib/mactag/tag/app.rb

@@ -2,17 +2,17 @@ module Mactag
   module Tag
     ##
     #
-    # Tags files in current Rails application.
+    # Tag files in Rails project.
     #
     # ==== Examples
     #   Mactag do
     #     # Tag single file
     #     app 'lib/super_duper.rb'
     #
-    #     # Tag all files in lib, recursive
+    #     # Tag all ruby files in lib, recursive
     #     app 'lib/**/*.rb'
     #
-    #     # Tag all helpers and models
+    #     # Tag all helper and model ruby files
     #     app 'app/helpers/*.rb', 'app/models/*.rb'
     #
     #     # Same as above

data/lib/mactag/tag/gem.rb

@@ -20,6 +20,8 @@ module Mactag
     #   do
     #
     class Gem
+      attr_accessor :name, :version
+
       def initialize(name, version = nil)
         @name = name
         @version = version
@@ -27,53 +29,51 @@ module Mactag
 
       def tag
         if exists?
-          if @version
-            gem = splash
-          else
-            gem = Gem.most_recent(@name)
+          unless version
+            @version = Mactag::Tag::Gem.last(name)
           end
-          File.join(Mactag::Config.gem_home, gem, 'lib', '**', '*.rb')
+
+          File.join(Mactag::Config.gem_home, combo, 'lib', '**', '*.rb')
         else
-          Mactag.warn "Gem #{@version ? splash : @name} not found"
+          raise GemNotFoundError.new(self)
         end
       end
 
-      def self.all
-        gems = {}
-        Bundler.load.specs.each do |spec|
-          gems[spec.name] = spec.version.to_s
-        end
-
-        default = Bundler.load.dependencies.select { |dependency| dependency.groups.include?(:default) }.collect(&:name)
-        default.delete('rails')
-        default.collect { |tmp| Gem.new(tmp, gems[tmp]) }
+      def exists?
+        Mactag::Tag::Gem.dirs(name).size > 0
       end
 
-      def self.most_recent(name)
-        versions = Dir.glob(File.join(Mactag::Config.gem_home, name) + "-*")
-        unless versions.empty?
-          if versions.size == 1
-            gem = versions.first
-          else
-            gem = versions.sort.last
+      class << self
+        def all
+          # Mactag::Bundler.gems
+          bundler = Mactag::Bundler.new
+          bundler.gems
+        end
+
+        def last(name)
+          dirs = Mactag::Tag::Gem.dirs(name)
+          unless dirs.empty?
+            if dirs.size == 1
+              gem = dirs.first
+            else
+              gem = dirs.sort.last
+            end
+            if /-(.+)$/.match(gem)
+              $1
+            end
           end
-          File.basename(gem)
+        end
+
+        def dirs(name)
+          Dir.glob(File.join(Mactag::Config.gem_home, "#{name}-*"))
         end
       end
 
 
       private
 
-      def exists?
-        if @version
-          File.directory?(File.join(Mactag::Config.gem_home, splash))
-        else
-          Gem.most_recent(@name)
-        end
-      end
-
-      def splash
-        "#{@name}-#{@version}"
+      def combo
+        "#{name}-#{version}"
       end
     end
   end

data/lib/mactag/tag/plugin.rb

@@ -2,7 +2,7 @@ module Mactag
   module Tag
     ##
     #
-    # Tags plugins in current Rails application.
+    # Tag plugins in Rails project.
     #
     # ==== Examples
     #   Mactag do
@@ -17,29 +17,35 @@ module Mactag
     #   do
     #
     class Plugin
-      PLUGIN_PATH = File.join('vendor', 'plugins')
+      PLUGIN_PATH = %w(vendor plugins)
 
-      def initialize(plugin)
-        @plugin = plugin
+      attr_accessor :name
+
+      def initialize(name)
+        @name = name
       end
 
       def tag
         if exists?
-          return File.join(PLUGIN_PATH, @plugin, 'lib', '**', '*.rb')
+          return File.join(PLUGIN_PATH, name, 'lib', '**', '*.rb')
         else
-          Mactag.warn "Plugin #{@plugin} not found"
+          raise PluginNotFoundError.new(self)
         end
       end
-      
-      def self.all
-        Dir.glob(File.join(PLUGIN_PATH, '*')).collect { |f| File.basename(f) }
-      end
-      
-      
-      private
-      
+
       def exists?
-        File.directory?(File.join(PLUGIN_PATH, @plugin))
+        File.directory?(path)
+      end
+
+      def path
+        File.join(PLUGIN_PATH, name)
+      end
+
+      def self.all
+        pattern = File.join(PLUGIN_PATH, '*')
+        Dir.glob(pattern).map do |f|
+          File.basename(f)
+        end
       end
     end
   end

data/lib/mactag/tag/rails.rb

@@ -41,52 +41,45 @@ module Mactag
     #   do
     #
     class Rails
-      PACKAGES = [:actionmailer, :actionpack, :activemodel, :activerecord, :activeresource, :railties, :activesupport]
 
-      def initialize(options)
-        @options = options
+      PACKAGES = %w(actionmailer actionpack activemodel activerecord activeresource activesupport railties)
+
+      attr_accessor :only, :except, :version
 
-        @only = packagize!(options[:only])
-        @except = packagize!(options[:except])
+      def initialize(options)
+        @only = packagize(options[:only])
+        @except = packagize(options[:except])
+        @version = options[:version]
       end
 
       def tag
-        result = []
-        packages.each do |package|
-          if PACKAGES.include?(package)
-            result << Gem.new(package.to_s, version).tag
-          end
+        packages.inject([]) do |array, package|
+          array << Gem.new(package, version).tag
+          array
         end
-        result
       end
 
-
-      private
-      
       def packages
-        result = []
-        unless @only || @except
-          result = PACKAGES
+        if only || except
+          only || PACKAGES - except
         else
-          if @only
-            result = @only
-          elsif @except
-            result = PACKAGES - @except
-          end
+          PACKAGES
         end
-        result
       end
-      
-      def packagize!(pkgs)
+
+
+      private
+
+      def packagize(pkgs)
         return nil if pkgs.blank?
 
-        Array(pkgs).collect do |pkg|
-          "#{pkg}".gsub(/[^a-z]/, '').to_sym
+        Array(pkgs).map do |pkg|
+          "#{pkg}".gsub(/[^a-z]/, '')
         end
       end
-      
+
       def version
-        @options[:version] || ::Rails.version
+        @version || ::Rails.version
       end
     end
   end

data/lib/tasks/mactag.rake

@@ -1,21 +1,8 @@
 task :environment
 
-def load_configuration
+desc 'Creates a Ctags file'
+task :mactag => :environment do
   require File.join(Rails.root, 'config', 'mactag')
-end
-
-namespace :mactag do
-  desc 'Creates Ctags file'
-  task :create => :environment do
-    load_configuration
-
-    Mactag::Builder.create
-  end
-
-  desc 'Starts the Mactag server'
-  task :server => :environment do
-    load_configuration
 
-    Mactag::Server.start
-  end
+  Mactag::Builder.create
 end

data/spec/mactag/builder_spec.rb

@@ -10,124 +10,143 @@ describe Mactag::Builder do
       @tag = Mactag::Tag::App.new('app')
     end
 
-    it 'should add single tag' do
+    it 'adds single tag' do
       @builder << @tag
 
-      @builder.instance_variable_get('@tags').should =~ [@tag]
+      @builder.instance_variable_get('@tags').should eq([@tag])
     end
 
-    it 'should add multiple tags' do
+    it 'adds multiple tags' do
       @builder << [@tag, @tag]
 
-      @builder.instance_variable_get('@tags').should =~ [@tag, @tag]
+      @builder.instance_variable_get('@tags').should eq([@tag, @tag])
     end
   end
 
   describe '#files' do
     before do
-      Dir.stub!(:glob).and_return { |file| [file] }
-      File.stub!(:expand_path).and_return { |file| file }
-      File.stub!(:directory?).and_return(false)
+      Dir.stub(:glob) { |file| [file] }
+      File.stub(:expand_path) { |file| file }
+      File.stub(:directory?) { false }
     end
 
-    it 'should flatten all files' do
-      @builder.stub!(:all).and_return([['app'], 'lib'])
-      @builder.files.should =~ ['app', 'lib']
+    it 'flattens all files' do
+      @builder.stub(:all) { [['app'], 'lib'] }
+      @builder.files.should eq(['app', 'lib'])
     end
 
-    it 'should compact all files' do
-      @builder.stub!(:all).and_return([nil, 'app', nil, 'lib', nil])
-      @builder.files.should =~ ['app', 'lib']
+    it 'compacts all files' do
+      @builder.stub(:all) { [nil, 'app', nil, 'lib', nil] }
+      @builder.files.should eq(['app', 'lib'])
     end
 
-    it 'should expand all files' do
-      @builder.stub!(:all).and_return(['app', 'lib'])
+    it 'expands all files' do
+      @builder.stub(:all) { ['app', 'lib'] }
       File.should_receive(:expand_path).with('app')
       File.should_receive(:expand_path).with('lib')
       @builder.files
     end
 
-    it 'should glob all files' do
-      @builder.stub!(:all).and_return(['app', 'lib'])
+    it 'globs all files' do
+      @builder.stub(:all) { ['app', 'lib'] }
       Dir.should_receive(:glob).with('app')
       Dir.should_receive(:glob).with('lib')
       @builder.files
     end
 
-    it 'should uniquify files' do
-      @builder.stub!(:all).and_return(['app', 'lib', 'lib', 'app'])
-      @builder.files.should =~ ['app', 'lib']
+    it 'uniquifies files' do
+      @builder.stub(:all) { ['app', 'lib', 'lib', 'app'] }
+      @builder.files.should eq(['app', 'lib'])
     end
-    
-    it 'should not return directories' do
-      @builder.stub!(:all).and_return(['app'])
-      Dir.stub!(:glob).and_return(['app'])
-      File.stub!(:directory?).and_return(true)
+
+    it 'does not return directories' do
+      @builder.stub(:all) { ['app'] }
+      Dir.stub(:glob) { ['app'] }
+      File.stub(:directory?) { true }
       @builder.files.should be_empty
     end
   end
-  
+
   describe '#directories' do
-    it 'should return all file dirnames' do
-      @builder.stub!(:files).and_return(['app/models/user.rb', 'lib/validate.rb'])
-      @builder.directories.should =~ ['app/models', 'lib']
+    it 'returns all file dirnames' do
+      @builder.stub(:files) { ['app/models/user.rb', 'lib/validate.rb'] }
+      @builder.directories.should eq(['app/models', 'lib'])
     end
-    
-    it 'should only return uniq directories' do
-      @builder.stub!(:files).and_return(['app/models/user.rb', 'app/models/post.rb'])
-      @builder.directories.should =~ ['app/models']
+
+    it 'returns uniq directories' do
+      @builder.stub(:files) { ['app/models/user.rb', 'app/models/post.rb'] }
+      @builder.directories.should eq(['app/models'])
     end
   end
 
   describe '#all' do
-    it 'should return all files' do
+    it 'returns all files' do
       @builder << Mactag::Tag::App.new('app')
       @builder << Mactag::Tag::App.new('lib')
 
-      @builder.all.should =~ ['app', 'lib']
+      @builder.all.should eq(['app', 'lib'])
     end
 
-    it 'should return empty array when no tags' do
+    it 'returns empty array when no tags' do
       @builder.all.should be_empty
     end
   end
 
   describe '#gems?' do
-    it 'should be true when tags exists' do
-      @builder.stub!(:all).and_return(['app'])
+    it 'is true when tags exists' do
+      @builder.stub(:all) { ['app'] }
+
+      @builder.should have_gems
+    end
+
+    it 'is false when no tags exists' do
+      @builder.stub(:all) { [] }
 
-      @builder.gems?.should be_true
+      @builder.should_not have_gems
     end
+  end
 
-    it 'should be false when no tags exists' do
-      @builder.stub!(:all).and_return([])
+  describe '#create' do
+    it 'raises error when gem home does not exist' do
+      Mactag::Builder.stub(:gem_home_exists?) { false }
+      proc {
+        Mactag::Builder.create
+      }.should raise_exception(Mactag::MactagError)
+    end
 
-      @builder.gems?.should be_false
+    it 'raises errors when gem home exists but there are no gems' do
+      Mactag::Builder.stub(:gem_home_exists?) { true }
+      Mactag::Builder.stub(:builder) { mock(:has_gems? => false) }
+      proc {
+        Mactag::Builder.create
+      }.should raise_exception(Mactag::MactagError)
     end
   end
 
   describe '#generate' do
-    it 'should accept a block as argument' do
-      lambda { Mactag::Builder.generate {} }.should_not raise_exception
+    it 'accepts a block as argument' do
+      proc {
+        Mactag::Builder.generate {}
+      }.should_not raise_exception
     end
   end
 
   describe '#gem_home_exists?' do
-    it 'should exist when directory exists' do
-      File.stub!(:directory?).and_return(true)
+    it 'exists when directory exists' do
+      File.stub(:directory?) { true }
 
       Mactag::Builder.gem_home_exists?.should be_true
     end
 
-    it 'should not exist when directory does not exist' do
+    it 'does not exist when directory does not exist' do
       File.stub!(:directory?).and_return(false)
 
       Mactag::Builder.gem_home_exists?.should be_false
     end
   end
-  
+
   describe '#builder' do
-    it 'should return builder instance' do
+    it 'returns builder instance' do
       Mactag::Builder.generate {}
       Mactag::Builder.builder.should == Mactag::Builder.instance_variable_get('@builder')
     end