skeletor 0.6.1

data/README.md

@@ -0,0 +1,22 @@
+Skeletor
+========
+
+Skeletor is a Ruby Library for setting up quick project skeletons based on code templates.
+
+Contributing to Skeletor
+------------------------
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+---------
+
+Copyright (c) 2011 OiNutter. See LICENSE.txt for
+further details.
+

data/bin/skeletor

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "skeletor"
+require "optparse"
+
+Skeletor::CLI.start

data/lib/skeletor.rb

@@ -0,0 +1,9 @@
+require 'skeletor/version'
+
+module Skeletor
+  autoload :Skeletons, 'skeletor/skeletons'
+  autoload :Tasks, 'skeletor/tasks'
+  autoload :Builder, 'skeletor/builder'
+  autoload :Includes, 'skeletor/includes'
+  autoload :CLI, 'skeletor/cli'
+end

data/lib/skeletor/builder.rb

@@ -0,0 +1,129 @@
+require 'fileutils'
+
+module Skeletor
+  
+  class Builder
+    
+    def initialize(project,template,path)
+      
+      @project = project
+      @template_name = File.basename(template).gsub('.yml','')
+      @template = Skeletons::Skeleton.new(template)
+      @path = path
+      
+    end
+    
+    def build()
+      
+      #check dir exists, if not, make it
+      if(!File.exists?(@path))
+        Dir.mkdir(@path)
+      end
+      
+      #build directory structure
+      puts 'Building directory structure'
+      build_skeleton(@template.directory_structure)
+      
+      #execute build tasks
+      puts 'Running build tasks'
+      execute_tasks(@template.tasks,@template.path)
+      
+      puts 'Skeleton built'
+      
+    end
+    
+    def build_skeleton(dirs,path=@path)
+        
+        dirs.each{
+          |node|
+          
+          if node.kind_of?(Hash) && !node.empty?()
+            node.each_pair{
+              |dir,content| 
+          
+              puts 'Creating directory ' + File.join(path,dir)
+              Dir.mkdir(File.join(path,dir))
+        
+              if content.kind_of?(Array) && !content.empty?()
+                build_skeleton(content,File.join(path,dir))
+              end
+              
+            }
+          elsif node.kind_of?(Array) && !node.empty?()
+            node.each{
+              |file|
+              
+              write_file(file,path)
+        
+            }
+          end
+          
+      }
+      
+    end
+    
+    def self.clean(path=@path)
+      
+      puts 'Cleaning directory of files and folders'
+      start_dir = Dir.new(path)
+      
+      start_dir.each{
+        |dir|
+        
+        if dir != '.' && dir != '..'
+          FileUtils.rm_r File.join(path,dir), {:secure=>true}  
+        end
+        
+      }
+      puts 'Directory cleaned'
+      
+    end
+    
+    def write_file(file,path)
+      
+      #if a pre-existing file is specified in the includes list, copy that, if not write a blank file      
+      if @template.includes.has_key?(file)
+        begin
+          Includes.copy_include(@template.includes[file],File.join(path,file),@template.path)
+        rescue TypeError => e
+          puts e.message
+          exit
+        end
+      else
+        puts 'Creating blank file: ' + File.join(path,file)
+        File.open(File.join(path,file),'w')
+      end
+      
+    end
+    
+    def execute_tasks(tasks,template_path)
+      
+      if File.exists?(File.expand_path(File.join(template_path,'tasks.rb')))
+        load File.expand_path(File.join(template_path,'tasks.rb'))
+      end
+       
+      tasks.each{
+        |task|
+        
+        puts 'Running Task: ' + task
+        
+        task = task.gsub('<skeleton_path>',@path)
+        task = task.gsub('<skeleton_project>',@project)
+        task = task.gsub('<skelton_template>',@template_name)
+        
+        options = task.split(', ')
+        action = options.slice!(0)
+        
+        if(Tasks.respond_to?(action))
+          Tasks.send action, options.join(', ')
+        else
+          send action, options.join(', ')
+        end
+        
+      }
+                  
+    end
+    
+  end
+  
+end

data/lib/skeletor/cli.rb

