shoes-core 4.0.0.pre3

data/lib/shoes/url.rb

@@ -0,0 +1,44 @@
+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
+    attr_accessor :app
+
+    Shoes::App.subscribe_to_dsl_methods self
+
+    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/version.rb

@@ -0,0 +1,3 @@
+class Shoes
+  VERSION = "4.0.0.pre3"
+end

data/lib/shoes/widget.rb

@@ -0,0 +1,67 @@
+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
+    include Common::Inspect
+
+    Shoes::App.subscribe_to_dsl_methods self
+
+    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.new_dsl_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
+
+    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/shoes-core.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('lib/shoes/core/version')
+
+Gem::Specification.new do |s|
+  s.name        = "shoes-core"
+  s.version     = Shoes::Core::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Team Shoes"]
+  s.email       = ["shoes@librelist.com"]
+  s.homepage    = "https://github.com/shoes/shoes4"
+  s.summary     = %q{The best little DSL for the best little GUI toolkit for Ruby.}
+  s.description = %q{Shoes is the best little GUI toolkit for Ruby. Shoes makes building for Mac, Windows, and Linux super simple. This is the DSL for writing your app. You'll need a backend to run it.}
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  # Curious why we don't install shoes? See ext/Rakefile for the nitty-gritty.
+  s.executables   = ['shoes-picker', 'shoes-stub']
+  s.extensions    = ['ext/install/Rakefile']
+end

data/spec/shoes/animation_spec.rb

@@ -0,0 +1,71 @@
+require 'shoes/spec_helper'
+
+shared_examples_for Shoes::Animation do
+  it "should start" do
+    subject.start
+    expect(subject).not_to be_stopped
+  end
+
+  it "should stop" do
+    subject.stop
+    expect(subject).to be_stopped
+  end
+
+  it "should toggle on" do
+    subject.stop
+    subject.toggle
+    expect(subject).not_to be_stopped
+  end
+
+  it "should toggle off" do
+    subject.start
+    subject.toggle
+    expect(subject).to be_stopped
+  end
+
+  it "increments frame" do
+    frame = subject.current_frame
+    subject.increment_frame
+    expect(subject.current_frame).to eq(frame + 1)
+  end
+end
+
+describe Shoes::Animation do
+  let(:app) { double('app', current_slot: slot) }
+  let(:slot) { double('slot', create_bound_block: bound_block) }
+  let(:app_gui) { double('app gui') }
+  let(:opts) { {} }
+  let(:block) { double('block') }
+  let(:bound_block) { double('bound block') }
+  subject { Shoes::Animation.new( app, opts, block ) }
+
+  before :each do
+    expect(app).to receive(:gui) { app_gui }
+  end
+
+  it_behaves_like Shoes::Animation
+
+  it "sets default framerate" do
+    expect(subject.framerate).to eq(10)
+  end
+
+  it "sets current frame to 0" do
+    expect(subject.current_frame).to eq(0)
+  end
+
+  it "calls through slot's context" do
+    expect(subject.blk).to eq(bound_block)
+  end
+
+  it { is_expected.not_to be_stopped }
+
+  describe "with framerate" do
+    let(:opts) { {:framerate => 36, :app => app} }
+
+    it "sets framerate" do
+      expect(subject.framerate).to eq(36)
+    end
+
+    it_behaves_like Shoes::Animation
+  end
+end

data/spec/shoes/app_spec.rb

@@ -0,0 +1,484 @@
+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) }
+
+  after do
+    Shoes.unregister_all
+  end
+
+  it_behaves_like "DSL container"
+  it { is_expected.to respond_to :clipboard }
+  it { is_expected.to respond_to :clipboard= }
+  it { is_expected.to 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 {} }
+
+    it "initializes style hash", :qt do
+      style = Shoes::App.new.style
+      expect(style.class).to 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
+        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 "inspect" do
+        include InspectHelpers
+
+        it "shows title in #to_s" do
+          expect(subject.to_s).to eq("(Shoes::App \"#{defaults.fetch :title}\")")
+        end
+
+        it "shows title in #inspect" do
+          expect(subject.inspect).to match("(Shoes::App:#{shoes_object_id_pattern} \"#{defaults.fetch :title}\")")
+        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
+
+      it "passes opts to InternalApp" do
+        expect(Shoes::InternalApp).to receive(:new).with(kind_of(Shoes::App), opts).and_call_original
+        subject
+      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 with defaults" do
+    let(:default_styles) { Shoes::Common::Style::DEFAULT_STYLES }
+
+    it "sets app defaults" do
+      expect(app.style).to eq(default_styles)
+    end
+
+    it "merges new styles with existing styles" do
+      subject.style strokewidth: 4
+      expect(subject.style).to eq(default_styles.merge(strokewidth: 4))
+    end
+
+    default_styles = Shoes::Common::Style::DEFAULT_STYLES
+
+    default_styles.each do |key, value|
+      describe "#{key}" do
+        it "defaults to #{value}" do
+          expect(subject.style[key]).to eq(value)
+        end
+
+        it "passes default to objects" do
+          expect(subject.line(0, 100, 100, 0).style[key]).to eq(value)
+        end
+
+      end
+    end
+
+
+    describe "default styles" do
+      it "are independent among Shoes::App instances" do
+        app1 = Shoes::App.new
+        app2 = Shoes::App.new
+
+        app1.strokewidth 10
+        expect(app1.line(0, 100, 100, 0).style[:strokewidth]).to eq(10)
+
+        # .. but does not affect app2
+        expect(app2.line(0, 100, 100, 0).style[:strokewidth]).not_to eq(10)
+
+      end
+    end
+  end
+
+  describe "app-level style setter" do
+    let(:goldenrod) { Shoes::COLORS[:goldenrod] }
+
+    pattern_styles = Shoes::DSL::PATTERN_APP_STYLES
+    other_styles = Shoes::DSL::OTHER_APP_STYLES
+
+    pattern_styles.each do |style|
+      it "sets #{style} for objects" do
+        subject.public_send(style, goldenrod)
+        expect(subject.line(0, 100, 100, 0).style[style]).to eq(goldenrod)
+      end
+    end
+
+    other_styles.each do |style|
+      it "sets #{style} for objects" do
+        subject.public_send(style, 'val')
+        expect(subject.line(0, 100, 100, 0).style[style]).to eq('val')
+      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
+      expect(my_self).to eq app
+    end
+  end
+
+  describe '#append' do
+    let(:input_blk) {Proc.new do append do para 'Hi' end end}
+
+    it 'understands append' do
+      expect(subject).to respond_to :append
+    end
+
+    it 'should receive a call to what is called in the append block' do
+      expect_any_instance_of(Shoes::App).to receive :para
+      subject
+    end
+  end
+
+  describe '#resize' do
+    it 'understands resize' do
+      expect(subject).to respond_to :resize
+    end
+  end
+
+  describe 'fullscreen' do
+    context 'defaults' do
+      it 'is not fullscreen' do
+        expect(app).not_to be_fullscreen
+      end
+
+      it 'can enter fullscreen' do
+        app.fullscreen = true
+        expect(app).to be_fullscreen
+      end
+    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 do
+        expect(app).not_to be_fullscreen
+      end
+
+      # Failing on Mac fullscreen doesnt seem to work see #397
+      it 'has its origina', :fails_on_osx 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 do
+        expect(app.height).to eq(defaults[:height])
+      end
+    end
+  end
+
+  describe '#clear' do
+    let(:input_blk) do
+      Proc.new do
+        para 'Hello'
+      end
+    end
+    let(:internal_app) {subject.instance_variable_get(:@__app__)}
+
+    it 'has initial contents' do
+      expect(subject.contents).to_not be_empty
+    end
+
+    it 'removes everything (regression)' do
+      subject.clear
+      expect(subject.contents).to be_empty
+    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 be_within(2).of(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 be_within(2).of(16)
+      end
+    end
+  end
+
+  describe "#parent" do
+    context "for a top-level element (not explicitly in a slot)" do
+      it "returns the top_slot" do
+        my_parent = nil
+        app = Shoes.app do
+          flow do
+            my_parent = parent
+          end
+        end
+        expect(my_parent).to eq app.instance_variable_get(:@__app__).top_slot
+      end
+    end
+
+    context "for an element within a slot" do
+      it "returns the enclosing slot" do
+        my_parent = nil
+        my_stack  = nil
+        app = Shoes.app do
+          my_stack = stack do
+            flow do
+              my_parent = parent
+            end
+          end
+        end
+
+        expect(my_parent).to eq my_stack
+      end
+    end
+
+  end
+
+  describe "additional context" do
+    it "fails on unknown method" do
+      expect { subject.asdf }.to raise_error(NoMethodError)
+    end
+
+    it "calls through to context if available" do
+      context = double("context", asdf: nil)
+      expect(context).to receive(:asdf)
+
+      subject.eval_with_additional_context(context) do
+        asdf
+      end
+    end
+
+    it "clears context when finished" do
+      context = double("context")
+
+      captured_context = nil
+      subject.eval_with_additional_context(context) do
+        captured_context = @__additional_context__
+      end
+
+      expect(captured_context).to eq(context)
+      expect(subject.instance_variable_get(:@__additional_context__)).to be_nil
+    end
+
+    it "still clears context when failure in eval" do
+      context = double("context")
+
+      expect do
+        subject.eval_with_additional_context(context) { raise "O_o" }
+      end.to raise_error(RuntimeError)
+
+      expect(subject.instance_variable_get(:@__additional_context__)).to be_nil
+    end
+  end
+
+  describe 'subscribing to DSL methods' do
+
+    class TestSubscribeClass
+      attr_reader :app
+      def initialize(app)
+        @app = app
+      end
+      Shoes::App.subscribe_to_dsl_methods(self)
+    end
+
+    let(:subscribed_instance) {TestSubscribeClass.new subject}
+
+    AUTO_SUBSCRIBED_CLASSES = [Shoes::App, Shoes::URL, Shoes::Widget]
+    SUBSCRIBED_CLASSES      = AUTO_SUBSCRIBED_CLASSES + [TestSubscribeClass]
+
+    describe '.subscribe_to_dsl_methods' do
+      it 'has its instances respond to the dsl methods of the app' do
+        expect(subscribed_instance).to respond_to :para, :image
+      end
+
+      it 'delegates does methods to the passed in app' do
+        expect(subject).to receive(:para)
+        subscribed_instance.para
+      end
+
+      SUBSCRIBED_CLASSES.each do |klazz|
+        it "#{klazz} responds to a regular DSL method" do
+          expect(klazz).to be_public_method_defined(:para)
+        end
+      end
+    end
+
+    describe '.new_dsl_method (for widget method notifications etc.)' do
+
+      before :each do
+        Shoes::App.new_dsl_method :widget_method do
+          # noop
+        end
+      end
+
+      SUBSCRIBED_CLASSES.each do |klazz|
+        it "#{klazz} now responds to this method" do
+          expect(klazz).to be_public_method_defined(:widget_method)
+        end
+      end
+    end
+
+    describe 'DELEGATE_METHODS' do
+      subject {Shoes::App::DELEGATE_METHODS}
+
+      describe 'does not include general ruby object methods' do
+        it {is_expected.not_to include :new, :initialize}
+      end
+
+      describe 'it has access to Shoes app and DSL methods' do
+        it {is_expected.to include :para, :rect, :stack, :flow, :image, :location}
+      end
+
+      describe 'it does not have access to private methods' do
+        it {is_expected.not_to include :pop_style, :style_normalizer, :create}
+      end
+
+      describe 'there are blacklisted methods that wreck havoc' do
+        it {is_expected.not_to include :parent, :app}
+      end
+    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")
+    expect(Shoes.apps.length).to eq(0)
+  end
+
+  context "with no apps" do
+    it { is_expected.to 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
+      expect(Shoes.main_app).to 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
+      expect(Shoes.main_app).to be(app_1)
+    end
+  end
+end