climine 0.0.7 → 0.0.8

data/vendor/bundle/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/code_objects/namespace_object.rb

@@ -1,200 +0,0 @@
-module YARD::CodeObjects
-  # A "namespace" is any object that can store other objects within itself.
-  # The two main Ruby objects that can act as namespaces are modules
-  # ({ModuleObject}) and classes ({ClassObject}).
-  class NamespaceObject < Base
-    attr_writer :constants, :cvars, :mixins, :child, :meths
-    attr_writer :class_attributes, :instance_attributes
-    attr_writer :included_constants, :included_meths
-
-    # @return [Array<String>] a list of ordered group names inside the namespace
-    # @since 0.6.0
-    attr_accessor :groups
-
-    # The list of objects defined in this namespace
-    # @return [Array<Base>] a list of objects
-    attr_reader :children
-
-    # A hash containing two keys, class and instance, each containing
-    # the attribute name with a { :read, :write } hash for the read and
-    # write objects respectively.
-    #
-    # @example The attributes of an object
-    #   >> Registry.at('YARD::Docstring').attributes
-    #   => {
-    #         :class => { },
-    #         :instance => {
-    #           :ref_tags => {
-    #             :read => #<yardoc method YARD::Docstring#ref_tags>,
-    #             :write => nil
-    #           },
-    #           :object => {
-    #             :read => #<yardoc method YARD::Docstring#object>,
-    #             :write => #<yardoc method YARD::Docstring#object=>
-    #            },
-    #            ...
-    #         }
-    #       }
-    # @return [Hash] a list of methods
-    attr_reader :attributes
-
-    # A hash containing two keys, :class and :instance, each containing
-    # a hash of objects and their alias names.
-    # @return [Hash] a list of methods
-    attr_reader :aliases
-
-    # Class mixins
-    # @return [Array<ModuleObject>] a list of mixins
-    attr_reader :class_mixins
-
-    # Instance mixins
-    # @return [Array<ModuleObject>] a list of mixins
-    attr_reader :instance_mixins
-
-    # Creates a new namespace object inside +namespace+ with +name+.
-    # @see Base#initialize
-    def initialize(namespace, name, *args, &block)
-      @children = CodeObjectList.new(self)
-      @class_mixins = CodeObjectList.new(self)
-      @instance_mixins = CodeObjectList.new(self)
-      @attributes = SymbolHash[:class => SymbolHash.new, :instance => SymbolHash.new]
-      @aliases = {}
-      @groups = []
-      super
-    end
-
-    # Only the class attributes
-    # @return [Hash] a list of method names and their read/write objects
-    # @see #attributes
-    def class_attributes
-      attributes[:class]
-    end
-
-    # Only the instance attributes
-    # @return [Hash] a list of method names and their read/write objects
-    # @see #attributes
-    def instance_attributes
-      attributes[:instance]
-    end
-
-    # Looks for a child that matches the attributes specified by +opts+.
-    #
-    # @example Finds a child by name and scope
-    #   namespace.child(:name => :to_s, :scope => :instance)
-    #   # => #<yardoc method MyClass#to_s>
-    # @return [Base, nil] the first matched child object, or nil
-    def child(opts = {})
-      if !opts.is_a?(Hash)
-        children.find {|o| o.name == opts.to_sym }
-      else
-        opts = SymbolHash[opts]
-        children.find do |obj|
-          opts.each do |meth, value|
-            break false if !(value.is_a?(Array) ? value.include?(obj[meth]) : obj[meth] == value)
-          end
-        end
-      end
-    end
-
-    # Returns all methods that match the attributes specified by +opts+. If
-    # no options are provided, returns all methods.
-    #
-    # @example Finds all private and protected class methods
-    #   namespace.meths(:visibility => [:private, :protected], :scope => :class)
-    #   # => [#<yardoc method MyClass.privmeth>, #<yardoc method MyClass.protmeth>]
-    # @option opts [Array<Symbol>, Symbol] :visibility ([:public, :private,
-    #   :protected]) the visibility of the methods to list. Can be an array or
-    #   single value.
-    # @option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the
-    #   scope of the methods to list. Can be an array or single value.
-    # @option opts [Boolean] :included (true) whether to include mixed in
-    #   methods in the list.
-    # @return [Array<MethodObject>] a list of method objects
-    def meths(opts = {})
-      opts = SymbolHash[
-        :visibility => [:public, :private, :protected],
-        :scope => [:class, :instance],
-        :included => true
-      ].update(opts)
-
-      opts[:visibility] = [opts[:visibility]].flatten
-      opts[:scope] = [opts[:scope]].flatten
-
-      ourmeths = children.select do |o|
-        o.is_a?(MethodObject) &&
-          opts[:visibility].include?(o.visibility) &&
-          opts[:scope].include?(o.scope)
-      end
-
-      ourmeths + (opts[:included] ? included_meths(opts) : [])
-    end
-
-    # Returns methods included from any mixins that match the attributes
-    # specified by +opts+. If no options are specified, returns all included
-    # methods.
-    #
-    # @option opts [Array<Symbol>, Symbol] :visibility ([:public, :private,
-    #   :protected]) the visibility of the methods to list. Can be an array or
-    #   single value.
-    # @option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the
-    #   scope of the methods to list. Can be an array or single value.
-    # @option opts [Boolean] :included (true) whether to include mixed in
-    #   methods in the list.
-    # @see #meths
-    def included_meths(opts = {})
-      opts = SymbolHash[:scope => [:instance, :class]].update(opts)
-      [opts[:scope]].flatten.map do |scope|
-        mixins(scope).inject([]) do |list, mixin|
-          next list if mixin.is_a?(Proxy)
-          arr = mixin.meths(opts.merge(:scope => :instance)).reject do |o|
-            next false if opts[:all]
-            child(:name => o.name, :scope => scope) || list.find {|o2| o2.name == o.name }
-          end
-          arr.map! {|o| ExtendedMethodObject.new(o) } if scope == :class
-          list + arr
-        end
-      end.flatten
-    end
-
-    # Returns all constants in the namespace
-    #
-    # @option opts [Boolean] :included (true) whether or not to include
-    #   mixed in constants in list
-    # @return [Array<ConstantObject>] a list of constant objects
-    def constants(opts = {})
-      opts = SymbolHash[:included => true].update(opts)
-      consts = children.select {|o| o.is_a? ConstantObject }
-      consts + (opts[:included] ? included_constants : [])
-    end
-
-    # Returns constants included from any mixins
-    # @return [Array<ConstantObject>] a list of constant objects
-    def included_constants
-      instance_mixins.inject([]) do |list, mixin|
-        if mixin.respond_to? :constants
-          list += mixin.constants.reject do |o|
-            child(:name => o.name) || list.find {|o2| o2.name == o.name }
-          end
-        else
-          list
-        end
-      end
-    end
-
-    # Returns class variables defined in this namespace.
-    # @return [Array<ClassVariableObject>] a list of class variable objects
-    def cvars
-      children.select {|o| o.is_a? ClassVariableObject }
-    end
-
-    # Returns for specific scopes. If no scopes are provided, returns all mixins.
-    # @param [Array<Symbol>] scopes a list of scopes (:class, :instance) to
-    #   return mixins for. If this is empty, all scopes will be returned.
-    # @return [Array<ModuleObject>] a list of mixins
-    def mixins(*scopes)
-      return class_mixins if scopes == [:class]
-      return instance_mixins if scopes == [:instance]
-      class_mixins | instance_mixins
-    end
-  end
-end

