fast_track 0.0.5 → 0.0.6

data/README.md

@@ -1,39 +1,41 @@
 # fast_track
 
-Create Rails apps quickly.
+Create Rails apps quickly. So far the number of recipes we have is somewhat limited, but it will grow very soon, 
+and very fast.
 
-## Status:
+## Install:
 
-Currently very alpha. Check out what's possible here:
+fast_track is a tool for building Rails apps, so you don't need to add it to your Gemfile. Just install it as you
+would any other gem:
 
 ```bash
-git clone git@github.com:EncomLabs/fast_track.git
-cd fast_track
+gem install fast_track
 ```
 
-The executable `bin/track` is where all the magic happens for the moment.
-
 ## Examples:
 
+Here's some examples of what fast_track can do so far. Note that this is actually a rather limited set of things
+compared to what it will be actually capable of.
+
 ### Create an app with Devise + Cancan + Rolify
 
 ```bash
-./bin/track --app whatever --tracks devise,cancan,rolify
+track --app cool_site --tracks devise,cancan,rolify
 ```
 
 ### Same as above, but add Devise views
 
 ```bash
-./bin/track --app whatever --tracks devise_with_views,cancan,rolify
+./bin/track --app cool_site --tracks devise_with_views,cancan,rolify
 ```
 
 ### Same as above, but with Twitter Bootstrap
 
 ```bash
-./bin/track --app whatever --tracks twitter_bootstrap,devise_with_view,cancan,rolify
+./bin/track --app cool_site --tracks twitter_bootstrap,devise_with_view,cancan,rolify
 ```
 
-## Why not use rails wizard / appscrolls / Rails app composer / some other Rails app builder ?
+## Why not use Rails Wizard / appscrolls / Rails app composer / some other Rails app builder ?
 
 In all the projects I've seen, most functionality is implemented in procedural scripts. They are not objects.
 In `fast_track`, all objects inherit from `Track`. Procedural is fine for quick scripts, but not for robust tools.

data/bin/track

@@ -4,4 +4,5 @@ $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'fast_track'
 
-FastTrack.new.start
+
+FastTrack::Commands.start(ARGV)

data/fast_track.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["farleyknight@gmail.com"]
   spec.summary       = %q{Create Rails apps quickly.}
   spec.description   = %q{Leverage the Rails generator to architect new Rails apps with lots of default gems, templates, and other recipes, quickly.}
-  spec.homepage      = ""
+  spec.homepage      = "http://fast-track.io"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -22,4 +22,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "gem-release"
+
+  spec.add_dependency "thor"
+  spec.add_dependency "rails"
+  spec.add_dependency "hooks"
 end

data/lib/fast_track.rb

@@ -1,94 +1,48 @@
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
 
 require 'open-uri'
-require 'slop'
-
-require 'pry'
 
 require 'rails/generators'
 require 'rails/generators/rails/app/app_generator'
 
+require 'fast_track/ext'
+require 'fast_track/dsl'
 require 'fast_track/exceptions'
 require 'fast_track/config'
 
 require 'fast_track/track_methods'
 require 'fast_track/track'
 
+require 'fast_track/commands'
 require 'fast_track/generator'
 
-# require 'fast_track/cancan'
-# require 'fast_track/rolify'
-# require 'fast_track/devise'
-
-# require 'fast_track/awesome_defaults'
-# require 'fast_track/twitter_bootstrap'
-
-# Load FastTrack tracks
-Dir[File.join(File.dirname(__FILE__), 'lib', 'tracks')].each do |file|
-  load file
-end
-
-# Load local tracks
-Dir[File.join(File.expand_path("~/"), ".fast_track", "*.rb")].each do |file|
-  load file
-end
-
-class FastTrack
-  def initialize
-    FastTrack.validate_options!
-  end
-
-  def app
-    @app ||= Generator.new([FastTrack.app_name])
-  end
-
-  def start
-    app.invoke
+module FastTrack
+  class App
+    def initialize(app_name, tracks)
+      FastTrack.options[:tracks] = tracks
+      @app ||= FastTrack::Generator.new([app_name])
+      @app.invoke
+    end
   end
 
   class << self
     def options
-      @opts
-    end
-
-    def app_name
-      options[:app]
-    end
-
-    def make_tracks
-      options[:tracks].map do |track|
-        klass = FastTrack.const_get(track.camelize)
-        if klass <= Track
-          klass
-        else
-          raise TrackNotFound.new(klass.name)
-        end
-      end
+      @options ||= {}
     end
 
     def tracks
       @tracks ||= make_tracks
     end
 
