sashimi 0.1.7 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,69 @@
+* *v0.2.0*
+
+* Tagged v0.2.0
+
+* Prepare for v0.2.0
+
+* Ignored flunked test cases
+
+* Massive changelog
+
+* rdoc formatting
+
+* Using, where possible, @@class_variable and cattr_reader instead of class methods. Documentation improvements.
+
+* Don't try to remove the gem from working copy at the beginning of Rake install
+
+* Print plugin name when execute uninstall command
+
+* Aliased #cache_content with #list in order to clean up AbstractRepository from stdout formattin code. The code was moved to Commands::List
+
+* Clean up for #with_path in test_helper.rb
+
+* Removed with_path from #files_scheduled_for_add and #files_scheduled_for_remove because #update_versioned_rails_plugins already works in vendor/plugins
+
+* Removed unnecessary with_path statement from AbstractRepository#prepare_installation
+
+* Removed unnecessary with_path statement from AbstractRepository#remove_temp_folder
+
+* Removed unnecessary with_path statement from AbstractRepository#update_unversioned_rails_plugins
+
+* Removed with_path from #update_rails_plugins, because update command should be always executed from the root of a Rails app
+
+* Removed unnecessary with_path statement from AbstractRepository#copy_plugin_to_rails_app
+
+* Removed unnecessary with_path statement for AbstractRepository#write_to_cache
+
+* Remove builded gem from working copy, after rake install task
+
+* Don't generate rdoc and ri on Rake install
+
+* Fixed AbstractRepository#update_versioned_rails_plugins. Made AbstractRepository#temp_plugin_name public
+
+* Created install Rake task
+
+* Improved test coverage for AbstractRepository
+
+* Added AbstractRepository#temp_plugin_name
+
+* File#join -> Array#to_path or String#to_path. Code cleanup.
+
+* Improved tests for AbstractRepository cache and instantiation
+
+* Improved test coverage for AbstractRepository
+
+* Added tests for uninstall. Re-enabled tests.
+
+* Initial rewriting of test suite
+
+* Added String#to_path and Array#to_path
+
+* Added AbstractRepository#with_path in order to scopify current directory changes
+
+* Added block support to Class#class_method_proxy
+
+
+
 * *v0.1.7*
 
 * Tagged v0.1.7

data/README

@@ -1,82 +1,80 @@
-Sashimi
-=======
+= Sashimi
 
 Sashimi is a Rails plugins manager.
+
 It allows to install your favourite plugins in a local repository and add them to your Rails apps.
 The main goal is to allow the plugins offline installation.
 
 
 
-Installation
-============
+= Installation
 
-$ (sudo) gem install sashimi
+  $ (sudo) gem install sashimi
 
 or
 
-$ (sudo) gem install jodosha-sashimi --source=http://gems.github.com
+  $ (sudo) gem install jodosha-sashimi --source=http://gems.github.com
 
 
 
-Usage
-=====
+= Usage
 
 Install a plugin from a subversion URL:
-$ sashimi install http://dev.rubyonrails.com/svn/rails/plugins/continuous_builder
+  $ sashimi install http://dev.rubyonrails.com/svn/rails/plugins/continuous_builder
 
 Install a plugin from a git URL:
-$ sashimi install git://github.com/jodosha/click-to-globalize.git
+  $ sashimi install git://github.com/jodosha/click-to-globalize.git
 
 Uninstall a plugin:
-$ sashimi uninstall continuous_builder
+  $ sashimi uninstall continuous_builder
 
 Update a plugin:
-$ sashimi update click-to-globalize
+  $ sashimi update click-to-globalize
 
 Update a plugin of a Rails app:
-$ sashimi update --rails click-to-globalize
+  $ sashimi update --rails click-to-globalize
 
 NOTE: If your application is versioned with Svn or Git, Sashimi will automatically schedules for add/remove the added/removed files.
 
 List all installed plugins:
-$ sashimi list
+  $ sashimi list
 
 Add installed plugin(s) to a Rails app:
-$ sashimi add click-to-globalize
-$ sashimi install --rails click-to-globalize
+  $ sashimi add click-to-globalize
+or
+  $ sashimi install --rails click-to-globalize
 
 
 
-Known And Common Issues
-=======================
+= Known And Common Issues
 
 * When add a plugin to an app, make sure your current directory is the rails root.
 
 * Only Subversion and Git repositories are currently supported.
 
 
-Contribute
-==========
+= Contribute
 
 * Check out the code and test it:
+
   $ git clone git://github.com/jodosha/sashimi.git
+  
   $ rake
 
-* Create a ticket to: http://sushistar.lighthouseapp.com
+* Create a ticket to the {Sushistar Lighthouse page}[http://sushistar.lighthouseapp.com]
 
 * Create a patch and add as attachement to the ticket.
 
 
-Credits
-=======
+= Credits
 
 Partially inspired to RaPT[http://rapt.rubyforge.org/].
 
 
 
-Home Page
-=========
-http://lucaguidi.com/pages/sashimi
+= Home Page
+
+The Sashimi homepage is http://lucaguidi.com/pages/sashimi
 
 
 

data/Rakefile

@@ -1,3 +1,4 @@
+$:.unshift 'lib'
 require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
@@ -20,3 +21,12 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+desc 'Build and install the gem (useful for development purposes).'
+task :install do
+  require 'sashimi'
+  system "gem build sashimi.gemspec"
+  system "sudo gem uninstall sashimi"
+  system "sudo gem install --local --no-rdoc --no-ri sashimi-#{Sashimi::VERSION::STRING}.gem"
+  system "rm sashimi-*.gem"
+end

data/lib/sashimi/commands.rb

@@ -125,6 +125,7 @@ module Sashimi
       def parse!(args)
         options.parse!(args)
         args.each do |name|
+          puts name.titleize + "\n"
           Plugin.new(name).uninstall
         end
       end
@@ -179,7 +180,10 @@ module Sashimi
       
       def parse!(args)
         options.parse!(args)
-        puts Plugin.list
+        output = Plugin.list.sort.collect do |plugin, contents|
+          "#{plugin}\t\t#{contents['summary']}"
+        end.join("\n")
+        puts output
       end
     end
 

data/lib/sashimi/core_ext/array.rb

@@ -0,0 +1,22 @@
+class Array
+  # Transform the current +Array+ to a path.
+  #
+  # It's an alias for <tt>File#join</tt>.
+  #
+  #    %w(path to app).to_path # => path/to/app+
+  #    %w(path to app).to_path(true) # => /Users/luca/path/to/app
+  def to_path(absolute = false)
+    path = File.join(self)
+    path = File.expand_path(path) if absolute
+    path
+  end
+
+  # Transform the current +Array+ to an absolute path.
+  #
+  #    %w(path to app).to_absolute_path # => /Users/luca/path/to/app
+  #    %w(path to app).to_abs_path # => /Users/luca/path/to/app
+  def to_absolute_path
+    to_path(true)
+  end
+  alias_method :to_abs_path, :to_absolute_path
+end

data/lib/sashimi/core_ext/class.rb

@@ -21,8 +21,8 @@ class Class
     method_names.each do |m|
       self.class_eval %{
         # Proxy method for <tt>#{self.class.name}##{m}</tt>
-        def #{m}(*args)
-          self.class.#{m}(*args)
+        def #{m}(*args, &block)
+          self.class.#{m}(*args, &block)
         end
         private :#{m}
       }, __FILE__, __LINE__

data/lib/sashimi/core_ext/string.rb

@@ -0,0 +1,13 @@
+class String
+  # Transform the current +String+ to a system path,
+  # according to the current platform file system.
+  #
+  #  "path/to/app".to_path # => path/to/app (on *nix)
+  #  "path/to/app".to_path # => path\to\app (on Windows)
+  #
+  #  "path/to/app".to_path(true) # => /Users/luca/path/to/app (on *nix)
+  #  "path/to/app".to_path(true) # => C:\path\to\app (on Windows)
+  def to_path(absolute = false)
+    self.split(/\/\\/).to_path(absolute)
+  end
+end

data/lib/sashimi/plugin.rb

@@ -30,9 +30,8 @@ module Sashimi
     def repository #:nodoc:
       @repository ||= instantiate_repository
     end
-    
-    # Read the content of the <tt>about.yml</tt>.
-    # New feature of Rails 2.1.x http:://dev.rubyonrails.org/changeset/9098
+
+    # Returns the informations about the plugin.
     def about
       @about ||= repository.about
     end
@@ -52,7 +51,7 @@ module Sashimi
       name
     end
     
-    # Serialize the plugin to Hash format.
+    # Serialize the plugin to +Hash+ format.
     def to_hash
       { self.guess_name => 
         { 'type' => repository.scm_type,

data/lib/sashimi/repositories/abstract_repository.rb

@@ -1,49 +1,63 @@
 module Sashimi
   class PluginNotFound < StandardError #:nodoc:
     def initialize(plugin_name, message = nil)
-      @plugin_name = plugin_name
-      @message     = message
+      @plugin_name, @message = plugin_name, message
     end
 
     def to_s
-      @message || @plugin_name + " isn't in the local repository."
+      @message || @plugin_name.to_s + " isn't in the local repository."
     end
   end
   
   class AbstractRepository
-    @@local_repository_sub_path = File.join('.rails', 'plugins')
+    TEMP_SUFFIX = '-tmp'
+
+    # It's the path where the plugins are stored.
+    @@plugins_path = ".rails/plugins".to_path
+
+    # Conventional path where Rails applications use to place their plugins.
+    @@rails_plugins_path = "vendor/plugins".to_path
+    cattr_reader :rails_plugins_path
+
+    # Cache file used to store informations about installed plugins.
     @@cache_file = '.plugins'
     cattr_accessor :cache_file
     
-    attr_accessor :plugin
+    attr_reader :plugin
     
     def initialize(plugin)
-      self.plugin = plugin
+      @plugin = plugin
     end
     
-    # Remove the repository
+    # Uninstall the current plugin.
     def uninstall
-      change_dir_to_local_repository
-      raise PluginNotFound.new(plugin.name) unless File.exists?(plugin.name)
-      FileUtils.rm_rf(plugin.name)
-      remove_from_cache
+      with_path local_repository_path do
+        raise PluginNotFound.new(plugin.name) unless File.exists?(plugin.name)
+        FileUtils.rm_rf(plugin.name)
+        remove_from_cache
+      end
     end
     
-    # Add to a Rails app.
+    # Add the current plugin to a Rails app.
     def add
+      raise PluginNotFound.new(plugin.name) unless cache_content.keys.include?(plugin.name)
       puts plugin.name.titleize + "\n"
       copy_plugin_and_remove_hidden_folders
       rename_temp_folder
       run_install_hook
     end
 
-    # Copy a plugin to a Rails app and remove SCM hidden folders
+    # Copy a plugin to a Rails app and remove SCM hidden folders.
     def copy_plugin_and_remove_hidden_folders
       copy_plugin_to_rails_app
-      remove_hidden_folders      
+      remove_hidden_folders
     end
 
     class << self
+      # Instantiate a repository (Svn or Git) for the given plugin.
+      #
+      # If the plugin was already installed it load from the cache,
+      # otherwise it try to guess information from its url.
       def instantiate_repository(plugin)
         unless plugin.name.nil?
           instantiate_repository_by_cache(plugin)
@@ -52,21 +66,16 @@ module Sashimi
         end.new(plugin)
       end
 
-      # Return all installed plugin names and summary, formatted for stdout.
-      def list
-        cache_content.sort.collect do |plugin, contents|
-          "#{plugin}\t\t#{contents['summary']}"
-        end.join("\n")
-      end
-
       # Return all installed plugins names.
       def plugins_names
         cache_content.keys.sort
       end
 
       # Update the plugins installed in a rails app.
+      #
+      # If the application is under version control, +Sashimi+ cares about to
+      # schedule add/remove plugin's files from/to your SCM of choice.
       def update_rails_plugins(plugins_names)
-        change_dir(path_to_rails_app)
         if under_version_control?
           update_versioned_rails_plugins(plugins_names)
         else
@@ -74,37 +83,39 @@ module Sashimi
         end
       end
 
-      # Update the plugins installed in a non versioned rails app.
+      # Update the plugins installed in a <b>not versioned</b> Rails app.
       def update_unversioned_rails_plugins(plugins_names)
-        change_dir(plugins_dir)
         plugins_names.each do |plugin_name|
-          FileUtils.rm_rf(plugin_name)
+          FileUtils.rm_rf [ absolute_rails_plugins_path, plugin_name ].to_path
           Plugin.new(plugin_name).add
         end
       end
 
-      # Update the plugins installed in a versioned rails app.
+      # Update the plugins installed in a <b>versioned</b> Rails app.
       def update_versioned_rails_plugins(plugins_names)
-        change_dir(plugins_dir)
-        plugins_names.each do |plugin_name|
-          raise PluginNotFound.new(plugin_name) unless File.exists?(plugin_name)
-          repository = Plugin.new(plugin_name).repository
-          repository.copy_plugin_and_remove_hidden_folders
-          files_scheduled_for_remove = repository.files_scheduled_for_remove
-          files_scheduled_for_add    = repository.files_scheduled_for_add
-          FileUtils.cp_r(plugin_name+'-tmp/.', plugin_name)
-          repository.remove_temp_folder
-          change_dir(plugin_name)
-          files_scheduled_for_remove.each {|file| scm_remove file}
-          files_scheduled_for_add.each {|file| scm_add file}
+        with_path absolute_rails_plugins_path do
+          plugins_names.each do |plugin_name|
+            raise PluginNotFound.new(plugin_name) unless File.exists?(plugin_name)
+            repository = Plugin.new(plugin_name).repository
+            repository.copy_plugin_and_remove_hidden_folders
+            files_scheduled_for_remove = repository.files_scheduled_for_remove
+            files_scheduled_for_add    = repository.files_scheduled_for_add
+            FileUtils.cp_r(repository.temp_plugin_name+'/.', plugin_name)
+            repository.remove_temp_folder
+            with_path plugin_name do
+              files_scheduled_for_remove.each {|file| scm_remove file}
+              files_scheduled_for_add.each {|file| scm_add file}
+            end
+          end
         end
       end
 
-      # Schedules an add for the given file on the current SCM system used by the Rails app.
+      # Schedules an <b>add</b> for the given file on the current SCM system used by the Rails app.
       def scm_add(file)
         scm_command(:add, file)
       end
 
+      # Schedules a <b>remove</b> for the given file on the current SCM system used by the Rails app.
       def scm_remove(file)
         scm_command(:rm, file)
       end
@@ -112,55 +123,51 @@ module Sashimi
       # Execute the given command for the current SCM system used by the Rails app.
       def scm_command(command, file)
         scm = guess_version_control_system
-        system("#{scm} #{command} #{file}")
+        Kernel.system("#{scm} #{command} #{file}")
       end
 
+      # It's the absolute path where the plugins are stored.
+      #
+      # Typically, it's under your home directory.
       def local_repository_path #:nodoc:
-        @local_repository_path ||= File.join(find_home, @@local_repository_sub_path) 
+        @local_repository_path ||= [ find_home, @@plugins_path ].to_path
       end
 
-      # Return the path to the Rails app where the user launched sashimi command.
+      # Return the path to the Rails app where the user launched <tt>sashimi</tt> command.
       def path_to_rails_app
         $rails_app
       end
 
       # Read the cache file and return the content as an <tt>Hash</tt>.
       def cache_content
-        change_dir_to_local_repository
-        @@cache_content ||= (YAML::load_file(cache_file) || {}).to_hash
+        with_path local_repository_path do
+          @@cache_content ||= (YAML::load_file(cache_file) || {}).to_hash
+        end
       end
+      alias_method :list, :cache_content
 
+      # Istantiate a +Repository+ for the given +plugin+, guessing if its url
+      # refers to a Svn or Git repository.
       def instantiate_repository_by_url(plugin)
         git_url?(plugin.url) ? GitRepository : SvnRepository
       end
 
+      # Instantiate a repository for the given +plugin+, loading informations
+      # from the cache.
       def instantiate_repository_by_cache(plugin)
         cached_plugin = cache_content[plugin.name]
         raise PluginNotFound.new(plugin.name) if cached_plugin.nil?
         cached_plugin['type'] == 'git' ? GitRepository : SvnRepository
       end
-
-      # Changes the current directory with the given one
-      def change_dir(dir)
-        FileUtils.cd(dir)
-      end
-      
-      # Change the current directory with local_repository_path
-      def change_dir_to_local_repository
-        change_dir(local_repository_path)
-      end
-      
-      # Change the current directory with the fully qualified
-      # path to Rails app and plugins_dir.
-      def change_dir_to_absolute_plugins_dir
-        change_dir(File.join(File.expand_path(path_to_rails_app), plugins_dir))
-      end
-      
-      # Rails app plugins dir
-      def plugins_dir
-        @@plugins_dir ||= File.join('vendor', 'plugins')
+            
+      # It's absolute path of plugins in your Rails app.
+      #
+      #   path/to/rails_app # => /Users/luca/path/to/rails_app/vendor/plugins
+      def absolute_rails_plugins_path
+        @@absolute_rails_plugins_path = [ path_to_rails_app,
+          rails_plugins_path ].to_path(true)
       end
-      
+
       # Check if the current working directory is under version control
       def under_version_control?
         !Dir.glob(".{git,svn}").empty?
@@ -194,6 +201,17 @@ module Sashimi
       def git_url?(url)
         url =~ /^git:\/\// || url =~ /\.git$/
       end
+      
+      # Yield the given block executing it in the specified path
+      def with_path(path, &block)
+        begin
+          old_path = Dir.pwd
+          FileUtils.cd(path)
+          yield
+        ensure
+          FileUtils.cd(old_path)
+        end
+      end
     end
 
     # Return the SCM type
@@ -205,48 +223,50 @@ module Sashimi
     end
     
     # Read the content of the <tt>about.yml</tt>.
-    # New feature of Rails 2.1.x http:://dev.rubyonrails.org/changeset/9098
+    #
+    # New feature of Rails 2.1.0 http://github.com/rails/rails/commit/f5b991d76dc5d21f1870da067fb3101440256fba
     def about
-      change_dir_to_plugin_path
-      return {} unless File.exists?('about.yml')
-      (YAML::load_file('about.yml') || {}).to_hash
+      with_path plugin_path do
+        (YAML::load_file('about.yml') rescue {}).to_hash
+      end
     end
 
     # Returns a list of files that should be scheduled for SCM add.
     def files_scheduled_for_add
-      change_dir_to_absolute_plugins_dir
-      Dir[plugin.name+"-tmp/**/*"].collect {|fn| fn.gsub(plugin.name+'-tmp', '.')} -
+      Dir[temp_plugin_name+"/**/*"].collect {|fn| fn.gsub(temp_plugin_name, '.')} -
         Dir[plugin.name+"/**/*"].collect{|fn| fn.gsub(plugin.name, '.')}
     end
     
     # Returns a list of files that should be scheduled for SCM remove.
     def files_scheduled_for_remove
-      change_dir_to_absolute_plugins_dir
       Dir[plugin.name+"/**/*"].collect {|fn| fn.gsub(plugin.name, '.')} -
-        Dir[plugin.name+"-tmp/**/*"].collect {|fn| fn.gsub(plugin.name+"-tmp", '.')}
+        Dir[temp_plugin_name+"/**/*"].collect {|fn| fn.gsub(temp_plugin_name, '.')}
     end
     
     # Remove the temp folder, used by update process.
     def remove_temp_folder
-      change_dir_to_absolute_plugins_dir
-      FileUtils.rm_rf(plugin.name+'-tmp')
+      FileUtils.rm_rf [ absolute_rails_plugins_path, temp_plugin_name ].to_path
     end
     
-    class_method_proxy :change_dir, :change_dir_to_local_repository,
-      :change_dir_to_absolute_plugins_dir, :local_repository_path,
-      :cache_file, :cache_content, :plugins_dir, :path_to_rails_app
+    # Returns the name used for temporary plugin folder.
+    def temp_plugin_name
+      plugin.name + TEMP_SUFFIX
+    end
+
+    class_method_proxy :local_repository_path, :cache_file,
+      :cache_content, :path_to_rails_app, :rails_plugins_path,
+      :with_path, :absolute_rails_plugins_path
 
   private
-    # Change the current directory with the plugin one
-    def change_dir_to_plugin_path
-      change_dir(File.join(local_repository_path, plugin.name || plugin.guess_name))
+    # Returns the path to the plugin
+    def plugin_path
+      [ local_repository_path, plugin.name || plugin.guess_name ].to_path
     end
 
     # Prepare the plugin installation
     def prepare_installation
-      FileUtils.mkdir_p(local_repository_path)
-      change_dir_to_local_repository
-      FileUtils.touch(cache_file)
+      FileUtils.mkdir_p local_repository_path
+      FileUtils.touch [ local_repository_path, cache_file ].to_path
     end
     
     # Add a plugin into the cache
@@ -262,17 +282,16 @@ module Sashimi
 
     # Write all the plugins into the cache
     def write_to_cache(plugins)
-      change_dir_to_local_repository
-      FileUtils.mv(cache_file, "#{cache_file}-backup")
-      File.open(cache_file, 'w'){|f| f.write(plugins.to_yaml)}
-      FileUtils.rm("#{cache_file}-backup")
+      File.atomic_write(cache_file) do |file|
+        file.write(plugins.to_yaml)
+      end
     end
     
     # Copy a plugin to a Rails app.
     def copy_plugin_to_rails_app
-      change_dir(path_to_rails_app)
-      FileUtils.mkdir_p(plugins_dir)
-      FileUtils.cp_r(File.join(local_repository_path, plugin.name), File.join(plugins_dir, plugin.name+'-tmp'))
+      FileUtils.mkdir_p absolute_rails_plugins_path
+      FileUtils.cp_r [ local_repository_path, plugin.name ].to_path,
+        [ absolute_rails_plugins_path, temp_plugin_name ].to_path
     end
     
     # Rename the *-tmp folder used by the installation process.
@@ -280,26 +299,27 @@ module Sashimi
     # Example:
     #   click-to-globalize-tmp # => click-to-globalize
     def rename_temp_folder
-      change_dir(path_to_rails_app)
-      FileUtils.mv(File.join(plugins_dir, plugin.name+'-tmp'), File.join(plugins_dir, plugin.name))
+      FileUtils.mv [ rails_plugins_path, temp_plugin_name ].to_path,
+        [ rails_plugins_path, plugin.name ].to_path
     end
     
     # Remove SCM hidden folders.
     def remove_hidden_folders
       require 'find'
-      change_dir(File.join(path_to_rails_app, plugins_dir, plugin.name+'-tmp'))
-      Find.find('./') do |path|
-        if File.basename(path) == '.'+scm_type
-          FileUtils.remove_dir(path, true)
-          Find.prune
+      with_path [ absolute_rails_plugins_path, temp_plugin_name ].to_path do
+        Find.find('./') do |path|
+          if File.basename(path) == '.'+scm_type
+            FileUtils.remove_dir(path, true)
+            Find.prune
+          end
         end
       end
     end
-    
+
     # Run the plugin install hook.
     def run_install_hook
-      install_hook_file = File.join(plugins_dir, plugin.name, 'install.rb')
-      load install_hook_file if File.exist? install_hook_file
+      install_hook_file = [ rails_plugins_path, plugin.name, 'install.rb' ].to_path
+      Kernel.load install_hook_file if File.exists? install_hook_file
     end
   end
 end