data/vendor/bundle/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/code_objects/proxy.rb

@@ -1,258 +0,0 @@
-module YARD
-  module CodeObjects
-    # A special type of +NoMethodError+ when raised from a {Proxy}
-    class ProxyMethodError < NoMethodError; end
-
-    # The Proxy class is a way to lazily resolve code objects in
-    # cases where the object may not yet exist. A proxy simply stores
-    # an unresolved path until a method is called on the object, at which
-    # point it does a lookup using {Registry.resolve}. If the object is
-    # not found, a warning is raised and {ProxyMethodError} might be raised.
-    #
-    # @example Creates a Proxy to the String class from a module
-    #   # When the String class is parsed this method will
-    #   # begin to act like the String ClassObject.
-    #   Proxy.new(mymoduleobj, "String")
-    # @see Registry.resolve
-    # @see ProxyMethodError
-    class Proxy
-      def self.===(other) other.is_a?(self) end
-
-      attr_reader :namespace
-      alias_method :parent, :namespace
-
-      # Creates a new Proxy
-      #
-      # @raise [ArgumentError] if namespace is not a NamespaceObject
-      # @return [Proxy] self
-      def initialize(namespace, name, type = nil)
-        namespace = Registry.root if !namespace || namespace == :root
-
-        if name =~ /^#{NSEPQ}/
-          namespace = Registry.root
-          name = name[2..-1]
-        end
-
-        if name =~ /(?:#{NSEPQ}|#{ISEPQ}|#{CSEPQ})([^#{NSEPQ}#{ISEPQ}#{CSEPQ}]+)$/
-          @orignamespace, @origname = namespace, name
-          @imethod = true if name.include? ISEP
-          namespace = Proxy.new(namespace, $`) unless $`.empty?
-          name = $1
-        else
-          @orignamespace, @origname, @imethod = nil, nil, nil
-        end
-
-        @name = name.to_sym
-        @namespace = namespace
-        @obj = nil
-        @imethod ||= nil
-        self.type = type
-
-        if @namespace.is_a?(ConstantObject)
-          @origname = nil # forget these for a constant
-          @orignamespace = nil
-          @namespace = Proxy.new(@namespace.namespace, @namespace.value)
-        end
-
-        unless @namespace.is_a?(NamespaceObject) or @namespace.is_a?(Proxy)
-          raise ArgumentError, "Invalid namespace object: #{namespace}"
-        end
-
-        # If the name begins with "::" (like "::String")
-        # this is definitely a root level object, so
-        # remove the namespace and attach it to the root
-        if @name =~ /^#{NSEPQ}/
-          @name.gsub!(/^#{NSEPQ}/, '')
-          @namespace = Registry.root
-        end
-      end
-
-      # (see Base#name)
-      def name(prefix = false)
-        prefix ? (@imethod ? ISEP : '') + @name.to_s : @name
-      end
-
-      # Returns a text representation of the Proxy
-      # @return [String] the object's #inspect method or P(OBJECTPATH)
-      def inspect
-        if obj = to_obj
-          obj.inspect
-        else
-          "P(#{path})"
-        end
-      end
-
-      # If the proxy resolves to an object, returns its path, otherwise
-      # guesses at the correct path using the original namespace and name.
-      #
-      # @return [String] the assumed path of the proxy (or the real path
-      #   of the resolved object)
-      def path
-        if obj = to_obj
-          obj.path
-        else
-          proxy_path
-        end
-      end
-      alias to_s path
-      alias to_str path
-      alias title path
-
-      # @return [Boolean]
-      def is_a?(klass)
-        if obj = to_obj
-          obj.is_a?(klass)
-        else
-          self.class <= klass
-        end
-      end
-
-      # @return [Boolean]
-      def ===(other)
-        if obj = to_obj
-          obj === other
-        else
-          self.class <= other.class
-        end
-      end
-
-      # @return [Boolean]
-      def <=>(other)
-        if other.respond_to? :path
-          path <=> other.path
-        else
-          false
-        end
-      end
-
-      # @return [Boolean]
-      def equal?(other)
-        if other.respond_to? :path
-          path == other.path
-        else
-          false
-        end
-      end
-      alias == equal?
-
-      # @return [Integer] the object's hash value (for equality checking)
-      def hash; path.hash end
-
-      # Returns the class name of the object the proxy is mimicking, if
-      # resolved. Otherwise returns +Proxy+.
-      # @return [Class] the resolved object's class or +Proxy+
-      def class
-        if obj = to_obj
-          obj.class
-        else
-          Proxy
-        end
-      end
-
-      # Returns the type of the proxy. If it cannot be resolved at the
-      # time of the call, it will either return the inferred proxy type
-      # (see {#type=}) or +:proxy+
-      # @return [Symbol] the Proxy's type
-      # @see #type=
-      def type
-        if obj = to_obj
-          obj.type
-        else
-          @type || :proxy
-        end
-      end
-
-      # Allows a parser to infer the type of the proxy by its path.
-      # @param [#to_sym] type the proxy's inferred type
-      # @return [void]
-      def type=(type) @type = type ? type.to_sym : nil end
-
-      # @return [Boolean]
-      def instance_of?(klass)
-        self.class == klass
-      end
-
-      # @return [Boolean]
-      def kind_of?(klass)
-        self.class <= klass
-      end
-
-      # @return [Boolean]
-      def respond_to?(meth, include_private = false)
-        if obj = to_obj
-          obj.respond_to?(meth, include_private)
-        else
-          super
-        end
-      end
-
-      # Dispatches the method to the resolved object.
-      #
-      # @raise [ProxyMethodError] if the proxy cannot find the real object
-      def method_missing(meth, *args, &block)
-        if obj = to_obj
-          obj.__send__(meth, *args, &block)
-        else
-          log.warn "Load Order / Name Resolution Problem on #{path}:"
-          log.warn "-"
-          log.warn "Something is trying to call #{meth} on object #{path} before it has been recognized."
-          log.warn "This error usually means that you need to modify the order in which you parse files"
-          log.warn "so that #{path} is parsed before methods or other objects attempt to access it."
-          log.warn "-"
-          log.warn "YARD will recover from this error and continue to parse but you *may* have problems"
-          log.warn "with your generated documentation. You should probably fix this."
-          log.warn "-"
-          begin
-            super
-          rescue NoMethodError
-            raise ProxyMethodError, "Proxy cannot call method ##{meth} on object '#{path}'"
-          end
-        end
-      end
-
-      # This class is never a root object
-      def root?; false end
-
-      private
-
-      # @note this method fixes a bug in 1.9.2: http://gist.github.com/437136
-      def to_ary; nil end
-
-      # Attempts to find the object that this unresolved object
-      # references by checking if any objects by this name are
-      # registered all the way up the namespace tree.
-      #
-      # @return [Base, nil] the registered code object or nil
-      def to_obj
-        return @obj if @obj
-        if @obj = Registry.resolve(@namespace, (@imethod ? ISEP : '') + @name.to_s, false, false, @type)
-          if @origname && @origname.include?("::") && !@obj.path.include?(@origname)
-            # the object's path should include the original proxy namespace,
-            # otherwise it's (probably) not the right object.
-            @obj = nil
-          else
-            @namespace = @obj.namespace
-            @name = @obj.name
-          end
-        end
-        @obj
-      end
-
-      def proxy_path
-        if @namespace.root?
-          (@imethod ? ISEP : "") + name.to_s
-        elsif @origname
-          if @origname =~ /^[A-Z]/
-            @origname
-          else
-            [namespace.path, @origname].join
-          end
-        elsif name.to_s =~ /^[A-Z]/ # const
-          name.to_s
-        else # class meth?
-          [namespace.path, name.to_s].join(CSEP)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/code_objects/root_object.rb

@@ -1,17 +0,0 @@
-module YARD
-  module CodeObjects
-    # Represents the root namespace object (the invisible Ruby module that
-    # holds all top level modules, class and other objects).
-    class RootObject < ModuleObject
-      def path; @path ||= "" end
-      def inspect; @inspect ||= "#<yardoc root>" end
-      def root?; true end
-      def title; 'Top Level Namespace' end
-      def equal?(other)
-        other == :root ? true : super(other)
-      end
-
-      def hash; :root.hash end
-    end
-  end
-end