skeleton_creator 0.2.0 → 0.4.0

data/README.rdoc

@@ -2,19 +2,103 @@
 
 Script to facilitate quick and easy creation of complex directory/file structures.
 
-1. Create a YAML directory structure file 
-  Structure should be similar to the examples in config-files
 
-  By default any leaf node results in a File being created. 
-  To override this, postfix with DIR, fx
+== YAML config file
+
+Create a YAML directory structure file 
+The structure should be similar to the examples in config-files, links.yml shows how to define symbolic links
+
+By default any leaf node results in a File being created. 
+
+root:
+  meta: ONLY_DIRS
+  a:
+    - bee
+    - cee
+
+Here a is created as a dir, with bee and cee as empty files 
+
+To override this, postfix entry with DIR, fx
   - my_dir DIR 
 
-  If you want all nodes in a tree to be created as dirs, supply a meta: in the root of the tree 
-  meta: ONLY_DIRS 
+Example: DIR
+  root:
+    a:
+      - bee DIR
+      - cee
+
+Here a and bee are created as a dirs, while cee is an empty file 
+
+===  Special meta data
+
+If you want all nodes in a tree to be created as dirs, supply a meta: in the root of the tree 
+
+meta: ONLY_DIRS 
+
+This will ensure all the following nodes in the tree are treated as dirs, until a REVERT is encountered (see below)
+
+Example: ONLY_DIRS
+
+root:
+  meta: ONLY_DIRS
+  a:
+    - bee
+    - cee
+
+Here bee and cee are created as dirs
+
+Example: 
+Using ONLY_DIRS and REVERT
+
+root:
+  - ONLY_DIRS
+  - bee
+  - cee
+  - REVERT
+  - dee
+  - 
+    eee:
+      meta: ONLY_DIRS
+        x:
+         - y
+         - z
 
-  This will ensure all nodes in the tree are treated as dirs
+Here bee and cee will be created as dirs while dee and eee become empty files. Later y and x also are dirs because of the meta: ONLY_DIRS
+
+Symbolic links:
+
+apps:
+  category: &app-category
+    - games ALIAS c-games
+    - business
+    - utils 
+    - other
+  all: &app-runtype
+    - my_games REF c-games 
+
+Here an alias c-games is created for the entry apps/category/games
+Later the symbolic link my-games is created to point at whatever the alias c-games currently points to, in this case apps/category/games
+An alias can be overridden later... this is illustrated below.
+
+apps:
+  category: &app-category
+    - games ALIAS c-games
+    - business
+    - my_games REF c-games 
+    - other
+    - cool-games ALIAS c-games
+  all: &app-runtype
+    - my_cool_games REF c-games 
+
+Results in this:
+
+my_games --> (c-games) --> games
+my_cool_games --> (c-games) --> cool-games
     
-1. Run it!
+== Usage
+
+Use the following ruby code as a 'template'. As shown, the options argument is optional
+ 
   require 'skeleton_creator'
 
   runner = FileSystem::Runner.new file_name [, options]
@@ -24,6 +108,22 @@ Fx to generate the skeleton structure inside ~/testing as per the apps.yml file
   runner = FileSystem::Runner.new 'apps.yml'
   runner.run "~/testing"
 
+OR using fake file and directory creators to simulate first 
+  runner = FileSystem::Runner.new 'apps.yml', :fake => true
+  runner.run "~/testing"
+  runner.run "~/testing2"
+
+OR
+  runner = FileSystem::Runner.new 'apps.yml'
+  runner.run "~/testing"
+  runner.run "~/testing2", :fake => true
+
+The options :fake is false by default. Setting it on the call to run overrides the initial value (set with Runner.new) for that particular run
+
+OR
+  runner.run ["testing2", "testing4"], :fake => true, :root => '~'
+
+Creates dirs in '~/testing2' and '~/testing4' 
 
 == Note on Patches/Pull Requests
  

data/lib/file_system/directory/directory_creator.rb

@@ -0,0 +1,12 @@
+require 'fileutils'
+require 'file_system/directory/fake_directory'
+
+module FileSystem
+  class DirectoryCreator < FakeDirectory
+    def create
+      # puts "DIR: #{name}"      
+      FileUtils.mkdir_p name
+    end
+
+  end
+end

