nucleon 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 603d0e71de8c01d2bcf419e4b3738256cea4a190
-  data.tar.gz: 1d673bd001130914d7adf48510e012722dba78dd
+  metadata.gz: 966899ec9ca819e5cbfc37f589762d08ee4d37d0
+  data.tar.gz: c39dc67b0a2ed70f0de66eac0b1caaccd452353c
 SHA512:
-  metadata.gz: c82d37027c3f4e450d7f83c757b1f56aa078de79f2ee5b601b1b9a8ee08c1fbdcddf6507e84818cee3be51f0abb97cc72987ab8f5e5a3845d335066b122f6674
-  data.tar.gz: 05eab733dbdf59e8a11d51bd3da83c172fcbaeafe8d85ce5956d119b86c2587074928be3c0e2ba6f0844934a949e5885a227268ec72e5660a9dbba40f072782e
+  metadata.gz: 4e20ea49274b90ba8f883ba9e8481ca9ba080678e3bf996b15a5abefb31d5d59b0b194e0f3c5db6b07be30ccba024d75d80f267ead918c049469c48b60c1c3fb
+  data.tar.gz: 6b9ce73ba51a95c903969b80334c05a520746a23d6e4e06e59b2aa81f49d0c93ce607c48db87cfe4054b09093c1c927a174da92f833b3fed81668fa911933467

data/VERSION

@@ -1 +1 @@
-0.2.5
+0.2.6

data/lib/nucleon/project/git.rb

@@ -2,28 +2,30 @@
 module Nucleon
 module Project
 class Git < Nucleon.plugin_class(:nucleon, :project)
-  
+
   #-----------------------------------------------------------------------------
   # Project plugin interface
-   
+
   def normalize(reload)
     unless reload
       @cli = Util::Liquid.new do |method, args, &code|
         options = {}
         options = args.shift if args.length > 0
-        git_exec(method, options, args, &code)  
+        git_exec(method, options, args, &code)
       end
     end
-    super    
+
+    @ignore_cache = {}
+    super
   end
-  
+
   #-----------------------------------------------------------------------------
   # Git interface (local)
-   
+
   def ensure_git(reset = false)
     if reset || @repo.nil?
       if directory.empty?
