rigit 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55f146cc6a111bbb185a681203d87a7cf5092ce5f461e3e1aac4aec11bd121aa
-  data.tar.gz: 46990712e2b86bd1b1c8785084d6e1b02e18f05de2248030a41e21ec8b7049b8
+  metadata.gz: d0e095455913e67ecceddde67453c5e1b80198c8a1e8b1cc73bd3729b6aaa745
+  data.tar.gz: a34322fc5be2a3e94bc585a4232cedb8f0bf4975203b14c993b13ffd0a548a5b
 SHA512:
-  metadata.gz: 8f33dbd202c77428e16e05bf42441b6359b49132ef78a977608d13029414327441c163e44e390957fb5182fc7554948e86ef359b4598daa4d794d8726280c5e2
-  data.tar.gz: 84f92225b7b0edeba9a5a4583a097ccac9047dc5e2b1fe837bd19be45ecf4f08c5be5d96e93530d3bf21be282613eb97d8117e49d01ba7552eed537a1ab670db
+  metadata.gz: 49ef20ec39ea53e8f3ceaa8ea3407fc7ef687c46f6d23f8b6449685e08d8aab3630c7093e480e3125c76a7f975210a828a90126b5abf077433f8672febb96de0
+  data.tar.gz: 00d2d1c8c2323004c704235ea3f7b2400c2e7ef37713597982ca63c01849aa062801b0647ba54f56ab7020f07c2e456e60e455afd1a693df5b3e5e751314e380

data/README.md

@@ -8,6 +8,8 @@ Rigit
 
 ---
 
+Build project templates easily, and without the need to write code.
+
 ![Rigit](rigit-header.png)
 
 ---
