nanumfont-rails 0.0.2 → 0.1

data/vendor/bundle/ruby/2.1.0/gems/actionpack-4.1.6/lib/action_dispatch/routing/routes_proxy.rb

@@ -0,0 +1,41 @@
+require 'active_support/core_ext/array/extract_options'
+
+module ActionDispatch
+  module Routing
+    class RoutesProxy #:nodoc:
+      include ActionDispatch::Routing::UrlFor
+
+      attr_accessor :scope, :routes
+      alias :_routes :routes
+
+      def initialize(routes, scope)
+        @routes, @scope = routes, scope
+      end
+
+      def url_options
+        scope.send(:_with_routes, routes) do
+          scope.url_options
+        end
+      end
+
+      def respond_to?(method, include_private = false)
+        super || routes.url_helpers.respond_to?(method)
+      end
+
+      def method_missing(method, *args)
+        if routes.url_helpers.respond_to?(method)
+          self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args)
+              options = args.extract_options!
+              args << url_options.merge((options || {}).symbolize_keys)
+              routes.url_helpers.#{method}(*args)
+            end
+          RUBY
+          send(method, *args)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/actionpack-4.1.6/lib/action_dispatch/routing/url_for.rb

@@ -0,0 +1,184 @@
+module ActionDispatch
+  module Routing
+    # In <tt>config/routes.rb</tt> you define URL-to-controller mappings, but the reverse
+    # is also possible: an URL can be generated from one of your routing definitions.
+    # URL generation functionality is centralized in this module.
+    #
+    # See ActionDispatch::Routing for general information about routing and routes.rb.
+    #
+    # <b>Tip:</b> If you need to generate URLs from your models or some other place,
+    # then ActionController::UrlFor is what you're looking for. Read on for
+    # an introduction. In general, this module should not be included on its own,
+    # as it is usually included by url_helpers (as in Rails.application.routes.url_helpers).
+    #
+    # == URL generation from parameters
+    #
+    # As you may know, some functions, such as ActionController::Base#url_for
+    # and ActionView::Helpers::UrlHelper#link_to, can generate URLs given a set
+    # of parameters. For example, you've probably had the chance to write code
+    # like this in one of your views:
+    #
+    #   <%= link_to('Click here', controller: 'users',
+    #           action: 'new', message: 'Welcome!') %>
+    #   # => <a href="/users/new?message=Welcome%21">Click here</a>
+    #
+    # link_to, and all other functions that require URL generation functionality,
+    # actually use ActionController::UrlFor under the hood. And in particular,
+    # they use the ActionController::UrlFor#url_for method. One can generate
+    # the same path as the above example by using the following code:
+    #
+    #   include UrlFor
+    #   url_for(controller: 'users',
+    #           action: 'new',
+    #           message: 'Welcome!',
+    #           only_path: true)
+    #   # => "/users/new?message=Welcome%21"
+    #
+    # Notice the <tt>only_path: true</tt> part. This is because UrlFor has no
+    # information about the website hostname that your Rails app is serving. So if you
+    # want to include the hostname as well, then you must also pass the <tt>:host</tt>
+    # argument:
+    #
+    #   include UrlFor
+    #   url_for(controller: 'users',
+    #           action: 'new',
+    #           message: 'Welcome!',
+    #           host: 'www.example.com')
+    #   # => "http://www.example.com/users/new?message=Welcome%21"
+    #
+    # By default, all controllers and views have access to a special version of url_for,
+    # that already knows what the current hostname is. So if you use url_for in your
+    # controllers or your views, then you don't need to explicitly pass the <tt>:host</tt>
+    # argument.
+    #
+    # For convenience reasons, mailers provide a shortcut for ActionController::UrlFor#url_for.
+    # So within mailers, you only have to type 'url_for' instead of 'ActionController::UrlFor#url_for'
+    # in full. However, mailers don't have hostname information, and that's why you'll still
+    # have to specify the <tt>:host</tt> argument when generating URLs in mailers.
+    #
+    #
+    # == URL generation for named routes
+    #
+    # UrlFor also allows one to access methods that have been auto-generated from
+    # named routes. For example, suppose that you have a 'users' resource in your
+    # <tt>config/routes.rb</tt>:
+    #
+    #   resources :users
+    #
+    # This generates, among other things, the method <tt>users_path</tt>. By default,
+    # this method is accessible from your controllers, views and mailers. If you need
+    # to access this auto-generated method from other places (such as a model), then
+    # you can do that by including Rails.application.routes.url_helpers in your class:
+    #
+    #   class User < ActiveRecord::Base
+    #     include Rails.application.routes.url_helpers
+    #
+    #     def base_uri
+    #       user_path(self)
+    #     end
+    #   end
+    #
+    #   User.find(1).base_uri # => "/users/1"
+    #
+    module UrlFor
+      extend ActiveSupport::Concern
+      include PolymorphicRoutes
+
+      included do
+        unless method_defined?(:default_url_options)
+          # Including in a class uses an inheritable hash. Modules get a plain hash.
+          if respond_to?(:class_attribute)
+            class_attribute :default_url_options
+          else
+            mattr_writer :default_url_options
+          end
+
+          self.default_url_options = {}
+        end
+
+        include(*_url_for_modules) if respond_to?(:_url_for_modules)
+      end
+
+      def initialize(*)
+        @_routes = nil
+        super
+      end
+
+      # Hook overridden in controller to add request information
+      # with `default_url_options`. Application logic should not
+      # go into url_options.
+      def url_options
+        default_url_options
+      end
+
+      # Generate a url based on the options provided, default_url_options and the
+      # routes defined in routes.rb. The following options are supported:
+      #
+      # * <tt>:only_path</tt> - If true, the relative url is returned. Defaults to +false+.
+      # * <tt>:protocol</tt> - The protocol to connect to. Defaults to 'http'.
+      # * <tt>:host</tt> - Specifies the host the link should be targeted at.
+      #   If <tt>:only_path</tt> is false, this option must be
+      #   provided either explicitly, or via +default_url_options+.
+      # * <tt>:subdomain</tt> - Specifies the subdomain of the link, using the +tld_length+
+      #   to split the subdomain from the host.
+      #   If false, removes all subdomains from the host part of the link.
+      # * <tt>:domain</tt> - Specifies the domain of the link, using the +tld_length+
+      #   to split the domain from the host.
+      # * <tt>:tld_length</tt> - Number of labels the TLD id composed of, only used if
+      #   <tt>:subdomain</tt> or <tt>:domain</tt> are supplied. Defaults to
+      #   <tt>ActionDispatch::Http::URL.tld_length</tt>, which in turn defaults to 1.
+      # * <tt>:port</tt> - Optionally specify the port to connect to.
+      # * <tt>:anchor</tt> - An anchor name to be appended to the path.
+      # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2009/"
+      # * <tt>:script_name</tt> - Specifies application path relative to domain root. If provided, prepends application path.
+      #
+      # Any other key (<tt>:controller</tt>, <tt>:action</tt>, etc.) given to
+      # +url_for+ is forwarded to the Routes module.
+      #
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', port: '8080'
+      #    # => 'http://somehost.org:8080/tasks/testing'
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', anchor: 'ok', only_path: true
+      #    # => '/tasks/testing#ok'
+      #    url_for controller: 'tasks', action: 'testing', trailing_slash: true
+      #    # => 'http://somehost.org/tasks/testing/'
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', number: '33'
+      #    # => 'http://somehost.org/tasks/testing?number=33'
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', script_name: "/myapp"
+      #    # => 'http://somehost.org/myapp/tasks/testing'
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', script_name: "/myapp", only_path: true
+      #    # => '/myapp/tasks/testing'
+      def url_for(options = nil)
+        case options
+        when nil
+          _routes.url_for(url_options.symbolize_keys)
+        when Hash
+          _routes.url_for(options.symbolize_keys.reverse_merge!(url_options))
+        when String
+          options
+        when Array
+          polymorphic_url(options, options.extract_options!)
+        else
+          polymorphic_url(options)
+        end
+      end
+
+      protected
+
+      def optimize_routes_generation?
+        return @_optimized_routes if defined?(@_optimized_routes)
+        @_optimized_routes = _routes.optimize_routes_generation? && default_url_options.empty?
+      end
+
+      def _with_routes(routes)
+        old_routes, @_routes = @_routes, routes
+        yield
+      ensure
+        @_routes = old_routes
+      end
+
+      def _routes_context
+        self
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/actionpack-4.1.6/lib/action_dispatch/testing/assertions.rb

