json-spec 0.1.0

data/cachivache/.gitignore

@@ -0,0 +1 @@
+.vagrant

data/cachivache/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'colorize'

data/cachivache/README.md

@@ -0,0 +1,247 @@
+# CabezaDeTermo::Cachivache
+
+Cachivache is a provisioner for Vagrant machines that use Ubuntu images.
+
+You can provision a Vagrant VM using shell scripts, or more sophisticated tools like [Puppet](https://puppetlabs.com/), [Chef](https://www.chef.io/chef/), [salt](https://docs.saltstack.com/en/latest/), [Ansible](http://www.ansible.com/) and by the time you are reading this probably a few more.
+
+If you are a developer, most of the time you just want to quickly provision you Vagrant with some bash script that installs some services and libraries, replace some parameter files in your application and probably run a few custom bash commands and that's pretty much it.
+The good thing about provisioning with bash scripts is that it is fast and very easy to implement (just google how to install something and toss the bash script into the provision script and that's it).
+On the other hand, the problems with shell provisions are that
+
+- bash is unreadable. That's not a problem most of the times, but when the a task becomes a little more complex than c&p the apt-get instructions to install something, it becomes one (even some super simple tasks like replacing parameters in a file)
+
+- it's very difficult to factorize and reuse
+
+- even if you factorize it into little bash scripts, you can't easyly declare dependencies between these scripts
+
+The provisioning tools like Puppet and Chef resolve these problems, and a lot more. Actually, they resolve so much more problems that is overkill to only use them to provision a Vagrant machine for developing.
+All of these tools define their own DSL and high level concepts and metaphors, they require you configure them, you must search for the correct recipes to install what you want, etc.
+These tools are a must to manage the provisioning of different environments, but for a developer machine they are way too much.
+
+Cachivache is a middle ground between bash scripts and these tools.
+Instead of reinventing the wheel with a brand new DSL and new metaphors, Cachivache uses a wheel that we have had for ages: [Rake](https://github.com/ruby/rake).
+
+The idea behind Cachivache is to put little bash scripts in Rake tasks, and the run those tasks from within the Vagrant VM. As the Ubuntu images already come with a Ruby installation, there's not much to do at all.
+
+So, Cachivache has very few concepts:
+
+- Bash scripts, which you put in Rake tasks
+
+- Rake tasks, that can depend on other Rake tasks
+
+- Ruby string interpolation, which allows you to easily parametrize stuff in the bash scripts
+
+- And the secret ingredient: stuff
+
+What is stuff? Stuff is a folder. That's it. Cachivache believes in giving power to the people, so instead of defining how, where and when you must organize your scripts, it will let you organize things in any way you want in a couple of folders: `stuff-library` and `stuff`. No recipes, playbooks, roles, bags, configurations, minions, masters, slaves, facts, etc. Just put stuff in a folder.
+[`stuff-library`](https://github.com/cabeza-de-termo/stuff-library) folder holds some existing stuff you can use to install things, and in `stuff` you can toss your own stuff for your project.
+
+## So, what does a stuff look like?
+
+Well, here's an example stuff that setups all the necessary things to work on a php library:
+
+```ruby
+dependencies = [
+   :'projects-setup',
+	:graphviz,
+   :xdebug,
+   :composer
+]
+
+namespace :stuff do
+   task :'php-json-spec' => dependencies do
+   	sh %{
+			cd #{PHPJsonSpec.project_folder}
+
+			composer install
+
+			# Run the test coverage report
+			php vendor/bin/phpunit -c phpunit-with-coverage.xml
+
+			# Generate the documentation
+			php vendor/bin/phpdoc   		
+   	}
+   end
+end
+
+class PHPJsonSpec
+   include LetBehaviour
+
+   let(:project_folder)     { Cachivache.src_folder }
+end
+```
+
+That's all there is. Bash + Rake + string interpolation + a little sintatic sugar.
+
+## What other awesome features has Cachivache?
+
+As I said before, all the work is done by Rake, so pretty much none.
+
+There is some sintactic sugar you can use to perform some common task though.
+
+If you haven't see any ruby code before, here are some tips to use in Cachivache stuffs:
+
+### You can define strings in several ways:
+
+```ruby
+task :'do-stuff' do
+   sh %Q{
+      echo "stuff"
+   }
+end
+
+# or
+
+task :'do-stuff' do
+   sh %Q[
+      echo "stuff"
+   ]
+end
+
+# or
+
+task :'do-stuff' do
+   sh %(
+      echo "stuff"
+   )
+end
+
+# or in a single line
+
+task :'do-stuff' do
+   sh %Q{echo "stuff"}
+end
+
+# or with ""
+
+task :'do-stuff' do
+   sh "echo \"stuff\""
+end
+```
+
+You see in the last example that if we define strings using "" we need to scape internals \", so the simpliest is to use `%Q{}`.
+
+### You can call as many `sh` blocks in a task as you like:
+
+```ruby
+task :'do-stuff' do
+   sh %Q{
+      echo "stuff"
+   }
+
+   sh %Q{
+      echo "even more stuff"
+   }
+end
+```
+
+### You can invoke and execute other tasks from within a task:
+
+```ruby
+task :'do-stuff' do
+   invoke 'install-apache'
+	execute 'restart-apache'
+end
+```
+
+The difference between :invoke and :execute is that :execute will perform the task every time it's called, whilst :invoke will only run the task once during the provision. So, to install and configure stuff use :invoke, but to turn things on and off use :execute.
+Or always use :execute to make things simplier. It's up to you.
+
+### Instead of using bash `if ! ...; then; .... fi`, you can use these Cachivache helpers:
+
+```ruby
+task :'do-stuff' do
+	sh_unless file_exists: '/bla.conf' do
+	   sh %Q{
+	      ls -la
+	      rm -rf bla
+	   }
+	end
+end
+```
+
+```ruby
+task :'do-stuff' do
+	sh_unless folder_exists: '/bla' do
+	   sh %Q{
+	      ls -la
+	      rm -rf bla
+	   }
+	end
+end
+```
+
+```ruby
+task :'do-stuff' do
+	sh_unless file: '/bla', contains: 'some regex' do
+	   sh %Q{
+	      ls -la
+	      rm -rf bla
+	   }
+	end
+end
+```
+
+```ruby
+task :'do-stuff' do
+	sh_unless command: 'java -version', contains: 'java 1.8' do
+	   sh %Q{
+	      ls -la
+	      rm -rf bla
+	   }
+	end
+end
+```
+
+- To append and replace text in a file, you can use this Cachivache helper:
+
+```ruby
+task :'do-stuff' do
+	sh_in_file "/etc/bla.conf" do
+	   replace pattern: "%user%", with: "admin"
+
+	   append "[cachivache]"
+	   append "path='/bla'"
+	end
+end
+```
+
+### If you want to remind the user of something after the provision is done, in any task use :remind_to
+
+```ruby
+task :'do-stuff' do
+	sh %Q{
+		ls -la
+	}
+
+	remind_to "Please don't forget to add '#{Cachivache.vagrant_ip_address} cachivache.com' to your /etc/hosts file"
+end
+```
+
+## Installation
+
+- Go to the root of your project
+- `git clone git@github.com:cabeza-de-termo/cachivache.git`
+- `cd cachivache/`
+- `rm -rf .git/`
+- `git submodule add git@github.com:cabeza-de-termo/stuff-library.git`
+
+Now edit `cachivache.rb` and set what stuff to install and your git email and user:
+
+- `pico cachivache.rb`
+
+## What if I want to use my own stuff-library?
+
+No prob! just replace or add to the previous step your custom library:
+
+- `git submodule add git@github.com:someuser/my-very-own-stuff-library.git`
+
+Cachivache will load any .rb file in the cachivache folder, so your library stuff will be loaded too.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cabeza-de-termo/cachivache.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/cachivache/Rakefile

@@ -0,0 +1,19 @@
+require_relative 'lib/rake-helper'
+
+raise_validation_error "Please, define some Cachivache:stuff_to_install in './cachivache.rb' task and run 'vagrant provision' again" if Cachivache.stuff_to_install.empty?
+
+task :provision do
+   Cachivache.stuff_to_install.each do |stuff_name|
+      show_info "Provisioning #{stuff_name}"
+
+      invoke stuff_name
+   end
+
+   show_info "All done!!!"
+end
+
+task default: :provision
+
+at_exit do 
+   show_reminders
+end

data/cachivache/Vagrantfile

@@ -0,0 +1,70 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+require_relative 'cachivache'
+
+Vagrant.configure(2) do |config|
+  # Every Vagrant development environment requires a box. You can search for
+  # boxes at https://atlas.hashicorp.com/search.
+  config.vm.box = "ubuntu/trusty32"
+
+  # Create a private network, which allows host-only access to the machine
+  # using a specific IP.
+  config.vm.network "private_network", ip: Cachivache.vagrant_ip_address
+
+  # Map the source folder
+  config.vm.synced_folder "../", Cachivache.src_folder
+
+  # Map the host ~/.ssh folder
+  config.vm.synced_folder "~/.ssh", Cachivache.ssh_keys_folder
+
+  # Provider-specific configuration so you can fine-tune various
+  # backing providers for Vagrant. These expose provider-specific options.
+
+  config.vm.provider "virtualbox" do |vb|
+  		# Display the VirtualBox GUI when booting the machine
+ 		vb.gui = Cachivache.wants_gui?
+  
+     	# Customize the amount of memory on the VM:
+    	vb.memory = Cachivache.wants_gui? ? "4096" : "1024"
+  end
+ 
+  # Enable provisioning with a shell script. Additional provisioners such as
+  # Puppet, Chef, Ansible, Salt, and Docker are also available. Please see the
+  # documentation for more information about their specific syntax and use.
+
+  # Provisioning the VM with the custom provision-scripts
+
+  config.vm.provision "rbenv",
+      type: "shell",
+      privileged: false,
+      inline: %Q{
+			# From https://www.digitalocean.com/community/tutorials/how-to-install-ruby-on-rails-with-rbenv-on-ubuntu-14-04
+			if [ ! -d $HOME/.rbenv/ ]; then
+
+	      	sudo apt-get install git-core -y
+
+				git clone git://github.com/sstephenson/rbenv.git .rbenv
+				echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
+				echo 'eval "$(rbenv init -)"' >> ~/.bash_profile
+
+				git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
+				echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' >> ~/.bash_profile
+				source ~/.bash_profile
+
+				git clone git://github.com/carsomyr/rbenv-bundler.git ~/.rbenv/plugins/bundler
+
+				sudo gem install bundler
+			fi
+      }
+
+  config.vm.provision "rake-provision",
+      type: "shell",
+      privileged: false,
+      inline: %Q{
+      	cd #{Cachivache.cachivache_folder}
+
+      	bundle install
+      	rake provision
+      }
+end

data/cachivache/cachivache.rb

@@ -0,0 +1,59 @@
+require_relative 'lib/let-behaviour'
+
+class Cachivache
+   include LetBehaviour
+
+   # Vagrant params
+
+   let(:vagrant_ip_address)      { '192.168.0.101' }
+
+   let(:home_folder)             { '/home/vagrant' }
+
+   let(:src_folder)              { home_folder + '/src' }
+   let(:ssh_keys_folder)         { home_folder + '/ssh-keys' }
+   let(:bin_folder)              { home_folder + '/bin-cachivache' }
+
+   # Cachivache folders
+
+   let(:cachivache_folder)       { src_folder + '/cachivache' }
+   let(:stuff_library_folder)    { cachivache_folder + '/stuff-library' }
+   let(:stuff_folder)            { cachivache_folder + '/stuff' }
+
+   let(:wants_gui?)              { false }
+
+   # Developer params
+
+   ####################################
+   # Define what stuff to install
+   ####################################
+
+   let(:stuff_to_install) {
+      [
+         'stuff:ruby-json-spec'
+      ]
+   }
+
+   ####################################
+   # Define your git user
+   ####################################
+
+   let(:git_user_email)    { 'martinrubi@gmail.com' }
+   let(:git_user_name)     { 'Martin Rubi' }
+
+   ####################################
+   # Define your git credentials
+   ####################################
+
+   let(:git_credentials) { %Q{
+host github.com
+   HostName github.com
+   IdentityFile #{Cachivache.ssh_keys_folder}/id_rsa
+   User git
+
+host bitbucket.org
+   HostName bitbucket.org
+   IdentityFile #{Cachivache.ssh_keys_folder}/id_rsa
+   User git    
+}
+   }
+end

data/cachivache/lib/let-behaviour.rb

@@ -0,0 +1,27 @@
+module LetBehaviour
+	def self.included(base)
+    	base.extend(self)
+  	end
+
+	def variables()
+		@variables ||= {}
+	end
+
+	def has_variable?(name)
+		variables.key?(name)
+	end
+
+	def is_defined?(name)
+		has_variable?(name) && !variables[name].nil?
+	end
+
+	def let(name, &block)
+		variables[name] = block.call
+	end
+
+	def method_missing(method_name, *args, &block)
+		return variables[method_name] if has_variable?(method_name)
+
+		super(method_name, *args, &block)
+	end
+end

data/cachivache/lib/rake-helper.rb

@@ -0,0 +1,131 @@
+require 'rake'
+require 'colorize'
+require 'pathname'
+
+require_relative 'let-behaviour'
+require_relative 'sh-file-context'
+require_relative 'sh-if-context'
+require_relative '../cachivache'
+
+public
+
+# Require all .rb files in a folder
+def require_all_rb_files_in(folder)
+	Dir[Pathname.new(folder) + '**/*.rb'].each do |file| 
+		require file
+	end
+end
+
+def invoke(task_name, *args)
+	Rake::Task[task_name].invoke(*args)
+end
+
+def execute(task_name, *args)
+	Rake::Task[task_name].execute(*args)
+end
+
+# Examples:
+#
+# sh_unless file_exists: '/bla.conf' do
+# 	sh %Q{
+# 		ls -la
+# 		rm -rf bla
+# 	}
+# end
+#
+# sh_unless folder_exists: '/bla' do
+# 	sh %Q{
+# 		ls -la
+# 		rm -rf bla
+# 	}
+# end
+#
+# sh_unless file: '/bla', contains: 'some regex' do
+# 	sh %Q{
+# 		ls -la
+# 		rm -rf bla
+# 	}
+# end
+#
+# sh_unless command: 'java -version', contains: 'java 1.8' do
+# 	sh %Q{
+# 		ls -la
+# 		rm -rf bla
+# 	}
+# end
+#
+def sh_unless(params, &block)
+	if params.key?(:file_exists)
+		sh unless_file_exists(params[:file_exists], &block)
+		return
+	end
+	if params.key?(:folder_exists)
+		sh unless_folder_exists(params[:folder_exists], &block)
+		return
+	end
+	if params.key?(:file) && params.key?(:contains)
+		sh unless_regex_in_file(params[:contains], params[:file], &block)
+		return
+	end
+	if params.key?(:command) && params.key?(:contains)
+		sh unless_regex_in_command(params[:contains], params[:command], &block)
+		return
+	end
+	raise 'Invalid unless option'
+end
+
+def unless_file_exists(filename, &block)
+	ShIfContext.with(guard: "[ ! -e #{filename} ]", &block)
+end
+
+def unless_folder_exists(folder, &block)
+	ShIfContext.with(guard: "[ ! -d #{folder} ]", &block)
+end
+
+def unless_regex_in_file(regex, filename, &block)
+	ShIfContext.with(guard: "! grep -q \"#{regex}\" \"#{filename}\"", &block)
+end
+
+def unless_regex_in_command(regex, command, &block)
+	ShIfContext.with(guard: "! #{command} | grep -q \"#{regex}\"", &block)
+end
+
+# Examples:
+#
+# sh_in_file "/bla.conf" do
+# 	replace pattern: "%user%", with: "admin"
+#
+# 	append "[cachivache]"
+# 	append "path='/bla'"
+# end
+def sh_in_file(filename, &block)
+	sh ShFileContext.with(file: filename, &block)
+end
+
+def reminders()
+	@reminders ||= []
+end
+
+# Examples:
+#
+# remind_to 'This is shown when the provision ends'
+def remind_to(text)
+	reminders << text
+end
+
+def show_info(text)
+	puts '-----------------------------------------------'.red
+	puts text.green
+	puts '-----------------------------------------------'.red
+end
+
+def show_reminders()
+	reminders.each { |alert| show_info(alert) }
+end
+
+def raise_validation_error(message)
+	show_info(message)
+	exit
+end
+
+require_all_rb_files_in Cachivache.cachivache_folder