paperclip-v2_7-patched-ruby-1_8_6 2.7.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 24dd04093b249918fb649dd1d8e559fd788644dc
+  data.tar.gz: c87063ee1786227fc7c1462c5237cc60d59544f2
+SHA512:
+  metadata.gz: 586ce2ccb867d6ac5e829092070522e65421f9199bee01056e1b4172df2481b0e3a2d10d2da983f468c3452bb9fc917611d2bf2b4b5bd3fca5af22aa7e96c7d1
+  data.tar.gz: 09564bed3a1aef274fc213c8e371732b156f97a5e480e557a52b3f501cc94fa78b8e04bd3fe9b659cae473e8d96ded08d598c8196b7a6dc3cc1ed7ad5370f19e

data/.gitignore

@@ -0,0 +1,23 @@
+*~
+*.swp
+.rvmrc
+.bundle
+tmp
+
+test/s3.yml
+test/debug.log
+test/paperclip.db
+test/doc
+test/pkg
+test/tmp
+
+public
+paperclip*.gem
+capybara*.html
+
+*.rbc
+.rbx
+
+*SPIKE*
+*emfile.lock
+tags

data/.travis.yml

@@ -0,0 +1,14 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - rbx-18mode
+
+before_script: "sudo ntpdate -ub ntp.ubuntu.com pool.ntp.org; true"
+script: "bundle exec rake clean test cucumber"
+
+gemfile:
+  - gemfiles/rails2.gemfile
+  - gemfiles/rails3.gemfile
+  - gemfiles/rails3_1.gemfile
+  - gemfiles/rails3_2.gemfile

data/Appraisals

@@ -0,0 +1,20 @@
+appraise "rails2" do
+  gem "rails", "~> 2.3.14"
+  gem "paperclip", :path => "../"
+end
+
+appraise "rails3" do
+  gem "rails", "~> 3.0.10"
+  gem "paperclip", :path => "../"
+end
+
+appraise "rails3_1" do
+  gem "rails", "~> 3.1.0"
+  gem "paperclip", :path => "../"
+end
+
+appraise "rails3_2" do
+  gem "rails", "~> 3.2.0"
+  gem "paperclip", :path => "../"
+end
+

data/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+We love pull requests. Here's a quick guide:
+
+1. Fork the repo.
+
+2. Run the tests. We only take pull requests with passing tests, and it's great
+to know that you have a clean slate: `bundle && rake`
+
+3. Add a test for your change. Only refactoring and documentation changes
+require no new tests. If you are adding functionality or fixing a bug, we need
+a test!
+
+4. Make the test pass.
+
+5. Push to your fork and submit a pull request.
+
+
+At this point you're waiting on us. We like to at least comment on, if not
+accept, pull requests within three business days (and, typically, one business
+day). We may suggest some changes or improvements or alternatives.
+
+Some things that will increase the chance that your pull request is accepted,
+taken straight from the Ruby on Rails guide:
+
+* Use Rails idioms and helpers
+* Include tests that fail without your code, and pass with it
+* Update the documentation, the surrounding one, examples elsewhere, guides,
+  whatever is affected by your contribution
+
+Syntax:
+
+* Two spaces, no tabs.
+* No trailing whitespace. Blank lines should not have any space.
+* Prefer &&/|| over and/or.
+* MyClass.my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
+* a = b and not a=b.
+* Follow the conventions you see used in the source already.
+
+And in case we didn't emphasize it enough: we love tests!

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "jruby-openssl", :platform => :jruby

data/LICENSE

@@ -0,0 +1,26 @@
+
+LICENSE
+
+The MIT License
+
+Copyright (c) 2008 Jon Yurek and thoughtbot, inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+

data/NEWS

