arfy 0.2 → 0.2.1

data/Changelog.md

@@ -1,8 +1,28 @@
+## 0.2.3
+  
+  Features:
+
+    - Specs to guarantee the support to all db: tasks
+    - Adds api to create migration files programatically
+    - Introduced the arfy executable which allow create predefined
+      migrations, here are some examples:
+      
+      * arfy create_table people name:string birth:date add_index:name
+      * arfy add_column people country:string limit:50 null:false
+      * arfy remove_index column:name
+      * arfy remove_index name:idx_awswome
+
+## 0.2.1
+
+  Features:
+
+    - Configurable workdir
+
 ## 0.2
 
 Features:
 
-  - Support to all tasks
+  - Support to all db: tasks
   - LICENSE file created
 
 ## 0.1.5

data/Readme.md

@@ -0,0 +1,101 @@
+# Arfy
+## Allow use Rails migrations, but without Rails ;)
+
+Are you working on a Ruby (non Rails) project, using relational database
+and missing the greateness of Rails Migrations? No more, arfy do the
+job!
+
+This gem main goal is to allow the use of Rails rake tasks on the db:
+namespace such as: migrations tasks, seed.rb loading, schema dump... You
+just need install arfy gem.
+
+    gem install arfy
+
+On your project dir, create a Rakefile and put this require on it:
+
+    require 'arfy_tasks'
+
+And... you are ready to go. Just like that, boom! You can check your
+available tasks, on you project dir, execute:
+
+    rake -T
+
+You should see some familiar tasks with some arfy tasks:
+
+    rake arfy:generate:migration  # Generate migration (options NAME=migration_file_name, OUTDIR=db/migrate, TARGET=environment)
+    rake arfy:rails_env           # Changes the environment (options TARGET=development) - use your's configuration name on database.yml
+    rake arfy:workdir             # Change dir where arfy searches for db and config dir (options DBDIR=db, MIGRATIONDIR=DBDIR/migrate, CONFIGDIR=d...
+    rake db:create                # Create the database from config/database.yml for the current Rails.env (use db:create:all to create all dbs in ...
+    rake db:drop                  # Drops the database for the current Rails.env (use db:drop:all to drop all databases)
+    rake db:fixtures:load         # Load fixtures into the current environment's database.
+    rake db:migrate               # Migrate the database (options: VERSION=x, VERBOSE=false).
+    rake db:migrate:status        # Display status of migrations
+    rake db:rollback              # Rolls the schema back to the previous version (specify steps w/ STEP=n).
+    rake db:schema:dump           # Create a db/schema.rb file that can be portably used against any DB supported by AR
+    rake db:schema:load           # Load a schema.rb file into the database
+    rake db:seed                  # Load the seed data from db/seeds.rb
+    rake db:setup                 # Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)
+    rake db:structure:dump        # Dump the database structure to an SQL file
+    rake db:version               # Retrieves the current schema version number
+
+---
+
+## Configuring
+
+You need to create your database.yml, just like when you are using a
+[Rails Project](http://guides.rubyonrails.org/getting_started.html).
+Create some migrations and run the tasks:
+
+    rake db:create:all
+    rake db:migrate
+
+By default, the directories used to configure and store your migrations
+are the same as the ones used by Rails:
+
+    your_project/
+        db/migrate/
+        config/
+
+But you can use any directory structure you want. There are two main
+ways to achieve this:
+
+* rake task workdir:
+
+      rake arfy:workdir MIGRATIONDIR=db/migrate CONFIGDIR=db/config CONFIGNAME=database.yml
+      (no exemplo foram usados os caminhos/nome padrão do Rails para facilitar o entendimento)
+      
+* configuration file:
+
+    - generate an .arfy file on your project root
+    - arfy expects this file in yml format with the following optional
+      parameters (any ommited parameter will be replaced by a default
+      value):
+
+      db:
+        seeds: db/seeds.rb
+        migrate: db/migrate
+        schema: db/schema.rb
+      config:
+        database: config/database.yml
+
+## Generating Migrations
+
+In order to create your migrations, follow the oficial 
+[Rails docs](http://api.rubyonrails.org/classes/ActiveRecord/Migration.html).
+To generate a new empty migrations, run the following task:
+
+    rake arfy:generate:migration NAME=my-MigrationName
+
+(The awkward migration name passed as NAME parameter is to ilustrate
+that this tasks will transform this string in a pretty file name,
+something like: 20110920000101_my_migration_name.rb).
+
+(In a future version, arfy is gonna give you an capable of do this kind
+of repetitive jobs)
+
+---
+
+Enjoy arfy, and, if you like it an can, help make it better reporting
+bugs, suggesting fetaures and even forking the project to kill some
+bugs registered on github issues.
+

data/Readme.pt_br.md

@@ -0,0 +1,105 @@
+# ATENÇÃO
+  Essa é uma documentação relativa a versão "edge" dessa gem, se você
+precisa saber sobre a gem de produção, verifique o [Readme.md](https://github.com/ricardovaleriano/arfy)
+
+# Arfy
+## Possibilita o uso das migrations do Rails, só que sem o Rails ;)
+
+Está trabalhando um projeto Ruby (não Rails) usando banco de dados relacional e andou
+sentindo falta das migrations do Rails? Arfy vai te ajudar a resolver isso.
+
+O objetivo principal dessa gem é possibilitar o uso das rake tasks do Rails
+presentes no namespace db:, isto é: migrations, carregamento do arquivo
+seeds.rb, schema dump... Basta instalar a gem do Arfy.
+
+    gem install arfy
+
+No diretório do seu projeto crie um Rakefile com o seguinte require:
+
+    require 'arfy_tasks'
+
+E... pronto. É só isso, você pode verificar todas as tarefas disponíveis
+usando:
+
+    rake -T
+
+Você deve ver algumas tarefas bem familiares e outras adicionadas pelo
+Arfy:
+
+    rake arfy:generate:migration  # Generate migration (options NAME=migration_file_name, OUTDIR=db/migrate, TARGET=environment)
+    rake arfy:rails_env           # Changes the environment (options TARGET=development) - use your's configuration name on database.yml
+    rake arfy:workdir             # Change dir where arfy searches for db and config dir (options DBDIR=db, MIGRATIONDIR=DBDIR/migrate, CONFIGDIR=d...
+    rake db:create                # Create the database from config/database.yml for the current Rails.env (use db:create:all to create all dbs in ...
+    rake db:drop                  # Drops the database for the current Rails.env (use db:drop:all to drop all databases)
+    rake db:fixtures:load         # Load fixtures into the current environment's database.
+    rake db:migrate               # Migrate the database (options: VERSION=x, VERBOSE=false).
+    rake db:migrate:status        # Display status of migrations
+    rake db:rollback              # Rolls the schema back to the previous version (specify steps w/ STEP=n).
+    rake db:schema:dump           # Create a db/schema.rb file that can be portably used against any DB supported by AR
+    rake db:schema:load           # Load a schema.rb file into the database
+    rake db:seed                  # Load the seed data from db/seeds.rb
+    rake db:setup                 # Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)
+    rake db:structure:dump        # Dump the database structure to an SQL file
+    rake db:version               # Retrieves the current schema version number
+
+---
+
+## Configuração
+
+Lembre-se de criar o seu arquivo database.yml, assim como você faria em
+seu projeto [Rails](http://guides.rubyonrails.org/getting_started.html).
+Crie suas migrations e rode as tarefas:
+
+    rake db:create:all
+    rake db:migrate
+
+Por convenção, os diretórios usados para configurar e armazenar as migrações
+são os mesmos da convenção utilizada pelo Rails:
+
+    your_project/
+        db/migrate/
+        config/
+
+Porém você pode usar qualquer estrutura de diretórios que desejar. Existem
+duas formas de configurar o caminho onde suas migrações serão salvas, onde
+o arfy precisa buscar as configurações (e afins):
+
+* rake task workdir:
+
+      rake arfy:workdir MIGRATIONDIR=db/migrate CONFIGDIR=db/config CONFIGNAME=database.yml
+      (no exemplo foram usados os caminhos/nome padrão do Rails para facilitar o entendimento)
+      
+* arquivo de configuração:
+
+    - crie um arquivo .arfy na raiz do seu projeto
+    - arfy espera que esse arquivo esteja no formato yml e tenha os
+      seguintes parâmetros (todos opcionais, valores padrão serão
+      utilizados caso algum deles não seja encontrado):
+
+      db:
+        seeds: db/seeds.rb
+        migrate: db/migrate
+        schema: db/schema.rb
+      config:
+        database: config/database.yml
+
+## Gerando Migrations
+
+Para criar suas migrações siga a documentação oficial do Rails: 
+[Rails docs](http://api.rubyonrails.org/classes/ActiveRecord/Migration.html).
+Para gerar uma migration vazia, use a rake task a seguir:
+
+    rake arfy:generate:migration NAME=my-MigrationName
+    
+(O nome estranho da migração passado como parâmetro aqui é só para ilustrar que a task vai
+criar um arquivo com o nome bonito para você, algo como: 20110920000101_my_migration_name.rb).
+
+(Numa próxima versão o arfy vai disponibilizar um executável para
+realizar esse tipo de tarefa)
+
+---
+
+Aproveite e, se puder, me ajude a melhorar essa ferramenta reportando
+bugs, sugerindo funcionalidades ou mesmo forkando o projeto caso queria
+solucionar algum bug reportado no issues do github.
+

data/bin/arfy

@@ -0,0 +1 @@
+#!/usr/bin/env ruby

data/lib/arfy.rb

@@ -1,26 +1,14 @@
 require 'active_record'
 require 'erb'
 
-require 'arfy/config_faker'
-require 'arfy/application_faker'
-require 'arfy/environment_faker'
-require 'arfy/rails_faker'
+require 'arfy/string_extensions'
+require 'arfy/environment'
 require 'arfy/generator'
+require 'arfy/migration_builder'
 
-def configured_paths
-  paths = {}
-  paths["config/database"] = "config/database.yml"
-  paths["db/seeds"] = "db/seeds.rb"
-  migrate_path = String.new("db/migrate")
-  def migrate_path.to_a
-    [self]
+unless defined? Rails
+  class Rails
+    extend Arfy::RailsFaker
   end
-  paths["db/migrate"] = migrate_path
-  paths
 end
 
-class Rails
-  extend RailsFaker
-end
-
-require "tasks/all"

data/lib/arfy/environment.rb

@@ -0,0 +1,200 @@
+module Arfy
+  class NoObjectDefinedError < Exception
+  end
+
+  class Environment
+    class EnvWorkdirConfiguration
+      def configuration_data
+        return @data unless @data.nil?
+
+        @data = {"db" => {}, "config" => {}}
+        if File.exists? ".arfy"
+          @data = YAML.load( IO.read(".arfy") )
+        end
+        @data
+      end
+
+      def migration_dirpath
+        configuration_data["db"]["migrate"] ||
+        ENV["db/migrate"] || "db/migrate"
+      end
+
+      def config_path
+        ENV["db/config"] || "config"
+      end
+
+      def database_config_path
+        configuration_data["config"]["database"] ||
+        "#{config_path}/#{ENV["db/config/database.yml"] || "database.yml"}"
+      end
+
+      def seed_rb_path
+        configuration_data["db"]["seeds"] ||
+        "#{ENV["db/seeds_dir"] || "db"}/#{ENV["db/seeds.rb"] || "seeds.rb"}"
+      end
+
+      def schema_path
+        configuration_data["db"]["schema"] ||
+        ENV["db/schema.rb"] || "db/schema.rb"
+      end
+    end
+
+    # TODO:should be possible change the result of this method to
+    # configure the paths
+    def configured_paths
+      workdir = EnvWorkdirConfiguration.new
+
+      paths = {}
+      paths["config/database"] = workdir.database_config_path
+      paths["db/seeds"] = workdir.seed_rb_path
+      migrate_path = String.new(workdir.migration_dirpath)
+      def migrate_path.to_a
+        [self]
+      end
+      paths["db/migrate"] = migrate_path
+      paths["db/schema"] = workdir.schema_path
+      ENV["SCHEMA"] = paths["db/schema"]
+      if paths["db/schema"].index("/") == 0
+        path = paths["db/schema"]
+      else
+        path = File.join(Dir.pwd, paths["db/schema"])
+      end
+      FileUtils.mkdir_p(File.dirname(path))
+      paths
+    end
+
+    def augment(object_or_module_name, module_name=nil)
+      object, module_name = initialize_module_name(object_or_module_name, module_name)
+      unless object
+        if block_given?
+          object = yield
+        else
+          object = Object.new
+        end
+      end
+      pimp_object(object, module_name)
+    end
+
+    def prepare_active_record_module
+      class << ActiveRecord::Base
+        def establish_connection(configuration = nil)
+          #forget about it, we already have a connection XD
+        end
+
+        def configurations
+          Rails.application.config.database_configuration
+        end
+      end
+    end
+
+    def set_rails_env(target)
+      ENV['RAILS_ENV'] = (target || ENV["RAILS_ENV"]) || "development"
+      puts "working on environment: #{ENV['RAILS_ENV']}" if ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"]
+    end
+
+    def database_connect
+      database_configurations = Rails.application.config.database_configuration
+      env_db_configuration = database_configurations[Rails.env]
+      ActiveRecord::Base.establish_connection(env_db_configuration)
+    end
+
+    def create_config(options_param={})
+      config = {
+        "config/database"   => "config/database.yml",
+        "db/seeds"          => "db/seeds.rb",
+        "db/migrate"        => "db/migrate"}.merge(options_param)
+
+      new_hash = {
+        "config"  => {
+          "database" => config["config/database"]
+      },
+        "db"      => {
+          "seeds"   => config["db/seeds"],
+          "migrate" => config["db/migrate"],
+          "schema"  => config["db/schema"]}
+      }
+
+      File.open(".arfy", "w") do |f|
+        f << new_hash.to_yaml
+      end
+    end
+
+    private
+    def initialize_module_name(object_or_module_name, module_name)
+      if module_name.nil?
+        module_name = object_or_module_name
+        object = nil
+      else
+        object = object_or_module_name
+      end
+      [object, module_name]
+    end
+
+    def pimp_object(object, module_name)
+      raise NoObjectDefinedError unless object
+      object.class.send(:include, module_name)
+      object
+    end
+
+  end
+
+  module ConfigFaker
+    #https://github.com/rails/rails/blob/master/railties/lib/rails/application/configuration.rb
+    def paths
+      Environment.new.configured_paths
+    end
+
+    def database_configuration
+      @configuration ||= YAML::load(ERB.new(IO.read(paths["config/database"])).result)
+      @configuration
+    end
+  end
+
+  module ApplicationFaker
+    def config
+      @fake_config = Environment.new.augment(@fake_config, Arfy::ConfigFaker)
+      @fake_config
+    end
+
+    def paths
+      Environment.new.configured_paths
+    end
+
+    def load_seed
+      seed_file = paths["db/seeds"]
+      load(seed_file) if File.exist?(seed_file)
+    end    
+  end
+
+  module EnvironmentFaker
+    def method_missing(who_ami, *params)
+      method = who_ami.to_s
+      ends_with_questionmark = method.index("?") == method.length - 1
+      if ends_with_questionmark
+        env_name_asked = method.slice(0, method.length-1)
+        return env_name_asked == ENV['RAILS_ENV'] || self.env
+      end
+      super
+    end
+  end
+
+  module RailsFaker
+    def root
+      "."
+    end
+
+    def env
+      @fake_env = Environment.new.augment(@fake_env, Arfy::EnvironmentFaker) do
+        String.new(ENV['RAILS_ENV'] ||= "development")
+      end
+      @fake_env
+    end
+
+    def application
+      @fake_application = Environment.new.augment(@fake_application, Arfy::ApplicationFaker)
+      @fake_application
+    end
+  end
+end
+