aina 0.2.0.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9bf384084ac4dcc6deb23c59231c73d92fc8676e
+  data.tar.gz: e1a802445afe753a40e06b6f70d558b92e015a52
+SHA512:
+  metadata.gz: 759048bad7a66d82e8435a7daa4bd74d4a47ce78fa28166ec11c893d228d1c50ff527464f4896ba292da46ac5c7736b8b4edab6bf7a902ab35e358f42d1cc755
+  data.tar.gz: 804cb8f919f337a57743ecffd388391ac07cbf32ba542be302586d4505f07955524e09e2bb34f75109886679fe363027b4f38a3a443f12fed19f4c34b0a6b861

data/README.rdoc

@@ -0,0 +1,6 @@
+= aina
+
+Describe your project here
+
+:include:aina.rdoc
+

data/aina.rdoc

@@ -0,0 +1,5 @@
+= aina
+
+Generate this with
+    aina rdoc
+After you have described your command line interface

data/bin/aina

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+require 'gli'
+
+require 'aina' 
+
+include GLI::App
+
+program_desc 'Code generator for WordPress themes'
+
+version Aina::VERSION
+
+# desc 'Describe some switch here'
+# switch [:s,:switch]
+
+# desc 'Describe some flag here'
+# default_value 'the default'
+# arg_name 'The name of the argument'
+# flag [:f,:flagname]
+
+desc 'Generates a piece of code from a template'
+arg_name 'element_type element_name'
+command [:generate, :g] do |c|
+  # c.desc 'Describe a switch to generate'
+  # c.switch :s
+
+  c.desc '[post_type] Content fields that a post_type supports, comma separated'
+  c.default_value PostType::DEFAULT_SUPPORT
+  c.arg_name 'supports'
+  c.flag [:s, :supports]
+
+  c.desc '[post_type] Capability type'
+  c.default_value PostType::DEFAULT_CAPABILITY
+  c.arg_name 'capability'
+  c.flag [:c, :capability]
+
+  c.desc 'Install Aina framework to easily create custom post_type fields'
+  c.switch [:i, :install]
+
+  c.action do |global_options,options,args|
+    @type = args.shift
+    @name = args.shift
+    
+    if @type.nil?
+      raise NoMethodError, 'You need to generate something'
+    elsif @name.nil?
+      raise NoMethodError, 'You need to put a name to what you want tot generate'
+    end
+
+    if Generable.accepts?(@type)
+      element = Object.const_get(Generable.class_name_for @type).new(@name, options)
+      unless File.exists?(element.file)
+        element.generate
+      else
+        raise Exception, "A #{@type} named #{element.name} already exists. Action aborted."
+      end
+      
+      output = "A #{@type} with name #{element.name} has been succesfully generated"
+      if options[:i]
+        output += ". Also, Aina's framework has been added.\n"
+      end
+
+      puts output
+    else
+      raise Exception, "#{@type} is not a generable piece of code. Options are: #{Generable.generable_types.join(', ')}"
+    end
+  end
+end
+
+desc 'Destroys a generated piece of code'
+arg_name 'element_type element_name'
+command [:destroy] do |c|
+  c.action do |global_options,options,args|
+    @type = args.shift
+    @name = args.shift
+
+    if @type.nil?
+      raise NoMethodError, 'You must specify what kind of file you want to destroy (i.e. post_type)'
+    elsif @name.nil?
+      raise NoMethodError, 'You must specify the name of what you want to destroy'
+    end
+
+    if Generable.accepts?(@type)
+      element = Object.const_get(Generable.class_name_for @type).new(@name)
+      if element.destroy
+        puts "The #{@type} #{element.name} has been succesfully destroyed"
+      end
+    else
+      raise Exception, "#{@type} is not a destroyable piece of code. Options are: #{Generable.generable_types.join(', ')}"
+    end
+  end
+end
+
+desc 'Add custom fields to post_types'
+arg_name 'element_name field:type'
+command [:add] do |c|
+  c.action do |global_options,options,args|
+    @name = args.shift
+
+    if @name.nil?
+      raise Exception, "Please, write the name of the post_type"
+    end
+
+    unless Aina.is_installed?
+      Aina.install
+      puts "We have installed Aina's framework for you. Next time, you can run `aina install` yourself ;-)"
+    end
+
+    add = Addable.new(@name, args)
+    add.add_custom_fields
+
+    puts "#{add.fields.map{|f| f[:key]}} fields have been added to #{@name}"
+  end
+end
+
+desc 'Installs Aina framework, that allows you to easily create custom fields for post_types'
+arg_name 'field:type'
+command [:install] do |c|
+  c.action do |global_options, options, args|
+    Aina.install(true)
+  end
+end
+
+pre do |global,command,options,args|
+  unless is_wordpress_theme? or tests_being_runned?
+    puts "This does not look like a WordPress theme"
+    return false
+  end
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+  # Use skips_post before a command to skip this
+  # block on that command only
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+exit run(ARGV)