@@ -0,0 +1,69 @@
+New in 2.7.5:
+
+* Feature: :s3_host_name can be a proc
+
+New in 2.7.4:
+
+* Feature: Allow :escape_url as an option in the defaults
+* Bug fix: Correcting some PATH-based tests.
+* Compatability: Cucumber tests work for Rails 3.2.8
+
+New in 2.7.2
+
+* Bug fix: Ensured the correct cocaine version.
+* Bug fix: Fixed some tests that shouldn't have been passing.
+
+New in 2.7.1:
+
+* Bug fix: Fixed the problem with E2BIG errors and an ever-expanding path
+
+New in 2.7.0:
+
+* Bug fix: Checking the existence of a file on S3 handles all AWS errors.
+* Bug fix: Clear the fingerprint when removing an attachment.
+* Bug fix: Attachment size validation message reads more nicely now.
+* Feature: Style names can be either symbols or strings.
+* Compatibility: Support for ActiveSupport < 2.3.12.
+* Compatibility: Support for Rails 3.2.
+
+New in 2.6.0:
+
+* Bug fix: Files are re-wound after reading.
+* Feature: Remove Rails dependency from specs that need Paperclip.
+* Feature: Validation matchers support conditionals.
+
+New in 2.5.2:
+
+* Bug fix: Can be installed on Windows.
+* Feature: The Fog bucket name, authentication, and host can be determined at runtime via Proc.
+* Feature: Special characters are replaced with underscores in #url and #path.
+
+New in 2.5.1:
+
+* Feature: After we've computed the content type, pass it to Fog.
+* Feature: S3 encryption with the new :s3_server_side_encryption option.
+* Feature: Works without ActiveRecord, allowing for e.g. mongo backends.
+
+New in 2.5.0:
+
+* Performance: Only connect to S3 when absolutely needed.
+* Bug fix: STI with cached classes respect new options.
+* Bug fix: conditional validations broke, and now work again.
+* Feature: URL generation is now parameterized and can be changed with plugins or custom code.
+* Feature: :convert_options and :source_file_options to control the ImageMagick processing.
+* Performance: String geometry specifications now parse more quickly.
+* Bug fix: Handle files with question marks in the filename.
+* Bug fix: Don't raise an error when generating an expiring URL on an unassigned attachment.
+* Bug fix: The rake task runs over all instances of an ActiveRecord model, ignoring default scopes.
+* Feature: DB migration has_attached_file and drop_attached_file methods.
+* Bug fix: Switch from AWS::S3 to AWS::SDK for the S3 backend.
+* Bug fix: URL generator uses '?' in the URL unless it already appears and there is no prior '='.
+* Bug fix: Always convert the content type to a string before stripping blanks.
+* Feature: The :keep_old_files option preserves the files in storage even when the attachment is cleared or changed.
+* Performance: Optimize Fog's public_url access by avoiding it when possible.
+* Bug fix: Avoid a runtime error when generating the ID partition for an unsaved attachment.
+* Performance: Do not calculate the fingerprint if it is never persisted.
+* Bug fix: Process the :original style before all others, in case of a dependency.
+* Feature: S3 headers can be set at runtime by passing a proc object as the value.
+* Bug fix: Generating missing attachment styles for a model which has had its attachment changed should not raise.
+* Bug fix: Do not collide with the built-in Ruby hashing method.

data/README.md