@@ -0,0 +1,40 @@
+require 'thor'
+
+module Skeletor
+  
+  class CLI < Thor
+    
+    desc "build TEMPLATE [options]", "Build project skeleton from TEMPLATE"
+    method_option :directory,             
+                  :aliases => "-d",
+                  :desc => "Sets the target directory. Defaults to current directory."
+    method_option :project, 
+                  :aliases => "-p",
+                  :desc => "Sets the project name. Defaults to current directory name."
+    def build(template)
+      path = options[:directory] || Dir.pwd
+      project = options[:project] || File.basename(path)
+      
+      skeleton = Builder.new(project,template,path)
+      skeleton.build
+    end
+
+    desc "clean [options]" ,"Clean directory"
+    method_option :directory,
+                  :aliases => "-d",
+                  :desc => "Sets the target directory. Defaults to current directory"
+    def clean
+      path = options[:directory] || Dir.pwd   
+      Builder.clean path
+    end
+    
+    desc "validate TEMPLATE" ,"Checks TEMPLATE is a valid YAML file and matches the required schema."    
+    def validate(template)
+      skeleton = Skeletons::Loader.loadTemplate(template)
+      validator = Skeletons::Validator.new(skeleton)
+      validator.validate()
+    end
+    
+  end
+  
+end

data/lib/skeletor/includes.rb

@@ -0,0 +1,49 @@
+require 'uri'
+
+autoload :HTTP, 'skeletor/protocols/http'
+autoload :HTTPS, 'skeletor/protocols/https'
+
+module Skeletor
+  
+  class Includes
+    
+    PROTOCOL_PATTERN = /(?:([a-z][\w-]+):(?:\/{1,3}|[a-z0-9%]))/
+    SUPPORTED_PROTOCOLS = ['http','https']
+    
+    def self.copy_include(include,target,path)
+      
+      #if include path includes a protocol. Load from that
+      matches = PROTOCOL_PATTERN.match(include).to_a
+      if !matches.empty?
+        protocol = matches[1].to_s.downcase
+        if !SUPPORTED_PROTOCOLS.find_index(protocol).nil?
+          case protocol
+            when 'http'
+              content = HTTP.get URI.parse(include)
+            when 'https'
+              uri = URI.parse(include)
+              http = HTTPS.new uri.host,443
+              http.use_ssl = true
+              req = HTTPS::Get.new uri.path
+              request = http.request(req)
+              content = request.body
+            else
+              raise TypeError, 'Unsupported protocol ' + protocol + ' for remote file. Only the following are supported: ' + SUPPORTED_PROTOCOLS.join(', ') 
+           end
+           puts 'Copying remote file ' + include + ' to ' + target
+        else
+          raise TypeError, 'Unsupported protocol for remote file. Only the following are supported: ' + SUPPORTED_PROTOCOLS.join(', ') 
+        end
+      else
+        puts 'Copying ' + include +  ' from template directory to ' + target
+        file = File.open(File.join(path,include))
+        content = file.gets 
+      end
+      
+      File.open(target,'w'){|f| f.write(content)}
+      
+    end
+    
+  end
+  
+end

data/lib/skeletor/protocols/http.rb

@@ -0,0 +1,2 @@
+require 'net/http'
+HTTP = Net::HTTP

data/lib/skeletor/protocols/https.rb

@@ -0,0 +1,3 @@
+#require 'always_verify_ssl_certificates'
+require 'net/https'
+HTTPS = Net::HTTP

data/lib/skeletor/skeletons.rb

@@ -0,0 +1,9 @@
+module Skeletor
+  
+  module Skeletons
+    autoload :Loader,     'skeletor/skeletons/loader'
+    autoload :Validator,  'skeletor/skeletons/validator' 
+    autoload :Skeleton,   'skeletor/skeletons/skeleton'
+  end  
+    
+end

data/lib/skeletor/skeletons/loader.rb

