revans-gitools 0.3.0 → 0.3.2

data/CHANGELOG.rdoc

@@ -1,5 +1,11 @@
+Version 0.3.2
+  * Refactored the Submodule Class
+  
+  
 Version 0.3.0
   * Added command line tools
+  * No more need for rake tasks
+  * Added option parser
   
 Version 0.2.0
   * Added individual task method

data/README.markdown

@@ -1,4 +1,13 @@
-# Git_tools
+# Git Tools
+
+## Install
+  
+You can either clone this or do:
+
+<pre>
+  gem sources -a http://gems.github.com
+  sudo gem install revans-gitools
+</pre>
 
 ## How to use
 
@@ -21,60 +30,15 @@ Add the git submodules that you want to want to use in your application like so:
     active_merchant: git://github.com/Shopify/active_merchant.git
 </pre>
 
-A couple of things, it needs to follow the structure above with the name submodules and defining each below it. Use the name
-that you want the plugin to be named when checking out. Put the git location as the value.
-
-Now, create a new Rake task in lib/tasks directory. I call mine submodules.rake. Here is what my file looks like:
-
-<pre>
-  require 'gitools'
-
-  @configration = File.join(RAILS_ROOT, "config/submodules.yml")
-
-  namespace :git do
-
-    namespace :submodule do
-
-      desc "Remove Submodule cache"
-      task :remove, :submodule do |task, args|
-        GitTools::Submodule.remove(args.submodule)
-      end
-
-    end
-
-
-    namespace :update do
-
-      desc "Update all Submodules"
-      task :all => :environment do
-        GitTools::Submodule.update_all(@configration)
-      end
-
-
-      GitTools::Submodule.individual_tasks(@configration) do |name|
-        desc "Update #{name} submodule"
-        task name.to_sym => :environment do
-          GitTools::Submodule.submodule_update("#{name}")
-        end
-      end
-
-    end
-
-  end
-</pre>
-
-
-## Command Line
-
-When creating a new project, it would be nice to just write your submodule.yml file and then shoot a command off in the terminal and have all your submodules installed for you. Well, now you can! Just do:
-
-<pre>
-  gitools all
-</pre>
 
-That will install all the submodules from your config/submodule.yml file. Here are a couple more commands you can run:
+### Command Line
 
 <pre>
-  gitools -u     # For a fresh clone that needs the submodules init/update
-  gitools rails  # To add rails as a submodule, if you have it specified in your config/submodules.yml file
+  gitools setup         # init and update all git submodules
+                          
+  gitools add all       # add all submodules
+  gitools add rails     # add rails as a submodule
+                          
+  gitools update all    # update all submodules
+  gitools update rails  # update rails submodule
 </pre>

data/lib/gitools.rb

@@ -1,5 +1,5 @@
 module GitTools
-  Version = "0.3.0"
+  Version = "0.3.2"
 end
 
 # Required Gems

data/lib/gitools/ci.rb

@@ -5,14 +5,50 @@ module GitTools
       init      = new
       @options  = options
       @yaml     = File.join(@options.yaml, 'config/submodules.yml')
-      if @options.update
-        GitTools::Submodule.checkout
-      elsif @options.library == "all"
-        GitTools::Submodule.install_all(@yaml)
+      
+      
+      case @options.command
+      when "setup"
+        GitTools::Submodule.setup
+      when "add"
+        case @options.library
+        when "all"
+          GitTools::Submodule.add_all(@yaml)
+        else
+          GitTools::Submodule.add(@yaml, @options.library) unless @options.library.nil? || @options.library.empty?
+        end
+      when "update"
+        case @options.library
+        when "all"
+          GitTools::Submodule.update_all(@yaml)
+        else
+          GitTools::Submodule.update(@options.library) unless @options.library.nil? || @options.library.empty?
+        end
       else
-        GitTools::Submodule.install_single(@yaml, @options.library)
+        puts "Your commands were invalid. See gitools' help: gitools -h"
+        exit(0)
       end
+      
+    rescue
+      puts "Your commands were invalid. See gitools' help: gitools -h"
+      exit(0)
     end
+    
+    
+
 
   end
-end
+end
+
+
+# API
+#
+# gitools setup         # Should init and update all git submodules
+# gitools add all       # Should add all submodules
+# gitools add rails     # Should add rails as a submodule
+# gitools update all    # Should update all submodules
+# gitools update rails  # Should update rails submodule
+
+# setup     -> GitTools::Submodule.setup
+# update    -> GitTools::Submodule.update_all(@yaml)  || GitTools::Submodule.update(@yaml, @options.library)
+# add       -> GitTools::Submodule.add_all(@yaml)     || GitTools::Submodule.add(@yaml, @options.library)

