openskies 0.0.1

data/lib/rails/generators/generated_attribute.rb

@@ -0,0 +1,107 @@
+require 'active_support/time'
+require 'active_support/core_ext/object/inclusion'
+require 'active_support/core_ext/object/blank'
+
+module Rails
+  module Generators
+    class GeneratedAttribute
+      attr_accessor :name, :type
+      attr_reader   :attr_options
+
+      class << self
+        def parse(column_definition)
+          name, type, has_index = column_definition.split(':')
+
+          # if user provided "name:index" instead of "name:string:index"
+          # type should be set blank so GeneratedAttribute's constructor
+          # could set it to :string
+          has_index, type = type, nil if %w(index uniq).include?(type)
+
+          type, attr_options = *parse_type_and_options(type)
+          new(name, type, has_index, attr_options)
+        end
+
+        private
+
+        # parse possible attribute options like :limit for string/text/binary/integer or :precision/:scale for decimals
+        # when declaring options curly brackets should be used
+        def parse_type_and_options(type)
+          case type
+          when /(string|text|binary|integer)\{(\d+)\}/
+            return $1, :limit => $2.to_i
+          when /decimal\{(\d+)(,|\.|\-)(\d+)\}/
+            return :decimal, :precision => $1.to_i, :scale => $3.to_i
+          else
+            return type, {}
+          end
+        end
+      end
+
+      def initialize(name, type=nil, index_type=false, attr_options={})
+        @name           = name
+        @type           = (type.presence || :string).to_sym
+        @has_index      = %w(index uniq).include?(index_type)
+        @has_uniq_index = %w(uniq).include?(index_type)
+        @attr_options   = attr_options
+      end
+
+      def field_type
+        @field_type ||= case type
+          when :integer              then :number_field
+          when :float, :decimal      then :text_field
+          when :time                 then :time_select
+          when :datetime, :timestamp then :datetime_select
+          when :date                 then :date_select
+          when :text                 then :text_area
+          when :boolean              then :check_box
+          else
+            :text_field
+        end
+      end
+
+      def default
+        @default ||= case type
+          when :integer                     then 1
+          when :float                       then 1.5
+          when :decimal                     then "9.99"
+          when :datetime, :timestamp, :time then Time.now.to_s(:db)
+          when :date                        then Date.today.to_s(:db)
+          when :string                      then name == "type" ? "" : "MyString"
+          when :text                        then "MyText"
+          when :boolean                     then false
+          when :references, :belongs_to     then nil
+          else
+            ""
+        end
+      end
+
+      def human_name
+        name.to_s.humanize
+      end
+
+      def index_name
+        reference? ? "#{name}_id" : name
+      end
+
+      def reference?
+        self.type.in?([:references, :belongs_to])
+      end
+
+      def has_index?
+        @has_index
+      end
+
+      def has_uniq_index?
+        @has_uniq_index
+      end
+
+      def inject_options
+        "".tap { |s| @attr_options.each { |k,v| s << ", :#{k} => #{v.inspect}" } }
+      end
+
+      def inject_index_options
+        has_uniq_index? ? ", :unique => true" : ''
+      end
+    end
+  end
+end

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

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

data/lib/rails/generators/js/assets/templates/javascript.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/lib/rails/generators/migration.rb

