gem_butler 0.1.0 → 0.2.0

data/README.md

@@ -15,13 +15,32 @@ Example file structure
     - Bootstrap.gemfile
 ```
 
+GemButler comes with the following main API:
+
+* `include_only :folders => {...}, :names => {...}`
+* `exclude :folders => {...}, :names => {...}`
+* `select *names`
+
+The method `include_only` takes an option hash with the keys `:folders` and `:names`. Butler will then select only the Gemfiles which are in the listed folders and have the given names.
+
+The method `exclude` is similar to `include_only` but instead excludes any Gemfiles either in any of the given folders or matching the given names.
+
+The `select` method take as list of names and will additionally select Gemfiles matching these names unless specifically listed in the set of excluded names. 
+
+This logic should be powerful enough to support most usage situations.
+
 In your Gemfile:
 
 ```ruby
 require 'butler'
-butler = GemButler.new
-butler.base_path = File.dirname(__FILE__) + '/gemfiles'
-butler.exclude = [:bootstrap]
+butler = GemButler.new File.dirname(__FILE__) + '/gemfiles'
+
+# include/exclude certain gemfiles
+# this would include only gemfiles living in the /view or /back_end folder named Test (or test)
+# additionally it would also select (include) the Facebook gemfile wherever it is, even if Facebook is not matched by the include_only logic.
+
+butler.include_only :folders => [:view, :back_end], :names => :test
+butler.select :facebook
 
 butler.included_gemfiles.each do |gemfile|
   # puts "gemfile: #{gemfile}"

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/gem_butler.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "gem_butler"
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kristian Mandrup"]

data/lib/gem_butler.rb

@@ -1,7 +1,9 @@
 class GemButler
   attr_accessor :base_path
 
-  attr_writer :exclude, :include_only
+  attr_writer :excluded_names, :include_only_names
+  attr_writer :include_only_folders, :excluded_folders
+  attr_writer :selected_names
 
   def initialize path
     @base_path = path
@@ -14,44 +16,79 @@ class GemButler
   def gemfile_names mode = :included
     list = case mode
     when :included
-      included_gemfiles
+      filtered
     else
       gemfiles
     end
-    list.map {|gemfile| gemfile.match(/\/(\w+)\.\w+$/)[1] }
+    list.map {|gemfile| gemfile.match(/\/(\w+)\.\w+$/i)[1] }
   end
 
   def gemfile_paths
     @gemfile_paths ||= gemfiles.map(&:to_s)
   end
 
-  def included_gemfiles         
+  def filtered
+    selected + (name_filtered & folder_filtered)
+  end
+
+  def name_filtered
     return only_included if only_included?
-    excluded
+    after_exclude
   end
 
-  def excluded
-    return [] if !exclude
-    @excluded ||= begin      
+  def after_exclude
+    return [] if !excluded_names
+    @after_excluded ||= begin      
       gemfile_paths - exclude_list.flatten
     end
   end
 
   def exclude_list