@@ -0,0 +1,18 @@
+module ActionDispatch
+  module Assertions
+    autoload :DomAssertions, 'action_dispatch/testing/assertions/dom'
+    autoload :ResponseAssertions, 'action_dispatch/testing/assertions/response'
+    autoload :RoutingAssertions, 'action_dispatch/testing/assertions/routing'
+    autoload :SelectorAssertions, 'action_dispatch/testing/assertions/selector'
+    autoload :TagAssertions, 'action_dispatch/testing/assertions/tag'
+
+    extend ActiveSupport::Concern
+
+    include DomAssertions
+    include ResponseAssertions
+    include RoutingAssertions
+    include SelectorAssertions
+    include TagAssertions
+  end
+end
+

data/vendor/bundle/ruby/2.1.0/gems/actionpack-4.1.6/lib/action_dispatch/testing/assertions/dom.rb

@@ -0,0 +1,27 @@
+require 'action_view/vendor/html-scanner'
+
+module ActionDispatch
+  module Assertions
+    module DomAssertions
+      # \Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
+      #
+      #   # assert that the referenced method generates the appropriate HTML string
+      #   assert_dom_equal '<a href="http://www.example.com">Apples</a>', link_to("Apples", "http://www.example.com")
+      def assert_dom_equal(expected, actual, message = nil)
+        expected_dom = HTML::Document.new(expected).root
+        actual_dom   = HTML::Document.new(actual).root
+        assert_equal expected_dom, actual_dom, message
+      end
+
+      # The negated form of +assert_dom_equivalent+.
+      #
+      #   # assert that the referenced method does not generate the specified HTML string
+      #   assert_dom_not_equal '<a href="http://www.example.com">Apples</a>', link_to("Oranges", "http://www.example.com")
+      def assert_dom_not_equal(expected, actual, message = nil)
+        expected_dom = HTML::Document.new(expected).root
+        actual_dom   = HTML::Document.new(actual).root
+        assert_not_equal expected_dom, actual_dom, message
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/actionpack-4.1.6/lib/action_dispatch/testing/assertions/response.rb