-        logger.warn("Can not manage Git project at #{directory} as it does not exist")  
+        logger.warn("Can not manage Git project at #{directory} as it does not exist")
       else
         logger.debug("Ensuring Git instance to manage #{directory}")
         @repo = Util::Git.load(directory, {
@@ -34,18 +36,18 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
     return myself
   end
   protected :ensure_git
-       
+
   #-----------------------------------------------------------------------------
   # Checks
-   
+
   def can_persist?
     ensure_git
     return true unless @repo.nil?
     return false
   end
- 
+
   #---
-          
+
   def top?(path)
     git_dir = File.join(path, '.git')
     if File.exist?(git_dir)
@@ -55,25 +57,25 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
     end
     return false
   end
-    
+
   #---
-          
+
   def subproject?(path)
     git_dir = File.join(path, '.git')
     if File.exist?(git_dir)
       unless File.directory?(git_dir)
-        git_dir = Util::Disk.read(git_dir)        
+        git_dir = Util::Disk.read(git_dir)
         unless git_dir.nil?
           git_dir = git_dir.gsub(/^gitdir\:\s*/, '').strip
           return true if File.directory?(git_dir)
-        end  
+        end
       end
     end
     return false
   end
-  
+
   #---
-      
+
   def project_directory?(path, require_top_level = false)
     path    = File.expand_path(path)
     git_dir = File.join(path, '.git')
@@ -86,53 +88,53 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
         unless git_dir.nil?
           git_dir = git_dir.gsub(/^gitdir\:\s*/, '').strip
           return true if File.directory?(git_dir)
-        end  
+        end
       end
     elsif File.exist?(path) && (path =~ /\.git$/ && File.exist?(File.join(path, 'HEAD')))
       return true
     end
     return false
   end
-  
+
   #---
-  
+
   def new?(reset = false)
     if get(:new, nil).nil? || reset
       result = cli.rev_parse({ :all => true })
-      
+
       if result && result.status == code.success
         set(:new, result.output.empty?)
-      end  
+      end
     end
     get(:new, false)
   end
-   
+
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
-  
+
   def repo
     return @repo if can_persist?
     return nil
   end
   protected :repo
-  
+
   #---
-  
+
   def cli
     @cli
   end
-    
+
   #---
-   
+
   def set_location(directory)
     super do
       ensure_git(true)
     end
     return myself
   end
-  
+
   #---
-  
+
   def config(name, options = {})
     return super do |config|
       result = cli.config(config.export, name)
@@ -140,42 +142,42 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
       nil
     end
   end
-  
+
   #---
-  
+
   def set_config(name, value, options = {})
     return super do |config, processed_value|
       result = cli.config(config.export, name, processed_value)
       result.status == code.success
     end
   end
-  
+
   #---
-  
+
   def delete_config(name, options = {})
     return super do |config|
       result = cli.config(config.import({ :remove_section => true }).export, name)
       result.status == code.success
     end
   end
-  
+
   #---
- 
+
   def subproject_config(options = {})
     return super do |config|
       result = {}
-      
+
       if new?
-        logger.debug("Project has no sub project configuration yet (has not been committed to)")  
+        logger.debug("Project has no sub project configuration yet (has not been committed to)")
       else
         gitmodules_file = File.join(directory, '.gitmodules')
-        
+
         gitmodules_data = ''
         gitmodules_data = Util::Disk.read(gitmodules_file) if File.exists?(gitmodules_file)
-          
+
         unless gitmodules_data.empty?
           logger.debug("Houston, we have some gitmodules!")
-        
+
           lines   = gitmodules_data.gsub(/\r\n?/, "\n" ).split("\n")
           current = nil
 
@@ -183,9 +185,9 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
             if line =~ /^\[submodule "(.+)"\]$/
               current         = $1
               result[current] = {}
-            
+
               logger.debug("Reading: #{current}")
-      
+
             elsif line =~ /^\s*(\w+)\s*=\s*(.+)\s*$/
               result[current][$1] = $2
             end
@@ -195,35 +197,35 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
       result
     end
   end
-  
+
   #-----------------------------------------------------------------------------
   # Operations
-    
+
   def init_cache
     super
-    ignore(cache.directory_name)   
+    ignore(cache.directory_name)
   end
-  
+
   #-----------------------------------------------------------------------------
   # Basic Git operations
-  
+
   def ignore(files)
     super do
       ensure_in_gitignore(files)
-    end  
+    end
   end
-  
+
   #---
-  
+
   def load_revision
     return super do
       if new?
         logger.debug("Project has no current revision yet (has not been committed to)")
-        nil        
+        nil
       else
         current_revision = nil
         result           = cli.rev_parse({ :abbrev_ref => true }, 'HEAD')
-        
+
         if result && result.status == code.success
           current_revision = result.output
         end
@@ -232,13 +234,13 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
       end
     end
   end
-  
+
   #---
-  
+
   def checkout(revision)
     return super do |success|
       if new?
-        logger.debug("Project can not be checked out (has not been committed to)")  
+        logger.debug("Project can not be checked out (has not been committed to)")
       else
         unless repo.bare?
           result = cli.checkout({}, revision)
@@ -247,131 +249,131 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
       result && result.status == code.success
     end
   end
-  
+
   #---
-  
+
   def commit(files = '.', options = {})
     return super do |config, time, user, message|
       cli.reset({}, 'HEAD') unless new? # Clear the index so we get a clean commit
-      
+
       files = array(files)
-      
+
       logger.debug("Adding files to Git index")
-      
+
       cli.add({}, *files)                  # Get all added and updated files
       cli.add({ :update => true }, *files) # Get all deleted files
-        
+
       commit_options = {
         :m           => "<#{user}> #{message}",
-        :allow_empty => config.get(:allow_empty, false) 
+        :allow_empty => config.get(:allow_empty, false)
       }
       commit_options[:author] = config[:author] if config.get(:author, false)
-    
+
       logger.debug("Composing commit options: #{commit_options.inspect}")
       result = cli.commit(commit_options)
-        
+
       if result.status == code.success
         new?(true)
         true
       else
         false
       end
-    end   
+    end
   end
 
   #-----------------------------------------------------------------------------
   # Subproject operations
- 
+
   def load_subprojects(options = {})
     return super do |project_path, data|
       File.exist?(File.join(project_path, '.git'))
     end
   end
-  
+
   #---
-  
+
   def add_subproject(path, url, revision, options = {})
     return super do |config|
       branch_options = ''
       branch_options = [ '-b', config[:revision] ] if config.get(:revision, false)
-      
+
       path = config[:path]
       url  = config[:url]
-        
+
       result = cli.submodule({}, 'add', *branch_options, url, path)
-        
+
       if result.status == code.success
-        config.set(:files, [ '.gitmodules', path ]) 
+        config.set(:files, [ '.gitmodules', path ])
         true
       else
         false
       end
-    end  
+    end
   end
-  
+
   #---
-  
+
   def delete_subproject(path)
     return super do |config|
       path          = config[:path]
       submodule_key = "submodule.#{path}"
-      
+
       logger.debug("Deleting Git configurations for #{submodule_key}")
       delete_config(submodule_key)
       delete_config(submodule_key, { :file => '.gitmodules' })
-      
+
       logger.debug("Cleaning Git index cache for #{path}")
       cli.rm({ :cached => true }, path)
-      
+
       logger.debug("Removing Git submodule directories")
       FileUtils.rm_rf(File.join(directory, path))
       FileUtils.rm_rf(File.join(repo.path, 'modules', path))
-      
+
       config.set(:files, [ '.gitmodules', path ])
-    end  
+    end
   end
- 
+
   #---
-   
+
   def update_subprojects(options = {})
     return super do |config|
       result = cli.submodule({}, 'update', '--init', '--recursive')
       result.status == code.success
     end
   end
-         
+
   #-----------------------------------------------------------------------------
   # Remote operations
-  
+
   def init_remotes
     return super do
       origin_url = config('remote.origin.url')
-      
+
       logger.debug("Original origin remote url: #{origin_url}") if origin_url
       origin_url
     end
   end
-  
+
   #---
-  
+
   def remote(name)
     return super do
       url = config("remote.#{name}.url")
       url.nil? || url.empty? ? nil : url
     end
   end
- 
+
   #---
-  
+
   def set_remote(name, url)
     return super do |processed_url|
       result = cli.remote({}, 'add', name, processed_url)
       result.status == code.success
     end
   end
-  
+
   #---
-  
+
   def add_remote_url(name, url, options = {})
     return super do |config, processed_url|
       result = cli.remote({
@@ -382,152 +384,152 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
       result.status == code.success
     end
   end
-  
+
   #---
-  
+
   def delete_remote(name)
     return super do
       remote = remote(name)
       if ! remote || remote.empty?
         logger.debug("Project can not delete remote #{name} because it does not exist yet")
-        true  
+        true
       else
         result = cli.remote({}, 'rm', name)
         result.status == code.success
       end
     end
   end
-  
+
   #---
-    
+
   def synchronize(cloud, options = {})
     return super do |config|
       config.init(:remote_path, '/var/git')
       config.set(:add, true)
     end
   end
-   
+
   #-----------------------------------------------------------------------------
   # SSH operations
-  
+
   def git_fetch(remote = :origin, options = {}, &block)
     config         = Config.ensure(options)
     local_revision = config.get(:revision, get(:revision, :master))
-     
+
     result = cli.fetch({}, remote, &block)
-       
+
     if result.status == code.success
       new?(true)
       checkout(local_revision)
     else
       false
-    end 
+    end
   end
   protected :git_fetch
-  
+
   #---
- 
+
   def pull(remote = :origin, options = {}, &block)
     return super do |config, processed_remote|
       success = false
-      
+
       if new? || get(:create, false)
-        success = git_fetch(processed_remote, config)  
+        success = git_fetch(processed_remote, config)
       end
-      
+
       pull_options = {}
       pull_options[:tags] = true if config.get(:tags, true)
-        
+
       local_revision = config.get(:revision, get(:revision, :master))
-      
+
       if checkout(local_revision)
         result = cli.pull(pull_options, processed_remote, local_revision, &block)
-      
+
         if result.status == code.success
           new?(true)
           success = true
         end
       end
-      success  
+      success
     end
   end
-  
+
   #---
-    
+
   def push(remote = :edit, options = {}, &block)
     return super do |config, processed_remote|
       push_branch = config.get(:revision, '')
-      
+
       push_options = {}
       push_options[:all]  = true if push_branch.empty?
       push_options[:tags] = true if ! push_branch.empty? && config.get(:tags, true)
-      
-      result = cli.push(push_options, processed_remote, push_branch, &block)      
+
+      result = cli.push(push_options, processed_remote, push_branch, &block)
       result.status == code.success
     end
   end
- 
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def translate_url(host, path, options = {})
     return super do |config|
       user = config.get(:user, 'git')
       auth = config.get(:auth, true)
-      
+
       user + (auth ? '@' : '://') + host + (auth ? ':' : '/') + path
     end
   end
-  
+
   #---
-  
+
   def translate_edit_url(url, options = {})
-    return super do |config|    
+    return super do |config|
       if matches = url.strip.match(/^(https?|git)\:\/\/([^\/]+)\/(.+)/)
         protocol, host, path = matches.captures
         translate_url(host, path, config.import({ :auth => true }))
       end
     end
   end
-  
+
   #---
-  
+
   def git_exec(command, options = {}, args = [])
     result = nil
-    
+
     if can_persist?
       check_value = lambda do |value|
         next false if value.nil?
         next false unless value.is_a?(String) || value.is_a?(Symbol)
         next false if value.to_s.empty?
-        true 
+        true
       end
-      
+
       localize(repo.workdir) do
         flags          = []
         data           = {}
         processed_args = []
-        
+
         options.each do |key, value|
           cli_option = key.to_s.gsub('_', '-')
-          
-          if value.is_a?(TrueClass) || value.is_a?(FalseClass) 
+
+          if value.is_a?(TrueClass) || value.is_a?(FalseClass)
             flags << cli_option if value == true
-            
+
           elsif check_value.call(value)
             data[cli_option] = value.to_s
           end
         end
-        
+
         args.each do |value|
           if check_value.call(value)
             processed_args << value.to_s
           end
         end
-        
+
         command_provider = get(:command_provider, Nucleon.type_default(:nucleon, :command))
-        quiet            = get(:quiet, true)        
-        
+        quiet            = get(:quiet, true)
+
         command = Nucleon.command({
           :command => :git,
           :data    => { 'git-dir=' => repo.path },
@@ -538,7 +540,7 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
             :args    => processed_args
           }
         }, command_provider)
-        
+
         result = command.exec({ :quiet => quiet }) do |op, cli_command, cli_data|
           block_given? ? yield(op, cli_command, cli_data) : true
         end
@@ -548,32 +550,48 @@ class Git < Nucleon.plugin_class(:nucleon, :project)
     result
   end
   protected :git_exec
-  
+
   #---
-  
+
   def ensure_in_gitignore(files)
     files        = [ files ] unless files.is_a?(Array)
     commit_files = nil
     changes      = false
-    
+
     gitignore_file = File.join(directory, '.gitignore')
     ignore_raw     = Util::Disk.read(gitignore_file)
     ignores        = []
-    ignores        = ignore_raw.split("\n") if ignore_raw && ! ignore_raw.empty?
-    
+    search         = []
+
+    if ignore_raw && ! ignore_raw.empty?
+      ignores = ignore_raw.split("\n")
+      search  = ignores.collect do |line|
+        line = line.strip
+        ( ! line.empty? && line[0] != '#' ? line : nil )
+      end.compact
+    end
+
     files.each do |file|
-      found = false
-      unless ignores.empty?
-        ignores.each do |ignore|
-          if ignore.strip.match(/^#{file}\/?$/)
-            found = true
-          end  
+      if @ignore_cache[file]
+        found = true
+      else
+        file_regex = Regexp.escape(file)
+        found      = false
+        unless search.empty?
+          search.each do |ignore|
+            if ignore.strip.match(/^#{file_regex}\/?$/)
+              found               = true
+              @ignore_cache[file] = true
+              break
+            end
+          end
         end
       end
       unless found
         ignores << file
-        changes = true
-      end 
+        changes             = true
+        @ignore_cache[file] = true
+      end
     end
     if changes
       Util::Disk.write(gitignore_file, ignores.join("\n"))

data/nucleon.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: nucleon 0.2.5 ruby lib
+# stub: nucleon 0.2.6 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "nucleon"
-  s.version = "0.2.5"
+  s.version = "0.2.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Adrian Webb"]
-  s.date = "2015-01-16"
+  s.date = "2015-01-18"
   s.description = "\nA framework that provides a simple foundation for building Ruby applications that are:\n\n* Highly configurable (with both distributed and persistent configurations)\n* Extremely pluggable and extendable\n* Easily parallel\n\nNote: This framework is still very early in development!\n"
   s.email = "adrian.webb@coralnexus.com"
   s.executables = ["nucleon"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nucleon
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Adrian Webb
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-16 00:00:00.000000000 Z
+date: 2015-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: log4r