@@ -0,0 +1,47 @@
+require 'YAML'
+
+module Skeletor
+  
+  module Skeletons
+
+    class Loader
+      
+      TEMPLATE_PATH = File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), "templates"))
+      USER_TEMPLATE_PATH = File.expand_path('~/.skeletor/templates')
+       
+      def self.loadTemplate(template)
+        
+        puts 'Loading Template - ' + template
+        
+        if File.exists?(template) && !File.directory?(template)
+          skeleton = YAML.load_file(template)
+          path = File.dirname(template)
+        elsif File.exists?(File.join(template,File.basename(template) + '.yml'))
+          skeleton = YAML.load_file(File.join(template,File.basename(template) + '.yml'))
+          path = template
+        elsif File.exists?(File.join(USER_TEMPLATE_PATH,template,template+'.yml'))
+          skeleton = YAML.load_file(File.join(USER_TEMPLATE_PATH,template,template+'.yml'))
+          path = File.join(USER_TEMPLATE_PATH,template)
+        elsif File.exists?(File.join(TEMPLATE_PATH,template,template+'.yml'))
+          skeleton = YAML.load_file(File.join(TEMPLATE_PATH,template,template+'.yml'))
+          path = File.join(TEMPLATE_PATH,template)
+        else
+          raise LoadError, 'Error: Template File ' + File.basename(template) + ' Could Not Be Found'
+        end
+        
+        puts 'Template ' + File.basename(template) + '.yml loaded from ' + path
+        if skeleton
+          skeleton['path'] = path
+        else
+          raise LoadError, 'Error: Template could not be parsed as vald YAML'
+        end
+        
+        return skeleton
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/skeletor/skeletons/skeleton.rb

@@ -0,0 +1,47 @@
+module Skeletor
+  
+  module Skeletons
+    
+    class Skeleton
+      
+      def initialize(template)
+        
+        begin
+          @template = Loader.loadTemplate(template)
+          validator = Validator.new(@template)
+          if validator.validate
+            @directory_structure = @template["directory_structure"] || []
+            @tasks = @template["tasks"] || {}
+            @includes = @template["includes"] || {}
+            @path = @template["path"]
+          else
+            exit
+          end
+        rescue LoadError => e
+          puts e.message
+          exit
+        end
+          
+      end
+      
+      def directory_structure
+        @directory_structure
+      end
+      
+      def tasks
+        @tasks
+      end
+      
+      def includes
+        @includes
+      end
+      
+      def path
+        @path
+      end   
+      
+    end
+    
+  end
+  
+end

data/lib/skeletor/skeletons/validator.rb

@@ -0,0 +1,169 @@
+module Skeletor
+  
+  module Skeletons
+    
+    class Validator
+      
+      SCHEMA_FILE = File.join Skeletons::Loader::TEMPLATE_PATH,'template-schema.yml'
+      
+      def initialize(template,schema=SCHEMA_FILE)
+        @errors = []
+        @template = template
+        @schema = Loader.loadTemplate(schema)
+        @types = @schema['types'] || {}
+      end
+      
+       def validate()
+        failed = []
+        
+        @schema['sections'].each{
+          |section|
+          
+          #check required sections are there
+          if (section['required'] && !@template.has_key?(section['name']))
+            @errors.push('Error: missing required section - ' + section['name'])
+            failed.push(section['name'])
+          elsif @template.has_key?(section['name'])
+            node = @template[section['name']]
+            validated = match_node(node,section,section['name'])
+            if(!validated)
+              failed.push(section['name'])
+            end
+          end
+               
+        }
+        
+        puts 'Result: ' + (failed.empty? ? 'Validated Successfully!' : 'Validation Failed!')
+        
+        if !failed.empty? && !@errors.empty?
+          puts 'Validation Failed with ' + @errors.count.to_s + ' errors';
+          puts ''
+          @errors.each{
+            |error|
+            puts error            
+          }
+          return false
+        else
+          return true
+        end
+        
+      end
+
+      def match_node(node,expected,label)
+        
+        #check type    
+        if !check_type(node,expected['type'],label,expected['ok_empty'])
+          return false
+        end
+        
+        if (node.kind_of?(Hash) || node.kind_of?(Array))
+          
+          if node.empty? && !expected['ok_empty']
+            @errors.push('Error: node ' + label + ' cannot be empty')
+            return false
+          elsif !node.empty? && expected.has_key?('accepts')
+            valid_content = false
+            
+            if node.kind_of?(Hash)
+              matched = []
+              unmatched = []
+              node.each_pair{
+                |key,value|
+                
+                expected['accepts'].each{
+                  |accepts|
+                     
+                  result = check_type(value,accepts,key)
+                  
+                  if result
+                    matched.push(key)
+                    if !unmatched.find_index(key).nil?
+                      unmatched.slice(unmatched.find_index(key))
+                    end
+                    break
+                  else
+                    unmatched.push(key)
+                  end
+                 
+                }
+                
+              }
+                         
+              if(matched.count==node.count)
+                valid_content = true
+               else
+                unmatched.each{
+                  |node|
+                  
+                  @errors.push('Error: node ' + node + ' is not of an accepted type. Should be one of ' + expected['accepts'].join(', '))
+                }
+              end
+              
+            elsif node.kind_of?(Array)
+              matched = []
+              unmatched = []
+              node.each_index{
+                |n|
+                
+                expected['accepts'].each{
+                  |accepts|
+                  
+                  key = label + '[' + n.to_s + ']'
+                  result = check_type(node[n],accepts,key)
+                  
+                  if result
+                    
+                    matched.push(key)
+                    if !unmatched.find_index(key).nil?
+                      unmatched.slice(unmatched.find_index(key))
+                    end
+                    break
+                  else
+                    unmatched.push(key)
+                  end
+                  
+                }
+              }
+              
+              if(matched.count==node.count)
+                valid_content = true
+              else
+                unmatched.each{
+                  |node|
+                  
+                  @errors.push('Error: node ' + node + ' is not of an accepted type. Should be one of ' + expected['accepts'].join(', '))
+                }
+              end
+            
+            end
+            
+            if !valid_content
+              @errors.push('Error: node ' + label + ' contains an unaccepted type.')
+              return false
+            end
+         end
+         
+        end
+       
+        return true
+                
+      end
+      
+      def check_type(node,expected_type,label,accept_nil = false)
+        
+        valid_type = true;
+        if(@types.has_key?(expected_type))
+          valid_type = match_node(node,@types[expected_type],label)
+        elsif node.class.to_s != expected_type && !(node.kind_of?(NilClass) && (expected_type=='empty' || accept_nil))
+          valid_type = false
+        end
+       
+        return valid_type
+        
+      end
+      
+      end
+      
+  end
+  
+end

