climine 0.0.7 → 0.0.8

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/lib/yard/code_objects/class_object.rb

@@ -1,143 +0,0 @@
-module YARD::CodeObjects
-  # A ClassObject represents a Ruby class in source code. It is a {ModuleObject}
-  # with extra inheritance semantics through the superclass.
-  class ClassObject < NamespaceObject
-    # The {ClassObject} that this class object inherits from in Ruby source.
-    # @return [ClassObject] a class object that is the superclass of this one
-    attr_reader :superclass
-
-    # Creates a new class object in +namespace+ with +name+
-    #
-    # @see Base.new
-    def initialize(namespace, name, *args, &block)
-      super
-
-      if is_exception?
-        self.superclass ||= "::Exception" unless P(namespace, name) == P(:Exception)
-      else
-        case P(namespace, name).path
-        when "BasicObject"
-          nil
-        when "Object"
-          self.superclass ||= "::BasicObject"
-        else
-          self.superclass ||= "::Object"
-        end
-      end
-    end
-
-    # Whether or not the class is a Ruby Exception
-    #
-    # @return [Boolean] whether the object represents a Ruby exception
-    def is_exception?
-      inheritance_tree.reverse.any? {|o| BUILTIN_EXCEPTIONS_HASH.has_key? o.path }
-    end
-
-    # Returns the inheritance tree of the object including self.
-    #
-    # @param [Boolean] include_mods whether or not to include mixins in the
-    #   inheritance tree.
-    # @return [Array<NamespaceObject>] the list of code objects that make up
-    #   the inheritance tree.
-    def inheritance_tree(include_mods = false)
-      list = (include_mods ? mixins(:instance, :class) : [])
-      if superclass.is_a?(Proxy) || superclass.respond_to?(:inheritance_tree)
-        list += [superclass] unless superclass == P(:Object) || superclass == P(:BasicObject)
-      end
-      [self] + list.map do |m|
-        next m if m == self
-        next m unless m.respond_to?(:inheritance_tree)
-        m.inheritance_tree(include_mods)
-      end.flatten.uniq
-    end
-
-    # Returns the list of methods matching the options hash. Returns
-    # all methods if hash is empty.
-    #
-    # @param [Hash] opts the options hash to match
-    # @option opts [Boolean] :inherited (true) whether inherited methods should be
-    #   included in the list
-    # @option opts [Boolean] :included (true) whether mixed in methods should be
-    #   included in the list
-    # @return [Array<MethodObject>] the list of methods that matched
-    def meths(opts = {})
-      opts = SymbolHash[:inherited => true].update(opts)
-      list = super(opts)
-      list += inherited_meths(opts).reject do |o|
-        next(false) if opts[:all]
-        list.find {|o2| o2.name == o.name && o2.scope == o.scope }
-      end if opts[:inherited]
-      list
-    end
-
-    # Returns only the methods that were inherited.
-    #
-    # @return [Array<MethodObject>] the list of inherited method objects
-    def inherited_meths(opts = {})
-      inheritance_tree[1..-1].inject([]) do |list, superclass|
-        if superclass.is_a?(Proxy)
-          list
-        else
-          list += superclass.meths(opts).reject do |o|
-            next(false) if opts[:all]
-            child(:name => o.name, :scope => o.scope) ||
-              list.find {|o2| o2.name == o.name && o2.scope == o.scope }
-          end
-        end
-      end
-    end
-
-    # Returns the list of constants matching the options hash.
-    #
-    # @param [Hash] opts the options hash to match
-    # @option opts [Boolean] :inherited (true) whether inherited constant should be
-    #   included in the list
-    # @option opts [Boolean] :included (true) whether mixed in constant should be
-    #   included in the list
-    # @return [Array<ConstantObject>] the list of constant that matched
-    def constants(opts = {})
-      opts = SymbolHash[:inherited => true].update(opts)
-      super(opts) + (opts[:inherited] ? inherited_constants : [])
-    end
-
-    # Returns only the constants that were inherited.
-    #
-    # @return [Array<ConstantObject>] the list of inherited constant objects
-    def inherited_constants
-      inheritance_tree[1..-1].inject([]) do |list, superclass|
-        if superclass.is_a?(Proxy)
-          list
-        else
-          list += superclass.constants.reject do |o|
-            child(:name => o.name) || list.find {|o2| o2.name == o.name }
-          end
-        end
-      end
-    end
-
-    # Sets the superclass of the object
-    #
-    # @param [Base, Proxy, String, Symbol, nil] object the superclass value
-    # @return [void]
-    def superclass=(object)
-      case object
-      when Base, Proxy, NilClass
-        @superclass = object
-      when String, Symbol
-        @superclass = Proxy.new(namespace, object)
-      else
-        raise ArgumentError, "superclass must be CodeObject, Proxy, String or Symbol"
-      end
-
-      if name == @superclass.name && namespace != YARD::Registry.root && !object.is_a?(Base)
-        @superclass = Proxy.new(namespace.namespace, object)
-      end
-
-      if @superclass == self
-        msg = "superclass #{@superclass.inspect} cannot be the same as the declared class #{self.inspect}"
-        @superclass = P("::Object")
-        raise ArgumentError, msg
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/lib/yard/code_objects/class_variable_object.rb