data/lib/file_system/{fake_directory.rb → directory/fake_directory.rb}

@@ -1,5 +1,3 @@
-require 'fileutils'
-
 module FileSystem
   class FakeDirectory
 

data/lib/file_system/{fake_file.rb → file/fake_file.rb}

@@ -3,7 +3,7 @@ module FileSystem
     attr_accessor :name    
     
     def initialize(traverser, name)
-      @name = ::File.join(traverser.current_dir, name)
+      @name = File.join(traverser.current_dir, name)
     end
 
     def create

data/lib/file_system/file/file_creator.rb

@@ -0,0 +1,12 @@
+require 'file_system/file/fake_file' 
+
+module FileSystem
+  class FileCreator < FakeFile
+    
+    def create        
+      # puts "FILE: #{name}"      
+      FileUtils.touch name
+    end
+    
+  end  
+end

data/lib/file_system/link/fake_symbolic_link.rb

@@ -0,0 +1,24 @@
+module FileSystem
+  class FakeSymbolicLink
+
+    attr_accessor :old_name, :new_name
+    def initialize(traverser, old_name, new_name)
+      @old_name = old_name
+      @new_name = File.join(traverser.current_dir, new_name)
+    end
+  
+    def create
+      puts "SYMBOLIC LINK: #{new_name} --> #{old_name}"      
+      # puts "ln_s #{old_name} #{new_name}"
+    end
+  
+    def is_file?
+      false
+    end
+
+    def is_dir?
+      true
+    end    
+    
+  end
+end

data/lib/file_system/link/symbolic_link_creator.rb

@@ -0,0 +1,22 @@
+require 'fileutils'
+require 'file_system/link/fake_symbolic_link'
+
+module FileSystem
+  class SymbolicLinkCreator < FakeSymbolicLink
+    def create
+      if !File.exist?(old_name)
+        puts "Can't to link to '#{old_name}' since it does not exist" 
+        return
+      end                                                                              
+      if File.exist?(new_name)
+        puts "Can't create alias '#{new_name}' since a file of that name already exists" 
+        return
+      end        
+      FileUtils.ln_s old_name, new_name 
+    end
+    
+    def exist?(name)
+      File.exist?(name) || File.symlink?(name)
+    end
+  end
+end

data/lib/file_system/traverser.rb

@@ -1,17 +1,22 @@
-require 'file_system/fake_file' 
-require 'file_system/fake_directory'
-require 'file_system/file' 
-require 'file_system/directory' 
-
+require 'file_system/directory/directory_creator' 
+require 'file_system/link/symbolic_link_creator' 
+require 'file_system/file/file_creator' 
 
 module FileSystem
   class Traverser
-    attr_accessor :root_dir, :dir_stack, :options
+    attr_accessor :root_dir, :dir_stack, :options, :reference_hash, :dirs_only
+
+    ONLY_DIRS = 'ONLY_DIRS'
+    REVERT    = 'REVERT'
+    ALIAS     = 'ALIAS'
+    REF       = 'REF'
+    DIR       = 'DIR'
     
     def initialize(root_dir, options = {})
       @root_dir ||= root_dir
       @dir_stack = []
       @options = options
+      @dirs_only = false
     end
 
     def traverse(obj, &blk)
@@ -26,7 +31,7 @@ module FileSystem
     end
 
     def current_dir
-      ::File.join(root_dir, dir_stack.join('/'))
+      File.join(root_dir, dir_stack.join('/'))
     end
     
     def visit_dir(name)
@@ -42,9 +47,7 @@ module FileSystem
     def handle_hash(obj, &blk)
       # Forget keys because I don't know what to do with them
       obj.each do |dir_name, dir_content|
-        options.merge! parse_meta(dir_name, dir_content)                          
-        blk.call(create_directory dir_name) if !(options && options[:dirs_only]) 
-        options.delete :dirs_only
+        blk.call(create_directory dir_name)
         traverse(dir_content, &blk)
         leave_dir      
       end
@@ -58,34 +61,103 @@ module FileSystem
 
     def handle_single(obj, &blk)
       if obj
