openskies 0.0.5.2 → 0.0.6.0

data/lib/rails/generators/generated_attribute.rb

@@ -1,107 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,2 +0,0 @@
-// 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

@@ -1,68 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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.