shoes 4.0.0.pre1 → 4.0.0.pre2

data/lib/shoes/timer.rb

@@ -1,10 +0,0 @@
-class Shoes
-  class Timer
-    def initialize app, n=1000, &blk
-      @app, @n, @blk = app, n, blk
-      @gui = Shoes.configuration.backend_for(self, @app.gui, @blk)
-    end
-    
-    attr_reader :n, :gui
-  end
-end

data/lib/shoes/url.rb

@@ -1,47 +0,0 @@
-class Shoes
-
-  # Backwards compatibility, kind of likely to be removed
-  def self.inherited(base_class)
-    base_class.send :include, URL #include is private, therefore send
-  end
-
-  module URL
-    extend Forwardable
-
-    def_delegators :app, *(Shoes::App::DELEGATE_METHODS)
-
-    attr_accessor :app
-
-    def self.included(base_class)
-      base_class.extend URLDefiner
-    end
-
-    def self.urls
-      @urls ||= {}
-    end
-
-  end
-
-  module URLDefiner
-    def url(page, method)
-      page = convert_page_to_regex(page)
-      url_class = self
-
-      Shoes::URL.urls[page] = proc do |app, arg|
-        new_url_instance = url_class.new
-        new_url_instance.app = app
-
-        if arg
-          new_url_instance.send(method, arg)
-        else
-          new_url_instance.send method
-        end
-      end
-    end
-
-    private
-    def convert_page_to_regex(page)
-      /^#{page}$/
-    end
-  end
-end

data/lib/shoes/widget.rb

@@ -1,73 +0,0 @@
-class Shoes
-  # This is the superclass for creating custom Shoes widgets.
-  #
-  # To use, inherit from {Shoes::Widget}. You get a few magical effects:
-  #
-  # * When you inherit from {Shoes::Widget}, you get a method in your Apps to
-  #   create your widgets. The method is lower- and snake-cased. It returns
-  #   an instance of your widget class.
-  # * Your widgets delegate missing methods to their app object. This
-  #   allows you to use the Shoes DSL within your widgets.
-  #
-  # @example
-  #   class SayHello < Shoes::Widget
-  #     def initialize word
-  #       para "Hello #{word}", stroke: green, size: 80
-  #     end
-  #   end
-  #
-  #   Shoes.app do
-  #     say_hello 'Shoes'
-  #   end
-  #
-  class Widget
-    extend Forwardable
-
-    # Delegate missing methods to app, so you can use the Shoes DSL
-    # inside the widget.
-    def_delegators :app, *Shoes::App::DELEGATE_METHODS
-
-    attr_accessor :parent
-    attr_writer   :app
-
-    class << self
-      attr_accessor :app
-    end
-
-    # lookup a bit more complicated as during initialize we do
-    # not have @app yet...
-    def app
-      @app || self.class.app
-    end
-
-    def self.inherited(klass, &blk)
-      dsl_method = dsl_method_name(klass)
-      Shoes::App.class_eval do
-        define_method(dsl_method) do |*args, &blk|
-          # we set app 2 times because widgets execute most of their code
-          # straight in initialize. I dunno if there is a good way of setting
-          # an @app instance variable before initialize is executed. We could
-          # hand it over in #initialize but that would break the interface
-          # and people would have to set it themselves or make sure to call
-          # super so for not it's like this.
-          # Setting the ref on the instance is important as we might have
-          # instances of the same widget in different Shoes::Apps so each one
-          # needs to save the reference to the one it was started with
-          klass.app              = self
-          widget_instance        = klass.new(*args, &blk)
-          widget_instance.app    = self
-          widget_instance.parent = @__app__.current_slot
-          widget_instance
-        end
-      end
-    end
-
-
-    private
-    def self.dsl_method_name(klass)
-      klass.to_s[/(^|::)(\w+)$/, 2].
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
-    end
-  end
-end

data/samples/good-clock-adjusted.rb