@@ -1,8 +0,0 @@
-module YARD::CodeObjects
-  # Represents a class variable inside a namespace. The path is expressed
-  # in the form "A::B::@@classvariable"
-  class ClassVariableObject < Base
-    # @return [String] the class variable's value
-    attr_accessor :value
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/lib/yard/code_objects/constant_object.rb

@@ -1,13 +0,0 @@
-module YARD::CodeObjects
-  # A +ConstantObject+ represents a Ruby constant (not a module or class).
-  # To access the constant's (source code) value, use {#value}.
-  class ConstantObject < Base
-    # The source code representing the constant's value
-    # @return [String] the value the constant is set to
-    attr_reader :value
-
-    def value=(value)
-      @value = format_source(value)
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/lib/yard/code_objects/extended_method_object.rb

@@ -1,23 +0,0 @@
-module YARD::CodeObjects
-  # Represents an instance method of a module that was mixed into the class
-  # scope of another namespace.
-  #
-  # @see MethodObject
-  class ExtendedMethodObject
-    instance_methods.each {|m| undef_method(m) unless m =~ /^__/ || m.to_sym == :object_id }
-
-    # @return [Symbol] always +:class+
-    def scope; :class end
-
-    # Sets up a delegate for {MethodObject} obj.
-    #
-    # @param [MethodObject] obj the instance method to treat as a mixed in
-    #   class method on another namespace.
-    def initialize(obj) @del = obj end
-
-    # Sends all methods to the {MethodObject} assigned in {#initialize}
-    # @see #initialize
-    # @see MethodObject
-    def method_missing(sym, *args, &block) @del.__send__(sym, *args, &block) end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/lib/yard/code_objects/extra_file_object.rb