@@ -0,0 +1,444 @@
+Paperclip
+=========
+
+[![Build Status](https://secure.travis-ci.org/thoughtbot/paperclip.png?branch=master)](http://travis-ci.org/thoughtbot/paperclip) [![Dependency Status](https://gemnasium.com/thoughtbot/paperclip.png?travis)](https://gemnasium.com/thoughtbot/paperclip)
+
+Paperclip is intended as an easy file attachment library for Active Record. The
+intent behind it was to keep setup as easy as possible and to treat files as
+much like other attributes as possible. This means they aren't saved to their
+final locations on disk, nor are they deleted if set to nil, until
+ActiveRecord::Base#save is called. It manages validations based on size and
+presence, if required. It can transform its assigned image into thumbnails if
+needed, and the prerequisites are as simple as installing ImageMagick (which,
+for most modern Unix-based systems, is as easy as installing the right
+packages). Attached files are saved to the filesystem and referenced in the
+browser by an easily understandable specification, which has sensible and
+useful defaults.
+
+See the documentation for `has_attached_file` in [`Paperclip::ClassMethods`](http://rubydoc.info/gems/paperclip/Paperclip/ClassMethods) for
+more detailed options.
+
+The complete [RDoc](http://rdoc.info/gems/paperclip) is online.
+
+
+Requirements
+------------
+
+ImageMagick must be installed and Paperclip must have access to it. To ensure
+that it does, on your command line, run `which convert` (one of the ImageMagick
+utilities). This will give you the path where that utility is installed. For
+example, it might return `/usr/local/bin/convert`.
+
+Then, in your environment config file, let Paperclip know to look there by adding that
+directory to its path.
+
+In development mode, you might add this line to `config/environments/development.rb)`:
+
+    Paperclip.options[:command_path] = "/usr/local/bin/"
+
+If you're on Mac OS X, you'll want to run the following with Homebrew:
+
+    brew install imagemagick
+
+If you are dealing with pdf uploads or running the test suite, you'll also need
+GhostScript to be installed. On Mac OS X, you can also install that using Homebrew:
+
+    brew install gs
+
+
+Installation
+------------
+
+Paperclip is distributed as a gem, which is how it should be used in your app. It's
+technically still installable as a plugin, but that's discouraged, as Rails plays
+well with gems.
+
+Include the gem in your Gemfile:
+
+    gem "paperclip", "~> 2.0"
+
+Or, if you want to get the latest, you can get master from the main paperclip repository:
+
+    gem "paperclip", :git => "git://github.com/thoughtbot/paperclip.git"
+
+If you're trying to use features that don't seem to be in the latest released gem, but are
+mentioned in this README, then you probably need to specify the master branch if you want to
+use them. This README is probably ahead of the latest released version, if you're reading it
+on GitHub.
+
+Anyway, if you don't use Bundler (though you probably should, even in Rails 2), with config.gem
+
+    # In config/environment.rb
+    ...
+    Rails::Initializer.run do |config|
+      ...
+      config.gem "paperclip", :version => "~> 2.4"
+      ...
+    end
+
+For Non-Rails usage:
+
+    class ModuleName < ActiveRecord::Base
+        include Paperclip::Glue
+        ...
+    end
+
+Quick Start
+-----------
+
+In your model:
+
+    class User < ActiveRecord::Base
+      has_attached_file :avatar, :styles => { :medium => "300x300>", :thumb => "100x100>" }
+    end
+
+In your migrations:
+
+    class AddAvatarColumnsToUser < ActiveRecord::Migration
+      def self.up
+        change_table :users do |t|
+          t.has_attached_file :avatar
+        end
+      end
+
+      def self.down
+        drop_attached_file :users, :avatar
+      end
+    end
+
+In your edit and new views:
+
+    <%= form_for :user, @user, :url => user_path, :html => { :multipart => true } do |form| %>
+      <%= form.file_field :avatar %>
+    <% end %>
+
+In your controller:
+
+    def create
+      @user = User.create( params[:user] )
+    end
+
+In your show view:
+
+    <%= image_tag @user.avatar.url %>
+    <%= image_tag @user.avatar.url(:medium) %>
+    <%= image_tag @user.avatar.url(:thumb) %>
+
+To detach a file, simply set the attribute to `nil`:
+
+    @user.avatar = nil
+    @user.save
+
+Usage
+-----
+
+The basics of paperclip are quite simple: Declare that your model has an
+attachment with the `has_attached_file` method, and give it a name.
+
+Paperclip will wrap up up to four attributes (all prefixed with that attachment's name,
+so you can have multiple attachments per model if you wish) and give them a
+friendly front end. These attributes are:
+
+* `<attachment>_file_name`
+* `<attachment>_file_size`
+* `<attachment>_content_type`
+* `<attachment>_updated_at`
+
+By default, only `<attachment>_file_name` is required for paperclip to operate.
+You'll need to add `<attachment>_content_type` in case you want to use content type
+validation.
+
+More information about the options to `has_attached_file` is available in the
+documentation of [`Paperclip::ClassMethods`](http://rubydoc.info/gems/paperclip/Paperclip/ClassMethods).
+
+For validations, attachments can be validated with these Paperclip's validation methods:
+
+* `validates_attachment_presence`
+* `validates_attachment_content_type`
+* `validates_attachment_size`
+
+Storage
+-------
+
+The files that are assigned as attachments are, by default, placed in the
+directory specified by the `:path` option to `has_attached_file`. By default, this
+location is `:rails_root/public/system/:attachment/:id/:style/:filename`. This
+location was chosen because on standard Capistrano deployments, the
+`public/system` directory is symlinked to the app's shared directory, meaning it
+will survive between deployments. For example, using that `:path`, you may have a
+file at
+
+    /data/myapp/releases/20081229172410/public/system/avatars/13/small/my_pic.png
+
+_**NOTE**: This is a change from previous versions of Paperclip, but is overall a
+safer choice for the default file store._
+
+You may also choose to store your files using Amazon's S3 service. To do so, include
+the `aws-sdk` gem in your Gemfile:
+
+    gem 'aws-sdk', '~> 1.3.4'
+
+And then you can specify using S3 from `has_attached_file`.
+You can find more information about configuring and using S3 storage in
+[the `Paperclip::Storage::S3` documentation](http://rubydoc.info/gems/paperclip/Paperclip/Storage/S3).
+
+Files on the local filesystem (and in the Rails app's public directory) will be
+available to the internet at large. If you require access control, it's
+possible to place your files in a different location. You will need to change
+both the `:path` and `:url` options in order to make sure the files are unavailable
+to the public. Both `:path` and `:url` allow the same set of interpolated
+variables.
+
+Post Processing
+---------------
+
+Paperclip supports an extensible selection of post-processors. When you define
+a set of styles for an attachment, by default it is expected that those
+"styles" are actually "thumbnails". However, you can do much more than just
+thumbnail images. By defining a subclass of Paperclip::Processor, you can
+perform any processing you want on the files that are attached. Any file in
+your Rails app's lib/paperclip\_processors directory is automatically loaded by
+paperclip, allowing you to easily define custom processors. You can specify a
+processor with the :processors option to has\_attached\_file:
+
+    has_attached\_file :scan, :styles => { :text => { :quality => :better } },
+                             :processors => [:ocr]
+
+This would load the hypothetical class Paperclip::Ocr, which would have the
+hash "{ :quality => :better }" passed to it along with the uploaded file. For
+more information about defining processors, see Paperclip::Processor.
+
+The default processor is Paperclip::Thumbnail. For backwards compatability
+reasons, you can pass a single geometry string or an array containing a
+geometry and a format, which the file will be converted to, like so:
+
+    has_attached_file :avatar, :styles => { :thumb => ["32x32#", :png] }
+
+This will convert the "thumb" style to a 32x32 square in png format, regardless
+of what was uploaded. If the format is not specified, it is kept the same (i.e.
+jpgs will remain jpgs). For more information on the accepted style formats, see
+[http://www.imagemagick.org/script/command-line-processing.php#geometry](here).
+
+Multiple processors can be specified, and they will be invoked in the order
+they are defined in the :processors array. Each successive processor will
+be given the result of the previous processor's execution. All processors will
+receive the same parameters, which are what you define in the :styles hash.
+For example, assuming we had this definition:
+
+    has_attached_file :scan, :styles => { :text => { :quality => :better } },
+                             :processors => [:rotator, :ocr]
+
+then both the :rotator processor and the :ocr processor would receive the
+options "{ :quality => :better }". This parameter may not mean anything to one
+or more or the processors, and they are expected to ignore it.
+
+_NOTE: Because processors operate by turning the original attachment into the
+styles, no processors will be run if there are no styles defined._
+
+If you're interested in caching your thumbnail's width, height and size in the
+database, take a look at the [paperclip-meta](https://github.com/y8/paperclip-meta) gem.
+
+Also, if you're interested in generating the thumbnail on-the-fly, you might want
+to look into the [attachment_on_the_fly](https://github.com/drpentode/Attachment-on-the-Fly) gem.
+
+Events
+------
+
+Before and after the Post Processing step, Paperclip calls back to the model
+with a few callbacks, allowing the model to change or cancel the processing
+step. The callbacks are `before_post_process` and `after_post_process` (which
+are called before and after the processing of each attachment), and the
+attachment-specific `before_<attachment>_post_process` and
+`after_<attachment>_post_process`. The callbacks are intended to be as close to
+normal ActiveRecord callbacks as possible, so if you return false (specifically
+\- returning nil is not the same) in a before\_ filter, the post processing step
+will halt. Returning false in an after\_ filter will not halt anything, but you
+can access the model and the attachment if necessary.
+
+_NOTE: Post processing will not even *start* if the attachment is not valid
+according to the validations. Your callbacks and processors will *only* be
+called with valid attachments._
+
+URI Obfuscation
+---------------
+
+Paperclip has an interpolation called `:hash` for obfuscating filenames of
+publicly-available files.
+
+Example Usage:
+
+    has_attached_file :avatar, {
+        :url => "/system/:hash.:extension",
+        :hash_secret => "longSecretString"
+    }
+
+
+The `:hash` interpolation will be replaced with a unique hash made up of whatever
+is specified in `:hash_data`. The default value for `:hash_data` is `":class/:attachment/:id/:style/:updated_at"`.
+
+`:hash_secret` is required, an exception will be raised if `:hash` is used without `:hash_secret` present.
+
+For more on this feature read the author's own explanation. [https://github.com/thoughtbot/paperclip/pull/416](https://github.com/thoughtbot/paperclip/pull/416)
+
+MD5 Checksum / Fingerprint
+-------
+
+A MD5 checksum of the original file assigned will be placed in the model if it
+has an attribute named fingerprint.  Following the user model migration example
+above, the migration would look like the following.
+
+    class AddAvatarFingerprintColumnToUser < ActiveRecord::Migration
+      def self.up
+        add_column :users, :avatar_fingerprint, :string
+      end
+
+      def self.down
+        remove_column :users, :avatar_fingerprint
+      end
+    end
+
+Custom Attachment Processors
+-------
+
+Custom attachment processors can be implemented and their only requirement is
+to inherit from `Paperclip::Processor` (see `lib/paperclip/processor.rb`).
+For example, when `:styles` are specified for an image attachment, the
+thumbnail processor (see `lib/paperclip/thumbnail.rb`) is loaded without having
+to specify it as a `:processor` parameter to `has_attached_file`.  When any
+other processor is defined it must be called out in the `:processors`
+parameter if it is to be applied to the attachment.  The thumbnail processor
+uses the imagemagick `convert` command to do the work of resizing image
+thumbnails.  It would be easy to create a custom processor that watermarks
+an image using imagemagick's `composite` command.  Following the
+implementation pattern of the thumbnail processor would be a way to implement a
+watermark processor.  All kinds of attachment processors can be created;
+a few utility examples would be compression and encryption processors.
+
+
+Dynamic Configuration
+---------------------
+
+Callable objects (lambdas, Procs) can be used in a number of places for dynamic
+configuration throughout Paperclip.  This strategy exists in a number of
+components of the library but is most significant in the possibilities for
+allowing custom styles and processors to be applied for specific model
+instances, rather than applying defined styles and processors across all
+instances.
+
+Dynamic Styles:
+
+Imagine a user model that had different styles based on the role of the user.
+Perhaps some users are bosses (e.g. a User model instance responds to #boss?)
+and merit a bigger avatar thumbnail than regular users. The configuration to
+determine what style parameters are to be used based on the user role might
+look as follows where a boss will receive a `300x300` thumbnail otherwise a
+`100x100` thumbnail will be created.
+
+    class User < ActiveRecord::Base
+      has_attached_file :avatar, :styles => lambda { |attachment| { :thumb => (attachment.instance.boss? ? "300x300>" : "100x100>") }
+    end
+
+Dynamic Processors:
+
+Another contrived example is a user model that is aware of which file processors
+should be applied to it (beyond the implied `thumbnail` processor invoked when
+`:styles` are defined). Perhaps we have a watermark processor available and it is
+only used on the avatars of certain models.  The configuration for this might be
+where the instance is queried for which processors should be applied to it.
+Presumably some users might return `[:thumbnail, :watermark]` for its
+processors, where a defined `watermark` processor is invoked after the
+`thumbnail` processor already defined by Paperclip.
+
+    class User < ActiveRecord::Base
+      has_attached_file :avatar, :processors => lambda { |instance| instance.processors }
+      attr_accessor :watermark
+    end
+
+Deploy
+------
+
+Paperclip is aware of new attachment styles you have added in previous deploy. The only thing you should do after each deployment is to call
+`rake paperclip:refresh:missing_styles`.  It will store current attachment styles in `RAILS_ROOT/public/system/paperclip_attachments.yml`
+by default. You can change it by:
+
+    Paperclip.registered_attachments_styles_path = '/tmp/config/paperclip_attachments.yml'
+
+Here is an example for Capistrano:
+
+    namespace :deploy do
+      desc "build missing paperclip styles"
+      task :build_missing_paperclip_styles, :roles => :app do
+        run "cd #{release_path}; RAILS_ENV=production bundle exec rake paperclip:refresh:missing_styles"
+      end
+    end
+
+    after("deploy:update_code", "deploy:build_missing_paperclip_styles")
+
+Now you don't have to remember to refresh thumbnails in production everytime you add new style.
+Unfortunately it does not work with dynamic styles - it just ignores them.
+
+If you already have working app and don't want `rake paperclip:refresh:missing_styles` to refresh old pictures, you need to tell
+Paperclip about existing styles. Simply create paperclip\_attachments.yml file by hand. For example:
+
+    class User < ActiveRecord::Base
+      has_attached_file :avatar, :styles => {:thumb => 'x100', :croppable => '600x600>', :big => '1000x1000>'}
+    end
+
+    class Book < ActiveRecord::Base
+      has_attached_file :cover, :styles => {:small => 'x100', :large => '1000x1000>'}
+      has_attached_file :sample, :styles => {:thumb => 'x100'}
+    end
+
+Then in `RAILS_ROOT/public/system/paperclip_attachments.yml`:
+
+    ---
+    :User:
+      :avatar:
+      - :thumb
+      - :croppable
+      - :big
+    :Book:
+      :cover:
+      - :small
+      - :large
+      :sample:
+      - :thumb
+
+Testing
+-------
+
+Paperclip provides rspec-compatible matchers for testing attachments. See the
+documentation on [Paperclip::Shoulda::Matchers](http://rubydoc.info/gems/paperclip/Paperclip/Shoulda/Matchers)
+for more information.
+
+Contributing
+------------
+
+If you'd like to contribute a feature or bugfix: Thanks! To make sure your
+fix/feature has a high chance of being included, please read the following
+guidelines:
+
+1. Ask on the mailing list[http://groups.google.com/group/paperclip-plugin], or
+   post a new GitHub Issue[http://github.com/thoughtbot/paperclip/issues].
+2. Make sure there are tests! We will not accept any patch that is not tested.
+   It's a rare time when explicit tests aren't needed. If you have questions
+   about writing tests for paperclip, please ask the mailing list.
+
+Please see CONTRIBUTING.md for details.
+
+Credits
+-------
+
+![thoughtbot](http://thoughtbot.com/images/tm/logo.png)
+
+Paperclip is maintained and funded by [thoughtbot, inc](http://thoughtbot.com/community)
+
+Thank you to all [the contributors](https://github.com/thoughtbot/paperclip/contributors)!
+
+The names and logos for thoughtbot are trademarks of thoughtbot, inc.
+
+License
+-------
+
+Paperclip is Copyright © 2008-2011 thoughtbot. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.
+