@@ -1,49 +0,0 @@
-#
-# Shoes Clock by Thomas Bell
-# posted to the Shoes mailing list on 04 Dec 2007
-# modified for Shoes 4, using fg instead of span in TextBlock.
-#
-Shoes.app height: 260, width: 250 do
-  @radius, @centerx, @centery = 90, 126, 140
-  animate(8) do
-    @time = Time.now
-    clear do
-      draw_background
-      stack do
-        background black
-        para(fg(@time.strftime("%a"), "#666"), fg(@time.strftime(" %b %d, %Y "), "#ccc"),
-          strong(fg(@time.strftime("%I:%M"), white)), fg(@time.strftime(".%S"), "#666"), margin: 4, align: 'center')
-      end
-      clock_hand @time.sec + (@time.usec * 0.000001),2,30,red
-      clock_hand @time.min + (@time.sec / 60.0),5
-      clock_hand @time.hour + (@time.min / 60.0),8,6
-    end
-  end
-  def draw_background
-    background rgb(230, 240, 200)
-
-    fill white
-    stroke black
-    strokewidth 4
-    oval @centerx - 102, @centery - 102, 204, 204
-
-    fill black
-    nostroke
-    oval @centerx - 5, @centery - 5, 10, 10
-
-    stroke black
-    strokewidth 1
-    line(@centerx, @centery - 102, @centerx, @centery - 95)
-    line(@centerx - 102, @centery, @centerx - 95, @centery)
-    line(@centerx + 95, @centery, @centerx + 102, @centery)
-    line(@centerx, @centery + 95, @centerx, @centery + 102)
-  end
-  def clock_hand(time, sw, unit=30, color=black)
-    radius_local = unit == 30 ? @radius : @radius - 15
-    _x = radius_local * Math.sin( time * Math::PI / unit )
-    _y = radius_local * Math.cos( time * Math::PI / unit )
-    stroke color
-    strokewidth sw
-    line(@centerx, @centery, @centerx + _x, @centery - _y)
-  end
-end

data/spec/async_helper.rb

@@ -1,21 +0,0 @@
-# from: https://gist.github.com/mattwynne/1228927
-# usage:
-# it "should return a result of 5" do
-#   eventually { long_running_thing.result.should eq(5) }
-# end
-module AsyncHelper
-  def eventually(options = {})
-    timeout = options[:timeout] || 2
-    interval = options[:interval] || 0.1
-    time_limit = Time.now + timeout
-    loop do
-      begin
-        yield
-      rescue => error
-      end
-      return if error.nil?
-      raise error if Time.now >= time_limit
-      sleep interval
-    end
-  end
-end

data/spec/code_coverage.rb

@@ -1,11 +0,0 @@
-require 'simplecov'
-# using coveralls to publish test coverage statistics
-require 'coveralls'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    Coveralls::SimpleCov::Formatter,
-    SimpleCov::Formatter::HTMLFormatter
-]
-SimpleCov.start do
-  add_filter '/spec/'
-end

data/spec/shoes/animation_spec.rb

@@ -1,65 +0,0 @@
-require 'shoes/spec_helper'
-
-shared_examples_for Shoes::Animation do
-  it "should start" do
-    subject.start
-    subject.should_not be_stopped
-  end
-
-  it "should stop" do
-    subject.stop
-    subject.should be_stopped
-  end
-
-  it "should toggle on" do
-    subject.stop
-    subject.toggle
-    subject.should_not be_stopped
-  end
-
-  it "should toggle off" do
-    subject.start
-    subject.toggle
-    subject.should be_stopped
-  end
-
-  it "increments frame" do
-    frame = subject.current_frame
-    subject.increment_frame
-    subject.current_frame.should eq(frame + 1)
-  end
-end
-
-describe Shoes::Animation do
-  let(:app) { double('app') }
-  let(:app_gui) { double('app gui') }
-  let(:opts) { {} }
-  let(:block) { double('block') }
-  subject { Shoes::Animation.new( app, opts, block ) }
-
-  before :each do
-    app.should_receive(:gui) { app_gui }
-  end
-
-  it_behaves_like Shoes::Animation
-
-  it "sets default framerate" do
-    subject.framerate.should eq(10)
-  end
-
-  it "sets current frame to 0" do
-    subject.current_frame.should eq(0)
-  end
-
-  it { should_not be_stopped }
-
-  describe "with framerate" do
-    let(:opts) { {:framerate => 36, :app => app} }
-
-    it "sets framerate" do
-      subject.framerate.should eq(36)
-    end
-
-    it_behaves_like Shoes::Animation
-  end
-end

data/spec/shoes/app_spec.rb

@@ -1,411 +0,0 @@
-require 'shoes/spec_helper'
-
-describe Shoes::App do
-  let(:input_blk) { Proc.new {} }
-  let(:opts) { Hash.new }
-  subject(:app) { Shoes::App.new(opts, &input_blk) }
-
-  it_behaves_like "DSL container"
-  it { should respond_to :clipboard }
-  it { should respond_to :clipboard= }
-  it { should respond_to :owner }
-
-  # For Shoes 3 compatibility
-  it "exposes self as #app" do
-    expect(app.app).to eq(app)
-  end
-
-  describe "initialize" do
-    let(:input_blk) { Proc.new {} }
-
-    before do
-      Shoes::App.any_instance.stub(:flow)
-    end
-
-    it "initializes style hash", :qt do
-      style = Shoes::App.new.style
-      style.class.should eq(Hash)
-    end
-
-    context "console" do
-    end
-
-    context "defaults" do
-      let(:opts) { Hash.new }
-      let(:defaults) { Shoes::InternalApp::DEFAULT_OPTIONS }
-
-      it "sets width", :qt do
-        subject.width.should == defaults[:width]
-        expect(subject.width).to eq defaults[:width]
-      end
-
-      it "sets height", :qt do
-        expect(subject.height).to eq defaults[:height]
-      end
-
-      it 'has an absolute_left of 0' do
-        expect(subject.absolute_left).to eq 0
-      end
-
-      it 'has an absolute_top of 0' do
-        expect(subject.absolute_top).to eq 0
-      end
-
-      describe "internal app state" do
-        let(:internal_app) { app.instance_variable_get(:@__app__) }
-
-        it "sets title", :qt do
-          expect(internal_app.app_title).to eq defaults[:title]
-        end
-
-        it "is resizable", :qt do
-          expect(internal_app.resizable).to be_true
-        end
-      end
-    end
-
-    context "from opts" do
-      let(:opts) { {:width => 150, :height => 2, :title => "Shoes::App Spec", :resizable => false} }
-
-      it "sets width", :qt do
-        expect(subject.width).to eq opts[:width]
-      end
-
-      it "sets height", :qt do
-        expect(subject.height).to eq opts[:height]
-      end
-
-      describe "internal app state" do
-        let(:internal_app) { app.instance_variable_get(:@__app__) }
-
-        it "sets title", :qt do
-          expect(internal_app.app_title).to eq opts[:title]
-        end
-
-        it "sets resizable", :qt do
-          expect(internal_app.resizable).to be_false
-        end
-      end
-
-      it 'initializes a flow with the right parameters' do
-        expect(Shoes::Flow).to receive(:new).with(anything, anything,
-                                                  {width:  opts[:width],
-                                                   height: opts[:height]}).
-                                                  and_call_original
-        subject
-      end
-    end
-
-    context "when registering" do
-      before :each do
-        Shoes.unregister_all
-      end
-
-      it "registers" do
-        old_apps_length = Shoes.apps.length
-        subject
-        expect(Shoes.apps.length).to eq(old_apps_length + 1)
-        expect(Shoes.apps).to include(subject)
-      end
-    end
-  end
-
-  describe "style" do
-    let(:black) { Shoes::COLORS[:black] }
-    let(:goldenrod) { Shoes::COLORS[:goldenrod] }
-    let(:defaults) { {stroke: black, strokewidth: 1} }
-
-    it "sets defaults" do
-      expect(app.style).to eq(defaults)
-    end
-
-    it "merges new styles with existing styles" do
-      new_styles = { strokewidth: 4 }
-      app.style new_styles
-      expect(app.style).to eq(defaults.merge(new_styles))
-    end
-
-    describe "strokewidth" do
-      it "defaults to 1" do
-        subject.style[:strokewidth].should eq(1)
-      end
-
-      it "passes default to objects" do
-        subject.line(0, 100, 100, 0).style[:strokewidth].should eq(1)
-      end
-
-      it "passes new values to objects" do
-        subject.strokewidth 10
-        subject.line(0, 100, 100, 0).style[:strokewidth].should eq(10)
-      end
-    end
-
-    describe "stroke" do
-      it "defaults to black" do
-        subject.style[:stroke].should eq(black)
-      end
-
-      it "passes default to objects" do
-        subject.oval(100, 100, 100).style[:stroke].should eq(black)
-      end
-
-      it "passes new value to objects" do
-        subject.stroke goldenrod
-        subject.oval(100, 100, 100).style[:stroke].should eq(goldenrod)
-      end
-    end
-
-    describe "default styles" do
-      it "is independent among Shoes::App instances" do
-        app1 = Shoes::App.new
-        app2 = Shoes::App.new
-
-        app1.strokewidth 10
-        app1.line(0, 100, 100, 0).style[:strokewidth].should == 10
-
-        # .. but does not affect app2
-        app2.line(0, 100, 100, 0).style[:strokewidth].should_not == 10
-      end
-    end
-  end
-  
-  describe "connecting with gui" do 
-    let(:gui) { app.instance_variable_get(:@__app__).gui }
-
-    describe "clipboard" do
-      it "gets clipboard" do
-        expect(gui).to receive(:clipboard)
-        subject.clipboard
-      end
-
-      it "sets clipboard" do
-        expect(gui).to receive(:clipboard=).with("test")
-        subject.clipboard = "test"
-      end
-    end
-
-    describe "quitting" do
-      it "#quit tells the GUI to quit" do
-        expect(gui).to receive :quit
-        subject.quit
-      end
-
-      it '#close tells the GUI to quit' do
-        expect(gui).to receive :quit
-        subject.close
-      end
-    end
-  end
-
-  describe "#started?" do
-    it "checks the window has been displayed or not" do
-      subject.started?
-    end
-  end
-
-  describe 'Execution context' do
-    it 'starts with self as the execution context' do
-      my_self = nil
-      app = Shoes.app do my_self = self end
-      my_self.should eq app
-    end
-  end
-
-  describe '#append' do
-    let(:input_blk) {Proc.new do append do para 'Hi' end end}
-
-    it 'understands append' do
-      subject.should respond_to :append
-    end
-
-    it 'should receive a call to what is called in the append block' do
-      Shoes::App.any_instance.should_receive :para
-      subject
-    end
-  end
-
-  describe '#resize' do
-    it 'understands resize' do
-      subject.should respond_to :resize
-    end
-  end
-
-  describe 'fullscreen' do
-    describe 'starting' do
-      let(:internal_app) { app.instance_variable_get(:@__app__) }
-
-      context 'with defaults' do
-        it 'does not start as fullscreen' do
-          expect(internal_app.start_as_fullscreen?).to be_false
-        end
-      end
-
-      describe 'with the fullscreen option' do
-        let(:opts) { {fullscreen: true} }
-
-        it 'starts as fullscreen ' do
-          expect(internal_app.start_as_fullscreen?).to be_true
-        end
-      end
-    end
-
-    it 'is not in fullscreen by default' do
-      expect(app).not_to be_fullscreen
-    end
-
-    it 'can be turned into fullscreen' do
-      app.fullscreen = true
-      expect(app).to be_fullscreen
-    end
-
-    describe 'going into fullscreen and back out again' do
-      let(:defaults) { Shoes::InternalApp::DEFAULT_OPTIONS }
-
-      before :each do
-        app.fullscreen = true
-        app.fullscreen = false
-      end
-
-      # Failing on Mac fullscreen doesnt seem to work see #397
-      it 'is not in fullscreen', :fails_on_osx => true do
-        expect(app).not_to be_fullscreen
-      end
-
-      # Failing on Mac fullscreen doesnt seem to work see #397
-      it 'has its original width', :fails_on_osx => true do
-        expect(app.width).to eq(defaults[:width])
-      end
-
-      # Failing on Mac fullscreen doesnt seem to work see #397
-      it 'has its original height', :fails_on_osx => true do
-        expect(app.height).to eq(defaults[:height])
-      end
-    end
-  end
-
-  describe '#add_child' do
-    let(:internal_app) { app.instance_variable_get(:@__app__) }
-    let(:child) {double 'child'}
-
-    it 'adds the child to the top_slot when there is one' do
-      top_slot_double = double 'top slot'
-      internal_app.stub(top_slot: top_slot_double)
-      expect(top_slot_double).to receive(:add_child).with(child)
-      internal_app.add_child child
-    end
-
-    it 'adds the child to the own contents when there is no top_slot' do
-      internal_app.stub top_slot: nil
-      internal_app.add_child child
-      internal_app.contents.should include child
-    end
-  end
-
-  describe '#clear' do
-    let(:input_blk) {Proc.new {para 'Hello'}}
-    let(:internal_app) {subject.instance_variable_get(:@__app__)}
-
-    it 'deletes everything (regression)' do
-      subject.clear
-      expect(internal_app.top_slot.contents).to be_empty
-    end
-
-    context 'clear in the initial input_block' do
-      let(:input_blk) {
-        Proc.new do
-          para 'Hello there'
-          clear do
-            para 'see you'
-          end
-        end
-      }
-
-      it 'does not raise an error calling clear on a top_slot that is nil' do
-        expect {subject}.not_to raise_error
-      end
-    end
-
-  end
-
-  describe "#gutter" do
-    context "when app has a scrollbar" do
-      let(:input_opts) { {width: 100, height: 100} }
-      let(:input_block) { Proc.new { para "Round peg, square hole" * 200 } }
-
-      it "has gutter of 16" do
-        expect(app.gutter).to eq(16)
-      end
-    end
-
-    context "when app has no scrollbar" do
-      let(:input_block) { Proc.new { para "Round peg, square hole" } }
-
-      it "has gutter of 16" do
-        expect(app.gutter).to eq(16)
-      end
-    end
-  end
-
-  describe 'DELEGATE_METHODS' do
-    subject {Shoes::App::DELEGATE_METHODS}
-
-    describe 'does not include general ruby object methods' do
-      it {should_not include :new, :initialize}
-    end
-
-    describe 'it has access to Shoes app and DSL methods' do
-      it {should include :para, :rect, :stack, :flow, :image, :location}
-    end
-
-    describe 'it does not have access to private methods' do
-      it {should_not include :pop_style, :style_normalizer, :create}
-    end
-
-    describe 'there are blacklisted methods which it should not include' do
-      it {should_not include :parent}
-    end
-  end
-end
-
-describe "App registry" do
-  subject { Shoes.apps }
-
-  before :each do
-    Shoes.unregister_all
-  end
-
-  it "only exposes a copy" do
-    subject << double("app")
-    Shoes.apps.length.should eq(0)
-  end
-
-  context "with no apps" do
-    it { should be_empty }
-  end
-
-  context "with one app" do
-    let(:app) { double('app') }
-    before :each do
-      Shoes.register(app)
-    end
-
-    its(:length) { should eq(1) }
-    it "marks first app as main app" do
-      Shoes.main_app.should be(app)
-    end
-  end
-
-  context "with two apps" do
-    let(:app_1) { double("app 1") }
-    let(:app_2) { double("app 2") }
-
-    before :each do
-      [app_1, app_2].each { |a| Shoes.register(a) }
-    end
-
-    its(:length) { should eq(2) }
-    it "marks first app as main app" do
-      Shoes.main_app.should be(app_1)
-    end
-  end
-end