-    def validate_options!
-      @opts ||= Slop.parse(ARGV || [], strict: true, arguments: true, help: true) do
-        banner 'Usage: track --A [app] --T [tracks]'
-
-        on 'A', 'app=',     'The application name'
-        on 'T', 'tracks=',  'The tracks to run', as: Array
-      end
-
-      # TODO: Is there a Ruby gem that has the same functionality as ActiveModel::Validations
-      # but doesn't require ActiveRecord?
-      #
-      # Because we should use that here..
-
-      if @opts[:app].blank?
-        raise "--app can't be blank!"
-      end
+    def available_tracks
+      @available_tracks ||= {}
+    end
 
-      if @opts[:tracks].blank?
-        raise "--tracks can't be blank!"
+    def find_track(name)
+      if available_tracks[name].present?
+        available_tracks[name]
+      else
+        raise TrackNotFound.new(name)
       end
     end
 
@@ -103,5 +57,28 @@ class FastTrack
     def template_root
       File.join(File.expand_path(root), "lib", "templates")
     end
+
+    protected
+
+    def make_tracks
+      options[:tracks].map do |track|
+        klass = FastTrack.find_track(track)
+        if klass <= Track
+          klass
+        else
+          raise TrackNotFound.new(klass.name)
+        end
+      end
+    end
   end
 end
+
+# Load FastTrack tracks
+Dir[File.join(File.dirname(__FILE__), 'tracks', "*.rb")].each do |file|
+  require file
+end
+
+# Load local tracks
+Dir[File.join(File.expand_path("~/"), ".fast_track", "*.rb")].each do |file|
+  require file
+end

data/lib/fast_track/commands.rb

@@ -0,0 +1,32 @@
+require "thor"
+
+module FastTrack
+  class Commands < Thor
+    desc "new APP_NAME", "Create a new Rails app, called APP_NAME"
+
+    method_option :tracks, {
+      :type     => :array,
+      :aliases  => "-T",
+      :desc     => "Tracks to run with this app",
+      :required => true
+    }
+
+    def new_app(name)
+      FastTrack::App.new(name, options[:tracks])
+    end
+
+    desc "list", "List all available tracks, with descriptions"
+
+    def list
+      puts ""
+      puts "Available Tracks:"
+      puts ""
+      FastTrack::Track.descendants.each do |track|
+        unless track.name.blank?
+          puts "#{track.name.ljust(30)} -- #{track.description}"
+        end
+      end
+      puts ""
+    end
+  end
+end

data/lib/fast_track/config.rb

@@ -1,4 +1,4 @@
-class FastTrack
+module FastTrack
   # TODO: This should take a YAML file and merge it with the defaults!
   class Config < Hash
     # TODO: This config file should have nested information for each

data/lib/fast_track/dsl.rb

@@ -0,0 +1,14 @@
+module FastTrack
+  module DSL
+    def track(*args, &block)
+      new_track = Class.new(FastTrack::Track, &block)
+      new_track.args = args
+
+      FastTrack.available_tracks[args.first] = new_track
+
+      new_track
+    end
+  end
+end
+
+extend FastTrack::DSL

data/lib/fast_track/exceptions.rb

@@ -1,4 +1,4 @@
-class FastTrack
+module FastTrack
   class TrackNotFound < Exception
     def initialize(track_name)
       super("Could not find track #{track_name}! Please double-check the provided params.")

data/lib/fast_track/ext.rb

@@ -0,0 +1,5 @@
+class Class
+  def descendants
+    ObjectSpace.each_object(::Class).select {|klass| klass < self }
+  end
+end

data/lib/fast_track/generator.rb

@@ -1,4 +1,4 @@
-class FastTrack
+module FastTrack
   class GemInstaller
     def run(generator)
       FastTrack.tracks.each do |klass|
@@ -19,6 +19,26 @@ class FastTrack
     end
   end
 
+  class AfterBundle
+    def run(generator)
+      FastTrack.tracks.each do |klass|
+        unless klass.after_bundle_block.blank?
+          generator.instance_eval(&klass.after_bundle_block)
+        end
+      end
+    end
+  end
+
+  class AfterMigrate
+    def run(generator)
+      FastTrack.tracks.each do |klass|
+        unless klass.after_migrate_block.blank?
+          generator.instance_eval(&klass.after_migrate_block)
+        end
+      end
+    end
+  end
+
   class Runner
     def run(generator)
       FastTrack.tracks.each do |klass|