data/lib/gitools/parse.rb

@@ -1,23 +1,29 @@
 module GitTools
   class Options
    
+   COMMANDS = ["update", "add", "setup"].freeze
+   
     def self.parse!(args)
       options           = OpenStruct.new
-      options.library   = args.first.sub(/(\s+)/, '_') unless args.first.nil?
+      options.command   = args.first
+      options.library   = args.last if args.size > 1
       options.yaml      = Dir.pwd
       
       opts = OptionParser.new do |opts|
         
-        opts.banner = "\nGit Tools Usage: gitools all will install all your git submodules"
+        opts.banner = "\nGit Tools Usage\n"
         opts.separator "You must be in your Application Root Directory when running this command."
+        opts.separator "There are a few basic commands:"
+        opts.separator ""
+        opts.separator "gitools setup                         will init and update your git submodules."
+        opts.separator "gitools update all                    will update all git submodules."
+        opts.separator "gitools update submodule_name         will update just that given submodule."
+        opts.separator "gitools install all                   will do git submodule add for all submodules declared in your config/submodules.yml file."
+        opts.separator "gitools install submodule_name        will do a git submodule add just for that submodule."
         opts.separator ""
-        
-        opts.on('-u', '--update', 'Update the Submodule instead of adding it.') do |ext|
-          options.update = ext
-        end
         
         opts.on_tail('-v', '--version', "Show GitTools' current version.") do
-          puts "\nGit Tools is at version #{GitTools::Version}\n"
+          puts "Git Tools is at version #{GitTools::Version}\n"
           exit(0)
         end
         
@@ -26,13 +32,18 @@ module GitTools
           exit(0)
         end
         
+
         opts.on_tail do
-          if (options.library.nil? || options.library == '') && !options.udpate
+          if (options.library.nil? || options.library == '') && options.command != "setup"
             puts "\nYou need to tell me what you want library you want to add to git submodule."
             puts "#{opts}\n"
             exit(0)
+          elsif !COMMANDS.include?(options.command)
+            puts "\nOnly setup, update, and install are supported commands."
+            puts "#{opts}\n"
+            exit(0)
           end
-        end  
+        end
       end # OptionParser
       
       opts.parse!(args)

data/lib/gitools/submodules.rb

@@ -1,60 +1,240 @@
+# module GitTools
+#   
+#   # TODO: Refactor Class
+#   class Submodule
+#     
+#     def self.update_all(yaml)
+#       @config = load_yaml(yaml)
+#       @config.each_key do |name| 
+#         message(name) { submodule_update(name) }
+#       end
+#     end
+#     
+#     def self.install_all(yaml)
+#       @config = load_yaml(yaml)
+#       @config.each { |plugin, repo| add(plugin, repo) }
+#     end
+#     
+#     def self.install_single(yaml, name)
+#       @config = load_yaml(yaml)
+#       add(name, @config[name])
+#     end
+#     
+#     
+#     def self.update_single(yaml, name)
+#       @config = load_yaml(yaml)
+#       submodule_update(name)
+#     end
+#     
+#     
+#     def self.add(name, repo)
+#       dir = name == "rails" ? "vendor/rails/" : "vendor/plugins/#{name}"
+#       system("git submodule add #{repo} #{dir}")
+#     end
+#     
+#     def self.checkout
+#       system("git submodule init")
+#       system("git submodule update")
+#     end
+#     
+#     def self.remove(submodule)
+#       system("git rm --cache vendor/plugins/#{submodule}")
+#     end
+#     
+#     def self.submodule_update(name)
+#       dir = name == "rails" ? "vendor/rails/" : "vendor/plugins/#{name}"
+#       system("cd #{dir} && git remote update && git merge origin/master")
+#     end
+#     
+#     def self.load_yaml(yaml)
+#       YAML::load(File.open(yaml))['submodules']
+#     end
+#     
+#     
+#     def self.message(name, &block)
+#       puts "Updating #{name.to_s}"
+#       yield
+#       puts "\n"
+#     end
+#     
+# 
+#     def self.individual_tasks(yaml, &block)
+#       @config = load_yaml(yaml)
+#       @config.each_key { |name| yield name }
+#     end  
+#     
+#   end
+#   
+# end
+
+
+
 module GitTools
   
-  # TODO: Refactor Class
   class Submodule
     
-    def self.update_all(yaml)
-      @config = load_yaml(yaml)
-      @config.each_key do |name| 
-        message(name) { submodule_update(name) }
-      end
-    end
+    attr_reader :config
+    
     
