require-me 0.5.5

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Kristian Mandrup
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,175 @@
+# Require-Me ##
+
+Includes a DSL for requiring files and folders and some also some static utility functions which can be used in combination. 
+These tools in combination facilitates managing requiring various subfolder structures.
+FIXED 
+
+## Require DSL ##
+  
+The following example code demonstrates how to use the Require DSL
+
+<pre>
+require 'require-dsl'  # to include the Require DSL language only
+
+Folder.enter 'mira' do |folder| # enter subfolder 'mira'
+  `# from new location, enter a subdir`
+  folder.enter 'subdir' do |path|  # mira/subdir      
+    folder.all('**/*.rb').except(/sound\/*.rb/).require  
+  end
+
+  folder.enter 'another/subdir' do |path|               
+    folder.all('**/*.rb').require # use file blobs here
+  end
+
+  folder.enter 'a_subdir' do |path|         
+    `# matching and except are to be used as include and exclude filters
+    # they each take a list containing regular expressions and strings
+    # string arguments are postfixed with .rb internally if not present`  
+    folder.all('blip/**/*.rb').matching(/_mixin.rb/, /.*\/power/).except(/sound/, /disco/).require
+
+    folder.enter 'sub_a' do |path|         
+      folder.enter 'sub_b' do |path| # a_subdir/sub_a/sub_b         
+        folder.all('grusch/**/*.rb').require
+      end
+
+    end
+    folder.all.require    
+  end
+end  
+</pre>
+
+If no argument, current path is used as initial folder
+ 
+<pre>
+require 'require-me' # include both the static require helpers and the DSL require language  
+  
+Folder.enter do |folder| # use current path as folder
+  folder.all('**/*.rb').require
+  folder.enter 'game' do |path|
+
+    `# use static require functions`
+    Require.base_path path # set base path to use for Require
+
+    `# include .rb files within data1, data2 but not within their subfolders (use recursive instead)`
+    Require.folders('data1', 'data2') 
+     
+    list = path.all('**/*.rb')    
+    puts list.matching('sound', 'network').except(/sound/).show_require(:relative)
+    list.matching('sound', 'network').except(/sound/).require
+  end
+end
+</pre>
+
+## Static helpers ##
+
+Unit tests demonstrations how to use the static helpers (tests currently broken due to missing data files!):
+
+### Setting the base path ##
+
+Setting global base_path
+<pre>
+Require.base_path = File.dirname(__FILE__)  
+</pre>
+
+Set basepath to use within block
+<pre>
+Require.enter 'sound' do |path|
+  Require.folders 'data' # can be used for any number of folders   
+  Require.folder 'data2' # for one folder only
+end
+</pre>
+
+#### Override base_path ##
+
+<pre>
+Require.folders 'data', {:base_path => File.dirname(__FILE__) + '/../my/path}
+</pre>
+
+Simple usage examples
+Require .rb files from a folder
+<pre>
+Require.folders 'data', 'data2' 
+Require.recursive 'data', 'data2' # recursively require all in subtrees
+</pre>
+
+### Simple debugging ##
+
+Get list of required files and print them
+<pre>
+required_files = Require.folder 'data'
+puts required_files  
+</pre>
+
+### Tracing mode (for debugging) ##
+
+Apply tracing to see output for the process of requiring the files
+<pre>  
+  Require.tracing = :on # turn on tracing globally
+  Require.folder 'data'  
+  Require.tracing = :off # turn off tracing globally
+</pre>
+
+Alternatively pass tracing as an option 
+
+<pre>
+Require.folder 'data', {:tracing => :on}  
+</pre>
+
+### Verbose mode (for detailed debugging) ##
+
+Set verbose mode on to see full path of each required file
+<pre>                      
+  Require.tracing = :on # turn on tracing          
+  Require.verbose = :on # turn on verbose globally
+  Require.folder 'data'  
+  Require.verbose = :off  # turn off verbose globally
+</pre>
+
+### Require.recursive ##
+
+Require all files within the top level folder 'data' recursively 
+<pre>
+required_files = Require.recursive 'data'  
+</pre>
+
+Require all files within the top level folders 'data' and 'data2' (non-recursively) 
+<pre>
+required_files = Require.recursive 'data', 'data2'  
+</pre>
+
+Require all files within the top level folders 'data' and 'data2' recursively
+<pre> 
+required_files = Require.recursive 'data', 'data2'
+</pre>
+
+### Require.folders ##
+
+Require files within the top level folders 'data' and 'data2' and also files within the subdirectory 'blip' if it exists 
+<pre>
+required_files = Require.folders 'data', 'data2', {:folders => 'blip'}  
+</pre>
+
+Require files within 'data/blip' and 'data2/blip' only, NOT including the root files
+<pre>
+required_files = Require.folders 'data', 'data2', {:folders => 'blip', :ignore_root_files => true}  
+</pre>
+
+Require files within 'data' and 'data2' first and then AFTER any files within the subdirectory 'blip' (default order)
+<pre>
+required_files = Require.folders 'data', 'data2', {:folders => 'blip', :root_files => :before}  
+</pre>
+
+Require files within 'data/blip' and 'data2/blip' first and then AFTER any files within 'data' and 'data2' folders (the root files)
+<pre>
+required_files = Require.folders(['data', 'data2'], {:folders => 'blip', :root_files => :after})
+</pre>
+
+Require files within 'data' and 'data2' (the root files) first (BEFORE) and then any files within the subdirectories 'blip' and 'blap'
+<pre>
+required_files = Require.folders(['data', 'data2'], {:folders => ['blip', 'blap'], :root_files => :before})  
+</pre>
+
+
+## Copyright
+
+Copyright (c) 2010 Kristian Mandrup. See LICENSE for details.

data/lib/require-dsl.rb

@@ -0,0 +1,119 @@
+require 'rake'
+require 'fileutils'
+require 'util/util'
+
+module Folder
+
+  def self.enter(path = '.', &block) 
+    m = Magic.new 
+    m.enter path      
+    yield m
+    m.dir_stack.pop 
+  end
+  
+  module MagicList 
+    attr_accessor :base_path
+    attr_accessor :rel_path
+        
+    def do_require
+      each do |file|
+        require file
+      end 
+      self
+    end
+
+    def show_require(*options)
+      each do |f|                                                      
+        if options.include? :relative                                 
+          file_path = File.join(rel_path, f)
+          path = Require::Dir.relative_path(base_path, file_path)
+        end
+        path = File.join(base_path, f) if !options.include? :relative
+        path
+      end  
+    end
+
+     
+    def delete_these(objs) 
+      reject! do |obj|  
+        a = false
+        objs.each do |del|         
+          a = true if obj.include? del
+        end
+        a
+      end
+    end
+    
+    def except(*reg_exps) 
+      duplicate = self.dup.extend(MagicList)  
+      duplicate.each do |file|    
+        reg_exps.each {|re| duplicate.delete(file) if file.match(re) }         
+      end
+      duplicate
+    end        
+
+    def postfix_rb(str)
+      str << '.rb' if !str.include? '.rb'            
+    end            
+
+    def fix(str)   
+      postfix_rb(str) 
+      str = Regexp.escape(str)
+      str.gsub! '\*', '[a-zA-Z0-9\s_-]*'
+      str.gsub! '/', '\/'
+      str
+    end
+    
+    def matching(*reg_exps) 
+      duplicate = self.dup.extend(MagicList)  
+      keep_list = []
+      duplicate.each do |file| 
+        reg_exps.each do |re|
+          re = fix(re) if re.kind_of? String
+          keep_list << file if file.match(re)
+        end
+      end                              
+      reject_list = (duplicate - keep_list).flatten
+      duplicate.delete_these(reject_list)
+      duplicate
+    end    
+  end
+
+  class Magic
+    attr_accessor :current_path
+    attr_accessor :dir_stack
+    
+    def initialize      
+      @dir_stack = []
+      @current_path = FileUtils.pwd
+    end
+    
+    def enter(dir)       
+      FileUtils.cd dir
+      dir_stack.push path = FileUtils.pwd   
+      @current_path = path
+      if block_given?
+        yield path            
+        current_path = dir_stack.last
+        old_dir = dir_stack.last if dir_stack.pop 
+        FileUtils.cd old_dir if old_dir               
+      end      
+      path
+    end
+
+    def all(*globs)
+      globs = '**/*.rb' if globs.empty?      
+      list = FileList.new(globs)
+      list.extend(MagicList)  
+      list.base_path = dir_stack.first 
+      list.rel_path = current_path    
+      list.freeze
+    end
+        
+  end
+end  
+              
+    
+    
+
+    

data/lib/require-me.rb

@@ -0,0 +1,143 @@
+require 'require-dsl'
+
+module Require
+  
+  class << self
+    attr_accessor :base_path
+    attr_accessor :tracing
+    attr_accessor :verbose
+  end
+
+  def self.recursive(*names, options, &block)
+    options = {} if !options     
+    options[:recursive] = true
+    names.each{|name| folder(name, options) }
+  end
+  
+  def self.folders(*names, options)
+    options = {} if !options 
+    required_files = []
+    names.each do |path| 
+      options[:root] = path if is_root?(path, options) 
+      required_files << folder(path, options)
+    end
+    required_files.flatten
+  end
+
+  def self.enter(name, options = {}, &block)
+    options[:recursive] = true
+    file = folder(name, options)
+    base_path = File.dirname(file)
+    yield base_path    
+  end
+
+
+  def self.folder(name, options = {})
+    recursive = options[:recursive]
+    folder_list = options[:folders]
+    file_pattern =  recursive ? "#{name}/**/*.rb" : "#{name}/*.rb" 
+  
+    base_dir = File.dirname(__FILE__)
+  
+    curr_base_path = options[:base_path] || base_path || base_dir
+  
+    # puts "base_path: #{curr_base_path}, base_dir:#{base_dir}, :base_path #{base_path}"
+
+    path = File.join(curr_base_path, file_pattern)
+    required_files = []
+
+    puts_trace "folder:: name: #{name}", options    
+
+    if !options[:root_files] || options[:root_files] == :before
+      required_files << require_root_files(name, folder_list, path, options)
+      # options[:root] = false
+      required_files << require_folder_list(name, folder_list, options)    
+    else
+      required_files << require_folder_list(name, folder_list, options)          
+      required_files << require_root_files(name, folder_list, path, options)
+      # options[:root] = false      
+    end
+    required_files.flatten
+  end    
+
+protected
+  def self.puts_trace(txt, options)
+    puts txt if tracing?(options)    
+  end
+
+  def self.tracing?(options)
+    tracing == :on || options[:tracing] == :on
+  end
+
+  def self.is_root?(path, options)
+    root = options[:root]
+    root == nil || (root && path.size < root.size)
+  end
+
+  def self.require_root_files(name, folder_list, path, options)
+    puts_trace "require_root_files:: name: #{name}, folders: #{folder_list.inspect}, path: #{path}", options    
+    required_files = []
+    i_am_root = options[:root] == name
+    if options[:ignore_root_files] && i_am_root
+      options.delete :ignore_root_files                        
+    else
+      includes_rexp = options[:include]
+      excludes_rexp = options[:exclude]      
+            
+      Dir.glob(path).each {|f| 
+        next if excludes_rexp &&  match(f, excludes_rexp)
+        if !includes_rexp || match(f, includes_rexp)
+          puts_trace "require: #{f}", options
+          required_files << do_require(f) 
+        end
+      }
+    end    
+    
+    required_files.flatten
+  end
+
+  def self.require_folder_list(name, folder_list, options)
+    puts_trace "require_folder_list:: name: #{name}, folders: #{folder_list.inspect}", options    
+    required_files = []
+    if folder_list
+      # options.delete :ignore_root_files            
+      options.delete :folders
+      
+      folder_list.each do |folder|
+        sub_folder = File.join(name, folder)
+        required_files << folders(sub_folder, options) 
+      end
+    end
+    required_files.flatten
+  end
+
+  def self.do_require(name)
+    require name 
+    list_name name
+  end
+
+  def self.list_name(name)    
+    if base_path && !(verbose == :on)
+      name.gsub(/#{Regexp.escape(base_path)}/, '')
+    else
+      name
+    end
+  end
+
+  def self.match(f, *rexp)      
+      rexp.each{|e| return true if match_single(f, rexp)}
+      false
+  end
+  
+  def self.match_single(f, rexp)
+    if rexp.kind_of? String
+      str = Regexp.escape(str)
+      str.gsub! '\*', '[a-zA-Z0-9\s_-]*'
+      str.gsub! '/', '\/'      
+    end
+    if rexp.kind_of? Regexp  
+      return f.match(re)
+    end    
+    false
+  end
+end

data/lib/util/util.rb

@@ -0,0 +1,13 @@
+require 'pathname'
+
+module Require
+  module Dir
+    def self.relative_path(base_path, path)
+      path.gsub! /#{Regexp.escape base_path}/ 
+      p1 = Pathname.new base_path
+      p2 = p1 + path
+      p4 = p2.relative_path_from(p1)  # Pathname:lib/ruby/1.8    
+    end
+  end
+end
+  

data/spec/fixtures/game/game.rb

@@ -0,0 +1 @@
+puts "Game was included"

data/spec/fixtures/game/graphics/graphics.rb

@@ -0,0 +1 @@
+puts "Graphics was included"

data/spec/fixtures/game/network/network.rb

@@ -0,0 +1 @@
+puts "Network was included"

data/spec/fixtures/game/sound/sound.rb

@@ -0,0 +1 @@
+puts "Sound was included"

data/spec/require-dsl_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RequireMagic" do
+  it "works" do
+    Folder.enter '../spec/fixtures' do |folder|
+      folder.enter 'game' do |path|
+        list = folder.all('**/*.rb')                                                    
+        l1 = list.matching( 'sound', 'network').except(/sound/).do_require        
+        l1_res = l1.show_require(:relative).inspect
+        l1_res.should include("network/network.rb")
+
+        l2 = list.matching( '*/sound', 'network').show_require(:relative).inspect        
+        l2.should include("network/network.rb")
+      end
+    end    
+  end
+
+  it "works with base folder " do 
+    Folder.enter do |folder|
+      puts folder.current_path
+      folder.enter 'game' do |path|
+        list = folder.all # ('**/*.rb')                                                    
+        l1 = list.matching( 'sound', 'network').except(/sound/).show_require(:relative).inspect        
+        l1.should include("network/network.rb")
+  
+        l2 = list.matching( '*/sound', 'network').show_require(:relative).inspect        
+        l2.should include("network/network.rb")
+      end
+    end    
+  end  
+  
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+# require 'require-dsl'
+require 'require-me'
+require 'rspec'
+require 'rspec/autorun'

data/test/test_require_folder.rb

@@ -0,0 +1,55 @@
+require 'require-magic'
+require "unit_test_require"
+ 
+class TestRequireFolder < UnitTestRequire
+    
+  def test_require_folder
+    required_files = Require.folder(@folder)
+        
+    found0 = match? required_files[0], 'data_a.rb'
+      
+    assert_equal 1, required_files.size, "Should require 1 file" 
+    assert found0, "Should require data_a.rb in /" 
+  
+  end
+  
+  def test_require_folder_recursive
+    required_files = Require.rfolder(@folder)
+    assert_equal 4, required_files.size, "Should require 4 files" 
+  end
+  
+  def test_require_folder_recursive_include
+    options = {:include => '_a'}
+    required_files = Require.folder(@folder, options)
+    assert_equal 1, required_files.size, "Should require 1 file" 
+  end
+
+  def test_require_folder_recursive_include_base_path
+    options = {:include => '_a'}
+    Require.base_path = File.dirname(__FILE__) + "/../lib"
+    required_files = Require.folder(@folder, options)
+    
+    assert_equal 1, required_files.size, "Should require 1 file" 
+    assert_equal "/data/data_a.rb", required_files[0], "Path of required files should be from base_path when verbose not :on"
+  end
+
+  
+  def test_require_folders_recursive_exclude_base_path
+    options = {:exclude => '_a'}
+    required_files = Require.folder(@folder, options)
+    assert_equal 0, required_files.size, "Should require 0 files" 
+  end  
+  
+  def test_require_folder_recursive_default_base_path_override
+    options = {:folders => ['blip'], :base_path => File.dirname(__FILE__) + "/../lib"}
+    required_files = Require.folder(@folder, options)
+    
+    assert_equal 3, required_files.size, "Should require 3 files" 
+        
+    found0 = match? required_files[0], 'data_a.rb'    
+    assert found0, "Should require root files such as 'data_a.rb' first"     
+  end  
+
+  
+end
+

data/test/test_require_folders.rb

@@ -0,0 +1,46 @@
+require 'require-magic'
+require "unit_test_require"
+ 
+class TestRequireFolders < UnitTestRequire
+    
+  def test_require_folders
+    required_files = Require.folders(@folders)
+    
+    found0 = match? required_files[0], 'data_a.rb'
+    found1 = match? required_files[1], 'data2/blap_a.rb'
+      
+    assert_equal 2, required_files.size, "Should require 2 files" 
+    assert found0, "Should require data_a.rb in /" 
+    assert found1, "Should require blap_a.rb in /data" 
+  end
+  
+  def test_require_folders_recursive
+    options = {:recursive => true}
+    required_files = Require.folders(@folders, options)
+    assert_equal 5, required_files.size, "Should require 5 files" 
+  end
+  
+  def test_require_folders_recursive_include
+    options = {:recursive => true, :include => 'blip_'}
+    required_files = Require.folders(@folders, options)
+    assert_equal 2, required_files.size, "Should require 2 files" 
+  end
+  
+  def test_require_folders_recursive_exclude
+    options = {:recursive => true, :exclude => 'blip_'}
+    required_files = Require.folders(@folders, options)
+    assert_equal 3, required_files.size, "Should require 3 file" 
+  end  
+  
+  def test_require_folders_recursive_default
+    options = {:folders => ['blip']}
+    required_files = Require.folders(@folders, options)
+    assert_equal 4, required_files.size, "Should require 4 files" 
+    
+    found0 = match? required_files[0], 'data_a.rb'    
+    assert found0, "Should require root files such as 'data_a.rb' first"     
+  end  
+
+  
+end
+

data/test/test_require_folders_adv.rb

@@ -0,0 +1,54 @@
+require 'require-magic'
+require "unit_test_require"
+ 
+class TestRequireFoldersAdv < UnitTestRequire
+
+  def test_require_folders_recursive
+    options = {:folders => ['blip'], :ignore_root_files => true}
+    required_files = Require.folders(@folders, options)
+    assert_equal 3, required_files.size, "Should require 3 files" 
+  end  
+
+  def test_require_folders_root_folders_before
+    options = {:folders => ['blip'], :root_files => :before}
+    required_files = Require.folders(@folders, options)
+    assert_equal 4, required_files.size, "Should require 4 files" 
+
+    root_first = match?(required_files[0], 'data_a.rb') 
+    assert root_first, "First required file should be root file 'data_a.rb'"                  
+  end  
+  
+  def test_require_folders_root_folders_after
+    options = {:folders => ['blip'], :root_files => :after}
+    required_files = Require.folders(@folders, options)
+    assert_equal 4, required_files.size, "Should require 4 files" 
+
+    root_last = match?(required_files[2], 'data_a.rb')        
+    assert root_last, "Last required file of 'data' should be root file 'data_a.rb'"
+  end
+
+  def test_require_folders_root_folders_before_but_ignore
+    options = {:folders => ['blip'], :root_files => :before, :ignore_root_files => true}
+    required_files = Require.folders(@folders, options)
+
+    assert_equal 3, required_files.size, "Should require 3 files" 
+  end
+
+  def test_require_folders_root_folders_after_but_ignore
+    options = {:folders => ['blip'], :root_files => :after, :ignore_root_files => true}
+    required_files = Require.folders(@folders, options)
+    assert_equal 3, required_files.size, "Should require 3 files" 
+  end
+
+  def test_require_folders_recursive_data_root_folders_after
+    options = {:folders => ['blip'], :root_files => :after}
+    required_files = Require.folders('data', options)
+    assert_equal 3, required_files.size, "Should require 3 files" 
+    
+    root_last = match?(required_files[2], 'data_a.rb')
+    
+    assert root_last, "Last required file should be root file 'data_a.rb'"     
+  end  
+
+
+end

data/test/unit_test_require.rb

@@ -0,0 +1,17 @@
+require "test/unit"
+
+class UnitTestRequire < Test::Unit::TestCase
+
+  def setup
+    @folders = ['data', 'data2']
+    @folder = 'data'
+  end
+
+  def match?(expr, rexp)    
+    !(expr =~ /#{Regexp.escape(rexp)}/).nil?
+  end
+  
+  def test_me
+    assert true, "true"
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: require-me
+version: !ruby/object:Gem::Version 
+  version: 0.5.5
+platform: ruby
+authors: 
+- Kristian Mandrup
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-03 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Lets you easily define how to include hierarchies of ruby files, and also apply inclusion/exclusion filters for what to include
+email: kmandrup@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- lib/require-dsl.rb
+- lib/require-me.rb
+- lib/util/util.rb
+- LICENSE
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/kristianmandrup/require-magic
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Facilitates requiring select ruby files in folders
+test_files: 
+- spec/fixtures/game/game.rb
+- spec/fixtures/game/graphics/graphics.rb
+- spec/fixtures/game/network/network.rb
+- spec/fixtures/game/sound/sound.rb
+- spec/require-dsl_spec.rb
+- spec/spec_helper.rb
+- test/test_require_folder.rb
+- test/test_require_folders.rb
+- test/test_require_folders_adv.rb
+- test/unit_test_require.rb