shoes 3.0.1 → 4.0.0.pre1

data/lib/ext/highlighter/markup.rb

@@ -0,0 +1,222 @@
+# syntax highlighting
+
+require_relative 'common'
+
+module HH::Markup
+
+  TOKENIZER = HH::Syntax.load "ruby"
+  COLORS = {
+    :comment => {:stroke => "#887"},
+    :keyword => {:stroke => "#111"},
+    :method => {:stroke => "#C09", :weight => "bold"},
+    # :class => {:stroke => "#0c4", :weight => "bold"},
+    # :module => {:stroke => "#050"},
+    # :punct => {:stroke => "#668", :weight => "bold"},
+    :symbol => {:stroke => "#C30"},
+    :string => {:stroke => "#C90"},
+    :number => {:stroke => "#396" },
+    :regex => {:stroke => "#000", :fill => "#FFC" },
+    # :char => {:stroke => "#f07"},
+    :attribute => {:stroke => "#369" },
+    # :global => {:stroke => "#7FB" },
+    :expr => {:stroke => "#722" },
+    # :escape => {:stroke => "#277" }
+    :ident => {:stroke => "#994c99"},
+    :constant => {:stroke => "#630", :weight => "bold"},
+    :class => {:stroke => "#630", :weight => "bold"},
+    :matching => {:stroke => "#ff0", :weight => "bold"},
+  }
+
+  
+  def highlight str, pos=nil, colors=COLORS
+    tokens = []
+    TOKENIZER.tokenize(str) do |t|
+      if t.group == :punct
+        # split punctuation into single characters tokens
+        # TODO: to it in the parser
+        tokens += t.split('').map{|s| HH::Syntax::Token.new(s, :punct)}
+      else
+        # add token as is
+        tokens << t
+      end
+    end
+
+    res = []
+    tokens.each do |token|
+      res <<
+        if colors[token.group]
+          #span(token, colors[token.group])
+          tmp = fg(token, colors[token.group][:stroke])
+          colors[token.group][:fill] ? bg(tmp, colors[token.group][:fill]) : tmp
+        elsif colors[:any]
+          #span(token, colors[:any])
+          tmp = fg(token, colors[:any][:stroke])
+          colors[:any][:fill] ? bg(tmp, colors[:any][:fill]) : tmp
+        else
+          token
+        end
+    end
+
+    if pos.nil? or pos < 0
+      return res
+    end
+
+    token_index, matching_index = matching_token(tokens, pos)
+
+    if token_index
+      #res[token_index] = span(tokens[token_index], colors[:matching])
+      tmp = fg(tokens[token_index], colors[:matching][:stroke])
+      res[token_index] = colors[:matching][:fill] ? bg(tmp, colors[:matching][:fill]) : tmp
+      if matching_index
+        #res[matching_index] = span(tokens[matching_index], colors[:matching])
+        tmp = fg(tokens[matching_index], colors[:matching][:stroke])
+        res[matching_index] = colors[:matching][:fill] ? bg(tmp, colors[:matching][:fill]) : tmp
+      end
+    end
+
+    res
+  end
+
+private
+  def matching_token(tokens, pos)
+    curr_pos = 0
+    token_index = nil
+    tokens.each_with_index do |t, i|
+      curr_pos += t.size
+      if token_index.nil? and curr_pos >= pos
+        token_index = i
+        break
+      end
+    end
+    if token_index.nil? then return nil end
+
+    match = matching_token_at_index(tokens, token_index);
+    if match.nil? and curr_pos == pos and token_index < tokens.size-1
+      # try the token before the cursor, instead of the one after
+      token_index += 1
+      match = matching_token_at_index(tokens, token_index)
+    end
+
+    if match
+      [token_index, match]
+    else
+      nil
+    end
+  end
+
+
+  def matching_token_at_index(tokens, index)
+    starts, ends, direction = matching_tokens(tokens, index)
+    if starts.nil?
+      return nil
+    end
+
+    stack_level = 1
+    index += direction
+    while index >= 0 and index < tokens.size
+      # TODO separate space in the tokenizer
+      t = tokens[index].gsub(/\s/, '')
+      if ends.include?(t) and not as_modifier?(tokens, index)
+        stack_level -= 1
+        return index if stack_level == 0
+      elsif starts.include?(t) and not as_modifier?(tokens, index)
+        stack_level += 1
+      end
+      index += direction
+    end
+    # no matching token found
+    return nil
+  end
+
+  # returns an array of tokens matching and the direction
+  def matching_tokens(tokens, index)
+    # TODO separate space in the tokenizer
+    token = tokens[index].gsub(/\s/, '')
+    starts = [token]
+    if OPEN_BRACKETS[token]
+      direction = 1
+      ends = [OPEN_BRACKETS[token]]
+    elsif CLOSE_BRACKETS[token]
+      direction = -1
+      ends = [CLOSE_BRACKETS[token]]
+    elsif OPEN_BLOCK.include?(token)
+      if as_modifier?(tokens, index)
+        return nil
+      end
+      direction = 1
+      ends = ['end']
+      starts = OPEN_BLOCK
+    elsif token == 'end'
+      direction = -1
+      ends = OPEN_BLOCK
+    else
+      return nil
+    end
+
+    [starts, ends, direction]
+  end
+
+  def as_modifier?(tokens, index)
+
+    if not MODIFIERS.include? tokens[index].gsub(/\s/, '')
+      return false
+    end
+    
+    index -= 1
+    # find last index before the token that is no space
+    index -= 1 while index >= 0 and tokens[index] =~ /\A[ \t]*\z/
+
+    if index < 0
+      # first character of the string
+      false
+    elsif tokens[index] =~ /\n[ \t]*\Z/
+      # first token of the line
+      false
+    elsif tokens[index].group == :punct
+      # preceded by a punctuation token on the same line
+      i = tokens[index].rindex(/\S/)
+      punc = tokens[index][i, 1]
+      # true if the preceeding statement was terminating
+      not NON_TERMINATING.include?(punc)
+    else
+      # preceded by a non punctuation token on the same line
+      true
+    end
+  end
+
+
+  OPEN_BRACKETS = {
+    '{' => '}',
+    '(' => ')',
+    '[' => ']',
+  }
+
+  #close_bracket = {}
+  #OPEN_BRACKETS.each{|open, close| opens_bracket[close] = open}
+  #CLOSE_BRACKETS = opens_bracket
+  # the following is more readable :)
+  CLOSE_BRACKETS = {
+    '}' => '{',
+    ')' => '(',
+    ']' => '[',
+  }
+
+  BRACKETS = CLOSE_BRACKETS.keys + OPEN_BRACKETS.keys
+
+  OPEN_BLOCK = [
+    'def',
+    'class',
+    'module',
+    'do',
+    'if',
+    'unless',
+    'while',
+    'until',
+    'begin',
+    'for'
+  ]
+
+  MODIFIERS = %w[if unless while until]
+
+  NON_TERMINATING = %w{+ - * / , . = ~ < > ( [}
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'fileutils'
+
+# See ext/install/Rakefile for why this cleanup is our responsibility.
+# Decide if user uninstalled executables based on our actual Ruby script.
+Gem.post_uninstall do |gem|
+  uninstalling_shoes = gem.spec.name == "shoes"
+  missing_executable = !File.exists?(File.join(Gem.bindir, "ruby-shoes")) &&
+                       !File.exists?(File.join(Gem.bindir, "ruby-shoes.bat"))
+
+  if uninstalling_shoes && missing_executable
+    puts "Removing shoes"
+    if Gem.win_platform?
+      FileUtils.rm(File.join(Gem.bindir, "shoes.bat"))
+    else
+      FileUtils.rm(File.join(Gem.bindir, "shoes"))
+    end
+  end
+end

data/lib/shoes.rb

@@ -1,548 +1,125 @@
-# -*- encoding: utf-8 -*-
-#
-# lib/shoes.rb
-# The Shoes base app, both a demonstration and the learning tool for
-# using Shoes.
-#
-ARGV.delete_if { |x| x =~ /-psn_/ }
+require 'pathname'
+require 'tmpdir'
+require 'fileutils'
+require 'forwardable'
 
-require 'open-uri'
-require 'optparse'
-require 'resolv-replace' if RUBY_PLATFORM =~ /win/
-require 'shoes/inspect'
-require 'shoes/cache'
-if Object.const_defined? :Shoes
-  require 'shoes/image'
-end
-require 'shoes/shybuilder'
-
-def Shoes.hook; end
-
-class Encoding
- %w[ASCII_8BIT UTF_16BE UTF_16LE UTF_32BE UTF_32LE US_ASCII].each do |ec|
-   eval "#{ec} = '#{ec.sub '_', '-'}'"
- end unless RUBY_PLATFORM =~ /linux/
-end
-
-class Range 
-  def rand 
-    conv = (Integer === self.end && Integer === self.begin ? :to_i : :to_f)
-    ((Kernel.rand * (self.end - self.begin)) + self.begin).send(conv) 
-  end 
-end
-
-unless Time.respond_to? :today
-  def Time.today
-    t = Time.now
-    t - (t.to_i % 86400)
-  end
-end
+require 'shoes/common/registration'
 
 class Shoes
-  RELEASES = %w[Curious Raisins Policeman]
-
-  NotFound = proc do
-    para "404 NOT FOUND, GUYS!"
-  end
- 
-  class << self; attr_accessor :locale, :language end
-  @locale = ENV["SHOES_LANG"] || ENV["LC_MESSAGES"] || ENV["LC_ALL"] || ENV["LANG"] || "C"
-  @language = @locale[/^(\w{2})_/, 1] || "en"
-
-  @mounts = []
-
-  OPTS = OptionParser.new do |opts|
-    opts.banner = "Usage: shoes [options] (app.rb or app.shy)"
-    
-    opts.on("-m", "--manual",
-            "Open the built-in manual.") do
-      show_manual
-    end
-
-    opts.on("-p", "--package",
-            "Package a Shoes app for Windows, OS X and Linux.") do |s|
-      make_pack
-    end
-
-    opts.on("-g", "--gem",
-            "Passes commands to RubyGems.") do
-      require 'shoes/setup'
-      require 'rubygems/gem_runner'
-      Gem::GemRunner.new.run(ARGV)
-      raise SystemExit, ""
-    end
-
-    opts.on("--manual-html DIRECTORY", "Saves the manual to a directory as HTML.") do |dir|
-      manual_as :html, dir
-      raise SystemExit, "HTML manual in: #{dir}"
-    end
-
-    opts.on("--install MODE SRC DEST", "Installs a file.") do |mode|
-      src, dest = ARGV
-      FileUtils.install src, dest, :mode => mode.to_i(8), :preserve => true
-      raise SystemExit, ""
-    end
-
-    opts.on("--nolayered", "No WS_EX_LAYERED style option.") do
-      $NOLAYERED = 1
-      Shoes.args!
-    end
-    
-    opts.on_tail("-v", "--version", "Display the version info.") do
-      raise SystemExit, File.read("#{DIR}/VERSION.txt").strip
-    end
-
-    opts.on_tail("-h", "--help", "Show this message") do
-      raise SystemExit, opts.to_s
-    end
-  end
-
-  class SettingUp < StandardError; end
-
-  @setups = {}
-
-  def self.setup &blk
-    require 'shoes/setup'
-    line = caller[0]
-    return if @setups[line]
-    script = line[/^(.+?):/, 1]
-    set = Shoes::Setup.new(script, &blk)
-    @setups[line] = true
-    unless set.no_steps?
-      raise SettingUp
-    end
-  end
-
-  def self.show_selector
-    fname = ask_open_file
-    Shoes.visit(fname) if fname
-  end
-
-  def self.package_app
-    fname = ask_open_file
-    return false unless fname
-    start_shy_builder fname
-  end
-
-  def self.splash
-    font "#{DIR}/fonts/Lacuna.ttf"
-    Shoes.app :width => 400, :height => 300, :resizable => false do  
-      style(Para, :align => "center", :weight => "bold", :font => "Lacuna Regular", :size => 13)
-      style(Link, :stroke => yellow, :underline => nil)
-      style(LinkHover, :stroke => yellow, :fill => nil)
-
-      x1 = 77; y1 = 122
-      x2 = 148; y2 = -122
-      x3 = 245; y3 = 0
-
-      nofill
-      strokewidth 40.0
-
-      @waves = stack :top => 0, :left => 0
-      
-      require 'shoes/search'
-      require 'shoes/help'
-
-      stack :margin => 18 do
-        para "Welcome to", :stroke => "#DFA", :margin => 0
-        para "SHOES", :size => 48, :stroke => "#DFA", :margin_top => 0
-        stack do
-          background black(0.2), :curve => 8
-          para link("Open an App.") { Shoes.show_selector and close }, :margin => 10, :margin_bottom => 4
-          #para link("Package an App.") { Shoes.package_app and close }, :margin => 10, :margin_bottom => 4
-					para link("Package an App.") { Shoes.make_pack and close }, :margin => 10, :margin_bottom => 4
-          para link("Read the Manual.") { Shoes.show_manual and close }, :margin => 10
-        end
-        inscription "Alt-Slash opens the console.", :stroke => "#DFA", :align => "center"
-      end
-
-      animate(10) do |ani|
-        a = Math.sin(ani * 0.02) * 20
-        @waves.clear do
-          background white
-          y = -30
-          16.times do |i|
-            shape do
-              move_to x = (-300 - (i*(a*0.8))), y
-              c = (a + 14) * 0.01
-              stroke rgb(i * 0.06, c + 0.1, 0.1, 1.0 - (ani * 0.0003))
-              4.times do
-                curve_to x1 + x, (y1-(i*a)) + y, x2 + x, (y2+(i*a)) + y, x3 + x, y3 + y
-                x += x3
-              end
-            end
-            y += 30
-          end
-        end
+  PI                  = Math::PI
+  TWO_PI              = 2 * PI
+  HALF_PI             = 0.5 * PI
+  DIR                 = Pathname.new(__FILE__).join("../..").realpath.to_s
+  LOG                 = []
+  LEFT_MOUSE_BUTTON   = 1
+  MIDDLE_MOUSE_BUTTON = 2
+  RIGHT_MOUSE_BUTTON  = 3
+
+  extend Common::Registration
+
+  class << self
+
+    def logger
+      Shoes.configuration.logger_instance
+    end
+
+    # To ease the upgrade path from Shoes 3 we warn users they need to install
+    # and require gems themselves.
+    #
+    # @example
+    #   Shoes.setup do
+    #     gem 'bluecloth =2.0.6'
+    #     gem 'metaid'
+    #   end
+    #
+    # @param block [Proc] The block that describes the gems that are needed
+    # @deprecated
+    def setup(&block)
+      $stderr.puts "WARN: The Shoes.setup method is deprecated, you need to install gems yourself." +
+                   "You can do this using the 'gem install' command or bundler and a Gemfile."
+      DeprecatedShoesGemSetup.new.instance_eval(&block)
+    end
+
+    # Load the backend in memory. This does not set any configuration.
+    #
+    # @param name [String|Symbol] The name, such as :swt or :mock
+    # @return The backend
+    def load_backend(name)
+      begin
+        require "shoes/#{name.to_s.downcase}"
+        Shoes.const_get(name.to_s.capitalize)
+      rescue LoadError => e
+        raise LoadError, "Couldn't load backend Shoes::#{name.capitalize}'. Error: #{e.message}\n#{e.backtrace.join("\n")}"
       end
     end
   end
 
-  def self.make_pack
-    require 'shoes/pack'
-    Shoes.app(:width => 500, :height => 480, :resizable => true, &PackMake)
-  end
-
-  def self.manual_p(str, path)
-    str.gsub(/\n+\s*/, " ").
-      gsub(/&/, '&amp;').gsub(/>/, '&gt;').gsub(/>/, '&lt;').gsub(/"/, '&quot;').
-      gsub(/`(.+?)`/m, '<code>\1</code>').gsub(/\[\[BR\]\]/i, "<br />\n").
-      gsub(/\^(.+?)\^/m, '\1').
-      gsub(/'''(.+?)'''/m, '<strong>\1</strong>').gsub(/''(.+?)''/m, '<em>\1</em>').
-      gsub(/\[\[(http:\/\/\S+?)\]\]/m, '<a href="\1" target="_new">\1</a>').
-      gsub(/\[\[(http:\/\/\S+?) (.+?)\]\]/m, '<a href="\1" target="_new">\2</a>').
-      gsub(/\[\[(\S+?)\]\]/m) do
-        ms, mn = $1.split(".", 2)
-        if mn
-          '<a href="' + ms + '.html#' + mn + '">' + mn + '</a>'
-        else
-          '<a href="' + ms + '.html">' + ms + '</a>'
-        end
-      end.
-      gsub(/\[\[(\S+?) (.+?)\]\]/m, '<a href="\1.html">\2</a>').
-      gsub(/\!(\{[^}\n]+\})?([^!\n]+\.\w+)\!/) do
-        x = "static/#$2"
-        FileUtils.cp("#{DIR}/#{x}", "#{path}/#{x}") if File.exists? "#{DIR}/#{x}"
-        '<img src="' + x + '" />'
-      end
-  end
-
-  def self.manual_link(sect)
-  end
-
-  TITLES = {:title => :h1, :subtitle => :h2, :tagline => :h3, :caption => :h4}
-
-  def self.manual_as format, *args
-    require 'shoes/search'
-    require 'shoes/help'
-
-    case format
-    when :shoes
-      Shoes.app(:width => 720, :height => 640, &Shoes::Help)
-    else
-      extend Shoes::Manual
-      man = self
-      dir, = args
-      FileUtils.mkdir_p File.join(dir, 'static')
-      FileUtils.cp "#{DIR}/static/shoes-icon.png", "#{dir}/static"
-      %w[manual.css code_highlighter.js code_highlighter_ruby.js].
-        each { |x| FileUtils.cp "#{DIR}/static/#{x}", "#{dir}/static" }
-      html_bits = proc do
-        proc do |sym, text|
-        case sym when :intro
-          div.intro { p { self << man.manual_p(text, dir) } }
-        when :code
-          pre { code.rb text.gsub(/^\s*?\n/, '') }
-        when :colors
-          color_names = (Shoes::COLORS.keys*"\n").split("\n").sort
-          color_names.each do |color|
-            c = Shoes::COLORS[color.intern]
-            f = c.dark? ? "white" : "black"
-            div.color(:style => "background: #{c}; color: #{f}") { h3 color; p c }
-          end
-        when :index
-          tree = man.class_tree
-          shown = []
-          i = 0
-          index_p = proc do |k, subs|
-            unless shown.include? k
-              i += 1
-              p "▸ #{k}", :style => "margin-left: #{20*i}px"
-              subs.uniq.sort.each do |s|
-                index_p[s, tree[s]]
-              end if subs
-              i -= 1
-              shown << k
-            end
-          end
-          tree.sort.each &index_p
-        #   index_page
-        when :list
-          ul { text.each { |x| li { self << man.manual_p(x, dir) } } }
-        when :samples
-          folder = File.join DIR, 'samples'
-          h = {}
-          Dir.glob(File.join folder, '*').each do |file|
-            if File.extname(file) == '.rb'
-              key = File.basename(file).split('-')[0]
-              h[key] ? h[key].push(file) : h[key] = [file]
-            end
-          end
-          h.each do |k, v|
-            p "<h4>#{k}</h4>"
-            samples = []
-            v.each do |file|
-              sample = File.basename(file).split('-')[1..-1].join('-')[0..-4]
-              samples << "<a href=\"http://github.com/shoes/shoes/raw/master/manual-snapshots/#{k}-#{sample}.png\">#{sample}</a>"
-            end
-            p samples.join ' '
-          end
-        else
-          send(TITLES[sym] || :p) { self << man.manual_p(text, dir) }
-        end
-        end
-      end
-
-      docs = load_docs(Shoes::Manual::path)
-      sections = docs.map { |x,| x }
-
-      docn = 1
-      docs.each do |title1, opt1|
-        subsect = opt1['sections'].map { |x,| x }
-        menu = sections.map do |x|
-          [x, (subsect if x == title1)]
-        end
-
-        path1 = File.join(dir, title1.gsub(/\W/, ''))
-        make_html("#{path1}.html", title1, menu) do
-          h2 "The Shoes Manual"
-          h1 title1
-          man.wiki_tokens opt1['description'], true, &instance_eval(&html_bits)
-          p.next { text "Next: "
-            a opt1['sections'].first[1]['title'], :href => "#{opt1['sections'].first[0]}.html" }
-        end
-
-        optn = 1
-        opt1['sections'].each do |title2, opt2|
-          path2 = File.join(dir, title2)
-          make_html("#{path2}.html", opt2['title'], menu) do
-            h2 "The Shoes Manual"
-            h1 opt2['title']
-            man.wiki_tokens opt2['description'], true, &instance_eval(&html_bits)
-            opt2['methods'].each do |title3, desc3|
-              sig, val = title3.split(/\s+»\s+/, 2)
-              aname = sig[/^[^(=]+=?/].gsub(/\s/, '').downcase
-              a :name => aname
-              div.method do
-                a sig, :href => "##{aname}"
-                text " » #{val}" if val
-              end
-              div.sample do
-                man.wiki_tokens desc3, &instance_eval(&html_bits)
-              end
-            end
-            if opt1['sections'][optn]
-              p.next { text "Next: "
-                a opt1['sections'][optn][1]['title'], :href => "#{opt1['sections'][optn][0]}.html" }
-            elsif docs[docn]
-              p.next { text "Next: "
-                a docs[docn][0], :href => "#{docs[docn][0].gsub(/\W/, '')}.html" }
-            end
-            optn += 1
-          end
-        end
-
-        docn += 1
-      end
-    end
-  end
-
-  def self.show_manual
-    manual_as :shoes
-  end
-
-  def self.show_log
-    require 'shoes/log'
-    return if @log_app and Shoes.APPS.include? @log_app
-    @log_app =
-      Shoes.app do
-        extend Shoes::LogWindow
-        setup
-      end
-  end
-
-  def self.mount(path, meth, &blk)
-    @mounts << [path, meth || blk]
-  end
-
-  SHOES_URL_RE = %r!^@([^/]+)(.*)$! 
-
-  def self.run(path)
-    uri = URI(path)
-    @mounts.each do |mpath, rout|
-      m, *args = *path.match(/^#{mpath}$/)
-      if m
-        unless rout.is_a? Proc
-          rout = rout[0].instance_method(rout[1])
-        end
-        return [rout, args]
-      end
-    end
-    case uri.path when "/"
-      [nil]
-    when SHOES_URL_RE
-      [proc { eval(URI("http://#$1:53045#$2").read) }]
-    else
-      [NotFound]
-    end
-  end
-
-  def self.args!
-    if RUBY_PLATFORM !~ /darwin/ and ARGV.empty?
-      Shoes.splash
-    end
-    OPTS.parse! ARGV
-    ARGV[0] or true
-  end
-
-  def self.uri(str)
-    if str =~ SHOES_URL_RE
-      URI("http://#$1:53045#$2")
-    else
-      URI(str) rescue nil
-    end
-  end
-
-  def self.visit(path)
-    uri = Shoes.uri(path)
-
-    case uri
-    when URI::HTTP
-      str = uri.read
-      if str !~ /Shoes\.app/
-        Shoes.app do
-          eval(uri.read)
-        end
-      else
-        eval(uri.read)
-      end
-    else
-      path = File.expand_path(path.gsub(/\\/, "/"))
-      if path =~ /\.shy$/
-        @shy = true
-        require 'shoes/shy'
-        base = File.basename(path, ".shy")
-        tmpdir = "%s/shoes-%s.%d" % [Dir.tmpdir, base, $$]
-        shy = Shy.x(path, tmpdir)
-        Dir.chdir(tmpdir)
-        Shoes.debug "Loaded SHY: #{shy.name} #{shy.version} by #{shy.creator}"
-        path = shy.launch
-      else
-        @shy = false
-        Dir.chdir(File.dirname(path))
-        path = File.basename(path)
-      end
-
-      $0.replace path
-      
-      code = read_file(path)
-      eval(code, TOPLEVEL_BINDING, path)
-    end
-  rescue SettingUp
-  rescue Object => e
-    error(e)
-    show_log
-  end
-
-  def self.read_file path
-    if RUBY_VERSION =~ /^1\.9/ and !@shy
-      #File.open(path, 'r:utf-8') { |f| f.read }
-      IO.read(path).force_encoding("UTF-8")
-    else
-      File.read(path)
-    end
-  end
-
-  def self.url(path, meth)
-    Shoes.mount(path, [self, meth])
-  end
-
-  module Basic
-    def tween opts, &blk
-      opts = opts.dup
-
-      if opts[:upward]
-        opts[:top] = self.top - opts.delete(:upward)
-      elsif opts[:downward]
-        opts[:top] = self.top + opts.delete(:downward)
-      end
-      
-      if opts[:sideways]
-        opts[:left] = self.left + opts.delete(:sideways)
-      end
-      
-      @TWEEN.remove if @TWEEN
-      @TWEEN = parent.animate(opts[:speed] || 20) do
-
-        # figure out a coordinate halfway between here and there
-        cont = opts.select do |k, v|
-          if self.respond_to? k
-            n, o = v, self.send(k)
-            if n != o
-              n = o + ((n - o) / 2)
-              n = v if o == n
-              self.send("#{k}=", n)
-            end
-            self.style[k] != v
-          end
-        end
-
-        # if we're there, get rid of the animation
-        if cont.empty?
-          @TWEEN.remove
-          @TWEEN = nil
-          blk.call if blk
-        end
-      end
-    end
-  end
-
-  # complete list of styles
-  BASIC_S = [:left, :top, :right, :bottom, :width, :height, :attach, :hidden,
-             :displace_left, :displace_top, :margin, :margin_left, :margin_top,
-             :margin_right, :margin_bottom]
-  TEXT_S  = [:strikecolor, :undercolor, :font, :size, :family, :weight,
-             :rise, :kerning, :emphasis, :strikethrough, :stretch, :underline,
-             :variant]
-  MOUSE_S = [:click, :motion, :release, :hover, :leave]
-  KEY_S   = [:keydown, :keypress, :keyup]
-  COLOR_S = [:stroke, :fill]
-
-  {Background => [:angle, :radius, :curve, *BASIC_S],
-   Border     => [:angle, :radius, :curve, :strokewidth, *BASIC_S],
-   Canvas     => [:scroll, :start, :finish, *(KEY_S|MOUSE_S|BASIC_S)],
-   Check      => [:click, :checked, *BASIC_S],
-   Radio      => [:click, :checked, :group, *BASIC_S],
-   EditLine   => [:change, :secret, :text, *BASIC_S],
-   EditBox    => [:change, :text, *BASIC_S],
-   Effect     => [:radius, :distance, :inner, *(COLOR_S|BASIC_S)],
-   Image      => MOUSE_S|BASIC_S,
-   ListBox    => [:change, :items, :choose, *BASIC_S],
-   # Pattern    => [:angle, :radius, *BASIC_S],
-   Progress   => BASIC_S,
-   Shape      => COLOR_S|MOUSE_S|BASIC_S,
-   TextBlock  => [:justify, :align, :leading, *(COLOR_S|MOUSE_S|TEXT_S|BASIC_S)],
-   Text       => COLOR_S|MOUSE_S|TEXT_S|BASIC_S}.
-  each do |klass, styles|
-    klass.class_eval do
-      include Basic
-      styles.each do |m|
-        case m when *MOUSE_S
-        else
-          define_method(m) { style[m] } unless klass.method_defined? m
-          define_method("#{m}=") { |v| style(m => v) } unless klass.method_defined? "#{m}="
-        end
-      end
-    end
-  end
-
-  class Types::Widget
-    @types = {}
-    def self.inherited subc
-      methc = subc.to_s[/(^|::)(\w+)$/, 2].
-              gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-              gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
-      @types[methc] = subc
-      Shoes.class_eval %{
-        def #{methc}(*a, &b)
-          a.unshift Widget.instance_variable_get("@types")[#{methc.dump}]
-          widget(*a, &b)
-        end
-      }
+  class DeprecatedShoesGemSetup
+    def gem(name)
+      name, version = name.split()
+      install_cmd = 'gem install ' + name
+      install_cmd += " --version \"#{version}\"" if version
+      $stderr.puts "WARN: To use the '#{name}' gem, install it with '#{install_cmd}', and put 'require \"#{name}\"' at the top of your Shoes program."
     end
   end
 end
 
-def window(*a, &b)
-  Shoes.app(*a, &b)
-end
+require 'shoes/version'
+require 'shoes/renamed_delegate'
+require 'shoes/dimension'
+require 'shoes/dimensions'
+
+require 'shoes/color'
+
+require 'shoes/common/background_element'
+require 'shoes/common/changeable'
+require 'shoes/common/clickable'
+require 'shoes/common/common_methods'
+require 'shoes/common/fill'
+require 'shoes/common/state'
+require 'shoes/common/stroke'
+require 'shoes/common/style'
+require 'shoes/common/style_normalizer'
+require 'shoes/builtin_methods'
+require 'shoes/check_button'
+require 'shoes/dsl'
+require 'shoes/text'
+require 'shoes/span'
+require 'shoes/input_box'
+
+# please keep this list tidy and alphabetically sorted
+require 'shoes/animation'
+require 'shoes/app'
+require 'shoes/arc'
+require 'shoes/background'
+require 'shoes/border'
+require 'shoes/button'
+require 'shoes/configuration'
+require 'shoes/color'
+require 'shoes/dialog'
+require 'shoes/download'
+require 'shoes/font'
+require 'shoes/gradient'
+require 'shoes/image'
+require 'shoes/image_pattern'
+require 'shoes/key_event'
+require 'shoes/line'
+require 'shoes/link'
+require 'shoes/link_hover'
+require 'shoes/list_box'
+require 'shoes/logger'
+require 'shoes/manual'
+require 'shoes/oval'
+require 'shoes/point'
+require 'shoes/progress'
+require 'shoes/radio'
+require 'shoes/rect'
+require 'shoes/shape'
+require 'shoes/slot_contents'
+require 'shoes/slot'
+require 'shoes/star'
+require 'shoes/sound'
+require 'shoes/text_block'
+require 'shoes/timer'
+require 'shoes/url'
+require 'shoes/widget'