@@ -0,0 +1,68 @@
+module Rails
+  module Generators
+    # Holds common methods for migrations. It assumes that migrations has the
+    # [0-9]*_name format and can be used by another frameworks (like Sequel)
+    # just by implementing the next migration version method.
+    #
+    module Migration
+      attr_reader :migration_number, :migration_file_name, :migration_class_name
+
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def migration_lookup_at(dirname) #:nodoc:
+          Dir.glob("#{dirname}/[0-9]*_*.rb")
+        end
+
+        def migration_exists?(dirname, file_name) #:nodoc:
+          migration_lookup_at(dirname).grep(/\d+_#{file_name}.rb$/).first
+        end
+
+        def current_migration_number(dirname) #:nodoc:
+          migration_lookup_at(dirname).collect do |file|
+            File.basename(file).split("_").first.to_i
+          end.max.to_i
+        end
+
+        def next_migration_number(dirname) #:nodoc:
+          raise NotImplementedError
+        end
+      end
+
+      # Creates a migration template at the given destination. The difference
+      # to the default template method is that the migration version is appended
+      # to the destination file name.
+      #
+      # The migration version, migration file name, migration class name are
+      # available as instance variables in the template to be rendered.
+      #
+      # ==== Examples
+      #
+      #   migration_template "migration.rb", "db/migrate/add_foo_to_bar.rb"
+      #
+      def migration_template(source, destination=nil, config={})
+        destination = File.expand_path(destination || source, self.destination_root)
+
+        migration_dir = File.dirname(destination)
+        @migration_number     = self.class.next_migration_number(migration_dir)
+        @migration_file_name  = File.basename(destination).sub(/\.rb$/, '')
+        @migration_class_name = @migration_file_name.camelize
+
+        destination = self.class.migration_exists?(migration_dir, @migration_file_name)
+
+        if !(destination && options[:skip]) && behavior == :invoke
+          if destination && options.force?
+            remove_file(destination)
+          elsif destination
+            raise Error, "Another migration is already named #{@migration_file_name}: #{destination}"
+          end
+          destination = File.join(migration_dir, "#{@migration_number}_#{@migration_file_name}.rb")
+        end
+
+        template(source, destination, config)
+      end
+    end
+  end
+end

data/lib/rails/generators/named_base.rb

@@ -0,0 +1,202 @@
+require 'active_support/core_ext/module/introspection'
+require 'rails/generators/base'
+require 'rails/generators/generated_attribute'
+
+module Rails
+  module Generators
+    class NamedBase < Base
+      argument :name, :type => :string
+      class_option :skip_namespace, :type => :boolean, :default => false,
+                                    :desc => "Skip namespace (affects only isolated applications)"
+
+      class_option :old_style_hash, :type => :boolean, :default => false,
+                                    :desc => "Force using old style hash (:foo => 'bar') on Ruby >= 1.9"
+
+      def initialize(args, *options) #:nodoc:
+        @inside_template = nil
+        # Unfreeze name in case it's given as a frozen string
+        args[0] = args[0].dup if args[0].is_a?(String) && args[0].frozen?
+        super
+        assign_names!(self.name)
+        parse_attributes! if respond_to?(:attributes)
+      end
+
+      no_tasks do
+        def template(source, *args, &block)
+          inside_template do
+            super
+          end
+        end
+      end
+
+      protected
+        attr_reader :file_name
+        alias :singular_name :file_name
+
+        # Wrap block with namespace of current application
+        # if namespace exists and is not skipped
+        def module_namespacing(&block)
+          content = capture(&block)
+          content = wrap_with_namespace(content) if namespaced?
+          concat(content)
+        end
+
+        def indent(content, multiplier = 2)
+          spaces = " " * multiplier
+          content = content.each_line.map {|line| "#{spaces}#{line}" }.join
+        end
+
+        def wrap_with_namespace(content)
+          content = indent(content).chomp
+          "module #{namespace.name}\n#{content}\nend\n"
+        end
+
+        def inside_template
+          @inside_template = true
+          yield
+        ensure
+          @inside_template = false
+        end
+
+        def inside_template?
+          @inside_template
+        end
+
+        def namespace
+          Rails::Generators.namespace
+        end
+
+        def namespaced?
+          !options[:skip_namespace] && namespace
+        end
+
+        def file_path
+          @file_path ||= (class_path + [file_name]).join('/')
+        end
+
+        def class_path
+          inside_template? || !namespaced? ? regular_class_path : namespaced_class_path
+        end
+
+        def regular_class_path
+          @class_path
+        end
+
+        def namespaced_file_path
+          @namespaced_file_path ||= namespaced_class_path.join("/")
+        end
+
+        def namespaced_class_path
+          @namespaced_class_path ||= begin
+            namespace_path = namespace.name.split("::").map {|m| m.underscore }
+            namespace_path + @class_path
+          end
+        end
+
+        def class_name
+          (class_path + [file_name]).map!{ |m| m.camelize }.join('::')
+        end
+
+        def human_name
+          @human_name ||= singular_name.humanize
+        end
+
+        def plural_name
+          @plural_name ||= singular_name.pluralize
+        end
+
+        def i18n_scope
+          @i18n_scope ||= file_path.gsub('/', '.')
+        end
+
+        def table_name
+          @table_name ||= begin
+            base = pluralize_table_names? ? plural_name : singular_name
+            (class_path + [base]).join('_')
+          end
+        end
+
+        def uncountable?
+          singular_name == plural_name
+        end
+
+        def index_helper
+          uncountable? ? "#{plural_table_name}_index" : plural_table_name
+        end
+
+        def singular_table_name
+          @singular_table_name ||= (pluralize_table_names? ? table_name.singularize : table_name)
+        end
+
+        def plural_table_name
+          @plural_table_name ||= (pluralize_table_names? ? table_name : table_name.pluralize)
+        end
+
+        def plural_file_name
+          @plural_file_name ||= file_name.pluralize
+        end
+
+        def route_url
+          @route_url ||= class_path.collect{|dname| "/" + dname  }.join('') + "/" + plural_file_name
+        end
+
+        # Tries to retrieve the application name or simple return application.
+        def application_name
+          if defined?(Rails) && Rails.application
+            Rails.application.class.name.split('::').first.underscore
+          else
+            "application"
+          end
+        end
+
+        def assign_names!(name) #:nodoc:
+          @class_path = name.include?('/') ? name.split('/') : name.split('::')
+          @class_path.map! { |m| m.underscore }
+          @file_name = @class_path.pop
+        end
+
+        # Convert attributes array into GeneratedAttribute objects.
+        def parse_attributes! #:nodoc:
+          self.attributes = (attributes || []).map do |attr|
+            Rails::Generators::GeneratedAttribute.parse(attr)
+          end
+        end
+
+        def pluralize_table_names?
+          !defined?(ActiveRecord::Base) || ActiveRecord::Base.pluralize_table_names
+        end
+
+        # Add a class collisions name to be checked on class initialization. You
+        # can supply a hash with a :prefix or :suffix to be tested.
+        #
+        # ==== Examples
+        #
+        #   check_class_collision :suffix => "Observer"
+        #
+        # If the generator is invoked with class name Admin, it will check for
+        # the presence of "AdminObserver".
+        #
+        def self.check_class_collision(options={})
+          define_method :check_class_collision do
+            name = if self.respond_to?(:controller_class_name) # for ScaffoldBase
+              controller_class_name
+            else
+              class_name
+            end
+
+            class_collisions "#{options[:prefix]}#{name}#{options[:suffix]}"
+          end
+        end
+
+        # Returns Ruby 1.9 style key-value pair if current code is running on
+        # Ruby 1.9.x. Returns the old-style (with hash rocket) otherwise.
+        def key_value(key, value)
+          if options[:old_style_hash] || RUBY_VERSION < '1.9'
+            ":#{key} => #{value}"
+          else
+            "#{key}: #{value}"
+          end
+        end
+    end
+  end
+end

data/lib/rails/generators/rails/app/USAGE

@@ -0,0 +1,15 @@
+Description:
+    The 'rails new' command creates a new Rails application with a default
+    directory structure and configuration at the path you specify.
+
+    You can specify extra command-line arguments to be used every time
+    'rails new' runs in the .railsrc configuration file in your home directory.
+
+    Note that the arguments specified in the .railsrc file don't affect the
+    defaults values shown above in this help message.
+
+Example:
+    rails new ~/Code/Ruby/weblog
+
+    This generates a skeletal Rails installation in ~/Code/Ruby/weblog.
+    See the README in the newly created application to get going.