@@ -16,34 +18,208 @@ Table of Contents
 --------------------------------------------------
 
 * [Installation](#installation)
+* [Key Features](#key-features)
+* [Usage](#usage)
 * [Quick Start](#quick-start)
 * [Installing Rigs](#installing-rigs)
 * [Using Rigs (Scaffolding)](#using-rigs-scaffolding)
+    * [Non-Interactive Execution](#non-interactive-execution)
 * [Creating Rigs](#creating-rigs)
-   * [Directory Structure](#directory-structure)
-   * [Config File](#config-file)
+    * [Directory Structure](#directory-structure)
+    * [Dynamic Tokens](#dynamic-tokens)
+    * [Config File](#config-file)
+
 
 
 Installation
 --------------------------------------------------
 
+    $ gem install rigit
+
+
+
+Key Features
+--------------------------------------------------
+
+Rigit was designed to allow the rapid building of reusable project templates.
+In Rigit, we call these templates "rigs".
+
+- No coding required.
+- Conventions-based [folder structure](#directory-structure).
+- A minimalistic [configuration file](#config-file) to allow specifying 
+  needed parameters.
+- [String replacement](#dynamic-tokens) in file names and file contents.
+- [Install rigs](#installing-rigs) from any remote git repository.
+
+
+
+Usage
+--------------------------------------------------
+
+```
+$ rig
+Usage:
+  rig build RIG [PARAMS...]
+  rig install RIG REPO
+  rig update RIG
+  rig info RIG
+  rig (-h|--help|--version)
+```
+
+
 
 Quick Start
 --------------------------------------------------
 
+After installing Rigit, you can follow these steps to quickly understand how
+it works, and how you can create your own rigs.
+
+First, create an empty folder:
+
+    $ mkdir myapp
+    $ cd muapp
+
+Install your first rig. You can use this [example rig][example-rig].
+
+    $ rig install example https://github.com/DannyBen/example-rig.git
+
+Now that your rig is installed (in `~/.rigs`), you can use it.
+
+    $ rig build example
+
+Input all the answers, and you are done. Your project has been rigged.
+
+
 
 Installing Rigs
 --------------------------------------------------
 
+Rigs are installed in `~/.rigs` by default. You can change the installation
+directory by setting the `RIG_HOME` environment variable to your desired 
+path.
+
+To install a rig, simply use the `rig install` command, and supply a name 
+(which will be the name of the rig in your local system) and a git URL (use 
+the same url as you would use in "git clone").
+
+    $ rig install example https://github.com/DannyBen/example-rig.git
+
+
 
 Using Rigs (Scaffolding)
 --------------------------------------------------
 
+After you have one or more installed rigs, you can use them to create a new
+project. Note that rigit works in the *current* directory, and will not 
+create the project root directory for you.
+
+    $ mkdir myapp
+    $ cd myapp
+    $ rig build example
+
+Most rigs will have parameters, you will be prompted to input them as needed.
+
+
+### Non-Interactive Execution
+
+You can also provide some (or all) of the parameters in the command line, 
+if you need to avoid interactivity.
+
+    $ rig build example name=myapp spec=y console=irb license=MIT
+
+To learn about the parameters of a rig:
+
+    $ rig info example
+
+
 
 Creating Rigs
 --------------------------------------------------
 
+> **Tip**: Take a look at the [example rig][example-rig] while reading 
+> this section.
+
+Rigit's main design goal was to allow rapid and easy creation of new 
+templates. There is no coding involved in creating a rig, and instead we 
+are using folders with specific names, to allow for a sort of "additive" 
+project building.
+
+The steps in creating a rig are:
+
+1. Start in a new, empty folder.
+2. Create a folder named `base`. Put all the files and folders of your 
+   project inside.
+3. Rename files and folders, and files as needed to include dynamic tokens.
+4. If you want to add some of the files only in specific cases (for example
+   only include a license file if the user wants to), you move the files to
+   a folder with s special `parameter=value` folder.
+5. Create a config file to specify the needed parameters.
+
+
 ### Directory Structure
 
+There are two types of folders in a rig template.
+
+1. Base folder (`base`) - files and folders here will be copied always
+2. Conditional folders (`parameter=value`) - contents in these folders will
+   only be copied if the user answerd `value` to the question `parameter`.
+
+
+### Dynamic Tokens
+
+You can use variable replacements (tokens) in file names, folder names and in
+file contents.
+
+Each token that you use, must also be declared in the config file.
+
+Tokens are specified using this syntax: 
+
+    %{name}
+
+
 ### Config File
 
+Place a `config.yml` file at the root of your rig template. A config file
+is optional for rigs that do not have any variables.
+
+A typical config file looks like this:
+
+```yaml
+intro: A sample generator
+
+params:
+  name:
+    prompt: "Name your project:"
+    type: text
+    default: project
+
+  spec: 
+    prompt: Include RSpec files?
+    type: yesno
+    default: y
+
+  console:
+    prompt: "Select console:"
+    type: select
+    list: [irb, pry]
+```
+
+| Key      | Purpose                                                 |
+|----------|---------------------------------------------------------|
+| `intro`  | A short message to display when building (Optional)     |
+| `params` | A list of parameters required by the rig                |
+
+The `params` key should start with the name of the variable (`name`, 
+`spec` and `console` in the above example), and contain the below 
+specifications:
+
+| Key       | Purpose                                                  |
+|-----------|----------------------------------------------------------|
+| `prompt`  | The text to display when asking for user input           |
+| `type`    | The variable tyoe. Can be `yesno`, `text` or `select`    |
+| `default` | The default value. When using `yesno`, use `y` and `n`   |
+| `list`    | An array of allowed options (only used in `select` type) |
+
+---
+
+[example-rig]: https://github.com/DannyBen/example-rig

data/lib/rigit/command_line.rb

@@ -1,13 +1,20 @@
 require 'super_docopt'
 require 'rigit/version'
 
+require 'rigit/commands/build'
+require 'rigit/commands/install'
+require 'rigit/commands/update'
+require 'rigit/commands/info'
+
 module Rigit
   class CommandLine < SuperDocopt::Base
     version VERSION
     docopt File.expand_path 'docopt.txt', __dir__
-    subcommands [:build, :install]
+    subcommands [:build, :install, :update, :info]
 
     include Commands::Build
     include Commands::Install
+    include Commands::Update
+    include Commands::Info
   end
 end

data/lib/rigit/commands/build.rb

@@ -3,10 +3,10 @@ require 'colsole'
 module Rigit::Commands
   module Build
     def build
-      Builder.new(args).execute
+      BuildHandler.new(args).execute
     end
 
-    class Builder
+    class BuildHandler
       attr_reader :args, :rig_name, :target_dir
 
       include Colsole
@@ -22,7 +22,13 @@ module Rigit::Commands
         say "!txtblu!#{config.intro}" if config.has_key? :intro
         verify_dirs
         arguments = prompt.get_input params
-        rig.scaffold arguments:arguments, target_dir: target_dir
+        rig.scaffold arguments:arguments, target_dir: target_dir do |file|
+          if File.exist? file
+            tty_prompt.yes? "Overwrite #{file}?", default: false
+          else
+            true
+          end
+        end
         say "Done"
       end
 

data/lib/rigit/commands/info.rb

@@ -0,0 +1,46 @@
+require 'colsole'
+
+module Rigit::Commands
+  module Info
+    def info
+      InfoHandler.new(args).execute
+    end
+
+    class InfoHandler
+      include Colsole
+
+      attr_reader :args, :rig_name
+
+      def initialize(args)
+        @args = args
+        @rig_name = args['RIG']
+      end
+
+      def execute
+        verify_presence
+        info
+      end
+
+      private
+
+      def info
+        rig.info.each do |key, value|
+          say "!txtgrn!#{key}!txtrst!:"
+          say word_wrap "  #{value}"
+          say ""
+        end
+      end
+
+      def rig
+        @rig ||= Rigit::Rig.new rig_name
+      end
+
+      def verify_presence
+        if !rig.exist?
+          say "Cannot find rig !txtgrn!#{rig_name}"
+          raise Rigit::Exit
+        end
+      end
+    end
+  end
+end

data/lib/rigit/commands/install.rb

@@ -4,10 +4,10 @@ require 'colsole'
 module Rigit::Commands
   module Install
     def install
-      Installer.new(args).execute
+      InstallHandler.new(args).execute
     end
 
-    class Installer
+    class InstallHandler
       include Colsole
 
       attr_reader :args, :rig_name, :repo
@@ -26,15 +26,20 @@ module Rigit::Commands
       private
 
       def install
-        say "Installing !txtgrn!#{repo}\n"
+        say "Installing !txtgrn!#{repo}"
         FileUtils.mkdir_p target_path unless Dir.exist? target_path
-        success = Git.clone repo, target_path
+        success = Rigit::Git.clone repo, target_path
 
         if success
-          say "\nRig installed !txtgrn!successfully!txtrst! in !txtgrn!#{target_path}"
+          say "Rig installed !txtgrn!successfully!txtrst! in !txtgrn!#{target_path}"
           say "To build a new project with this rig, run this in any empty directory:\n"
           say "  !txtpur!rig build #{rig_name}\n"
+        else
+          # :nocov:
+          say "!txtred!Installation failed"
+          # :nocov:
         end
+
       end
 
       def rig
@@ -46,8 +51,8 @@ module Rigit::Commands
       end
 
       def verify_dirs
-        if Dir.exist? target_path
-          say "Rig !txtgrn!#{rig_name}!txtrst! is already installed."
+        if rig.exist?
+          say "Rig !txtgrn!#{rig_name}!txtrst! is already installed"
           say "In order to update it from the source repository, run:\n"
           say "  !txtpur!rig update #{rig_name}\n"
           raise Rigit::Exit

data/lib/rigit/commands/update.rb

@@ -0,0 +1,54 @@
+require 'colsole'
+
+module Rigit::Commands
+  module Update
+    def update
+      UpdateHandler.new(args).execute
+    end
+
+    class UpdateHandler
+      include Colsole
+
+      attr_reader :args, :rig_name
+
+      def initialize(args)
+        @args = args
+        @rig_name = args['RIG']
+      end
+
+      def execute
+        verify_dirs
+        update
+      end
+
+      private
+
+      def update
+        say "Updating !txtgrn!#{rig_name}"
+        success = Rigit::Git.pull target_path
+        if success
+          say "Rig updated !txtgrn!successfully!txtrst!"
+        else
+          # :nocov:
+          say "!txtred!Update failed"
+          # :nocov:
+        end
+      end
+
+      def rig
+        @rig ||= Rigit::Rig.new rig_name
+      end
+
+      def target_path
+        @target_path ||= rig.path
+      end
+
+      def verify_dirs
+        if !rig.exist?
+          say "Rig !txtgrn!#{rig_name}!txtrst! is not installed"
+          raise Rigit::Exit
+        end
+      end
+    end
+  end
+end

data/lib/rigit/docopt.txt

@@ -3,6 +3,9 @@ Rigit
 Usage:
   rig build RIG [PARAMS...]
   rig install RIG REPO
+  rig update RIG
+  rig info RIG
+  rig (-h|--help|--version)
 
 Commands:
   build
@@ -12,6 +15,15 @@ Commands:
     If you wish to execute this command without interactivity, you may
     use specify all parameters in the PARAMS parameter (see below).
 
+  install
+    Clone a remote rig git repository and install it locally.
+
+  update
+    Update an installed rig to its latest version.
+
+  info
+    Show some meta information about an installed rig.
+
 Parameters:
   RIG
     The name of the source folder (installed rig).
@@ -24,6 +36,13 @@ Parameters:
     Specify any of the rig's parameters in the format 'param=value'.
     For boolean parameters, use 'param=y' or 'param=n'.
 
+Environment Variables:
+  RIG_HOME
+    The path where your local rigs are installed (default: ~/.rigs)
+
 Examples:
   rig build gem name=mygem spec=y
-  rig install example https://github.com/DannyBen/example-rig.git
+  rig install example https://github.com/DannyBen/example-rig.git
+  rig update example
+  rig info example
+

data/lib/rigit/git.rb

@@ -4,6 +4,12 @@ module Rigit
       execute %Q[git clone #{repo} "#{target_path}"]
     end
 
+    def self.pull(target_path)
+      Dir.chdir target_path do
+        execute %Q[git pull]
+      end
+    end
+
     private
 
     def self.execute(command)

data/lib/rigit/rig.rb

@@ -14,13 +14,15 @@ module Rigit
       @name = name
     end
 
-    def scaffold(arguments: {}, target_dir:'.')
-      scaffold_dir "#{path}/base", arguments, target_dir
+    def scaffold(arguments: {}, target_dir:'.', &block)
+      scaffold_dir dir: "#{path}/base", arguments: arguments, 
+        target_dir: target_dir, &block
 
       arguments.each do |key, value| 
         additive_dir = "#{path}/#{key}=#{value}"
         if Dir.exist? additive_dir
-          scaffold_dir additive_dir, arguments, target_dir
+          scaffold_dir dir: additive_dir, arguments: arguments, 
+            target_dir: target_dir, &block
         end
       end
     end
@@ -33,6 +35,10 @@ module Rigit
       Dir.exist? path
     end
 
+    def has_config?
+      File.exist? config_file
+    end
+
     def config_file
       "#{path}/config.yml"
     end
@@ -41,13 +47,24 @@ module Rigit
       @config ||= Config.load(config_file)
     end
 
+    def info
+      {
+        name: name,
+        path: path,
+        config: (has_config? ? File.read(config_file) : '<empty>')
+      }
+    end
+
     private
 
-    def scaffold_dir(dir, arguments, target_dir)
+    def scaffold_dir(dir:, arguments:, target_dir:)
       files = Dir["#{dir}/**/*"].reject { |file| File.directory? file }
 
       files.each do |file|
         target_file = (file % arguments).sub dir, target_dir
+
+        next if block_given? and !yield target_file
+
         content = File.read(file) % arguments
         File.deep_write target_file, content
       end

data/lib/rigit/version.rb

@@ -1,3 +1,3 @@
 module Rigit
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/rigit.rb

@@ -5,9 +5,6 @@ require 'rigit/errors'
 require 'rigit/prompt'
 require 'rigit/rig'
 require 'rigit/git'
-
-require 'rigit/commands/build'
-require 'rigit/commands/install'
 require 'rigit/command_line'
 
 module Rigit

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rigit
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Danny Ben Shitrit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-16 00:00:00.000000000 Z
+date: 2018-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: super_docopt
@@ -190,7 +190,9 @@ files:
 - lib/rigit.rb
 - lib/rigit/command_line.rb
 - lib/rigit/commands/build.rb
+- lib/rigit/commands/info.rb
 - lib/rigit/commands/install.rb
+- lib/rigit/commands/update.rb
 - lib/rigit/config.rb
 - lib/rigit/docopt.txt
 - lib/rigit/errors.rb