@@ -1,128 +0,0 @@
-module YARD::CodeObjects
-  # An ExtraFileObject represents an extra documentation file (README or other
-  # file). It is not strictly a CodeObject (does not inherit from `Base`) although
-  # it implements `path`, `name` and `type`, and therefore should be structurally
-  # compatible with most CodeObject interfaces.
-  class ExtraFileObject
-    attr_accessor :filename
-    attr_writer :attributes
-    attr_accessor :name
-    # @since 0.8.3
-    attr_reader :locale
-
-    # Creates a new extra file object.
-    # @param [String] filename the location on disk of the file
-    # @param [String] contents the file contents. If not set, the contents
-    #   will be read from disk using the +filename+.
-    def initialize(filename, contents = nil)
-      self.filename = filename
-      self.name = File.basename(filename).gsub(/\.[^.]+$/, '')
-      self.attributes = SymbolHash.new(false)
-      @original_contents = contents
-      @parsed = false
-      @locale = nil
-      ensure_parsed
-    end
-
-    alias path name
-
-    def attributes
-      ensure_parsed
-      @attributes
-    end
-
-    def title
-      attributes[:title] || name
-    end
-
-    def contents
-      ensure_parsed
-      @contents
-    end
-
-    def contents=(contents)
-      @original_contents = contents
-      @parsed = false
-    end
-
-    # @param [String] locale the locale name to be translated.
-    # @return [void]
-    # @since 0.8.3
-    def locale=(locale)
-      @locale = locale
-      @parsed = false
-    end
-
-    def inspect
-      "#<yardoc #{type} #{filename} attrs=#{attributes.inspect}>"
-    end
-    alias to_s inspect
-
-    def type; :extra_file end
-
-    def ==(other)
-      return false unless self.class === other
-      other.filename == filename
-    end
-    alias eql? ==
-    alias equal? ==
-    def hash; filename.hash end
-
-    private
-
-    def ensure_parsed
-      return if @parsed
-      @parsed = true
-      @contents = parse_contents(@original_contents || File.read(@filename))
-    end
-
-    # @param [String] data the file contents
-    def parse_contents(data)
-      retried = false
-      cut_index = 0
-      data = translate(data)
-      data = data.split("\n")
-      data.each_with_index do |line, index|
-        case line
-        when /^#!(\S+)\s*$/
-          if index == 0
-            attributes[:markup] = $1
-          else
-            cut_index = index
-            break
-          end
-        when /^\s*#\s*@(\S+)\s*(.+?)\s*$/
-          attributes[$1] = $2
-        else
-          cut_index = index
-          break
-        end
-      end
-      data = data[cut_index..-1] if cut_index > 0
-      contents = data.join("\n")
-
-      if contents.respond_to?(:force_encoding) && attributes[:encoding]
-        begin
-          contents.force_encoding(attributes[:encoding])
-        rescue ArgumentError
-          log.warn "Invalid encoding `#{attributes[:encoding]}' in #{filename}"
-        end
-      end
-      contents
-    rescue ArgumentError => e
-      if retried && e.message =~ /invalid byte sequence/
-        # This should never happen.
-        log.warn "Could not read #{filename}, #{e.message}. You probably want to set `--charset`."
-        return ''
-      end
-      data.force_encoding('binary') if data.respond_to?(:force_encoding)
-      retried = true
-      retry
-    end
-
-    def translate(data)
-      text = YARD::I18n::Text.new(data, :have_header => true)
-      text.translate(YARD::Registry.locale(locale))
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/lib/yard/code_objects/macro_object.rb

