view_mapper 0.3.0 → 0.3.1

data/test/rails_generator/scripts.rb

@@ -1,89 +0,0 @@
-require File.dirname(__FILE__) + '/options'
-
-module Rails
-  module Generator
-    module Scripts
-
-      # Generator scripts handle command-line invocation.  Each script
-      # responds to an invoke! class method which handles option parsing
-      # and generator invocation.
-      class Base
-        include Options
-        default_options :collision => :ask, :quiet => false
-
-        # Run the generator script.  Takes an array of unparsed arguments
-        # and a hash of parsed arguments, takes the generator as an option
-        # or first remaining argument, and invokes the requested command.
-        def run(args = [], runtime_options = {})
-          begin
-            parse!(args.dup, runtime_options)
-          rescue OptionParser::InvalidOption => e
-            # Don't cry, script. Generators want what you think is invalid.
-          end
-
-          # Generator name is the only required option.
-          unless options[:generator]
-            usage if args.empty?
-            options[:generator] ||= args.shift
-          end
-
-          # Look up generator instance and invoke command on it.
-          Rails::Generator::Base.instance(options[:generator], args, options).command(options[:command]).invoke!
-        rescue => e
-          puts e
-          puts "  #{e.backtrace.join("\n  ")}\n" if options[:backtrace]
-          raise SystemExit
-        end
-
-        protected
-          # Override with your own script usage banner.
-          def banner
-            "Usage: #{$0} generator [options] [args]"
-          end
-
-          def usage_message
-            usage = "\nInstalled Generators\n"
-            Rails::Generator::Base.sources.inject([]) do |mem, source|
-              # Using an association list instead of a hash to preserve order,
-              # for aesthetic reasons more than anything else.
-              label = source.label.to_s.capitalize
-              pair = mem.assoc(label)
-              mem << (pair = [label, []]) if pair.nil?
-              pair[1] |= source.names
-              mem
-            end.each do |label, names|
-              usage << "  #{label}: #{names.join(', ')}\n" unless names.empty?
-            end
-
-            usage << <<end_blurb
-
-More are available at http://wiki.rubyonrails.org/rails/pages/AvailableGenerators
-  1. Download, for example, login_generator.zip
-  2. Unzip to directory #{Dir.user_home}/.rails/generators/login
-     to use the generator with all your Rails apps
-end_blurb
-
-            if Object.const_defined?(:RAILS_ROOT)
-              usage << <<end_blurb
-     or to #{File.expand_path(RAILS_ROOT)}/lib/generators/login
-     to use with this app only.
-end_blurb
-            end
-
-            usage << <<end_blurb
-  3. Run generate with no arguments for usage information
-       #{$0} login
-
-Generator gems are also available:
-  1. gem search -r generator
-  2. gem install login_generator
-  3. #{$0} login
-
-end_blurb
-            return usage
-          end
-      end # Base
-
-    end
-  end
-end

data/test/rails_generator/secret_key_generator.rb

@@ -1,24 +0,0 @@
-require 'active_support/deprecation'
-
-module Rails
-  # A class for creating random secret keys. This class will do its best to create a
-  # random secret key that's as secure as possible, using whatever methods are
-  # available on the current platform. For example:
-  #
-  #   generator = Rails::SecretKeyGenerator("some unique identifier, such as the application name")
-  #   generator.generate_secret     # => "f3f1be90053fa851... (some long string)"
-  #
-  # This class is *deprecated* in Rails 2.2 in favor of ActiveSupport::SecureRandom.
-  # It is currently a wrapper around ActiveSupport::SecureRandom.
-  class SecretKeyGenerator
-    def initialize(identifier)
-    end
-
-    # Generate a random secret key with the best possible method available on
-    # the current platform.
-    def generate_secret
-      ActiveSupport::SecureRandom.hex(64)
-    end
-    deprecate :generate_secret=>"You should use ActiveSupport::SecureRandom.hex(64)"
-  end
-end

data/test/rails_generator/simple_logger.rb

@@ -1,46 +0,0 @@
-module Rails
-  module Generator
-    class SimpleLogger # :nodoc:
-      attr_reader :out
-      attr_accessor :quiet
-
-      def initialize(out = $stdout)
-        @out = out
-        @quiet = false
-        @level = 0
-      end
-
-      def log(status, message, &block)
-        @out.print("%12s  %s%s\n" % [status, '  ' * @level, message]) unless quiet
-        indent(&block) if block_given?
-      end
-
-      def indent(&block)
-        @level += 1
-        if block_given?
-          begin
-            block.call
-          ensure
-            outdent
-          end
-        end
-      end
-
-      def outdent
-        @level -= 1
-        if block_given?
-          begin
-            block.call
-          ensure
-            indent
-          end
-        end
-      end
-
-      private
-        def method_missing(method, *args, &block)
-          log(method.to_s, args.first, &block)
-        end
-    end
-  end
-end

data/test/rails_generator/spec.rb

@@ -1,44 +0,0 @@
-module Rails
-  module Generator
-    # A spec knows where a generator was found and how to instantiate it.
-    # Metadata include the generator's name, its base path, and the source
-    # which yielded it (PathSource, GemPathSource, etc.)
-    class Spec
-      attr_reader :name, :path, :source
-
-      def initialize(name, path, source)
-        @name, @path, @source = name, path, source
-      end
-
-      # Look up the generator class.  Require its class file, find the class
-      # in ObjectSpace, tag it with this spec, and return.
-      def klass
-        unless @klass
-          require class_file
-          @klass = lookup_class
-          @klass.spec = self
-        end
-        @klass
-      end
-
-      def class_file
-        "#{path}/#{name}_generator.rb"
-      end
-
-      def class_name
-        "#{name.camelize}Generator"
-      end
-
-      private
-        # Search for the first Class descending from Rails::Generator::Base
-        # whose name matches the requested class name.
-        def lookup_class
-          ObjectSpace.each_object(Class) do |obj|
-            return obj if obj.ancestors.include?(Rails::Generator::Base) and
-                          obj.name.split('::').last == class_name
-          end
-          raise NameError, "Missing #{class_name} class in #{class_file}"
-        end
-    end
-  end
-end