-    @exclude_list ||= [exclude].flatten.inject([]) do |res, gemfile|
-      res += gemfile_paths.grep(/#{Regexp.escape(gemfile)}\.gemfile$/i)
+    @exclude_list ||= [excluded_names].flatten.inject([]) do |res, gemfile|
+      res += gemfile_paths.grep(/#{prepare gemfile}\.gemfile$/i)
       res
     end
   end    
 
+  def exclude_folders_list
+    @exclude_folders_list ||= [excluded_folders].flatten.inject([]) do |res, folder|
+      res += gemfile_paths.grep(/#{folder}\//i)
+      res
+    end
+  end
+
+  def after_exclude_folders
+    return [] if !excluded_folders
+    @after_excluded_folders ||= begin      
+      gemfile_paths - exclude_folders_list.flatten
+    end
+  end
+
   def only_included?
     !only_included.empty?
   end
 
+  def folder_filtered
+    return only_included_folders if only_included_folders?
+    after_exclude_folders
+  end
+
+  def only_included_folders?
+    !only_included_folders.empty?
+  end
+
+  def only_included_folders
+    return [] if !include_only_folders
+    @only_included_folders ||= [include_only_folders].flatten.inject([]) do |res, folder|
+      res += gemfile_paths.grep(/#{folder}\//i)
+      res
+    end
+  end
+
   def only_included
-    return [] if !include_only
-    @only_included ||= [include_only].flatten.inject([]) do |res, gemfile|
-      res += gemfile_paths.grep(/#{Regexp.escape(gemfile)}\.gemfile$/i)
+    return [] if !include_only_names
+    @only_included ||= [include_only_names].flatten.inject([]) do |res, gemfile|
+      res += gemfile_paths.grep(/#{prepare gemfile}\.gemfile$/i)
       res
     end
   end
@@ -60,12 +97,77 @@ class GemButler
     File.expand_path(base_path, __FILE__)
   end
 
-  def include_only
-    @include_only ||= []    
+  def include_only options = {}
+    self.include_only_names   = options.delete(:names)
+    self.include_only_folders = options.delete(:folders)
   end
 
-  def exclude
-    @exclude ||= []
+  def exclude options = {}
+    self.excluded_names   = options.delete(:names)
+    self.excluded_folders = options.delete(:folders)
   end
+
+  def include_only_names
+    @include_only_names ||= []    
+  end
+
+  def excluded_names
+    @excluded_names ||= []
+  end
+
+  def include_only_folders
+    @include_only_folders ||= []    
+  end
+
+  def excluded_folders
+    @excluded_folders ||= []
+  end
+
+  def selected
+    return [] if !include_only_folders
+    @selected ||= [select_list].flatten.inject([]) do |res, gemfile|
+      res += gemfile_paths.grep(/#{prepare gemfile}\.gemfile$/i)
+      res
+    end        
+  end
+
+  def select_list
+    [selected_names].flatten - [excluded_names].flatten
+  end
+
+  def select *names
+    self.selected_names = names.flatten.compact.uniq
+  end
+
+  def selected_names
+    @selected_names ||= []
+  end
+
+  protected
+
+  def prepare gemfile
+    Regexp.escape GemButler.camelize(gemfile)
+  end
+
+  def self.underscore(camel_cased_word)
+    word = camel_cased_word.to_s.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+
+  def self.camelize(term, uppercase_first_letter = true)
+    string = term.to_s
+    if uppercase_first_letter
+      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+    else
+      string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { $&.downcase }
+    end
+    string.gsub(/(?:_|(\/))([a-z\d]*)/i) { $2.capitalize }.gsub('/', '::')
+  end    
 end
 

data/spec/gem_butler_spec.rb

@@ -7,34 +7,103 @@ describe GemButler do
 
   let(:path)  { File.join File.dirname(__FILE__), 'app/gemfiles' }
 
+  describe 'self.camelize' do
+    it 'should camelize' do
+      GemButler.camelize(:data_store).should == 'DataStore'
+    end
+  end
+
   context "none excluded" do
     its(:gemfile_names) { should include('Assets', 'Bootstrap', 'DataStore', 'Facebook')}
   end
 
-  context "assets excluded" do
+  context "excluded assets" do
     before do
-      subject.exclude = [:assets] 
+      subject.excluded_names = [:assets] 
     end
 
-    its(:exclude)         { should include(:assets) }
+    its(:excluded_names)   { should include(:assets) }
     its(:only_included?)  { should_not be_true }
     its(:only_included)   { should be_empty }
-    its(:excluded)        { should_not be_empty }
+    its(:after_exclude)   { should_not be_empty }
     specify { subject.exclude_list.first.should match /Assets\.gemfile/ }
     its(:gemfile_names)   { should_not include('Assets') }
   end
 
-  context "assets include only" do
+  context "include only assets" do
     before do
-      subject.exclude = []
-      subject.include_only = [:assets, :view] 
+      subject.excluded_names = []
+      subject.include_only_names = [:assets, :data_store] 
     end
 
-    its(:include_only)    { should include(:assets, :view) }
+    its(:include_only_names)    { should include(:assets, :data_store) }
     its(:only_included?)  { should be_true }
-    its(:only_included)   { should_not be_empty }
-    its(:excluded)        { should_not be_empty }    
-    its(:gemfile_names)   { should include('Assets') }
+    its(:only_included)   { should have(2).items }
+    its(:after_exclude)   { should_not be_empty }    
+    its(:gemfile_names)   { should include('Assets', 'DataStore') }
+    its(:gemfile_names)   { should_not include('Bootstrap') }
+  end
+
+  context "include only view folder" do
+    before do
+      subject.include_only_folders = [:view] 
+    end
+
+    its(:include_only_folders)   { should include(:view) }
+    its(:only_included_folders?) { should be_true }
+    its(:only_included_folders)  { should have(1).item }
+    specify { subject.only_included_folders.first.should match('view/Bootstrap') }
+
+    its(:filtered)        { should have(1).item }
+    its(:gemfile_names)   { should include('Bootstrap') }
+    its(:gemfile_names)   { should_not include('Assets') }
+  end
+
+  context "exclude view folder" do
+    before do
+      subject.excluded_folders = [:view] 
+    end
+
+    its(:excluded_folders)         { should include(:view) }
+    its(:excluded_folders)         { should have(1).item }
+    its(:only_included_folders?)  { should be_false }
+
+    its(:gemfile_names)   { should_not include('Bootstrap') }
+    its(:gemfile_names)   { should include('DataStore') }
+  end
+
+  context "exclude view folder using option" do
+    before do
+      subject.exclude :folders => :view
+    end
+
     its(:gemfile_names)   { should_not include('Bootstrap') }
+    its(:gemfile_names)   { should include('DataStore') }
+  end
+
+  context "include view folder using option" do
+    before do
+      subject.include_only :folders => :view, :names => :facebook
+    end
+
+    its(:gemfile_names)   { should be_empty }
+  end
+
+  context "include /view folder and then :facebook via select names" do
+    before do
+      subject.include_only :folders => :view
+      subject.selected_names = :facebook
+    end
+
+    its(:gemfile_names)   { should include('Bootstrap', 'Facebook') }
+  end
+
+  context 'select names via #select' do
+    before do
+      subject.include_only :folders => :view
+      subject.select :facebook
+    end
+
+    its(:gemfile_names)   { should include('Bootstrap', 'Facebook') }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gem_butler
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -131,7 +131,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3847435360100278583
+      hash: -4221513400261791526
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: