shoes 4.0.0.pre1 → 4.0.0.pre2

data/lib/ext/highlighter/markup.rb

@@ -1,222 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-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/animation.rb

@@ -1,55 +0,0 @@
-class Shoes
-  class Animation
-
-    # Creates a new Animation.
-    #
-    # @overload initialize(opts, &blk)
-    #   @param [Hash] opts An options hash
-    #   @param [Proc] blk A block of code to be executed for each
-    #     animation frame
-    #   @option opts [Integer] :framerate (24) The framerate (frames per second)
-    #   @option opts [Shoes::App] :app The current Shoes app
-    def initialize(app, opts, blk)
-      @style = opts
-      @framerate = @style[:framerate] || 10
-      @app = app
-      @blk = blk
-      @current_frame = 0
-      @stopped = false
-      @gui = Shoes.configuration.backend_for(self, @app.gui)
-    end
-
-    attr_reader :current_frame, :framerate, :blk
-
-    def start
-      @stopped = false
-    end
-
-    def stop
-      @stopped = true
-    end
-
-    def stopped?
-      @stopped
-    end
-
-    def toggle
-     @stopped = !@stopped
-    end
-
-    def remove
-      @removed = true
-    end
-
-    def removed?
-      @removed
-    end
-
-    # Increments the current frame by 1
-    #
-    # @return [Integer] The new current frame
-    def increment_frame
-      @current_frame += 1
-    end
-  end
-end

data/lib/shoes/app.rb

@@ -1,320 +0,0 @@
-class Shoes
-  shoes_icon = File.expand_path("../../../static/shoes-icon.png", __FILE__)
-  if shoes_icon.include? '.jar!'
-    SHOES_ICON = File.join(Dir.tmpdir, 'shoes-icon.png').freeze
-    open SHOES_ICON, 'wb' do |fw|
-      open shoes_icon, 'rb' do |fr|
-        fw.write fr.read
-      end
-    end
-  else
-    SHOES_ICON = shoes_icon.freeze
-  end
-
-  # Instantiates a new Shoes app.
-  #
-  # @param opts [Hash] A hash of options used instantiate the Shoes::App object with.
-  # @param blk  [Proc] The block containing the DSL instructions for the actual app.
-  #
-  # @example
-  #   Shoes.app(title: "Chunky") do
-  #     para "Bacon is awesome!"
-  #   end
-  #
-  # @return A new instance of Shoes::App
-  #
-  # @see Shoes::App#initialize
-
-  def self.app(opts={}, &blk)
-    Shoes::App.new(opts, &blk)
-  end
-
-
-  # This is the user-facing App object. It is `self` inside of a Shoes.app
-  # block, and is the context in which a Shoes app is evaled. It delegates most
-  # of its functionality to an InternalApp object, which interacts with other
-  # Shoes objects. There should be no unnecessary instance variables or methods
-  # in this class, so users are free to use whatever names they choose for
-  # their own code.
-  class App
-    include DSL
-    include BuiltinMethods
-
-    # Instantiates a new Shoes app.
-    #
-    # @param  opts [Hash] The options to initialize the app with.
-    # @param  blk  [Proc] The block containing the DSL instructions to be executed within the app.
-    #
-    # @option opts [String]  :title      ("Shoes 4") The title of the window
-    # @option opts [Boolean] :resizable  (true)      Whether the window is resizable
-    # @option opts [Boolean] :fullscreen (false)     Whether the app should start in fullscreen
-    # @option opts [Fixnum]  :width      (600)       The width of the app window
-    # @option opts [Fixnum]  :height     (500)       The height of the app window
-    #
-    # @see Dimension#initialize
- 
-    def initialize(opts={}, &blk)
-      @__app__ = Shoes::InternalApp.new(self, opts, &blk)
-      @__app__.setup_gui
-      Shoes.register self
-      @__app__.open_gui
-    end
-
-    # Shoes 3 exposes the app object like this, so we keep it for
-    # compatibility
-    def app
-      self
-    end
-
-    def window(options={}, &block)
-      options.merge! owner: self
-      self.class.new(options, &block)
-    end
-
-    def close
-      quit
-    end
-
-    def quit
-      Shoes.unregister self
-      @__app__.quit
-    end
-
-    def to_s
-      'Shoes App: ' + @__app__.app_title
-    end
-    
-    %w(
-      width height owner started? location left top absolute_left
-      absolute_top rotate click release clear fullscreen fullscreen=
-      contents
-    ).each do |method|
-      define_method method do |*args, &block|
-        @__app__.public_send method, *args, &block
-      end
-    end
-
-    alias_method :fullscreen?, :fullscreen
-
-    # inspect normally recursively inspects the values of all instance
-    # variables... as the app has a reference to EVERYTHING this turns
-    # out to be quite a lot/so much that the app runs out of memory #504
-    def inspect
-      "#<#{self.class}:0x#{hash.to_s(16)} @__app__=So much stuff literally breaks the memory limit. Look at it selectively.>"
-    end
-
-    DELEGATE_BLACKLIST = [:parent]
-
-    # class definitions are evaluated top to bottom, want to have all of them
-    # so define at bottom
-    DELEGATE_METHODS = ((Shoes::App.public_instance_methods(false) +
-      Shoes::DSL.public_instance_methods) - DELEGATE_BLACKLIST).freeze
-  end
-
-
-  # This is the representation of the app that is used internally by Shoes
-  # objects. It is *NOT* the app object that a user interacts with in a
-  # Shoes.app block. The user facing App object is...the App object.
-  #
-  # The InternalApp object is responsible for maintaining the state of the App
-  # and providing the bulk of the functionality, leaving the App a relatively
-  # blank slate for users to bend to their will.
-  class InternalApp
-    include Common::Style
-    include Common::Clickable
-    include DimensionsDelegations
-
-    DEFAULT_OPTIONS = { :width      => 600,
-                        :height     => 500,
-                        :title      => "Shoes 4",
-                        :resizable  => true,
-                        :background => Shoes::COLORS.fetch(:shoes_background) }.freeze
-
-    def initialize(app, opts, &blk)
-      @app = app
-      @blk = blk
-      set_attributes_from_options(opts)
-      set_initial_attributes
-    end
-
-    def setup_gui
-      @gui = Shoes.configuration.backend::App.new self
-
-      execution_blk = create_execution_block(blk)
-      eval_block execution_blk
-
-      add_console
-    end
-
-    attr_reader :gui, :top_slot, :contents, :app, :dimensions,
-                :mouse_motion, :owner, :element_styles, :resize_callbacks
-    attr_accessor :elements, :current_slot, :opts, :blk, :mouse_button,
-                  :mouse_pos, :mouse_hover_controls, :resizable, :app_title,
-                  :width, :height, :start_as_fullscreen, :location
-
-    def clear(&blk)
-      top_slot.clear &blk
-    end
-
-    def width
-      started? ? gui.width : @dimensions.width
-    end
-
-    def height
-      started? ? gui.height : @dimensions.height
-    end
-
-    def font(path = Shoes::DEFAULT_TEXTBLOCK_FONT)
-      app.font path
-    end
-
-    def started?
-      gui && gui.started?
-    end
-
-    def rotate angle=nil
-      @rotate = angle || @rotate || 0
-    end
-
-    def add_child(child)
-      if top_slot
-        top_slot.add_child child
-      else
-        contents << child
-      end
-    end
-
-    def default_styles
-      {
-        :stroke      => Shoes::COLORS[:black],
-        :strokewidth => 1
-      }
-    end
-
-    def in_bounds?(x, y)
-      true
-    end
-
-    def fullscreen=(state)
-      gui.fullscreen = state
-    end
-
-    def fullscreen
-      gui.fullscreen
-    end
-
-    alias_method :start_as_fullscreen?, :start_as_fullscreen
-
-    def add_mouse_hover_control(element)
-      unless mouse_hover_controls.include? element
-        mouse_hover_controls << element
-      end
-    end
-
-    def open_gui
-      gui.open
-    end
-
-    def quit
-      @gui.quit
-    end
-
-    def scroll_top
-      gui.scroll_top
-    end
-
-    def scroll_top=(n)
-      gui.scroll_top = n
-    end
-
-    def clipboard
-      gui.clipboard
-    end
-
-    def clipboard=(str)
-      gui.clipboard = str
-    end
-
-    def download(url, opts, &block)
-      app.download url, opts, &block
-    end
-
-    def textcursor(line_height)
-      app.line(0, 0, 0, line_height, hidden: true, strokewidth: 1, stroke: ::Shoes::COLORS[:black])
-    end
-
-    def execute_block(blk)
-      app.instance_eval &blk
-    end
-
-    def gutter
-      gui.gutter
-    end
-
-    def add_resize_callback(blk)
-      @resize_callbacks << blk
-    end
-
-    private
-    def eval_block(execution_blk)
-      # creating it first, then appending is important because that way
-      # top_slot already exists and methods may be called on it
-      @top_slot = Flow.new self, self, width: width, height: height
-      @top_slot.append &execution_blk
-    end
-
-    def create_execution_block(blk)
-      if blk
-        execution_blk = Proc.new do
-          execute_block blk
-        end
-      elsif Shoes::URL.urls.keys.any? { |page| page.match '/' }
-        execution_blk = Proc.new do
-          app.visit '/'
-        end
-      else
-        execution_blk = nil
-      end
-      execution_blk
-    end
-
-    def set_initial_attributes
-      @style                = default_styles
-      @element_styles       = {}
-      @contents             = []
-      @mouse_motion         = []
-      @mouse_button         = 0
-      @mouse_pos            = [0, 0]
-      @mouse_hover_controls = []
-      @resize_callbacks     = []
-      @rotate               = 0
-    end
-
-    def set_attributes_from_options(opts)
-      opts = DEFAULT_OPTIONS.merge(opts)
-
-      @app_title           = opts[:title]
-      @resizable           = opts[:resizable]
-      @start_as_fullscreen = opts[:fullscreen]
-      @opts                = opts
-      @owner               = opts[:owner]
-      @dimensions          = AbsoluteDimensions.new opts
-      self.absolute_left   = 0
-      self.absolute_top    = 0
-    end
-
-    def add_console
-      console = Proc.new do 
-        keypress do |key|
-          ::Shoes::Logger.setup if key == :"alt_/"
-        end
-      end
-      @app.instance_eval &console
-    end
-
-    def inspect
-      "#<#{self.class}:0x#{hash.to_s(16)} @app_title=#{@app_title} @dimensions=#{@dimensions.inspect} and a lot of stuff that's too much too handle... and leads to OutOfMemoryErrors>"
-    end
-
-  end
-end