data/lib/aina.rb

@@ -0,0 +1,53 @@
+# Lib
+Dir.glob(File.dirname(__FILE__) + "/aina/*.rb") { |file|  require file }
+Dir.glob(File.dirname(__FILE__) + "/aina/generable/*.rb") { |file|  require file }
+Dir.glob(File.dirname(__FILE__) + "/aina/generable/types/*.rb") { |file|  require file }
+
+# Templates
+Dir.glob(File.expand_path('..') + "/templates/*") { |file|  require file }
+
+module Aina
+	def self.aina_version
+		Aina::VERSION
+	end
+
+	def self.install(output = false)
+		unless Dir.exists?(Dir.pwd + '/inc')
+			Dir.mkdir(Dir.pwd + '/inc')
+		end
+
+		# Install Aina
+		unless self.is_installed?
+			text = File.read(Aina::TEMPLATES_DIR + '/aina_framework.php')
+
+			['{{aina_version}}'].each do |replace|
+				attribute = replace.gsub(/[{}]/, '')
+				@output = text.gsub!(/#{replace}/, self.send(attribute))
+			end
+
+			File.open(Dir.pwd + "/inc/aina.php", "w") {|file| file.puts @output}
+
+			message = "Aina has been installed in your WordPress theme.\n"
+			message += "\n\nIf you want your post type to be automatically included, put this is functions.php:\n"
+	    message += "function aina_post_types() {\n"
+	    message += " return array('your_post_type', 'another_post_type', 'etc');\n"
+	    message += "}\n"
+		else
+			message = "Aina was already installed in your WordPress theme ;-)\n"
+		end
+
+		# Include Aina
+		unless functions_php_exists?
+			create_empty_functions_php
+		end
+		File.open(functions_php, "a+") {|file| file.puts aina_inclusion}
+
+		if output
+	    puts message
+	  end
+	end
+
+	def self.is_installed?
+		File.exists?(Dir.pwd + "/inc/aina.php")
+	end
+end

data/lib/aina/addable.rb

@@ -0,0 +1,106 @@
+class Addable
+	attr_accessor :name, :aina_version, :fields
+
+	def initialize(name, fields = nil)
+		@type = 'post_type'
+		@name = validate_name(name)
+		@aina_version = Aina::VERSION
+
+		parse_fields(fields)
+	end
+
+	def parse_fields(fields)
+		@fields = Array.new
+		fields.each do |f|
+			a = f.split(':')
+			# TODO: Validate type against a whitelist
+			@fields << {key: a[0], type: a[1]}
+		end
+	end
+
+	def fields_php_array
+		a = ''
+		@fields.each do |f|
+			a += "'#{f[:key]}' => array(\n"
+			a += "  'label'     => '#{f[:key].capitalize}',\n"
+			a += "  'type'      => '#{f[:type]}',\n"
+			a += "  'options' 	=> array('option_1', 'option_2', 'etc'),\n" if %w(radio checkbox select).include?(f[:type])
+			a += "),\n"
+		end
+		a
+	end
+
+	def custom_fields
+		c = Array.new
+		c << "/**"
+		c << " * Custom data fields"
+		c << " * Add these custom fields to the #{@name} post type"
+		c << " * IMPORTANT: Thou shalt not rename this function, or bad things may happen"
+		c << " */"
+		c << "if ( ! function_exists( '#{@name}_custom_fields' ) ) {"
+		c << " function #{@name}_custom_fields() {"
+		c << "	 return array("
+		c << "     #{fields_php_array}"
+		c << "	 );"
+		c << " }"
+		c << "}"
+		c.join("\n")
+	end
+
+	def add_custom_fields
+		@file = Dir.pwd + "/post-types/#{@name}.php"
+		
+		# The post type wasn't using custom fields yet, 
+		# so wrap them with the custom_fields function
+		unless File.read(@file).include? "function #{@name}_custom_fields"
+			File.open(@file, 'a+') {|file| file.puts custom_fields}
+		else
+			output = Array.new
+			counter = 0 # This will help us keep track of lines
+
+			File.open(@file).each do |line|
+				output << line
+
+				# When we reach a line that includes "function #{@name}_custom_fields"
+				# it means that we have to add the items two lines later
+				if line.include?("function #{@name}_custom_fields")
+					# Negative number, so we know that this + 1 will we the line
+					# after which we want to add text
+					counter = -2
+				end
+
+				# Ok! It's ok to add the new items here, after 'return array('
+				if counter === -1 and line.include?('return array(')
+					output << fields_php_array
+				end
+
+				counter = counter + 1
+			end
+
+			File.open(@file, 'w') {|file| file.puts output}
+		end
+
+		# Make sure they can be saved
+		text = File.read(@file)
+		unless text.include? "function #{@name}_meta_box"
+			template = File.read("#{Aina::TEMPLATES_DIR}/add.php")
+			['{{name}}'].each do |replace|
+				attribute = replace.gsub(/[{}]/, '')
+				@output = template.gsub!(/#{replace}/, self.send(attribute))
+			end
+			File.open(@file, "a+") {|file| file.puts @output}
+		end
+	end
+
+	def self.accepts?(type)
+		Generable.accepts?(type)
+	end
+
+	protected
+		def validate_name(name)
+			unless File.exists?(Dir.pwd + "/post-types/#{name}.php")
+				raise Exception, "There's no file named /post-types/#{name}.php"
+			end
+			name
+		end
+end

data/lib/aina/generable.rb

@@ -0,0 +1,62 @@
+module Generable
+	# List of generable types
+	def self.generable_types
+		g = Array.new
+		Dir.glob(File.dirname(__FILE__) + "/generable/types/*.rb").each do |f|
+			g << f.split('/').last.split('.rb').join()
+		end
+		g
+	end
+
+	def self.class_name_for(type)
+		"Generable::#{type.camelcase}"
+	end
+
+	# Is generable?
+	def self.accepts?(type)
+		generable_types.include?(type)
+	end
+
+	# Does type need to be created in a directory?
+	# Then, in type use: 
+	# dir 'my-directory'
+	def dir(directory)
+		@dir = directory
+	end
+
+	def get_dir
+		@dir
+	end
+
+	# Does type use a template?
+	# Then, in type use: 
+	# template 'my-template.php'
+	def template(template)
+		@template = "#{Aina::TEMPLATES_DIR}/#{template}" if template
+	end
+
+	def get_template
+		@template
+	end
+
+	# Does type template need custom replacements?
+	# Then, in type use: 
+	# replacements %w({{replace_this}} {{and_this_too}})
+	def replacements(*replacements)
+		@replacements = %w(name aina_version)
+		@replacements += replacements.flatten if replacements
+		@replacements = @replacements.map { |r| "{{#{r}}}" }
+	end
+
+	def get_replacements
+		@replacements
+	end
+
+	def after_generate(*callbacks)
+		@after_generate = callbacks
+	end
+
+	def get_after_generate
+		@after_generate
+	end
+end

data/lib/aina/generable/base.rb

@@ -0,0 +1,72 @@
+# Generable class
+class Generable::Base
+	extend Generable
+	attr_reader :name, :template, :file, :aina_version, :supports
+
+	def initialize(name, options=nil)
+		@name = name
+		@options = options
+		@aina_version = Aina::VERSION
+		@template = self.template
+		@dir = self.dir
+		@file = generate_file_name
+
+		set_custom_vars
+	end
+	
+	def set_custom_vars
+		# Nothing here
+		# This can be used in types to parse required instance variables
+	end
+
+	def dir
+		self.class.get_dir
+	end
+
+	def template
+		self.class.get_template
+	end
+
+	def replacements
+		self.class.get_replacements
+	end
+
+	def generate
+		text = File.read(@template)
+		replacements.each do |replace|
+			attribute = replace.gsub(/[{}]/, '')
+			@output = text.gsub!(/#{replace}/, self.send(attribute))
+		end
+  	File.open(@file, "w") {|file| file.puts @output}
+
+  	after_generate
+	end
+
+	def after_generate
+		if self.class.get_after_generate
+			self.class.get_after_generate.each do |callback|
+				self.send(callback)
+			end
+		end
+	end
+
+	def destroy
+		if File.exists?(@file)
+			File.delete(@file)
+		else
+			raise "No #{self.class} with name #{@name}"
+		end
+	end
+
+	private
+		def generate_file_name
+			unless @dir.nil?
+				unless Dir.exists?(Dir.pwd + '/' + @dir)
+					Dir.mkdir(Dir.pwd + '/' + @dir)
+				end
+				Dir.pwd + "/#{@dir}/#{@name}.php"
+			else
+				Dir.pwd + "/#{@name}.php"
+			end
+		end
+end

data/lib/aina/generable/types/post_type.rb

@@ -0,0 +1,49 @@
+class PostType < Generable::Base
+	attr_reader :name_capitalize, :capability, :supports
+
+	DEFAULT_SUPPORT 	 = 'title,editor,excerpt,thumbnail'
+	DEFAULT_CAPABILITY = 'post'
+
+	template 'post_type.php'
+	dir 'post-types'
+	replacements %w(name_capitalize capability supports)
+
+	after_generate :install_aina_framework?, :include_post_type
+
+	def set_custom_vars
+		@name_capitalize = self.name.capitalize
+		if @options
+			@supports = get_supports
+			@capability = get_capability
+		end
+	end
+
+	def get_supports
+		s = @options[:s] ? @options[:s] : DEFAULT_SUPPORT
+		s = s.split(',')
+
+		supports = Array.new
+		s.each do |item|
+			supports << "'#{item}'"
+		end
+		supports.join(',')
+	end
+
+	def get_capability
+		@options[:c] ? @options[:c] : DEFAULT_CAPABILITY
+	end
+
+	protected
+		def install_aina_framework?
+			if @options and @options[:i]
+				Aina.install
+			end
+		end
+
+		def include_post_type
+			unless functions_php_exists?
+				create_empty_functions_php
+			end
+			File.open(functions_php, "a+") {|file| file.puts "\n/* Include #{self.name} */\nrequire_once '#{dir}/#{self.name}.php';\n"}
+		end
+end

data/lib/aina/globals.rb

@@ -0,0 +1,3 @@
+module Aina
+	TEMPLATES_DIR = File.expand_path('../../..',__FILE__) + '/templates'
+end

data/lib/aina/support.rb

@@ -0,0 +1,46 @@
+def is_wordpress_theme?
+	theme_path = Dir.pwd.split('/')
+	theme_path.pop
+	theme_path.last(2).join('/') == 'wp-content/themes'
+end
+
+def tests_being_runned?
+	ENV['HOME'] == 'tmp/aruba'
+end
+
+def functions_php
+	Dir.pwd + "/functions.php"
+end
+
+def functions_php_exists?
+  File.exists?(Dir.pwd + "/functions.php")
+end
+
+def create_empty_functions_php
+	unless functions_php_exists?
+		File.open(functions_php, "w") {|file| file.puts "<?php\n"}
+	end
+end
+
+def aina_inclusion
+	output = "\n/**\n"
+	output += " * Include Aina's framework\n"
+	output += " */\n"
+	output += "if ( file_exists( dirname(__FILE__) . '/inc/aina.php' ) ) {\n"
+	output += "	require_once 'inc/aina.php';\n"
+	output += "}\n"
+end
+
+class String
+	def camelcase
+		r = Array.new
+
+		pieces = self.split(' ')
+		pieces = self.split('_') unless pieces.length > 1
+
+		pieces.each do |p|
+			r << p.capitalize
+		end
+		r.join()
+	end
+end

data/lib/aina/version.rb

@@ -0,0 +1,3 @@
+module Aina
+  VERSION = '0.2.0.beta'
+end

data/templates/add.php

@@ -0,0 +1,29 @@
+/**
+ * Add meta box
+ * add_meta_box( $id, $title, $callback, $post_type, $context, $priority );
+ */
+if ( ! function_exists('{{name}}_meta_box') ) {
+	function {{name}}_meta_box(){
+	  add_meta_box("{{name}}_meta", "Extra", "add_{{name}}_custom_fields", "{{name}}", "normal", "low");
+	}
+	add_action("admin_init", "{{name}}_meta_box");
+}
+
+/**
+ * Add Custom Fields
+ */
+if ( ! function_exists('add_{{name}}_custom_fields') ) {
+	function add_{{name}}_custom_fields() {
+	    aina_add_custom_fields('{{name}}');
+	}
+}
+
+/**
+ * Make sure we can save it
+ */
+if ( ! function_exists('save_{{name}}_custom') ) {
+	function save_{{name}}_custom() {
+	  aina_save_custom('{{name}}');
+	}
+	add_action('save_post', 'save_{{name}}_custom');
+}

data/templates/aina_framework.php

@@ -0,0 +1,138 @@
+<?php
+
+/**
+ * Aina
+ * Generated with Aina. Version {{aina_version}}
+ */
+
+/**
+ * Include Custom Post-Types
+ */
+if ( function_exists( 'aina_post_types' ) ) {
+  foreach ( aina_post_types() as $pt ) {
+    require dirname(dirname(__FILE__)) . '/post-types/' . $pt . '.php';
+  }
+}
+
+/**
+ * Add Post-Type Custom Fields
+ */
+function aina_add_custom_fields($post_type) {
+    global $post;
+    $custom = get_post_custom($post->ID);
+
+    $add_custom_function = $post_type . '_custom_fields';
+
+    $custom_fields = $add_custom_function();
+  
+    foreach ( $custom_fields as $field => $args ) {
+        $value  = isset($custom[$field][0]) ? $custom[$field][0] : null;
+        echo aina_custom_field_for($field, $value, $args);
+    }
+}
+
+/**
+ * Make sure we can save it
+ */
+function aina_save_custom($post_type) {
+  global $post;
+
+  // Is this a new post being created?
+  if ( ! isset($post->ID) ) return;
+
+  $add_custom_function = $post_type . '_custom_fields';
+
+  $save_fields = $add_custom_function();
+  
+  foreach ( $save_fields as $field => $args ) {
+    $value = null;
+    if ( isset($_POST[$field]) ) {
+        if ( is_array($_POST[$field]) ) {
+            $value = $_POST[$field][0];
+        } else {
+            $value = $_POST[$field];
+        }
+    }
+    update_post_meta($post->ID, $field, $value);
+  }
+}
+
+/**
+ * Get single custom fields
+ */
+function aina_get_field($post_type, $field = '') {
+    global $post;
+    $custom_fields = get_post_custom($post->ID);
+    return isset($custom_fields[$field][0]) ? $custom_fields[$field][0] : false;
+}
+
+/**
+ * Echo single custom fields
+ * This is a wrapper for aina_get_field()
+ */
+function aina_field($post_type, $field = '') {
+    echo aina_get_field($post_type, $field);
+}
+
+/**
+ * Custom Field For
+ */
+function aina_custom_field_for($field, $value, $args = array()) {
+  
+  $return = '';
+
+  if ( isset($args) && is_array($args) ) {
+    
+    // Is label set?
+    if ( isset($args['label']) ) {
+      $return .= '<label>' . ucfirst($args['label']) . '</label><br />';
+    } else {
+      $return .= '<label>' . ucfirst($field) . '</label><br />';
+    }
+
+    // Options
+    $placeholder = isset($args['placeholder']) ? $args['placeholder'] : '';
+
+    // Is type set?
+    if ( isset($args['type']) ) {
+      switch ($args['type']) {
+        // Simple inputs
+        case 'text':
+          $return .= '<input type="text" name="' . $field . '" value="' . $value . '" placeholder="' . $placeholder . '" />';
+          break;
+        case 'url':
+          $return .= '<input type="url" name="' . $field . '" value="' . $value . '" placeholder="' . $placeholder . '" />';
+          break;
+        case 'email':
+          $return .= '<input type="email" name="' . $field . '" value="' . $value . '" placeholder="' . $placeholder . '" />';
+          break;
+        case 'datetime-local':
+        case 'datetime':
+          $return .= '<input type="datetime-local" name="' . $field . '" value="' . $value . '" />';
+          break;
+        case 'textarea':
+          $return .= '<textarea name="' . $field . '">' . $value . '</textarea>';
+          break;
+
+        // With options
+        case 'radio':
+          if ( isset($args['options']) && is_array($args['options']) ) {
+            foreach ($args['options'] as $option) {
+              $checked = $option == $value ? true : false;
+              $is_checked = $checked == true ? 'checked' : '';
+              $return .= '<input type="radio" name=" ' . $field . '[]" value="' . $option . '" ' . $is_checked . '/>' . $option;
+            }
+          }
+          break;
+        default:
+          # code...
+          break;
+      }
+    }
+  } else {
+    $return .= '<label>' . ucfirst($field) . '</label><br />';
+    $return .= '<input type="text" name=" ' . $field . '" value="' . $value . '" />';
+  }
+
+  return '<p>' . $return . '</p>';
+}

data/templates/post_type.php

@@ -0,0 +1,101 @@
+<?php
+
+/**
+ * Custom Post Type: {{name_capitalize}}
+ * Generated with Aina. Version {{aina_version}}
+ */
+
+/* {{name_capitalize}} Properties */
+function {{name}}_register() {
+	$labels = array(
+		'name'                  => _x("{{name_capitalize}}", '{{name}}'),
+		'singular_name'         => _x("{{name_capitalize}} Item", '{{name}}'),
+		'add_new'               => _x('New {{name_capitalize}} Item', '{{name}}'),
+		'add_new_item'          => __('Add New {{name_capitalize}} Item'),
+		'edit_item'             => __('Edit {{name_capitalize}} Item'),
+		'new_item'              => __('New {{name_capitalize}} Item'),
+		'view_item'             => __('View {{name_capitalize}} Item'),
+		'search_items'          => __('Search {{name_capitalize}} Items'),
+		'not_found'             => __('Nothing found'),
+		'not_found_in_trash'    => __('Nothing found in Trash'),
+		'parent_item_colon'     => '',
+	);
+	$args = array(
+		'labels'                => $labels,
+		'public'                => true,
+		'publicly_queryable'    => true,
+		'show_ui'               => true,
+		'query_var'             => true,
+		'menu_icon'             => false, // get_stylesheet_directory_uri() . '/your_pt_icon_here.png'
+		'rewrite'               => true,
+		'capability_type'       => '{{capability}}',
+		'hierarchical'          => true,
+		'has_archive'           => true,
+		'menu_position'         => null,
+		'supports'              => array({{supports}}),
+	); 
+	register_post_type( '{{name}}' , $args );
+}
+
+add_action('init', '{{name}}_register');
+
+
+/* {{name_capitalize}} Taxonomy */
+add_action( 'init', 'register_taxonomy_{{name}}categories' );
+
+function register_taxonomy_{{name}}categories() {
+	// Taxonomy slug
+	${{name}}_taxonomy = '{{name}}categories';
+
+	$labels = array( 
+		'name'                       => _x( '{{name_capitalize}} Categories', ${{name}}_taxonomy ),
+		'singular_name'              => _x( '{{name_capitalize}} Category', ${{name}}_taxonomy ),
+		'search_items'               => _x( 'Search {{name_capitalize}} Category', ${{name}}_taxonomy ),
+		'popular_items'              => _x( 'Popular {{name_capitalize}} Category', ${{name}}_taxonomy ),
+		'all_items'                  => _x( 'All {{name_capitalize}} Category', ${{name}}_taxonomy ),
+		'parent_item'                => _x( 'Parent {{name_capitalize}} Category', ${{name}}_taxonomy ),
+		'parent_item_colon'          => _x( 'Parent {{name_capitalize}} Category:', ${{name}}_taxonomy ),
+		'edit_item'                  => _x( 'Edit {{name_capitalize}} Category', ${{name}}_taxonomy ),
+		'update_item'                => _x( 'Update {{name_capitalize}} Category', ${{name}}_taxonomy ),
+		'add_new_item'               => _x( 'Add New {{name_capitalize}} Category', ${{name}}_taxonomy ),
+		'new_item_name'              => _x( 'New {{name_capitalize}} Category', ${{name}}_taxonomy ),
+		'separate_items_with_commas' => _x( 'Separate {{name_capitalize}} Categories with commas', ${{name}}_taxonomy ),
+		'add_or_remove_items'        => _x( 'Add or remove {{name_capitalize}} Categories', ${{name}}_taxonomy ),
+		'choose_from_most_used'      => _x( 'Choose from the most used {{name_capitalize}} Categories', ${{name}}_taxonomy ),
+		'menu_name'                  => _x( '{{name_capitalize}} Category', ${{name}}_taxonomy ),
+	);
+
+	$args = array( 
+		'labels'                => $labels,
+		'public'                => true,
+		'show_in_nav_menus'     => true,
+		'show_ui'               => true,
+		'show_tagcloud'         => true,
+		'show_admin_column'     => true,
+		'hierarchical'          => true,
+		//'update_count_callback' => '',
+		'rewrite'               => array( 'hierarchical' => true ), // Use taxonomy as categories
+		'query_var'             => true
+	);
+
+	register_taxonomy( ${{name}}_taxonomy, array('{{name}}'), $args );
+}
+
+/**
+ * Displays the {{name_capitalize}} post type icon in the dashboard
+ */
+//add_action( 'admin_head', '{{name}}_icon' );
+function {{name}}_icon() {
+	echo '<style type="text/css" media="screen">
+					#menu-posts-projecte .wp-menu-image {
+							background: url(<?php echo get_stylesheet_directory_uri(); ?>/img/{{name}}-icon.png) no-repeat 6px 6px !important;
+					}
+					#menu-posts-projecte:hover .wp-menu-image, #menu-posts-projecte.wp-has-current-submenu .wp-menu-image {
+							background-position:6px -16px !important;
+					}
+					#icon-edit.icon32-posts-projecte {
+							background: url(<?php echo get_stylesheet_directory_uri(); ?>/img/{{name}}-32x32.png) no-repeat;
+					}
+			</style>';
+}
+

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: aina
+version: !ruby/object:Gem::Version
+  version: 0.2.0.beta
+platform: ruby
+authors:
+- Carles Jove i Buxeda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.8.1
+description: 
+email: info@joanielena.cat
+executables:
+- aina
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- aina.rdoc
+files:
+- bin/aina
+- lib/aina/addable.rb
+- lib/aina/generable.rb
+- lib/aina/globals.rb
+- lib/aina/support.rb
+- lib/aina/version.rb
+- lib/aina/generable/base.rb
+- lib/aina/generable/types/post_type.rb
+- templates/add.php
+- templates/aina_framework.php
+- templates/post_type.php
+- lib/aina.rb
+- README.rdoc
+- aina.rdoc
+homepage: http://joanielena.cat
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --title
+- aina
+- --main
+- README.rdoc
+- -ri
+require_paths:
+- lib
+- lib
+- templates
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Code generation for WordPress
+test_files: []