lightrail 0.0.1 → 0.99.0

data/lib/lightrail/generators/base.rb

@@ -0,0 +1,378 @@
+begin
+  require 'thor/group'
+rescue LoadError
+  puts "Thor is not available.\nIf you ran this command from a git checkout " \
+       "of Lightrail, please make sure thor is installed,\nand run this command " \
+       "as `ruby #{$0} #{(ARGV | ['--dev']).join(" ")}`"
+  exit
+end
+
+require 'rails/generators/actions'
+require 'active_support/core_ext/object/inclusion'
+
+module Lightrail
+  module Generators
+    class Error < Thor::Error
+    end
+
+    class Base < Thor::Group
+      include Thor::Actions
+      include Rails::Generators::Actions
+
+      add_runtime_options!
+
+      # Returns the source root for this generator using default_source_root as default.
+      def self.source_root(path=nil)
+        @_source_root = path if path
+        @_source_root ||= default_source_root
+      end
+
+      # Tries to get the description from a USAGE file one folder above the source
+      # root otherwise uses a default description.
+      def self.desc(description=nil)
+        return super if description
+        usage = source_root && File.expand_path("../USAGE", source_root)
+
+        @desc ||= if usage && File.exist?(usage)
+          ERB.new(File.read(usage)).result(binding)
+        else
+          "Description:\n    Create #{base_name.humanize.downcase} files for #{generator_name} generator."
+        end
+      end
+
+      # Convenience method to get the namespace from the class name. It's the
+      # same as Thor default except that the Generator at the end of the class
+      # is removed.
+      def self.namespace(name=nil)
+        return super if name
+        @namespace ||= super.sub(/_generator$/, '').sub(/:generators:/, ':')
+      end
+
+      # Convenience method to hide this generator from the available ones when
+      # running rails generator command.
+      def self.hide!
+        Lightrail::Generators.hide_namespace self.namespace
+      end
+
+      # Invoke a generator based on the value supplied by the user to the
+      # given option named "name". A class option is created when this method
+      # is invoked and you can set a hash to customize it.
+      #
+      # ==== Examples
+      #
+      #   module Lightrail::Generators
+      #     class ControllerGenerator < Base
+      #       hook_for :test_framework, :aliases => "-t"
+      #     end
+      #   end
+      #
+      # The example above will create a test framework option and will invoke
+      # a generator based on the user supplied value.
+      #
+      # For example, if the user invoke the controller generator as:
+      #
+      #   rails generate controller Account --test-framework=test_unit
+      #
+      # The controller generator will then try to invoke the following generators:
+      #
+      #   "rails:test_unit", "test_unit:controller", "test_unit"
+      #
+      # Notice that "rails:generators:test_unit" could be loaded as well, what
+      # Rails looks for is the first and last parts of the namespace. This is what
+      # allows any test framework to hook into Rails as long as it provides any
+      # of the hooks above.
+      #
+      # ==== Options
+      #
+      # The first and last part used to find the generator to be invoked are
+      # guessed based on class invokes hook_for, as noticed in the example above.
+      # This can be customized with two options: :base and :as.
+      #
+      # Let's suppose you are creating a generator that needs to invoke the
+      # controller generator from test unit. Your first attempt is:
+      #
+      #   class AwesomeGenerator < Lightrail::Generators::Base
+      #     hook_for :test_framework
+      #   end
+      #
+      # The lookup in this case for test_unit as input is:
+      #
+      #   "test_unit:awesome", "test_unit"
+      #
+      # Which is not the desired the lookup. You can change it by providing the
+      # :as option:
+      #
+      #   class AwesomeGenerator < Lightrail::Generators::Base
+      #     hook_for :test_framework, :as => :controller
+      #   end
+      #
+      # And now it will lookup at:
+      #
+      #   "test_unit:controller", "test_unit"
+      #
+      # Similarly, if you want it to also lookup in the rails namespace, you just
+      # need to provide the :base value:
+      #
+      #   class AwesomeGenerator < Lightrail::Generators::Base
+      #     hook_for :test_framework, :in => :rails, :as => :controller
+      #   end
+      #
+      # And the lookup is exactly the same as previously:
+      #
+      #   "rails:test_unit", "test_unit:controller", "test_unit"
+      #
+      # ==== Switches
+      #
+      # All hooks come with switches for user interface. If you do not want
+      # to use any test framework, you can do:
+      #
+      #   rails generate controller Account --skip-test-framework
+      #
+      # Or similarly:
+      #
+      #   rails generate controller Account --no-test-framework
+      #
+      # ==== Boolean hooks
+      #
+      # In some cases, you may want to provide a boolean hook. For example, webrat
+      # developers might want to have webrat available on controller generator.
+      # This can be achieved as:
+      #
+      #   Lightrail::Generators::ControllerGenerator.hook_for :webrat, :type => :boolean
+      #
+      # Then, if you want webrat to be invoked, just supply:
+      #
+      #   rails generate controller Account --webrat
+      #
+      # The hooks lookup is similar as above:
+      #
+      #   "rails:generators:webrat", "webrat:generators:controller", "webrat"
+      #
+      # ==== Custom invocations
+      #
+      # You can also supply a block to hook_for to customize how the hook is
+      # going to be invoked. The block receives two arguments, an instance
+      # of the current class and the class to be invoked.
+      #
+      # For example, in the resource generator, the controller should be invoked
+      # with a pluralized class name. But by default it is invoked with the same
+      # name as the resource generator, which is singular. To change this, we
+      # can give a block to customize how the controller can be invoked.
+      #
+      #   hook_for :resource_controller do |instance, controller|
+      #     instance.invoke controller, [ instance.name.pluralize ]
+      #   end
+      #
+      def self.hook_for(*names, &block)
+        options = names.extract_options!
+        in_base = options.delete(:in) || base_name
+        as_hook = options.delete(:as) || generator_name
+
+        names.each do |name|
+          defaults = if options[:type] == :boolean
+            { }
+          elsif default_value_for_option(name, options).in?([true, false])
+            { :banner => "" }
+          else
+            { :desc => "#{name.to_s.humanize} to be invoked", :banner => "NAME" }
+          end
+
+          unless class_options.key?(name)
+            class_option(name, defaults.merge!(options))
+          end
+
+          hooks[name] = [ in_base, as_hook ]
+          invoke_from_option(name, options, &block)
+        end
+      end
+
+      # Remove a previously added hook.
+      #
+      # ==== Examples
+      #
+      #   remove_hook_for :orm
+      #
+      def self.remove_hook_for(*names)
+        remove_invocation(*names)
+
+        names.each do |name|
+          hooks.delete(name)
+        end
+      end
+
+      # Make class option aware of Lightrail::Generators.options and Lightrail::Generators.aliases.
+      def self.class_option(name, options={}) #:nodoc:
+        options[:desc]    = "Indicates when to generate #{name.to_s.humanize.downcase}" unless options.key?(:desc)
+        options[:aliases] = default_aliases_for_option(name, options)
+        options[:default] = default_value_for_option(name, options)
+        super(name, options)
+      end
+
+      # Returns the default source root for a given generator. This is used internally
+      # by rails to set its generators source root. If you want to customize your source
+      # root, you should use source_root.
+      def self.default_source_root
+        return unless base_name && generator_name
+        path = File.expand_path(File.join(base_name, generator_name, 'templates'), base_root)
+        path if File.exists?(path)
+      end
+
+      # Returns the base root for a common set of generators. This is used to dynamically
+      # guess the default source root.
+      def self.base_root
+        File.dirname(__FILE__)
+      end
+
+      # Cache source root and add lib/generators/base/generator/templates to
+      # source paths.
+      def self.inherited(base) #:nodoc:
+        super
+
+        # Invoke source_root so the default_source_root is set.
+        base.source_root
+
+        if base.name && base.name !~ /Base$/
+          Lightrail::Generators.subclasses << base
+
+          Lightrail::Generators.templates_path.each do |path|
+            if base.name.include?('::')
+              base.source_paths << File.join(path, base.base_name, base.generator_name)
+            else
+              base.source_paths << File.join(path, base.generator_name)
+            end
+          end
+        end
+      end
+
+      protected
+
+        # Check whether the given class names are already taken by user
+        # application or Ruby on Rails.
+        #
+        def class_collisions(*class_names) #:nodoc:
+          return unless behavior == :invoke
+
+          class_names.flatten.each do |class_name|
+            class_name = class_name.to_s
+            next if class_name.strip.empty?
+
+            # Split the class from its module nesting
+            nesting = class_name.split('::')
+            last_name = nesting.pop
+
+            # Extract the last Module in the nesting
+            last = nesting.inject(Object) do |last_module, nest|
+              break unless last_module.const_defined?(nest, false)
+              last_module.const_get(nest)
+            end
+
+            if last && last.const_defined?(last_name.camelize, false)
+              raise Error, "The name '#{class_name}' is either already used in your application " <<
+                           "or reserved by Ruby on Rails. Please choose an alternative and run "  <<
+                           "this generator again."
+            end
+          end
+        end
+
+        # Use Rails default banner.
+        #
+        def self.banner
+          "rails generate #{namespace.sub(/^rails:/,'')} #{self.arguments.map{ |a| a.usage }.join(' ')} [options]".gsub(/\s+/, ' ')
+        end
+
+        # Sets the base_name taking into account the current class namespace.
+        #
+        def self.base_name
+          @base_name ||= begin
+            if base = name.to_s.split('::').first
+              base.underscore
+            end
+          end
+        end
+
+        # Removes the namespaces and get the generator name. For example,
+        # Lightrail::Generators::ModelGenerator will return "model" as generator name.
+        #
+        def self.generator_name
+          @generator_name ||= begin
+            if generator = name.to_s.split('::').last
+              generator.sub!(/Generator$/, '')
+              generator.underscore
+            end
+          end
+        end
+
+        # Return the default value for the option name given doing a lookup in
+        # Lightrail::Generators.options.
+        #
+        def self.default_value_for_option(name, options)
+          default_for_option(Lightrail::Generators.options, name, options, options[:default])
+        end
+
+        # Return default aliases for the option name given doing a lookup in
+        # Lightrail::Generators.aliases.
+        #
+        def self.default_aliases_for_option(name, options)
+          default_for_option(Lightrail::Generators.aliases, name, options, options[:aliases])
+        end
+
+        # Return default for the option name given doing a lookup in config.
+        #
+        def self.default_for_option(config, name, options, default)
+          if generator_name and c = config[generator_name.to_sym] and c.key?(name)
+            c[name]
+          elsif base_name and c = config[base_name.to_sym] and c.key?(name)
+            c[name]
+          elsif config[:rails].key?(name)
+            config[:rails][name]
+          else
+            default
+          end
+        end
+
+        # Keep hooks configuration that are used on prepare_for_invocation.
+        #
+        def self.hooks #:nodoc:
+          @hooks ||= from_superclass(:hooks, {})
+        end
+
+        # Prepare class invocation to search on Rails namespace if a previous
+        # added hook is being used.
+        #
+        def self.prepare_for_invocation(name, value) #:nodoc:
+          return super unless value.is_a?(String) || value.is_a?(Symbol)
+
+          if value && constants = self.hooks[name]
+            value = name if TrueClass === value
+            Lightrail::Generators.find_by_namespace(value, *constants)
+          elsif klass = Lightrail::Generators.find_by_namespace(value)
+            klass
+          else
+            super
+          end
+        end
+
+        # Small macro to add ruby as an option to the generator with proper
+        # default value plus an instance helper method called shebang.
+        #
+        def self.add_shebang_option!
+          class_option :ruby, :type => :string, :aliases => "-r", :default => Thor::Util.ruby_command,
+                              :desc => "Path to the Ruby binary of your choice", :banner => "PATH"
+
+          no_tasks {
+            define_method :shebang do
+              @shebang ||= begin
+                command = if options[:ruby] == Thor::Util.ruby_command
+                  "/usr/bin/env #{File.basename(Thor::Util.ruby_command)}"
+                else
+                  options[:ruby]
+                end
+                "#!#{command}"
+              end
+            end
+          }
+        end
+
+    end
+  end
+end

data/lib/lightrail/generators/templates/Gemfile

@@ -0,0 +1,25 @@
+source 'https://rubygems.org'
+
+gem 'lightrail', '<%= Lightrail::VERSION %>'
+gem 'activerecord'
+gem 'activeresource'
+gem 'actionmailer'
+
+<%= "gem 'jruby-openssl'\n" if defined?(JRUBY_VERSION) -%>
+<%= assets_gemfile_entry %>
+<%= javascript_gemfile_entry %>
+
+# To use ActiveModel has_secure_password
+# gem 'bcrypt-ruby', '~> 3.0.0'
+
+# To use Jbuilder templates for JSON
+# gem 'jbuilder'
+
+# Use unicorn as the web server
+# gem 'unicorn'
+
+# Deploy with Capistrano
+# gem 'capistrano', :group => :development
+
+# To use debugger
+# gem 'ruby-debug19', :require => 'ruby-debug'

data/lib/lightrail/generators/templates/README

@@ -0,0 +1,259 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug19 to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug19</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |       |-- images
+  |       |-- javascripts
+  |       `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      |-- assets
+          `-- stylesheets
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. If the app has frozen rails,
+  those gems also go here, under vendor/rails/. This directory is in the load path.