data/lib/skeletor/tasks.rb

@@ -0,0 +1,16 @@
+module Skeletor
+  
+  class Tasks
+    
+    def self.git_init(path)
+      system "cd " + path + '
+              git init'
+    end
+    
+    def self.capify(path)
+      system "capify " + path
+    end
+    
+  end
+  
+end

data/lib/skeletor/templates/js-lib/js-lib.yml

@@ -0,0 +1,14 @@
+directory_structure:
+  -
+    src:
+    lib:
+    test:
+      -
+        functional:
+          -
+            - foo
+            
+        unit:
+  -
+    - README.md
+    - LICENSE

data/lib/skeletor/templates/template-schema.yml

@@ -0,0 +1,38 @@
+sections:
+  - name: directory_structure
+    required: yes
+    type: Array
+    ok_empty: yes
+    accepts:
+      - directory_list
+      - file_list
+  - name: tasks
+    required: no
+    type: Array
+    accepts: 
+      - String
+  - name: includes
+    required: no
+    type: Hash
+    accepts:
+      - String
+types:
+  directory_list:
+    type: Hash
+    ok_empty: no
+    accepts:
+      - directory
+  file_list:
+    type: Array
+    ok_empty: no
+    accepts:
+      - file
+  directory:
+    type: Array
+    ok_empty: yes
+    accepts:
+      - empty
+      - directory_list
+      - file_list
+  file:
+    type: String

data/lib/skeletor/version.rb

@@ -0,0 +1,3 @@
+module Skeletor
+  VERSION="0.6.1"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: skeletor
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 1
+  version: 0.6.1
+platform: ruby
+authors: 
+- Will McKenzie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-25 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Skeletor is a Ruby Gem for creating skeleton directory structures based on a YAML template.
+email: 
+- will@oinutter.co.uk
+executables: 
+- skeletor
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- lib/skeletor/builder.rb
+- lib/skeletor/cli.rb
+- lib/skeletor/includes.rb
+- lib/skeletor/protocols/http.rb
+- lib/skeletor/protocols/https.rb
+- lib/skeletor/skeletons/loader.rb
+- lib/skeletor/skeletons/skeleton.rb
+- lib/skeletor/skeletons/validator.rb
+- lib/skeletor/skeletons.rb
+- lib/skeletor/tasks.rb
+- lib/skeletor/version.rb
+- lib/skeletor.rb
+- bin/skeletor
+- lib/skeletor/templates/js-lib/js-lib.yml
+- lib/skeletor/templates/template-schema.yml
+has_rdoc: true
+homepage: http://github.com/OiNutter/skeletor
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: skeletor
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Gem for creating project skeletons based on YAML templates
+test_files: []
+