@@ -30,18 +50,24 @@ class FastTrack
   end
 
   class Generator < Rails::Generators::AppGenerator
-    include TrackMethods
-
     source_root Rails::Generators::AppGenerator.source_root
 
-    def fasttrack
+    def fast_track
       FastTrack::GemInstaller.new.run(self)
       run("bundle install")
+      FastTrack::AfterBundle.new.run(self)
 
       FastTrack::Runner.new.run(self)
 
       FastTrack::BeforeMigrate.new.run(self)
       rake("db:migrate")
+      FastTrack::AfterMigrate.new.run(self)
+    end
+
+    protected
+
+    def do_whatever
+      puts "Does thor call this?"
     end
   end
 end

data/lib/fast_track/track.rb

@@ -1,5 +1,8 @@
-class FastTrack
+require "hooks"
+
+module FastTrack
   class Track
+    include Hooks
     include TrackMethods
 
     attr_accessor :generator
@@ -8,72 +11,105 @@ class FastTrack
       @generator = generator
     end
 
-    # Describe a Gemfile using `gem` and `gem_group`
-    def self.gemfile(&block)
-      @gemfile_block = block
-    end
-
-    def self.gemfile_block
-      @gemfile_block
-    end
-
-    # Tasks before migration
-    def self.before_migrate(&block)
-      @before_migrate_block = block
-    end
-
-    def self.before_migrate_block
-      @before_migrate_block
-    end
-
-    # If you need to get the base-level generator object, it's
-    # available here.
-    def g
-      generator
-    end
-
-    # Add a gem
-    #
-    # TODO: Find a way to consolidate all gems at once, so we only have to run
-    # `bundle install` once.
-    def gem(*args)
-      g.gem(*args)
-    end
-
-    # Run rake
-    def rake(*args)
-      g.rake(*args)
-    end
-
-    # Run any command
-    def run(*args)
-      g.run(*args)
-    end
-
-    alias :bundle_install! :bundle_install
-
-    def generate(*args)
-      g.generate(*args)
-    end
-
-    # Add a route to config/routes.rb
-    def route(*args)
-      g.route(*args)
-    end
-
-    # Add a file
-    def create_file(*args)
-      g.create_file(*args)
-    end
-
-    # Create a gem group
-    def gem_group(*args, &block)
-      generator.gem_group(*args, &block)
-    end
-
-    # Read a file from the templates directory
-    def read_file(file_name)
-      File.read(File.join(FastTrack.template_root, template_directory, file_name))
+    class << self
+      def args=(other)
+        @args = other
+      end
+
+      def args
+        @args || []
+      end
+
+      def name_from_args
+        if args.length == 1
+          @args.first
+        end
+      end
+
+      def name(name = nil)
+        if name.blank?
+          # @name || name_from_args || ""
+          name_from_args || ""
+        else
+          @name = name
+        end
+      end
+
+      def description(arg = nil)
+        if arg.blank?
+          @description
+        else
+          @description = arg
+        end
+      end
+
+      alias :desc :description
+
+      # The required tracks this track needs.
+      def requires(*args)
+        if args.blank?
+          @requires
+        else
+          @requires = args
+        end
+      end
+
+      def rubygem(name)
+        @rubygem = name
+      end
+
+      def tutorial_url(url)
+        @tutorial_urls ||= []
+        @tutorial_urls << url
+      end
+
+      def github_url(url)
+        @github_url = url
+      end
+
+      def github_description(description)
+        @github_description = description
+      end
+
+      # Describe a Gemfile using `gem` and `gem_group`
+      def gemfile(&block)
+        @gemfile_block = block
+      end
+
+      def gemfile_block
+        @gemfile_block
+      end
+
+      # Tasks before migration
+      def before_migrate(&block)
+        @before_migrate_block = block
+      end
+
+      def before_migrate_block
+        @before_migrate_block
+      end
+
+      alias :before_migration :before_migrate
+
+      # Tasks before migration
+      def after_migrate(&block)
+        @after_migrate_block = block
+      end
+
+      def after_migrate_block
+        @after_migrate_block
+      end
+
+      alias :after_migration :after_migrate
+
+      # After bundle
+      def after_bundle(&block)
+        @after_bundle_block = block
+      end
+
+      def after_bundle_block
+        @after_bundle_block
+      end
     end
   end
 end