drnic-haml 2.3.0

data/.yardopts

@@ -0,0 +1,5 @@
+--readme          README.md
+--markup          markdown
+--markup-provider maruku
+--protected
+--no-highlight

data/CONTRIBUTING

@@ -0,0 +1,4 @@
+Contributions are welcomed. Please see the following sites for guidelines:
+
+  http://haml-lang.com/development.html#contributing
+  http://sass-lang.com/development.html#contributing

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2009 Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein
+
+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/README.md

@@ -0,0 +1,347 @@
+# Haml and Sass
+
+Haml and Sass are templating engines
+for the two most common types of documents on the web:
+HTML and CSS, respectively.
+They are designed to make it both easier and more pleasant
+to code HTML and CSS documents,
+by eliminating redundancy,
+reflecting the underlying structure that the document represents,
+and providing elegant, easily understandable, and powerful syntax.
+
+## Using
+
+Haml and Sass can be used from the command line
+or as part of a Ruby web framework.
+The first step is to install the gem:
+
+    gem install haml
+
+After you convert some HTML to Haml or some CSS to Sass,
+you can run
+
+    haml document.haml
+    sass style.sass
+
+to compile them.
+For more information on these commands, check out
+
+    haml --help
+    sass --help
+
+To install Haml and Sass as a Rails plugin,
+just run `haml --rails path/to/rails/app`
+and both Haml and Sass will be installed.
+Views with the `.html.haml` extension will automatically use Haml.
+Sass is a little more complicated;
+`.sass` files should be placed in `public/stylesheets/sass`,
+where they'll be automatically compiled
+to corresponding CSS files in `public/stylesheets` when needed
+(the Sass template directory is customizable...
+see [the Sass reference](http://sass-lang.com/docs/yardoc/SASS_REFERENCE.md.html#template_location-option) for details).
+
+For Merb, `.html.haml` views will work without any further modification.
+To enable Sass, you also need to add a dependency.
+To do so, just add
+
+    dependency "merb-haml"
+
+to `config/dependencies.rb` (or `config/init.rb` in a flat/very flat Merb application).
+Then it'll work just like it does in Rails.
+
+To use Haml and Sass programatically,
+check out the [YARD documentation](http://haml-lang.com/docs/yardoc).
+
+## Formatting
+
+### Haml
+
+The most basic element of Haml
+is a shorthand for creating HTML:
+
+    %tagname{:attr1 => 'value1', :attr2 => 'value2'} Contents
+
+No end-tag is needed; Haml handles that automatically.
+If you prefer HTML-style attributes, you can also use:
+
+    %tagname(attr1='value1' attr2='value2') Contents
+
+Adding `class` and `id` attributes is even easier.
+Haml uses the same syntax as the CSS that styles the document:
+
+    %tagname#id.class
+
+In fact, when you're using the `<div>` tag,
+it becomes _even easier_.
+Because `<div>` is such a common element,
+a tag without a name defaults to a div. So
+
+    #foo Hello!
+
+becomes
+
+    <div id='foo'>Hello!</div>
+
+Haml uses indentation
+to bring the individual elements to represent the HTML structure.
+A tag's children are indented beneath than the parent tag.
+Again, a closing tag is automatically added.
+For example:
+
+    %ul
+      %li Salt
+      %li Pepper
+
+becomes:
+
+    <ul>
+      <li>Salt</li>
+      <li>Pepper</li>
+    </ul>
+
+You can also put plain text as a child of an element:
+
+    %p
+      Hello,
+      World!
+
+It's also possible to embed Ruby code into Haml documents.
+An equals sign, `=`, will output the result of the code.
+A hyphen, `-`, will run the code but not output the result.
+You can even use control statements
+like `if` and `while`:
+
+    %p
+      Date/Time:
+      - now = DateTime.now
+      %strong= now
+      - if now > DateTime.parse("December 31, 2006")
+        = "Happy new " + "year!"
+
+Haml provides far more tools than those presented here.
+Check out the reference documentation in the Haml module.
+
+### Sass
+
+At its most basic,
+Sass is just another way of writing CSS.
+Although it's very much like normal CSS,
+the basic syntax offers a few helpful features:
+indentation indicates the properties in a rule,
+rather than non-DRY brackets;
+and newlines indicate the end of a properties,
+rather than a semicolon.
+For example:
+
+    #main
+      background-color: #f00
+      width: 98%
+
+becomes:
+
+    #main {
+      background-color: #f00;
+      width: 98% }
+
+However, Sass provides much more than a way to make CSS look nice.
+In CSS, it's important to have accurate selectors,
+so your styles don't just apply to everything.
+However, in order to do this,
+you need to use nested element selectors.
+These get very ugly very quickly.
+I'm sure everyone's had to write something like
+"#main .sidebar .top p h1 a",
+followed by
+"#main .sidebar .top p h1 a:visited" and
+"#main .sidebar .top p h1 a:hover".
+Well, Sass gets rid of that.
+Like Haml, it uses indentation to indicate the structure of the document.
+So, what was:
+
+    #main {
+      width: 90%;
+    }
+    #main p {
+      border-style: solid;
+      border-width: 1px;
+      border-color: #00f;
+    }
+    #main p a {
+      text-decoration: none;
+      font-weight: bold;
+    }
+    #main p a:hover {
+      text-decoration: underline;
+    }
+
+becomes:
+
+    #main
+      width: 90%
+      p
+        border-style: solid
+        border-width: 1px
+        border-color: #00f
+        a
+          text-decoration: none
+          font-weight: bold
+        a:hover
+          text-decoration: underline
+
+Pretty nice, no? Well, it gets better.
+One of the main complaints against CSS is that it doesn't allow variables.
+What if have a color or a width you re-use all the time?
+In CSS, you just have to re-type it each time,
+which is a nightmare when you decide to change it later.
+Not so for Sass!
+You can use the `!` character to set variables.
+Then, if you put `=` after your property name,
+you can set it to a variable.
+For example:
+
+    !note_bg= #55aaff
+
+    #main
+      width: 70%
+      .note
+        background-color = !note_bg
+      p
+        width: 5em
+        background-color = !note_bg
+
+becomes:
+
+    #main {
+      width: 70%; }
+      #main .note {
+        background-color: #55aaff; }
+      #main p {
+        width: 5em;
+        background-color: #55aaff; }
+
+You can even do simple arithmetic operations with variables,
+adding numbers and even colors together:
+
+    !main_bg= #46ar12
+    !main_width= 40em
+
+    #main
+      background-color = !main_bg
+      width = !main_width
+      .sidebar
+        background-color = !main_bg + #333333
+        width = !main_width - 25em
+
+becomes:
+
+    #main {
+      background-color: #46a312;
+      width: 40em; }
+      #main .sidebar {
+        background-color: #79d645;
+        width: 15em; }
+
+Taking the idea of variables a bit further are mixins.
+These let you group whole bunches of CSS properties into a single
+directive and then include those anywhere you want:
+
+    =blue-border
+      border:
+        color: blue
+        width: 2px
+        style: dotted
+
+    .comment
+      +blue-border
+      padding: 2px
+      margin: 10px 0
+
+    .reply
+      +blue-border
+
+becomes:
+
+    .comment {
+      border-color: blue;
+      border-width: 2px;
+      border-style: dotted;
+      padding: 2px;
+      margin: 10px 0;
+    }
+
+    .reply {
+      border-color: blue;
+      border-width: 2px;
+      border-style: dotted;
+    }
+
+A comprehensive list of features is in
+the documentation for the Sass module.
+
+## Indentation
+
+Indentation can be made up of one or more tabs or spaces.
+However, indentation must be consistent within a given document.
+Hard tabs and spaces can't be mixed,
+and the same number of tabs or spaces must be used throughout.
+
+## Executables
+
+The Haml gem includes several executables that are useful
+for dealing with Haml and Sass from the command line.
+
+### `haml`
+
+The `haml` executable transforms a source Haml file into HTML.
+See `haml --help` for further information and options.
+
+### `sass`
+
+The `sass` executable transforms a source Sass file into CSS.
+See `sass --help` for further information and options.
+
+### `html2haml`
+
+The `html2haml` executable attempts to transform HTML,
+optionally with ERB markup, into Haml code.
+Since HTML is so variable, this transformation is not always perfect;
+it's a good idea to have a human check the output of this tool.
+See `html2haml --help` for further information and options.
+
+### `css2sass`
+
+The `css2sass` executable attempts to transform CSS into Sass code.
+This transformation attempts to use Sass nesting where possible.
+See `css2sass --help` for further information and options.
+
+## Authors
+
+Haml and Sass were created by [Hampton Catlin](http://hamptoncatlin.com)
+(hcatlin) and he is the author of the original implementation. However, Hampton
+doesn't even know his way around the code anymore and now occasionally consults
+on the language issues.  Hampton lives in Jacksonville, Florida and is the lead
+mobile developer for Wikimedia.
+
+[Nathan Weizenbaum](http://nex-3.com) is the primary developer and architect of
+the "modern" Ruby implementation of Haml. His hard work has kept the project
+alive by endlessly answering forum posts, fixing bugs, refactoring, finding
+speed improvements, writing documentation, implementing new features, and
+getting Hampton coffee (a fitting task for a boy-genius). Nathan lives in
+Seattle, Washington and while not being a student at the University of
+Washington or working at an internship, he consults for Unspace Interactive.
+
+[Chris Eppstein](http://acts-as-architect.blogspot.com) is a core contributor to
+Sass and the creator of Compass, the first Sass-based framework. Chris focuses
+on making Sass more powerful, easy to use, and on ways to speed its adoption
+through the web development community. Chris lives in San Jose, California with
+his wife and daughter. He is the Software Architect for
+[Caring.com](http://caring.com), a website devoted to the 34 Million caregivers
+whose parents are sick or elderly, that uses Haml and Sass.
+
+If you use this software, you must pay Hampton a compliment. And
+buy Nathan some jelly beans. Maybe pet a kitten. Yeah. Pet that kitty.
+
+Some of the work on Haml was supported by Unspace Interactive.
+
+Beyond that, the implementation is licensed under the MIT License.
+Okay, fine, I guess that means compliments aren't __required__.

data/REVISION

@@ -0,0 +1 @@
+(unknown)

data/Rakefile

@@ -0,0 +1,371 @@
+# ----- Benchmarking -----
+
+desc <<END
+Benchmark haml against ERb.
+  TIMES=n sets the number of runs. Defaults to 1000.
+END
+task :benchmark do
+  sh "ruby test/benchmark.rb #{ENV['TIMES']}"
+end
+
+# ----- Default: Testing ------
+
+if ENV["RUN_CODE_RUN"] == "true"
+  task :default => :"test:rails_compatibility"
+else
+  task :default => :test
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  test_files = FileList['test/**/*_test.rb']
+  test_files.exclude('test/rails/*')
+  test_files.exclude('test/haml/spec/*')
+  t.test_files = test_files
+  t.verbose = true
+end
+Rake::Task[:test].send(:add_comment, <<END)
+To run with an alternate version of Rails, make test/rails a symlink to that version.
+END
+
+# ----- Packaging -----
+
+require 'rake/gempackagetask'
+load    'haml.gemspec'
+
+Rake::GemPackageTask.new(HAML_GEMSPEC) do |pkg|
+  if Rake.application.top_level_tasks.include?('release')
+    pkg.need_tar_gz  = true
+    pkg.need_tar_bz2 = true
+    pkg.need_zip     = true
+  end
+end
+
+task :revision_file do
+  require 'lib/haml'
+
+  release = Rake.application.top_level_tasks.include?('release') || File.exist?('EDGE_GEM_VERSION')
+  if Haml.version[:rev] && !release
+    File.open('REVISION', 'w') { |f| f.puts Haml.version[:rev] }
+  elsif release
+    File.open('REVISION', 'w') { |f| f.puts "(release)" }
+  else
+    File.open('REVISION', 'w') { |f| f.puts "(unknown)" }
+  end
+end
+Rake::Task[:package].prerequisites.insert(0, :revision_file)
+
+# We also need to get rid of this file after packaging.
+at_exit { File.delete('REVISION') rescue nil }
+
+desc "Install Haml as a gem."
+task :install => [:package] do
+  sudo = RUBY_PLATFORM =~ /win32/ ? '' : 'sudo'
+  gem  = RUBY_PLATFORM =~ /java/  ? 'jgem' : 'gem' 
+  sh %{#{sudo} #{gem} install --no-ri pkg/haml-#{File.read('VERSION').strip}}
+end
+
+desc "Release a new Haml package to Rubyforge."
+task :release => [:check_release, :release_elpa, :package] do
+  name = File.read("VERSION_NAME").strip
+  version = File.read("VERSION").strip
+  sh %{rubyforge login}
+  sh %{rubyforge add_release haml haml "#{name} (v#{version})" pkg/haml-#{version}.gem}
+  sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.tar.gz}
+  sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.tar.bz2}
+  sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.zip}
+end
+
+# Releases haml-mode.el and sass-mode.el to ELPA.
+task :release_elpa do
+  require 'tlsmail'
+  require 'time'
+
+  version = File.read("VERSION").strip
+
+  haml_unchanged = mode_unchanged?(:haml, version)
+  sass_unchanged = mode_unchanged?(:sass, version)
+  next if haml_unchanged && sass_unchanged
+  raise "haml-mode.el and sass-mode.el are out of sync." if haml_unchanged ^ sass_unchanged
+
+  rev = File.read('.git/HEAD').strip
+  if rev =~ /^ref: (.*)$/
+    rev = File.read(".git/#{$1}").strip
+  end
+
+  from = `git config user.email`.strip
+  raise "Don't know how to send emails except via Gmail" unless from =~ /@gmail.com$/
+
+  to = "elpa@tromey.com"
+  Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE)
+  Net::SMTP.start('smtp.gmail.com', 587, 'gmail.com', from, read_password("GMail Password"), :login) do |smtp|
+    smtp.send_message(<<CONTENT, from, to)
+From: Nathan Weizenbaum <#{from}>
+To: #{to}
+Subject: Submitting haml-mode and sass-mode #{version}
+Date: #{Time.now.rfc2822}
+
+haml-mode and sass-mode #{version} are packaged and ready to be included in ELPA.
+They can be downloaded from:
+
+  http://github.com/nex3/haml/raw/#{rev}/extra/haml-mode.el
+  http://github.com/nex3/haml/raw/#{rev}/extra/sass-mode.el
+CONTENT
+  end
+end
+
+# Ensures that the version have been updated for a new release.
+task :check_release do
+  version = File.read("VERSION").strip
+  raise "There have been changes since current version (#{version})" if changed_since?(version)
+  raise "VERSION_NAME must not be 'Bleeding Edge'" if File.read("VERSION_NAME") == "Bleeding Edge"
+end
+
+# Reads a password from the command line.
+#
+# @param name [String] The prompt to use to read the password
+def read_password(prompt)
+  require 'readline'
+  system "stty -echo"
+  Readline.readline("#{prompt}: ").strip
+ensure
+  system "stty echo"
+  puts
+end
+
+# Returns whether or not the repository, or specific files,
+# has/have changed since a given revision.
+#
+# @param rev [String] The revision to check against
+# @param files [Array<String>] The files to check.
+#   If this is empty, checks the entire repository
+def changed_since?(rev, *files)
+  IO.popen("git diff --exit-code #{rev} #{files.join(' ')}") {}
+  return !$?.success?
+end
+
+# Returns whether or not the given Emacs mode file (haml or sass)
+# has changed since the given version.
+#
+# @param mode [String, Symbol] The name of the mode
+# @param version [String] The version number
+def mode_unchanged?(mode, version)
+  mode_version = File.read("extra/#{mode}-mode.el").scan(/^;; Version: (.*)$/).first.first
+  return false if mode_version == version
+  return true unless changed_since?(mode_version, "extra/#{mode}-mode.el")
+  raise "#{mode}-mode.el version is #{version.inspect}, but it has changed as of #{version.inspect}"
+  return false
+end
+
+task :release_edge do
+  ensure_git_cleanup do
+    puts "#{'=' * 50} Running rake release_edge"
+
+    sh %{git checkout edge-gem}
+    sh %{git reset --hard origin/edge-gem}
+    sh %{git merge origin/master}
+
+    # Get the current master branch version
+    version = File.read('VERSION').strip.split('.').map {|n| n.to_i}
+    unless version[1] % 2 == 1 && version[2] == 0
+      raise "#{version.join('.')} is not a development version" 
+    end
+
+    # Bump the edge gem version
+    edge_version = File.read('EDGE_GEM_VERSION').strip.split('.').map {|n| n.to_i}
+    if edge_version[0..1] != version[0..1]
+      # A new master branch version was released, reset the edge gem version
+      edge_version[0..1] = version[0..1]
+      edge_version[2] = 0
+    else
+      # Just bump the teeny version
+      edge_version[2] += 1
+    end
+    edge_version = edge_version.join('.')
+    File.open('EDGE_GEM_VERSION', 'w') {|f| f.puts(edge_version)}
+    sh %{git commit -m "Bump edge gem version to #{edge_version}." EDGE_GEM_VERSION}
+    sh %{git push origin edge-gem}
+
+    # Package the edge gem with the proper version
+    File.open('VERSION', 'w') {|f| f.puts(edge_version)}
+    sh %{rake package}
+    sh %{git checkout VERSION}
+
+    sh %{rubyforge login}
+    sh %{rubyforge add_release haml haml-edge "Bleeding Edge (v#{edge_version})" pkg/haml-edge-#{edge_version}.gem}
+  end
+end
+
+task :watch_for_update do
+  sh %{ruby extra/update_watch.rb}
+end
+
+# ----- Documentation -----
+
+task :rdoc do
+  puts '=' * 100, <<END, '=' * 100
+Haml uses the YARD documentation system (http://github.com/lsegal/yard).
+Install the yard gem and then run "rake doc".
+END
+end
+
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new do |t|
+    t.files = FileList.new('lib/**/*.rb') do |list|
+      list.exclude('lib/haml/template/*.rb')
+      list.exclude('lib/haml/helpers/action_view_mods.rb')
+    end.to_a
+    t.options << '--use-cache' if Rake.application.top_level_tasks.include?('redoc')
+    t.options += FileList.new('yard/*.rb').to_a.map {|f| ['-e', f]}.flatten
+    files = FileList.new('doc-src/*').to_a.sort_by {|s| s.size} + %w[MIT-LICENSE VERSION]
+    t.options << '--files' << files.join(',')
+  end
+  Rake::Task['yardoc'].instance_variable_set('@comment', nil)
+
+  desc "Generate Documentation"
+  task :doc => :yardoc
+  task :redoc => :yardoc
+rescue LoadError
+  desc "Generate Documentation"
+  task :doc => :rdoc
+  task :yardoc => :rdoc
+end
+
+task :pages do
+  ensure_git_cleanup do
+    puts "#{'=' * 50} Running rake pages PROJ=#{ENV["PROJ"].inspect}"
+    raise 'No ENV["PROJ"]!' unless proj = ENV["PROJ"]
+    sh %{git checkout #{proj}-pages}
+    sh %{git reset --hard origin/#{proj}-pages}
+
+    sh %{rake build --trace}
+    sh %{rsync -av --delete site/ /var/www/#{proj}-pages}
+  end
+end
+
+# ----- Coverage -----
+
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |t|
+    t.test_files = FileList['test/**/*_test.rb']
+    t.rcov_opts << '-x' << '"^\/"'
+    if ENV['NON_NATIVE']
+      t.rcov_opts << "--no-rcovrt"
+    end
+    t.verbose = true
+  end
+rescue LoadError; end
+
+# ----- Profiling -----
+
+begin
+  require 'ruby-prof'
+
+  desc <<END
+Run a profile of haml.
+  ENGINE=str sets the engine to be profiled. Defaults to Haml.
+  TIMES=n sets the number of runs. Defaults to 1000.
+  FILE=str sets the file to profile.
+    Defaults to 'standard' for Haml and 'complex' for Sass.
+  OUTPUT=str sets the ruby-prof output format.
+    Can be Flat, CallInfo, or Graph. Defaults to Flat. Defaults to Flat.
+END
+  task :profile do
+    engine = (ENV['ENGINE'] || 'haml').downcase
+    times  = (ENV['TIMES'] || '1000').to_i
+    file   = ENV['FILE']
+
+    if engine == 'sass'
+      require 'lib/sass'
+
+      file = File.read("#{File.dirname(__FILE__)}/test/sass/templates/#{file || 'complex'}.sass")
+      result = RubyProf.profile { times.times { Sass::Engine.new(file).render } }
+    else
+      require 'lib/haml'
+
+      file = File.read("#{File.dirname(__FILE__)}/test/haml/templates/#{file || 'standard'}.haml")
+      obj = Object.new
+      Haml::Engine.new(file).def_method(obj, :render)
+      result = RubyProf.profile { times.times { obj.render } }
+    end
+
+    RubyProf.const_get("#{(ENV['OUTPUT'] || 'Flat').capitalize}Printer").new(result).print 
+  end
+rescue LoadError; end
+
+# ----- Testing Multiple Rails Versions -----
+
+rails_versions = [
+  "v2.3.0",
+  "v2.2.2",
+  "v2.1.2",
+  "v2.0.5"
+]
+
+namespace :test do
+  desc "Test all supported versions of rails. This takes a while."
+  task :rails_compatibility do
+    `rm -rf test/rails`
+    puts "Checking out rails. Please wait."
+    `git clone git://github.com/rails/rails.git test/rails` rescue nil
+    begin
+      rails_versions.each do |version|
+        Dir.chdir "test/rails" do
+          `git checkout #{version}`
+        end
+        puts "Testing Rails #{version}"
+        Rake::Task['test'].reenable
+        Rake::Task['test'].execute
+      end
+    ensure
+      `rm -rf test/rails`
+    end
+  end
+end
+
+# ----- Handling Updates -----
+
+def ensure_git_cleanup
+  yield
+ensure
+  sh %{git reset --hard HEAD}
+  sh %{git clean -xdf}
+  sh %{git checkout master}
+end
+
+task :handle_update do
+  unless ENV["REF"] =~ %r{^refs/heads/(master|stable|(?:haml|sass)-pages)$}
+    puts "#{'=' * 20} Ignoring rake handle_update REF=#{ENV["REF"].inspect}"
+    next
+  end
+  branch = $1
+
+  puts
+  puts
+  puts '=' * 150
+  puts "Running rake handle_update REF=#{ENV["REF"].inspect}"
+
+  sh %{git fetch origin}
+  sh %{git checkout stable}
+  sh %{git reset --hard origin/stable}
+  sh %{git checkout master}
+  sh %{git reset --hard origin/master}
+
+  if branch == "master"
+    sh %{rake release_edge --trace}
+  elsif branch == "stable"
+    sh %{rake pages --trace PROJ=haml}
+    sh %{rake pages --trace PROJ=sass}
+  elsif branch =~ /^(haml|sass)-pages$/
+    sh %{rake pages --trace PROJ=#{$1}}
+  end
+
+  puts 'Done running handle_update'
+  puts '=' * 150
+end