openskies 0.0.1

data/lib/rails/generators/base.rb

@@ -0,0 +1,390 @@
+begin
+  require 'thor/group'
+rescue LoadError
+  puts "Thor is not available.\nIf you ran this command from a git checkout " \
+       "of Rails, 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 Rails
+  module Generators
+    class Error < Thor::Error
+    end
+
+    class Base < Thor::Group
+      include Thor::Actions
+      include Rails::Generators::Actions
+
+      add_runtime_options!
+      strict_args_position! if respond_to?(:strict_args_position!)
+
+      # 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
+
+        @desc ||= if usage_path
+          ERB.new(File.read(usage_path)).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
+
+      # 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 Rails::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 < Rails::Generators::Base
+      #     hook_for :test_framework
+      #   end
+      #
+      # The lookup in this case for test_unit as input is:
+      #
+      #   "test_framework:awesome", "test_framework"
+      #
+      # Which is not the desired the lookup. You can change it by providing the
+      # :as option:
+      #
+      #   class AwesomeGenerator < Rails::Generators::Base
+      #     hook_for :test_framework, :as => :controller
+      #   end
+      #
+      # And now it will lookup at:
+      #
+      #   "test_framework:controller", "test_framework"
+      #
+      # Similarly, if you want it to also lookup in the rails namespace, you just
+      # need to provide the :base value:
+      #
+      #   class AwesomeGenerator < Rails::Generators::Base
+      #     hook_for :test_framework, :in => :rails, :as => :controller
+      #   end
+      #
+      # And the lookup is exactly the same as previously:
+      #
+      #   "rails:test_framework", "test_framework:controller", "test_framework"
+      #
+      # ==== 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:
+      #
+      #   Rails::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 Rails::Generators.options and Rails::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
+        return unless default_generator_root
+        path = File.join(default_generator_root, 'templates')
+        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$/
+          Rails::Generators.subclasses << base
+
+          Rails::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
+
+            # Hack to limit const_defined? to non-inherited on 1.9
+            extra = []
+            extra << false unless Object.method(:const_defined?).arity == 1
+
+            # Extract the last Module in the nesting
+            last = nesting.inject(Object) do |last_module, nest|
+              break unless last_module.const_defined?(nest, *extra)
+              last_module.const_get(nest)
+            end
+
+            if last && last.const_defined?(last_name.camelize, *extra)
+              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,
+        # Rails::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
+        # Rails::Generators.options.
+        #
+        def self.default_value_for_option(name, options)
+          default_for_option(Rails::Generators.options, name, options, options[:default])
+        end
+
+        # Return default aliases for the option name given doing a lookup in
+        # Rails::Generators.aliases.
+        #
+        def self.default_aliases_for_option(name, options)
+          default_for_option(Rails::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
+            Rails::Generators.find_by_namespace(value, *constants)
+          elsif klass = Rails::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
+
+        def self.usage_path
+          paths = [
+            source_root && File.expand_path("../USAGE", source_root),
+            default_generator_root && File.join(default_generator_root, "USAGE")
+          ]
+          paths.compact.detect { |path| File.exists? path }
+        end
+
+        def self.default_generator_root
+          path = File.expand_path(File.join(base_name, generator_name), base_root)
+          path if File.exists?(path)
+        end
+
+    end
+  end
+end

data/lib/rails/generators/css/assets/assets_generator.rb

@@ -0,0 +1,13 @@
+require "rails/generators/named_base"
+
+module Css
+  module Generators
+    class AssetsGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+
+      def copy_stylesheet
+        copy_file "stylesheet.css", File.join('app/assets/stylesheets', class_path, "#{file_name}.css")
+      end
+    end
+  end
+end

data/lib/rails/generators/css/assets/templates/stylesheet.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/lib/rails/generators/css/scaffold/scaffold_generator.rb

@@ -0,0 +1,16 @@
+require "rails/generators/named_base"
+
+module Css
+  module Generators
+    class ScaffoldGenerator < Rails::Generators::NamedBase
+      # In order to allow the Sass generators to pick up the default Rails CSS and
+      # transform it, we leave it in a standard location for the CSS stylesheet
+      # generators to handle. For the simple, default case, just copy it over.
+      def copy_stylesheet
+        dir = Rails::Generators::ScaffoldGenerator.source_root
+        file = File.join(dir, "scaffold.css")
+        create_file "app/assets/stylesheets/scaffold.css", File.read(file)
+      end
+    end
+  end
+end

data/lib/rails/generators/erb/controller/controller_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators/erb'
+
+module Erb
+  module Generators
+    class ControllerGenerator < Base
+      argument :actions, :type => :array, :default => [], :banner => "action action"
+
+      def copy_view_files
+        base_path = File.join("app/views", class_path, file_name)
+        empty_directory base_path
+
+        actions.each do |action|
+          @action = action
+          @path = File.join(base_path, filename_with_extensions(action))
+          template filename_with_extensions(:view), @path
+        end
+      end
+    end
+  end
+end

data/lib/rails/generators/erb/controller/templates/view.html.erb

@@ -0,0 +1,2 @@
+<h1><%= class_name %>#<%= @action %></h1>
+<p>Find me in <%= @path %></p>

data/lib/rails/generators/erb/mailer/mailer_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators/erb/controller/controller_generator'
+
+module Erb
+  module Generators
+    class MailerGenerator < ControllerGenerator
+      protected
+
+      def format
+        :text
+      end
+    end
+  end
+end

data/lib/rails/generators/erb/mailer/templates/view.text.erb

@@ -0,0 +1,3 @@
+<%= class_name %>#<%= @action %>
+
+<%%= @greeting %>, find me in app/views/<%= @path %>

data/lib/rails/generators/erb/scaffold/scaffold_generator.rb

@@ -0,0 +1,29 @@
+require 'rails/generators/erb'
+require 'rails/generators/resource_helpers'
+
+module Erb
+  module Generators
+    class ScaffoldGenerator < Base
+      include Rails::Generators::ResourceHelpers
+
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      def create_root_folder
+        empty_directory File.join("app/views", controller_file_path)
+      end
+
+      def copy_view_files
+        available_views.each do |view|
+          filename = filename_with_extensions(view)
+          template filename, File.join("app/views", controller_file_path, filename)
+        end
+      end
+
+    protected
+
+      def available_views
+        %w(index edit show new _form)
+      end
+    end
+  end
+end

data/lib/rails/generators/erb/scaffold/templates/_form.html.erb

@@ -0,0 +1,23 @@
+<%%= form_for(@<%= singular_table_name %>) do |f| %>
+  <%% if @<%= singular_table_name %>.errors.any? %>
+    <div id="error_explanation">
+      <h2><%%= pluralize(@<%= singular_table_name %>.errors.count, "error") %> prohibited this <%= singular_table_name %> from being saved:</h2>
+
+      <ul>
+      <%% @<%= singular_table_name %>.errors.full_messages.each do |msg| %>
+        <li><%%= msg %></li>
+      <%% end %>
+      </ul>
+    </div>
+  <%% end %>
+
+<% attributes.each do |attribute| -%>
+  <div class="field">
+    <%%= f.label :<%= attribute.name %> %><br />
+    <%%= f.<%= attribute.field_type %> :<%= attribute.name %> %>
+  </div>
+<% end -%>
+  <div class="actions">
+    <%%= f.submit %>
+  </div>
+<%% end %>

data/lib/rails/generators/erb/scaffold/templates/edit.html.erb

@@ -0,0 +1,6 @@
+<h1>Editing <%= singular_table_name %></h1>
+
+<%%= render 'form' %>
+
+<%%= link_to 'Show', @<%= singular_table_name %> %> |
+<%%= link_to 'Back', <%= index_helper %>_path %>

data/lib/rails/generators/erb/scaffold/templates/index.html.erb

@@ -0,0 +1,27 @@
+<h1>Listing <%= plural_table_name %></h1>
+
+<table>
+  <tr>
+<% attributes.each do |attribute| -%>
+    <th><%= attribute.human_name %></th>
+<% end -%>
+    <th></th>
+    <th></th>
+    <th></th>
+  </tr>
+
+<%% @<%= plural_table_name %>.each do |<%= singular_table_name %>| %>
+  <tr>
+<% attributes.each do |attribute| -%>
+    <td><%%= <%= singular_table_name %>.<%= attribute.name %> %></td>
+<% end -%>
+    <td><%%= link_to 'Show', <%= singular_table_name %> %></td>
+    <td><%%= link_to 'Edit', edit_<%= singular_table_name %>_path(<%= singular_table_name %>) %></td>
+    <td><%%= link_to 'Destroy', <%= singular_table_name %>, <%= key_value :method, ":delete" %>, <%= key_value :data, "{ #{key_value :confirm, "'Are you sure?'"} }" %> %></td>
+  </tr>
+<%% end %>
+</table>
+
+<br />
+
+<%%= link_to 'New <%= human_name %>', new_<%= singular_table_name %>_path %>

data/lib/rails/generators/erb/scaffold/templates/new.html.erb

@@ -0,0 +1,5 @@
+<h1>New <%= singular_table_name %></h1>
+
+<%%= render 'form' %>
+
+<%%= link_to 'Back', <%= index_helper %>_path %>

data/lib/rails/generators/erb/scaffold/templates/show.html.erb

@@ -0,0 +1,12 @@
+<p id="notice"><%%= notice %></p>
+
+<% attributes.each do |attribute| -%>
+<p>
+  <b><%= attribute.human_name %>:</b>
+  <%%= @<%= singular_table_name %>.<%= attribute.name %> %>
+</p>
+
+<% end -%>
+
+<%%= link_to 'Edit', edit_<%= singular_table_name %>_path(@<%= singular_table_name %>) %> |
+<%%= link_to 'Back', <%= index_helper %>_path %>

data/lib/rails/generators/erb.rb

@@ -0,0 +1,21 @@
+require 'rails/generators/named_base'
+
+module Erb
+  module Generators
+    class Base < Rails::Generators::NamedBase #:nodoc:
+      protected
+
+      def format
+        :html
+      end
+
+      def handler
+        :erb
+      end
+
+      def filename_with_extensions(name)
+        [name, format, handler].compact.join(".")
+      end
+    end
+  end
+end