-    def self.install_all(yaml)
-      @config = load_yaml(yaml)
-      @config.each { |plugin, repo| add(plugin, repo) }
+    # Initialize
+    #
+    # ==== Description
+    #
+    # Will load the YAML file given.
+    #
+    #
+    def initialize(yaml = nil)
+      @config = load_yaml(yaml) unless yaml.nil?
     end
     
-    def self.install_single(yaml, name)
-      @config = load_yaml(yaml)
-      add(name, @config[name])
+
+    def self.setup
+      system("git submodule init")
+      system("git submodule update")
     end
     
-    def self.add(name, repo)
-      dir = name == "rails" ? "vendor/rails/" : "vendor/plugins/#{name}"
-      system("git submodule add #{repo} #{dir}")
+    
+    # Update All
+    #
+    # ==== Description
+    #
+    # This will update all the git submodules
+    # specified in the YAML file.
+    #
+    
+    def self.update_all(yaml)
+      git = new(yaml)
+      git.config.each_key { |name| git.update_submodule(name) }
     end
     
-    def self.checkout
-      system("git submodule init")
-      system("git submodule update")
+    
+    # Update
+    #
+    # ==== Description
+    #
+    # Updates a single submodule in the project
+    #
+    #
+    def self.update(name)
+      new.update_submodule(name)
     end
     
-    def self.remove(submodule)
-      system("git rm --cache vendor/plugins/#{submodule}")
+    
+    # Add All
+    #
+    # ==== Description
+    # 
+    # This will go through the YAML file and do
+    # git submodule add for each one.
+    #
+    #
+    def self.add_all(yaml)
+      git = new(yaml)
+      git.config.each { |name, repo| git.add_submodule(name, repo) }
     end
     
-    def self.submodule_update(name)
-      dir = name == "rails" ? "vendor/rails/" : "vendor/plugins/#{name}"
-      system("cd #{dir} && git remote update && git merge origin/master")
+    
+    # Add
+    #
+    # ==== Description
+    #
+    # Adds a single submodule to the project.
+    #
+    #
+    def self.add(yaml, name)
+      git = new(yaml)
+      git.add_submodule(name, git.config[name])
     end
     
-    def self.load_yaml(yaml)
-      YAML::load(File.open(yaml))['submodules']
+    
+    # Remove Cache
+    #
+    # ==== Description
+    #
+    # This will remove the submodule from git's cache
+    #
+    #
+    def self.remove_cache(name)
+      system("git rm --cache #{directory_to_install(name)}")
     end
     
     
-    def self.message(name, &block)
-      puts "Updating #{name.to_s}"
-      yield
-      puts "\n"
+    # Update
+    #
+    # ==== Description
+    #
+    # This can be used by the Class Methods for either updating
+    # a single submodule or all of the submodules listed in the
+    # YAML file.
+    #
+    #
+    def update_submodule(name)
+      message(name) { system("cd #{directory_to_install(name)} && git remote update && git merge origin/master") }
+    end
+  
+  
+    # Add
+    #
+    # ==== Description
+    #
+    # This can be used by the Class Methods for either adding
+    # a single submodule or all of them listed in the YAML
+    # file.
+    #
+    #
+    def add_submodule(name, repo)
+      message(name) { system("git submodule add #{repo} #{directory_to_install(name)}") }
     end
+  
     
+    
+    private
+
 
-    def self.individual_tasks(yaml, &block)
-      @config = load_yaml(yaml)
-      @config.each_key { |name| yield name }
-    end  
+      # Load YAML
+      #
+      # ==== Description
+      #
+      # Loads the YAML file.
+      #
+      #
+      def load_yaml(yaml)
+        YAML::load(File.open(yaml))['submodules']
+      rescue
+        puts "The YAML file cannot be found."
+        exit(0)
+      end
+      
+      
+      # Directory to Install
+      #
+      # ==== Description
+      #
+      # This will determine if we have plugin or rails itself
+      # and return the directory in which we should work with.
+      #
+      # ==== Parameters
+      #
+      # * name => The name of the submodule to work with.
+      #
+      #
+      def directory_to_install(name)
+        name == "rails" ? "vendor/rails/" : "vendor/plugins/#{name}"
+      end
+      
+      
+      # Message
+      #
+      # ==== Description
+      #
+      # Displays a simple message of what is being updated/added.
+      #
+      #
+      def message(name, &block)
+        puts "-----#{name}-----\n"
+        yield
+        puts "\n"
+      end
     
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: revans-gitools
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors: 
 - Robert R Evans