redcar 0.3.2dev → 0.3.3

data/lib/openssl/mocha/vendor/coderay-0.7.4.215/lib/coderay/tokens.rb

@@ -0,0 +1,368 @@
+module CodeRay
+
+  # = Tokens
+  #
+  # The Tokens class represents a list of tokens returnd from
+  # a Scanner.
+  #
+  # A token is not a special object, just a two-element Array
+  # consisting of
+  # * the _token_ _kind_ (a Symbol representing the type of the token)
+  # * the _token_ _text_ (the original source of the token in a String)
+  #
+  # A token looks like this:
+  #
+  #   [:comment, '# It looks like this']
+  #   [:float, '3.1415926']
+  #   [:error, '���']
+  #
+  # Some scanners also yield some kind of sub-tokens, represented by special
+  # token texts, namely :open and :close .
+  #
+  # The Ruby scanner, for example, splits "a string" into:
+  #
+  #  [
+  #   [:open, :string],
+  #   [:delimiter, '"'],
+  #   [:content, 'a string'],
+  #   [:delimiter, '"'],
+  #   [:close, :string]
+  #  ]
+  #
+  # Tokens is also the interface between Scanners and Encoders:
+  # The input is split and saved into a Tokens object. The Encoder
+  # then builds the output from this object.
+  #
+  # Thus, the syntax below becomes clear:
+  #
+  #   CodeRay.scan('price = 2.59', :ruby).html
+  #   # the Tokens object is here -------^
+  #
+  # See how small it is? ;)
+  #
+  # Tokens gives you the power to handle pre-scanned code very easily:
+  # You can convert it to a webpage, a YAML file, or dump it into a gzip'ed string
+  # that you put in your DB.
+  #
+  # Tokens' subclass TokenStream allows streaming to save memory.
+  class Tokens < Array
+
+    class << self
+
+      # Convert the token to a string.
+      #
+      # This format is used by Encoders.Tokens.
+      # It can be reverted using read_token.
+      def write_token text, type
+        if text.is_a? String
+          "#{type}\t#{escape(text)}\n"
+        else
+          ":#{text}\t#{type}\t\n"
+        end
+      end
+
+      # Read a token from the string.
+      #
+      # Inversion of write_token.
+      #
+      # TODO Test this!
+      def read_token token
+        type, text = token.split("\t", 2)
+        if type[0] == ?:
+          [text.to_sym, type[1..-1].to_sym]
+        else
+          [type.to_sym, unescape(text)]
+        end
+      end
+
+      # Escapes a string for use in write_token.
+      def escape text
+        text.gsub(/[\n\\]/, '\\\\\&')
+      end
+
+      # Unescapes a string created by escape.
+      def unescape text
+        text.gsub(/\\[\n\\]/) { |m| m[1,1] }
+      end
+
+    end
+
+    # Whether the object is a TokenStream.
+    #
+    # Returns false.
+    def stream?
+      false
+    end
+
+    # Iterates over all tokens.
+    #
+    # If a filter is given, only tokens of that kind are yielded.
+    def each kind_filter = nil, &block
+      unless kind_filter
+        super(&block)
+      else
+        super() do |text, kind|
+          next unless kind == kind_filter
+          yield text, kind
+        end
+      end
+    end
+
+    # Iterates over all text tokens.
+    # Range tokens like [:open, :string] are left out.
+    #
+    # Example:
+    #   tokens.each_text_token { |text, kind| text.replace html_escape(text) }
+    def each_text_token
+      each do |text, kind|
+        next unless text.respond_to? :to_str
+        yield text, kind
+      end
+    end
+
+    # Encode the tokens using encoder.
+    #
+    # encoder can be
+    # * a symbol like :html oder :statistic
+    # * an Encoder class
+    # * an Encoder object
+    #
+    # options are passed to the encoder.
+    def encode encoder, options = {}
+      unless encoder.is_a? Encoders::Encoder
+        unless encoder.is_a? Class
+          encoder_class = Encoders[encoder]
+        end
+        encoder = encoder_class.new options
+      end
+      encoder.encode_tokens self, options
+    end
+
+
+    # Turn into a string using Encoders::Text.
+    #
+    # +options+ are passed to the encoder if given.
+    def to_s options = {}
+      encode :text, options
+    end
+
+
+    # Redirects unknown methods to encoder calls.
+    #
+    # For example, if you call +tokens.html+, the HTML encoder
+    # is used to highlight the tokens.
+    def method_missing meth, options = {}
+      Encoders[meth].new(options).encode_tokens self
+    end
+
+    # Returns the tokens compressed by joining consecutive
+    # tokens of the same kind.
+    #
+    # This can not be undone, but should yield the same output
+    # in most Encoders.  It basically makes the output smaller.
+    #
+    # Combined with dump, it saves space for the cost of time.
+    #
+    # If the scanner is written carefully, this is not required -
+    # for example, consecutive //-comment lines could already be
+    # joined in one comment token by the Scanner.
+    def optimize
+      print ' Tokens#optimize: before: %d - ' % size if $DEBUG
+      last_kind = last_text = nil
+      new = self.class.new
+      for text, kind in self
+        if text.is_a? String
+          if kind == last_kind
+            last_text << text
+          else
+            new << [last_text, last_kind] if last_kind
+            last_text = text
+            last_kind = kind
+          end
+        else
+          new << [last_text, last_kind] if last_kind
+          last_kind = last_text = nil
+          new << [text, kind]
+        end
+      end
+      new << [last_text, last_kind] if last_kind
+      print 'after: %d (%d saved = %2.0f%%)' %
+        [new.size, size - new.size, 1.0 - (new.size.to_f / size)] if $DEBUG
+      new
+    end
+
+    # Compact the object itself; see optimize.
+    def optimize!
+      replace optimize
+    end
+    
+    # Ensure that all :open tokens have a correspondent :close one.
+    #
+    # TODO: Test this!
+    def fix
+      # Check token nesting using a stack of kinds.
+      opened = []
+      for token, kind in self
+        if token == :open
+          opened.push kind
+        elsif token == :close
+          expected = opened.pop
+          if kind != expected
+            # Unexpected :close; decide what to do based on the kind:
+            # - token was opened earlier: also close tokens in between
+            # - token was never opened: delete the :close (skip with next)
+            next unless opened.rindex expected
+            tokens << [:close, kind] until (kind = opened.pop) == expected
+          end
+        end
+        tokens << [token, kind]
+      end
+      # Close remaining opened tokens
+      tokens << [:close, kind] while kind = opened.pop
+      tokens
+    end
+    
+    def fix!
+      replace fix
+    end
+    
+    # Makes sure that:
+    # - newlines are single tokens
+    #   (which means all other token are single-line)
+    # - there are no open tokens at the end the line
+    #
+    # This makes it simple for encoders that work line-oriented,
+    # like HTML with list-style numeration.
+    def split_into_lines
+      raise NotImplementedError
+    end
+
+    def split_into_lines!
+      replace split_into_lines
+    end
+
+    # Dumps the object into a String that can be saved
+    # in files or databases.
+    #
+    # The dump is created with Marshal.dump;
+    # In addition, it is gzipped using GZip.gzip.
+    #
+    # The returned String object includes Undumping
+    # so it has an #undump method. See Tokens.load.
+    #
+    # You can configure the level of compression,
+    # but the default value 7 should be what you want
+    # in most cases as it is a good comprimise between
+    # speed and compression rate.
+    #
+    # See GZip module.
+    def dump gzip_level = 7
+      require 'coderay/helpers/gzip_simple'
+      dump = Marshal.dump self
+      dump = dump.gzip gzip_level
+      dump.extend Undumping
+    end
+
+    # The total size of the tokens.
+    # Should be equal to the input size before
+    # scanning.
+    def text_size
+      map { |t, k| t }.join.size
+    end
+
+    # Include this module to give an object an #undump
+    # method.
+    #
+    # The string returned by Tokens.dump includes Undumping.
+    module Undumping
+      # Calls Tokens.load with itself.
+      def undump
+        Tokens.load self
+      end
+    end
+
+    # Undump the object using Marshal.load, then
+    # unzip it using GZip.gunzip.
+    #
+    # The result is commonly a Tokens object, but
+    # this is not guaranteed.
+    def Tokens.load dump
+      require 'coderay/helpers/gzip_simple'
+      dump = dump.gunzip
+      @dump = Marshal.load dump
+    end
+
+  end
+
+
+  # = TokenStream
+  #
+  # The TokenStream class is a fake Array without elements.
+  #
+  # It redirects the method << to a block given at creation.
+  #
+  # This allows scanners and Encoders to use streaming (no
+  # tokens are saved, the input is highlighted the same time it
+  # is scanned) with the same code.
+  #
+  # See CodeRay.encode_stream and CodeRay.scan_stream
+  class TokenStream < Tokens
+
+    # Whether the object is a TokenStream.
+    #
+    # Returns true.
+    def stream?
+      true
+    end
+
+    # The Array is empty, but size counts the tokens given by <<.
+    attr_reader :size
+
+    # Creates a new TokenStream that calls +block+ whenever
+    # its << method is called.
+    #
+    # Example:
+    #
+    #   require 'coderay'
+    #   
+    #   token_stream = CodeRay::TokenStream.new do |kind, text|
+    #     puts 'kind: %s, text size: %d.' % [kind, text.size]
+    #   end
+    #   
+    #   token_stream << [:regexp, '/\d+/']
+    #   #-> kind: rexpexp, text size: 5.
+    #
+    def initialize &block
+      raise ArgumentError, 'Block expected for streaming.' unless block
+      @callback = block
+      @size = 0
+    end
+
+    # Calls +block+ with +token+ and increments size.
+    #
+    # Returns self.
+    def << token
+      @callback.call token
+      @size += 1
+      self
+    end
+
+    # This method is not implemented due to speed reasons. Use Tokens.
+    def text_size
+      raise NotImplementedError,
+        'This method is not implemented due to speed reasons.'
+    end
+
+    # A TokenStream cannot be dumped. Use Tokens.
+    def dump
+      raise NotImplementedError, 'A TokenStream cannot be dumped.'
+    end
+
+    # A TokenStream cannot be optimized. Use Tokens.
+    def optimize
+      raise NotImplementedError, 'A TokenStream cannot be optimized.'
+    end
+
+  end
+
+end