@@ -1,172 +0,0 @@
-require 'ostruct'
-
-module YARD
-  module CodeObjects
-    # A MacroObject represents a docstring defined through +@!macro NAME+ and can be
-    # reused by specifying the tag +@!macro NAME+. You can also provide the
-    # +attached+ type flag to the macro definition to have it attached to the
-    # specific DSL method so it will be implicitly reused.
-    #
-    # Macros are fully described in the {file:docs/Tags.md#macro Tags Overview}
-    # document.
-    #
-    # @example Creating a basic named macro
-    #   # @!macro prop
-    #   #   @!method $1(${3-})
-    #   #   @return [$2] the value of the $0
-    #   property :foo, String, :a, :b
-    #
-    #   # @!macro prop
-    #   property :bar, Numeric, :value
-    #
-    # @example Creating a macro that is attached to the method call
-    #   # @!macro [attach] prop2
-    #   #   @!method $1(value)
-    #   property :foo
-    #
-    #   # Extra data added to docstring
-    #   property :bar
-    class MacroObject < Base
-      MACRO_MATCH = /(\\)?\$(?:\{(-?\d+|\*)(-)?(-?\d+)?\}|(-?\d+|\*))/
-
-      class << self
-        # Creates a new macro and fills in the relevant properties.
-        # @param [String] macro_name the name of the macro, must be unique.
-        # @param [String] data the data the macro should expand when re-used
-        # @param [CodeObjects::Base] method_object an object to attach this
-        #   macro to. If supplied, {#attached?} will be true
-        # @return [MacroObject] the newly created object
-        def create(macro_name, data, method_object = nil)
-          obj = new(:root, macro_name)
-          obj.macro_data = data
-          obj.method_object = method_object
-          obj
-        end
-
-        # Finds a macro using +macro_name+
-        # @param [#to_s] macro_name the name of the macro
-        # @return [MacroObject] if a macro is found
-        # @return [nil] if there is no registered macro by that name
-        def find(macro_name)
-          Registry.at('.macro.' + macro_name.to_s)
-        end
-
-        # Parses a given docstring and determines if the macro is "new" or
-        # not. If the macro has $variable names or if it has a @!macro tag
-        # with the [new] or [attached] flag, it is considered new.
-        #
-        # If a new macro is found, the macro is created and registered. Otherwise
-        # the macro name is searched and returned. If a macro is not found,
-        # nil is returned.
-        #
-        # @param [#to_s] macro_name the name of the macro
-        # @param [CodeObjects::Base] method_object an optional method to attach
-        #   the macro to. Only used if the macro is being created, otherwise
-        #   this argument is ignored.
-        # @return [MacroObject] the newly created or existing macro, depending
-        #   on whether the @!macro tag was a new tag or not.
-        # @return [nil] if the +data+ has no macro tag or if the macro is
-        #   not new and no macro by the macro name is found.
-        def find_or_create(macro_name, data, method_object = nil)
-          if macro = find(name)
-            macro
-          else
-            create(macro_name, data, method_object)
-          end
-        end
-        alias create_docstring find_or_create
-
-        # Expands +macro_data+ using the interpolation parameters.
-        #
-        # Interpolation rules:
-        # * $0, $1, $2, ... = the Nth parameter in +call_params+
-        # * $* = the full statement source (excluding block)
-        # * Also supports $!{N-M} ranges, as well as negative indexes on N or M
-        # * Use \$ to escape the variable name in a macro.
-        #
-        # @!macro [new] macro.expand
-        #   @param [Array<String>] call_params the method name and parameters
-        #     to the method call. These arguments will fill \$0-N
-        #   @param [String] full_source the full source line (excluding block)
-        #     interpolated as \$*
-        #   @param [String] block_source Currently unused. Will support
-        #     interpolating the block data as a variable.
-        #   @return [String] the expanded macro data
-        # @param [String] macro_data the macro data to expand (taken from {#macro_data})
-        def expand(macro_data, call_params = [], full_source = '', block_source = '')
-          macro_data = macro_data.all if macro_data.is_a?(Docstring)
-          macro_data.gsub(MACRO_MATCH) do
-            escape, first, last, rng = $1, $2 || $5, $4, $3 ? true : false
-            next $&[1..-1] if escape
-            if first == '*'
-              last ? $& : full_source
-            else
-              first_i = first.to_i
-              last_i = (last ? last.to_i : call_params.size)
-              last_i = first_i unless rng
-              params = call_params[first_i..last_i]
-              params ? params.join(", ") : ''
-            end
-          end
-        end
-
-        # Applies a macro on a docstring by creating any macro data inside of
-        # the docstring first. Equivalent to calling {find_or_create} and {apply_macro}
-        # on the new macro object.
-        #
-        # @param [Docstring] docstring the docstring to create a macro out of
-        # @!macro macro.expand
-        # @see find_or_create
-        def apply(docstring, call_params = [], full_source = '', block_source = '', method_object = nil)
-          docstring = docstring.all if Docstring === docstring
-          parser = Docstring.parser
-          handler = OpenStruct.new
-          handler.call_params = call_params[1..-1]
-          handler.caller_method = call_params.first
-          handler.statement = OpenStruct.new(:source => full_source)
-          parser.parse(docstring, nil, handler).to_docstring.to_raw
-        end
-
-        # Applies a macro to a docstring, interpolating the macro's data on the
-        # docstring and appending any extra local docstring data that was in
-        # the original +docstring+ object.
-        #
-        # @param [MacroObject] macro the macro object
-        # @!macro macro.expand
-        def apply_macro(macro, docstring, call_params = [], full_source = '', block_source = '')
-          apply(docstring, call_params, full_source, block_source)
-        end
-      end
-
-      # @return [String] the macro data stored on the object
-      attr_accessor :macro_data
-
-      # @return [CodeObjects::Base] the method object that this macro is
-      #   attached to.
-      attr_accessor :method_object
-
-      # @return [Boolean] whether this macro is attached to a method
-      def attached?; method_object ? true : false end
-
-      # Overrides {Base#path} so the macro path is ".macro.MACRONAME"
-      def path; '.macro.' + name.to_s end
-
-      # Overrides the separator to be '.'
-      def sep; '.' end
-
-      # Expands the macro using
-      # @param [Array<String>] call_params a list of tokens that are passed
-      #   to the method call
-      # @param [String] full_source the full method call (not including the block)
-      # @param [String] block_source the source passed in the block of the method
-      #   call, if there is a block.
-      # @example Expanding a Macro
-      #   macro.expand(%w(property foo bar), 'property :foo, :bar', '') #=>
-      #     "...macro data interpolating this line of code..."
-      # @see expand
-      def expand(call_params = [], full_source = '', block_source = '')
-        self.class.expand(macro_data, call_params, full_source, block_source)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/lib/yard/code_objects/method_object.rb