@@ -0,0 +1,87 @@
+
+module ActionDispatch
+  module Assertions
+    # A small suite of assertions that test responses from \Rails applications.
+    module ResponseAssertions
+      # Asserts that the response is one of the following types:
+      #
+      # * <tt>:success</tt>   - Status code was in the 200-299 range
+      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
+      # * <tt>:missing</tt>   - Status code was 404
+      # * <tt>:error</tt>     - Status code was in the 500-599 range
+      #
+      # You can also pass an explicit status number like <tt>assert_response(501)</tt>
+      # or its symbolic equivalent <tt>assert_response(:not_implemented)</tt>.
+      # See Rack::Utils::SYMBOL_TO_STATUS_CODE for a full list.
+      #
+      #   # assert that the response was a redirection
+      #   assert_response :redirect
+      #
+      #   # assert that the response code was status code 401 (unauthorized)
+      #   assert_response 401
+      def assert_response(type, message = nil)
+        message ||= "Expected response to be a <#{type}>, but was <#{@response.response_code}>"
+
+        if Symbol === type
+          if [:success, :missing, :redirect, :error].include?(type)
+            assert @response.send("#{type}?"), message
+          else
+            code = Rack::Utils::SYMBOL_TO_STATUS_CODE[type]
+            if code.nil?
+              raise ArgumentError, "Invalid response type :#{type}"
+            end
+            assert_equal code, @response.response_code, message
+          end
+        else
+          assert_equal type, @response.response_code, message
+        end
+      end
+
+      # Assert that the redirection options passed in match those of the redirect called in the latest action.
+      # This match can be partial, such that <tt>assert_redirected_to(controller: "weblog")</tt> will also
+      # match the redirection of <tt>redirect_to(controller: "weblog", action: "show")</tt> and so on.
+      #
+      #   # assert that the redirection was to the "index" action on the WeblogController
+      #   assert_redirected_to controller: "weblog", action: "index"
+      #
+      #   # assert that the redirection was to the named route login_url
+      #   assert_redirected_to login_url
+      #
+      #   # assert that the redirection was to the url for @customer
+      #   assert_redirected_to @customer
+      #
+      #   # asserts that the redirection matches the regular expression
+      #   assert_redirected_to %r(\Ahttp://example.org)
+      def assert_redirected_to(options = {}, message=nil)
+        assert_response(:redirect, message)
+        return true if options === @response.location
+
+        redirect_is       = normalize_argument_to_redirection(@response.location)
+        redirect_expected = normalize_argument_to_redirection(options)
+
+        message ||= "Expected response to be a redirect to <#{redirect_expected}> but was a redirect to <#{redirect_is}>"
+        assert_operator redirect_expected, :===, redirect_is, message
+      end
+
+      private
+        # Proxy to to_param if the object will respond to it.
+        def parameterize(value)
+          value.respond_to?(:to_param) ? value.to_param : value
+        end
+
+        def normalize_argument_to_redirection(fragment)
+          if Regexp === fragment
+            fragment
+          else
+            handle = @controller || Class.new(ActionController::Metal) do
+              include ActionController::Redirecting
+              def initialize(request)
+                @_request = request
+              end
+            end.new(@request)
+            handle._compute_redirect_to_location(fragment)
+          end
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/actionpack-4.1.6/lib/action_dispatch/testing/assertions/routing.rb