-        file_name = obj      
-        if file_name =~ /DIR/ || 
-          dir_name = file_name.gsub(/DIR/, '').strip
-          blk.call(create_directory dir_name)
-          leave_dir      
-        else        
-          blk.call(create_file file_name)          
+        return if parse_meta(obj)                          
+        file_name = obj                          
+        if ref?(obj)                      
+          blk.call(create_symbolic_link ref_name(obj), name(obj))
+          return                     
+        end        
+        name = name(obj)
+        if alias?(obj)                      
+          create_reference alias_name(obj), name
         end
+        handle_single_entry(name, &blk)                                       
+      end
+    end
+
+    def handle_single_entry(file_name, &blk) 
+      if enforce_dir? file_name
+        dir_name = file_name.gsub( /\s#{DIR}\s/, '').strip
+        blk.call(create_directory dir_name)
+        leave_dir      
+      else                
+        blk.call(create_file file_name)          
       end
     end
+
+    def enforce_dir?(file_name)
+      dirs_only || !/\sDIR\s/.match(file_name).nil?
+    end
+
+    def create_reference(alias_name, name)
+      @reference_hash ||= {}
+      dir = File.join(root_dir, dir_stack.join(File::SEPARATOR), name)
+      @reference_hash.merge!({alias_name.to_sym => dir})      
+    end
     
     def create_directory(name)
       return FileSystem::FakeDirectory.new(self, name) if options[:fake]
-      FileSystem::Directory.new(self, name)         
+      FileSystem::DirectoryCreator.new(self, name)         
     end
 
     def create_file(name)
       return FileSystem::FakeFile.new(self, name) if options[:fake]
-      FileSystem::File.new(self, name)         
+      FileSystem::FileCreator.new(self, name)         
+    end
+
+    def create_symbolic_link(ref_name, new_name)
+      old_name = reference_hash[ref_name.to_sym].strip
+      # puts "create_symbolic_link: r:#{ref_name}, n:#{new_name}, o:#{old_name}"         
+      return FileSystem::FakeSymbolicLink.new(self, old_name, new_name) if options[:fake]
+      FileSystem::SymbolicLinkCreator.new(self, old_name, new_name)         
     end
+
   
-    def parse_meta(key, value)
-      return {dirs_only: true} if key == 'meta' && value == 'ONLY_DIRS'             
-      {}
+    def parse_meta(key, value = "") 
+      if revert?(key, value)
+        @dirs_only = false
+        return true 
+      end                      
+      if only_dirs?(key, value)
+        @dirs_only = true
+        return true
+      end
+      false
+    end
+
+    def only_dirs?(key, value = "")
+      key == ONLY_DIRS || key == 'meta' && value == ONLY_DIRS      
+    end
+
+    def revert?(key, value = "")
+      key == REVERT || key == 'meta' && value == REVERT      
+    end
+
+
+    def name(value)
+      value = value.gsub(/\s#{ALIAS}\s/, ',').gsub(/\s#{REF}\s/, ',')
+      value.split(',').first.strip
+    end
+    
+    def alias?(value)
+      value.include?(ALIAS)
     end
 
+    def alias_name(value)
+      value.split(ALIAS).last.strip
+    end
+
+    def ref?(value)
+      value.include?(REF)
+    end
+
+    def ref_name(value)
+      value.split(REF).last.strip
+    end
+
+
     def dirs_only?
-      options && options[:dirs_only]
+      dirs_only
     end
     
   end

data/lib/skeleton_creator.rb

@@ -6,23 +6,35 @@ require 'file_system/traverser'
 module FileSystem  
   class Runner   
     attr_accessor :yml_content, :options
+    attr_reader :root_dir
     
-    def initialize(filename, options = false)      
+    def initialize(filename, options = {})      
       @yml_content = YAML.load_file(filename)
       @options = options
     end
     
-    def run(root_dir, options = {})  
+    def run(dir, options = {})  
+      return run_list(dir, options) if dir.respond_to? :each
+
       @options = options if !options.nil?      
-      root = root_dir.gsub /~/, "#{ENV['HOME']}"
+      @root_dir = dir.gsub /\~/, "#{ENV['HOME']}"
       yml_content.each do |key, value|
-        if key == 'DIRECTORY'
-          traverser = FileSystem::Traverser.new root, options
+        if key == 'DIRECTORY' 
+          traverser = FileSystem::Traverser.new root_dir, options
           traverser.traverse(value) do |file_node|
             file_node.create
           end
         end
       end
     end
+
+    protected
+    def run_list(dir_list, options = {})  
+      dir_list.each do |dir|
+        dir = File.join(options[:root], dir) if options[:root]
+        run(dir, options)          
+      end
+    end
+
   end
 end   

data/spec/skeleton_creator_spec.rb

@@ -4,37 +4,44 @@ require 'rake'
 describe "SkeletonCreator" do
   it "should create a directory structure" do
     file_name = File.expand_path(File.join(Dir.pwd,  '../config-files/apps.yml'))
-    puts "=========="    
-    puts file_name
     runner = FileSystem::Runner.new file_name
     root_dir = "~/testing"
     runner.run root_dir
-    FileUtils.cd root_dir do
+    FileUtils.cd runner.root_dir do
       FileList['**/*'].size.should > 30 
-      FileUtils.rm_rf root_dir
+      FileUtils.rm_rf runner.root_dir
     end
   end
 
+  it "should create a directory structure with symbolic links" do
+    file_name = File.expand_path(File.join(Dir.pwd,  '../config-files/links.yml'))
+    runner = FileSystem::Runner.new file_name
+    root_dir = "~/testing"    
+    runner.run root_dir
+    FileUtils.cd File.join(runner.root_dir, '_tags/all') do
+      File.symlink?('my_games').should == true      
+    end
+    FileUtils.rm_rf runner.root_dir          
+  end
+  
   it "should not create a directory structure if set to fake" do
     file_name = File.expand_path(File.join(Dir.pwd,  '../config-files/apps.yml'))
-    puts "=========="    
-    puts file_name
     runner = FileSystem::Runner.new file_name
     root_dir = "~/testing4"
     runner.run root_dir, :fake => true
-    File.directory?(root_dir).should == false
-  end
+    File.directory?(runner.root_dir).should == false
+  end   
     
-  it "should create multiple of the same directory structures in differet locaions" do
+  it "should create multiple of the same directory structures in differet locations" do
     file_name = File.expand_path(File.join(Dir.pwd,  '../config-files/apps.yml'))
     runner = FileSystem::Runner.new file_name
-    root_dirs = ["~/testing", "#{ENV['HOME']}/testing2"]
-    root_dirs.each do |root_dir|    
-      runner.run root_dir
-      FileUtils.cd root_dir
-      FileList['**/*'].size.should > 70 
-      FileUtils.rm_rf root_dir
+    root_dirs = ["testing2", "testing4"] 
+    runner.run root_dirs, :root => '~'
+    root_dirs.each do |root_dir|
+      dir = File.join("#{ENV['HOME']}", root_dir)
+      File.directory?(dir).should == true
+      FileUtils.rm_rf dir      
     end
-  end 
+  end  
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: skeleton_creator
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Kristian Mandrup
@@ -30,15 +30,19 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
+- README
 - README.rdoc
 files: 
-- lib/file_system/directory.rb
-- lib/file_system/fake_directory.rb
-- lib/file_system/fake_file.rb
-- lib/file_system/file.rb
+- lib/file_system/directory/directory_creator.rb
+- lib/file_system/directory/fake_directory.rb
+- lib/file_system/file/fake_file.rb
+- lib/file_system/file/file_creator.rb
+- lib/file_system/link/fake_symbolic_link.rb
+- lib/file_system/link/symbolic_link_creator.rb
 - lib/file_system/traverser.rb
 - lib/skeleton_creator.rb
 - LICENSE
+- README
 - README.rdoc
 has_rdoc: true
 homepage: http://github.com/aslakhellesoy/cucumber-rails

data/lib/file_system/directory.rb

@@ -1,10 +0,0 @@
-require 'fileutils'
-
-module FileSystem
-  class Directory < FakeDirectory
-    def create
-      FileUtils.mkdir_p name
-    end
-
-  end
-end

data/lib/file_system/file.rb

@@ -1,9 +0,0 @@
-module FileSystem
-  class File < FakeFile
-    
-    def create
-      FileUtils.touch name
-    end
-    
-  end  
-end