@@ -1,191 +0,0 @@
-module YARD::CodeObjects
-  # Represents a Ruby method in source
-  class MethodObject < Base
-    # The scope of the method (+:class+ or +:instance+)
-    #
-    # @return [Symbol] the scope
-    attr_reader :scope
-
-    # Whether the object is explicitly defined in source or whether it was
-    # inferred by a handler. For instance, attribute methods are generally
-    # inferred and therefore not explicitly defined in source.
-    #
-    # @return [Boolean] whether the object is explicitly defined in source.
-    attr_accessor :explicit
-
-    # Returns the list of parameters parsed out of the method signature
-    # with their default values.
-    #
-    # @return [Array<Array(String, String)>] a list of parameter names followed
-    #   by their default values (or nil)
-    attr_accessor :parameters
-
-    # Creates a new method object in +namespace+ with +name+ and an instance
-    # or class +scope+
-    #
-    # If scope is +:module+, this object is instantiated as a public
-    # method in +:class+ scope, but also creates a new (empty) method
-    # as a private +:instance+ method on the same class or module.
-    #
-    # @param [NamespaceObject] namespace the namespace
-    # @param [String, Symbol] name the method name
-    # @param [Symbol] scope +:instance+, +:class+, or +:module+
-    def initialize(namespace, name, scope = :instance, &block)
-      @module_function = false
-      @scope = nil
-
-      # handle module function
-      if scope == :module
-        other = self.class.new(namespace, name, &block)
-        other.visibility = :private
-        scope = :class
-        @module_function = true
-      end
-
-      @visibility = :public
-      self.scope = scope
-      self.parameters = []
-
-      super
-    end
-
-    # Changes the scope of an object from :instance or :class
-    # @param [Symbol] v the new scope
-    def scope=(v)
-      reregister = @scope ? true : false
-
-      # handle module function
-      if v == :module
-        other = self.class.new(namespace, name)
-        other.visibility = :private
-        @visibility = :public
-        @module_function = true
-        @path = nil
-      end
-
-      YARD::Registry.delete(self)
-      @path = nil
-      @scope = v.to_sym
-      if @scope == :module
-        @scope = :class
-      end
-      YARD::Registry.register(self) if reregister
-    end
-
-    # @return whether or not the method is the #initialize constructor method
-    def constructor?
-      name == :initialize && scope == :instance && namespace.is_a?(ClassObject)
-    end
-
-    # @return [Boolean] whether or not this method was created as a module
-    #   function
-    # @since 0.8.0
-    def module_function?
-      @module_function
-    end
-
-    # Returns the read/writer info for the attribute if it is one
-    # @return [SymbolHash] if there is information about the attribute
-    # @return [nil] if the method is not an attribute
-    # @since 0.5.3
-    def attr_info
-      return nil unless namespace.is_a?(NamespaceObject)
-      namespace.attributes[scope][name.to_s.gsub(/=$/, '')]
-    end
-
-    # @return [Boolean] whether the method is a writer attribute
-    # @since 0.5.3
-    def writer?
-      !!((info = attr_info) && info[:write] == self)
-    end
-
-    # @return [Boolean] whether the method is a reader attribute
-    # @since 0.5.3
-    def reader?
-      !!((info = attr_info) && info[:read] == self)
-    end
-
-    # Tests if the object is defined as an attribute in the namespace
-    # @return [Boolean] whether the object is an attribute
-    def is_attribute?
-      return false unless info = attr_info
-      info[name.to_s =~ /=$/ ? :write : :read] ? true : false
-    end
-
-    # Tests if the object is defined as an alias of another method
-    # @return [Boolean] whether the object is an alias
-    def is_alias?
-      return false unless namespace.is_a?(NamespaceObject)
-      namespace.aliases.has_key? self
-    end
-
-    # Tests boolean {#explicit} value.
-    #
-    # @return [Boolean] whether the method is explicitly defined in source
-    def is_explicit?
-      explicit ? true : false
-    end
-
-    # @return [MethodObject] the object that this method overrides
-    # @return [nil] if it does not override a method
-    # @since 0.6.0
-    def overridden_method
-      return nil if namespace.is_a?(Proxy)
-      meths = namespace.meths(:all => true)
-      meths.find {|m| m.path != path && m.name == name && m.scope == scope }
-    end
-
-    # Returns all alias names of the object
-    # @return [Array<Symbol>] the alias names
-    def aliases
-      list = []
-      return list unless namespace.is_a?(NamespaceObject)
-      namespace.aliases.each do |o, aname|
-        list << o if aname == name && o.scope == scope
-      end
-      list
-    end
-
-    # Override path handling for instance methods in the root namespace
-    # (they should still have a separator as a prefix).
-    # @return [String] the path of a method
-    def path
-      @path ||= if !namespace || namespace.path == ""
-        sep + super
-      else
-        super
-      end
-    end
-
-    # Returns the name of the object.
-    #
-    # @example The name of an instance method (with prefix)
-    #   an_instance_method.name(true) # => "#mymethod"
-    # @example The name of a class method (with prefix)
-    #   a_class_method.name(true) # => "mymethod"
-    # @param [Boolean] prefix whether or not to show the prefix
-    # @return [String] returns {#sep} + +name+ for an instance method if
-    #   prefix is true
-    # @return [Symbol] the name without {#sep} if prefix is set to false
-    def name(prefix = false)
-      prefix ? (sep == ISEP ? "#{sep}#{super}" : super.to_s) : super
-    end
-
-    # Override separator to differentiate between class and instance
-    # methods.
-    # @return [String] "#" for an instance method, "." for class
-    def sep
-      if scope == :class
-        namespace && namespace != YARD::Registry.root ? CSEP : NSEP
-      else
-        ISEP
-      end
-    end
-
-    protected
-
-    def copyable_attributes
-      super - %w(scope module_function)
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/lib/yard/code_objects/module_object.rb

@@ -1,18 +0,0 @@
-module YARD::CodeObjects
-  # Represents a Ruby module.
-  class ModuleObject < NamespaceObject
-    # Returns the inheritance tree of mixins.
-    #
-    # @param [Boolean] include_mods if true, will include mixed in
-    #   modules (which is likely what is wanted).
-    # @return [Array<NamespaceObject>] a list of namespace objects
-    def inheritance_tree(include_mods = false)
-      return [self] unless include_mods
-      [self] + mixins(:instance, :class).map do |m|
-        next if m == self
-        next m unless m.respond_to?(:inheritance_tree)
-        m.inheritance_tree(true)
-      end.compact.flatten.uniq
-    end
-  end
-end