@@ -0,0 +1,218 @@
+require 'uri'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/access'
+require 'action_controller/metal/exceptions'
+
+module ActionDispatch
+  module Assertions
+    # Suite of assertions to test routes generated by \Rails and the handling of requests made to them.
+    module RoutingAssertions
+      # Asserts that the routing of the given +path+ was handled correctly and that the parsed options (given in the +expected_options+ hash)
+      # match +path+. Basically, it asserts that \Rails recognizes the route given by +expected_options+.
+      #
+      # Pass a hash in the second argument (+path+) to specify the request method. This is useful for routes
+      # requiring a specific HTTP method. The hash should contain a :path with the incoming request path
+      # and a :method containing the required HTTP verb.
+      #
+      #   # assert that POSTing to /items will call the create action on ItemsController
+      #   assert_recognizes({controller: 'items', action: 'create'}, {path: 'items', method: :post})
+      #
+      # You can also pass in +extras+ with a hash containing URL parameters that would normally be in the query string. This can be used
+      # to assert that values in the query string string will end up in the params hash correctly. To test query strings you must use the
+      # extras argument, appending the query string on the path directly will not work. For example:
+      #
+      #   # assert that a path of '/items/list/1?view=print' returns the correct options
+      #   assert_recognizes({controller: 'items', action: 'list', id: '1', view: 'print'}, 'items/list/1', { view: "print" })
+      #
+      # The +message+ parameter allows you to pass in an error message that is displayed upon failure.
+      #
+      #   # Check the default route (i.e., the index action)
+      #   assert_recognizes({controller: 'items', action: 'index'}, 'items')
+      #
+      #   # Test a specific action
+      #   assert_recognizes({controller: 'items', action: 'list'}, 'items/list')
+      #
+      #   # Test an action with a parameter
+      #   assert_recognizes({controller: 'items', action: 'destroy', id: '1'}, 'items/destroy/1')
+      #
+      #   # Test a custom route
+      #   assert_recognizes({controller: 'items', action: 'show', id: '1'}, 'view/item1')
+      def assert_recognizes(expected_options, path, extras={}, msg=nil)
+        request = recognized_request_for(path, extras)
+
+        expected_options = expected_options.clone
+
+        expected_options.stringify_keys!
+
+        msg = message(msg, "") {
+          sprintf("The recognized options <%s> did not match <%s>, difference:",
+                  request.path_parameters, expected_options)
+        }
+
+        assert_equal(expected_options, request.path_parameters, msg)
+      end
+
+      # Asserts that the provided options can be used to generate the provided path. This is the inverse of +assert_recognizes+.
+      # The +extras+ parameter is used to tell the request the names and values of additional request parameters that would be in
+      # a query string. The +message+ parameter allows you to specify a custom error message for assertion failures.
+      #
+      # The +defaults+ parameter is unused.
+      #
+      #   # Asserts that the default action is generated for a route with no action
+      #   assert_generates "/items", controller: "items", action: "index"
+      #
+      #   # Tests that the list action is properly routed
+      #   assert_generates "/items/list", controller: "items", action: "list"
+      #
+      #   # Tests the generation of a route with a parameter
+      #   assert_generates "/items/list/1", { controller: "items", action: "list", id: "1" }
+      #
+      #   # Asserts that the generated route gives us our custom route
+      #   assert_generates "changesets/12", { controller: 'scm', action: 'show_diff', revision: "12" }
+      def assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)
+        if expected_path =~ %r{://}
+          fail_on(URI::InvalidURIError) do
+            uri = URI.parse(expected_path)
+            expected_path = uri.path.to_s.empty? ? "/" : uri.path
+          end
+        else
+          expected_path = "/#{expected_path}" unless expected_path.first == '/'
+        end
+        # Load routes.rb if it hasn't been loaded.
+
+        generated_path, extra_keys = @routes.generate_extras(options, defaults)
+        found_extras = options.reject { |k, _| ! extra_keys.include? k }
+
+        msg = message || sprintf("found extras <%s>, not <%s>", found_extras, extras)
+        assert_equal(extras, found_extras, msg)
+
+        msg = message || sprintf("The generated path <%s> did not match <%s>", generated_path,
+            expected_path)
+        assert_equal(expected_path, generated_path, msg)
+      end
+
+      # Asserts that path and options match both ways; in other words, it verifies that <tt>path</tt> generates
+      # <tt>options</tt> and then that <tt>options</tt> generates <tt>path</tt>. This essentially combines +assert_recognizes+
+      # and +assert_generates+ into one step.
+      #
+      # The +extras+ hash allows you to specify options that would normally be provided as a query string to the action. The
+      # +message+ parameter allows you to specify a custom error message to display upon failure.
+      #
+      #  # Assert a basic route: a controller with the default action (index)
+      #  assert_routing '/home', controller: 'home', action: 'index'
+      #
+      #  # Test a route generated with a specific controller, action, and parameter (id)
+      #  assert_routing '/entries/show/23', controller: 'entries', action: 'show', id: 23
+      #
+      #  # Assert a basic route (controller + default action), with an error message if it fails
+      #  assert_routing '/store', { controller: 'store', action: 'index' }, {}, {}, 'Route for store index not generated properly'
+      #
+      #  # Tests a route, providing a defaults hash
+      #  assert_routing 'controller/action/9', {id: "9", item: "square"}, {controller: "controller", action: "action"}, {}, {item: "square"}
+      #
+      #  # Tests a route with a HTTP method
+      #  assert_routing({ method: 'put', path: '/product/321' }, { controller: "product", action: "update", id: "321" })
+      def assert_routing(path, options, defaults={}, extras={}, message=nil)
+        assert_recognizes(options, path, extras, message)
+
+        controller, default_controller = options[:controller], defaults[:controller]
+        if controller && controller.include?(?/) && default_controller && default_controller.include?(?/)
+          options[:controller] = "/#{controller}"
+        end
+
+        generate_options = options.dup.delete_if{ |k, _| defaults.key?(k) }
+        assert_generates(path.is_a?(Hash) ? path[:path] : path, generate_options, defaults, extras, message)
+      end
+
+      # A helper to make it easier to test different route configurations.
+      # This method temporarily replaces @routes
+      # with a new RouteSet instance.
+      #
+      # The new instance is yielded to the passed block. Typically the block
+      # will create some routes using <tt>set.draw { match ... }</tt>:
+      #
+      #   with_routing do |set|
+      #     set.draw do
+      #       resources :users
+      #     end
+      #     assert_equal "/users", users_path
+      #   end
+      #
+      def with_routing
+        old_routes, @routes = @routes, ActionDispatch::Routing::RouteSet.new
+        if defined?(@controller) && @controller
+          old_controller, @controller = @controller, @controller.clone
+          _routes = @routes
+
+          # Unfortunately, there is currently an abstraction leak between AC::Base
+          # and AV::Base which requires having the URL helpers in both AC and AV.
+          # To do this safely at runtime for tests, we need to bump up the helper serial
+          # to that the old AV subclass isn't cached.
+          #
+          # TODO: Make this unnecessary
+          @controller.singleton_class.send(:include, _routes.url_helpers)
+          @controller.view_context_class = Class.new(@controller.view_context_class) do
+            include _routes.url_helpers
+          end
+        end
+        yield @routes
+      ensure
+        @routes = old_routes
+        if defined?(@controller) && @controller
+          @controller = old_controller
+        end
+      end
+
+      # ROUTES TODO: These assertions should really work in an integration context
+      def method_missing(selector, *args, &block)
+        if defined?(@controller) && @controller && @routes && @routes.named_routes.helpers.include?(selector)
+          @controller.send(selector, *args, &block)
+        else
+          super
+        end
+      end
+
+      private
+        # Recognizes the route for a given path.
+        def recognized_request_for(path, extras = {})
+          if path.is_a?(Hash)
+            method = path[:method]
+            path   = path[:path]
+          else
+            method = :get
+          end
+
+          # Assume given controller
+          request = ActionController::TestRequest.new
+
+          if path =~ %r{://}
+            fail_on(URI::InvalidURIError) do
+              uri = URI.parse(path)
+              request.env["rack.url_scheme"] = uri.scheme || "http"
+              request.host = uri.host if uri.host
+              request.port = uri.port if uri.port
+              request.path = uri.path.to_s.empty? ? "/" : uri.path
+            end
+          else
+            path = "/#{path}" unless path.first == "/"
+            request.path = path
+          end
+
+          request.request_method = method if method
+
+          params = fail_on(ActionController::RoutingError) do
+            @routes.recognize_path(path, { :method => method, :extras => extras })
+          end
+          request.path_parameters = params.with_indifferent_access
+
+          request
+        end
+
+        def fail_on(exception_class)
+          yield
+        rescue exception_class => e
+          raise Minitest::Assertion, e.message
+        end
+    end
+  end
+end