data/lib/openssl/mocha/vendor/meta_project-0.4.15/CHANGES

@@ -0,0 +1,295 @@
+= MetaProject Changelog
+
+== Version 0.4.15
+
+Bugfix release
+
+* Nothing really new from 0.14 except that this time the code is committed to CVS (forgot that last time)
+
+== Version 0.4.14
+
+Bugfix release
+
+* Fixed [#2889] RubyForge login seems broken [Emmanuel Charpentier] (http://rubyurl.com/cfu)
+
+== Version 0.4.13
+
+Bugfix release
+
+* Removed some irritating debugging
+
+== Version 0.4.12
+
+This release improves the issue tracking API
+
+* Removed reference to nonexistant e in JiraTracker.
+* Add support for creation of RubyForge issues.
+* Add support for closing of RubyForge issues.
+
+== Version 0.4.11
+
+This release fixes several bugs in the XForge release code and improves documentation.
+
+* Fixed #2398: Rake::XForge::Release doesn't allow manual setting of release_notes or release_changes
+* Fixed #2399: Net::HTTPRequestURITooLong 414 readbody=true
+* Fixed #2400: Project release always selects the *first* package
+
+== Version 0.4.10
+
+This version fixes some bugs in the JIRA and SourceForge APIs.
+
+* Made error reporting better for JIRA exceptions.
+* Avoid exception rippling through when login credentials are not specified.
+* Made SourceForge tracker API more robust.
+
+== Version 0.4.9
+
+This release makes the validation of Browser objects more robust.
+
+* Moved Browser spec attributes to validating setters.
+
+== Version 0.4.8
+
+This release fixes some bugs with XForge (RubyForge) Rake tasks.
+
+* Documented how to avoid parsing of CHANGES.
+* Fixed a bug in interactive modus for user name and password prompts.
+* Fixed a bug in retrieval of package_id when releasing to RubyForge.
+* Fixed bug in open-uri extension that clobbered HTTP request headers failing login.
+* Fixed a bug in the determination of Trac version.
+
+== Version 0.4.7
+
+This release makes HTTP access more robust and improves the Pathname API.
+
+* More robust HTTP GET with retries and better error messages.
+* Added Pathname.basename and Pathname.parent
+* Small improvements to ScmWeb API.
+* More robust detection of XForge package_id.
+
+== Version 0.4.6
+
+This release updates documentaion, adds iteration support to Pathname and fixes some minor bugs.
+
+* Updated README.
+* Added PathnameIterator mixin that can be used to iterate over Pathname and MetaProject::ScmWeb::Pathname to
+  do e.g. egrep or other operations.
+* Fixed a bug in Project::RubyForge that prevented group_id from being recognised for some projects.
+* Made the scm_web test for rubyforge be less fragile by storing the compared local file locally.
+
+== Version 0.4.5
+
+This version improves the MetaProject::ScmWeb::Pathname support, allowing online contents in scm web interfaces to be navigated and read in a similar fashion to the standard library's Pathname class.
+
+* Better support for Pathname. children, directory? and open now supported.
+* Fixed some bugs for JIRA support.
+* Improved Pathname settings for Codehaus, SourceForge, Trac and RubyForge.
+* Pathname now takes a revision argument in the constructor.
+* Moved ScmWeb to ScmWeb::Browser.
+* Added a subset of the Ruby stlib Pathname API to ScmWeb.
+* Added a String extension for dealing with trailing slashes in URLs.
+
+== Version 0.4.4
+
+This release introduces a new Domain Specific Language (DSL) for SCM commit messages similar to Trac's post-commit hook for updating tickets.
+Patois is supported in a tracker-agnostic way (although it's only half implemented for JIRA only ATM).
+There is also initial support for FreshMeat and RAA thanks to Thomas Leitner.
+
+* Added support for Patois parsing (See RubyDoc).
+* Gave the Patois DSL its name.
+* Improved the Tracker::Issue API to be more OO and uniform across trackers.
+* Adds support for FreshMeat and RAA (Fixes #2323). This is not aligned with the rest of the MetaProject API yet.
+
+== Version 0.4.3
+
+This release fixes some bugs and implements some new issue tracker features.
+
+* Aligned properties between TracTracker and JiraTracker with ProjectAnalyzer.
+* Stripping leading and trailing whitespace from issue summaries (SF seems to have changed).
+* Added name to XForge projects.
+* Added create_issue to JiraTracker.
+
+== Version 0.4.2
+
+This is a minor release that accommodates fos some changes needed by DamageControl.
+
+* Made tracker constructors empty so they can be used from DamageControl.
+* Made ScmWeb constructor empty so it can be used from DamageControl.
+* Made JiraTracker look for user/password in environment variables and log error if not defined.
+
+== Version 0.4.1
+
+This version renames xforge to meta_project. This is because the scope of this project
+has grown beyond SourceForge clones.
+
+* renamed gem
+
+== Version 0.4.0
+
+This release of XForge completely reorganises classes and modules into a more
+coherent API for accessing projects' issue trackers, scms and scm browsers. The toplevel
+namespace is now MetaProject.
+
+The new ScmWeb class now supports *any* scm browser through its flexible
+configuration options.
+
+In order to easily gather information from various hosting services, XForge comes with a ProjectAnalyzer
+class, which given an scm browser URL will discover the associated issue tracker, preconfigured scm_web,
+project home page and of course, an RSCM object.
+
+Supported project sources:
+- RubyForge.org
+- SourceForge.org
+- Codehaus.org
+- Trac projects
+
+Supported issue trackers:
+- RubyForge.org
+- SourceForge.org
+- JIRA
+- Trac projects
+
+Supported SCM browsers:
+- *Any* scm browser through its flexible configuration options.
+
+Supported SCMs:
+- Any SCM implemented in the <a href="http://rscm.rubyforge.org/">RSCM</a> project.
+
+The QRS Rake tasks for releasing files and news on RubyForge has changed slightly. Please refer to XForge's
+own Rakefile for details.
+
+== Version 0.3.5
+
+This is a bugfix release that fixes some bugs in ViewCvs.
+
+* Changed the way the server path of RSCM::Cvs objects are initialised from ViewCvs to fix a subtle bug.
+* Factored out generic file_uri to ScmWeb::FileUri.
+* Fixed bug in RubyForge's recognition of modules in ViewCvs.
+
+== Version 0.3.4
+
+This release simplifies ViewCvs configuration
+
+* Removed project_unix_name from ViewCvs' uri_specs
+* Tuned how XForge::Project is YAMLed, to avoid backreferences
+* Renamed some Tracker classes to be prefixed with the module name. This was to ease DamageControl integration.
+
+== Version 0.3.3
+
+This is a minor refactoring release
+
+* Decoupled Trac::Project from RSCM::Subversion
+* Made Tracker::ViewCvs use Strings as values instead of symbols (to make it easier to post from a web form)
+
+== Version 0.3.2
+
+This release adds more support for other issue trackers ans scm browsers.
+
+* Fixed #2242
+* Added a lot of tracker and scm_web classes (factored out from DamageControl)
+* Decoupled view_cvs from rubyforge/sourceforge
+
+== Version 0.3.1
+
+This XForge release adds initial support for Trac and JIRA.
+
+* Added support for formatting of text containing issue identifiers
+* Refactored trackers into other modules
+* Added support for JIRA issue tracker
+* Added support for Trac's issue tracker
+* Added support for diff URLs on SourceForge and RubyForge
+
+== Version 0.2.1
+
+This XForge release adds support for tracker meta info
+
+* Added Project.tracker method
+* Require Rake tasks from toplevel xforge.rb
+
+== Version 0.2.0
+
+First stable release of the XForge QRS.
+
+* Renamed Project.name to Project.unix_name
+* Wrote better documentation
+* Included CVS tagging in the Rakefile
+
+== Version 0.1.9
+
+This release adds more functionality for news publishing
+
+* Added Session.publish_news
+
+== Version 0.1.8
+
+This release adds more functionality for RubyForge projects' home page
+
+* Added Project.home_page_uri and Project.project_uri
+
+== Version 0.1.7
+
+Updated README
+
+== Version 0.1.6
+
+This release of XForge improves scm browser capabilities.
+
+* Added ViewCvs.uri(path, options) method to get an URI to a file on the web
+* Added an rspec suite
+* Added logic for parsing top-level CVS modules
+* Made Rake Release task use RubyForge by default
+
+== Version 0.1.5
+
+This release of XForge adds functionality to access scm browsers (ViewCvs) and RSCM objects.
+
+* Refactored classes into separate files
+* Added Project.scm_web to access a ViewCvs object 
+* Added ViewCvs.scms to access an array of RSCM::Cvs
+
+== Version 0.1.4
+
+This is the first functional release of XForge, a Ruby library and Rake task to automate release of
+files on RubyForge and other SourceForge clones.
+
+It's as simple as this:
+
+require 'xforge'
+
+desc "Create a new release on RubyForge"
+task :publish_files => [:gem] do
+  release_files = FileList[
+    "pkg/#{PKG_FILE_NAME}.gem"
+  ]
+
+  Rake::XForge::Release.new(PKG_NAME) do |release|
+    # Never hardcode user name and password in the Rakefile!
+    release.user_name = ENV['RUBYFORGE_USER']
+    release.password = ENV['RUBYFORGE_PASSWORD']
+    release.files = release_files.to_a
+    release.release_name = "XForge #{PKG_VERSION}"
+    # The rest of the options are defaults (among others, release_notes and release_changes, parsed from CHANGES)
+  end
+end
+
+* Added logic for parsing of CHANGES files and include it in the release notes when publishing.
+* Wrote some proper release notes for once.
+
+== Version 0.1.3
+
+* Added logic for parsing of CHANGES files and include it in the release notes when publishing.
+
+== Version 0.1.2
+
+This release is a minor release with fixes in the Rake script.
+
+* Fixed RDoc for gem
+* Cleaned up documentation
+
+== Version 0.1.1
+
+* Rakefile: Don't include old gems in release.
+
+== Version 0.1
+
+* Added support for file releases