shoes-core 4.0.0.pre7 → 4.0.0.pre8

data/spec/shoes/download_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Download do
-  include_context "dsl app"
-
-  let(:name) { "http://www.google.com/logos/nasa50th.gif" }
-  let(:response_body) { "NASA 50th logo" }
-  let(:response_status) { ["200", "OK"] }
-  let(:response_headers) { { "content-length" => "42" } }
-  let(:opts) { {save: "nasa50th.gif"} }
-
-  subject(:download) { Shoes::Download.new app, parent, name, opts, &input_block }
-
-  let(:percent) { download.percent }
-  let(:length) { download.length }
-  let(:content_length) { download.content_length }
-
-  before do
-    expect(app.current_slot).to receive(:create_bound_block).at_least(1) { |blk| blk ? blk : nil }
-
-    stub_request(:get, name)
-      .to_return(status: response_status, body: response_body, headers: response_headers)
-  end
-
-  after do
-    File.delete opts[:save] if File.exist? opts[:save]
-  end
-
-  context 'before it has been started' do
-    it 'is 0 percent' do
-      expect(percent).to eq(0)
-    end
-
-    it 'understands abort' do
-      expect(download).to respond_to(:abort)
-    end
-
-    it 'has initial content_length of 1' do
-      expect(content_length).to eq(1)
-    end
-
-    it 'has initial length of 1' do
-      expect(length).to eq(1)
-    end
-  end
-
-  context 'without a progress proc' do
-    before :each do
-      download.start
-      download.join_thread
-    end
-
-    it 'finishes' do
-      expect(download).to be_finished
-    end
-
-    it 'starts' do
-      expect(download).to be_started
-    end
-
-    it 'creates the file specified by save' do
-      expect(File.exist?(opts[:save])).to be_truthy
-    end
-  end
-
-  context 'with a progress proc' do
-    let(:progress_proc) { proc {} }
-    let(:opts) { {save: "nasa50th.gif", progress: progress_proc} }
-    subject(:download) { Shoes::Download.new app, parent, name, opts }
-
-    before :each do
-      allow(download.gui).to receive :eval_block
-      download.start
-      download.join_thread
-    end
-
-    context 'with content length' do
-      it 'calls the progress proc from start, download and finish' do
-        expect(download.gui).to have_received(:eval_block)
-          .with(progress_proc, download)
-          .exactly(3).times
-      end
-    end
-
-    context 'without content length' do
-      let(:response_headers) { Hash.new }
-
-      it 'does not call on progress, but called from content length and finish' do
-        expect(download.gui).to have_received(:eval_block)
-          .with(progress_proc, download)
-          .twice
-      end
-
-      it 'can call percent just fine thanks' do
-        expect(download.percent).to eq(0)
-      end
-    end
-  end
-
-  describe 'after it is finished' do
-    let(:result) { download }
-    let(:response) { download.response }
-
-    before :each do
-      allow(download.gui).to receive(:eval_block)
-      download.start
-      download.join_thread
-    end
-
-    context 'with a block' do
-      it 'calls the block with a result' do
-        expect(download.gui).to have_received(:eval_block).with(input_block, result)
-      end
-
-      describe 'response object' do
-        it 'has headers hash' do
-          expect(response.headers).to eql(response_headers)
-        end
-
-        it 'has body text' do
-          expect(response.body).to eql(response_body)
-        end
-
-        it 'has status array' do
-          expect(response.status).to eql(response_status)
-        end
-      end
-    end
-
-    context 'without a block' do
-      subject(:download) { Shoes::Download.new app, parent, name, opts }
-
-      it 'does not call the block' do
-        expect(download.gui).not_to have_received(:eval_block)
-      end
-    end
-
-    context 'with a finish proc' do
-      let(:finish_proc) { proc {} }
-      let(:opts) { {save: "nasa50th.gif", finish: finish_proc} }
-      subject(:download) { Shoes::Download.new app, parent, name, opts }
-
-      it 'calls the finish proc' do
-        expect(download.gui).to have_received(:eval_block).with(finish_proc, subject)
-      end
-    end
-  end
-
-  describe 'when things go wrong' do
-    it 'reports back to the parent thread' do
-      error = StandardError.new("Nope")
-
-      expect(download.gui).to receive(:eval_block).with(anything, error)
-      allow(download).to receive(:open).and_raise(error)
-
-      download.start
-      download.join_thread
-    end
-
-    it 'reports empty values for the response' do
-      error = StandardError.new("Nope")
-      allow(download).to receive(:open).and_raise(error)
-
-      download.start
-      download.join_thread
-
-      expect(download.response.body).to be_empty
-      expect(download.response.headers).to be_empty
-      expect(download.response.status).to be_empty
-    end
-
-    it 'does not die on socket errors, but logs them' do
-      error = SocketError.new('Badumz')
-
-      expect(download.gui).not_to receive(:eval_block)
-      expect(Shoes.logger).to receive(:error).with error
-      allow(download).to receive(:open).and_raise(error)
-
-      download.start
-      download.join_thread
-    end
-
-    describe 'with custom error blocks' do
-      let(:error_proc) { proc {} }
-      let(:opts) { {save: "nasa50th.gif", error: error_proc} }
-
-      it 'gets called' do
-        error = StandardError.new("Nope")
-
-        expect(download.gui).to receive(:eval_block).with(error_proc, error)
-        allow(download).to receive(:open).and_raise(error)
-
-        download.start
-        download.join_thread
-      end
-    end
-  end
-end

data/spec/shoes/flow_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-require 'shoes/helpers/fake_element'
-
-describe Shoes::Flow do
-  include_context "dsl app"
-
-  subject(:flow) { Shoes::Flow.new(app, parent, input_opts, input_block) }
-
-  it_behaves_like "clickable object"
-  it_behaves_like "Slot"
-  it_behaves_like "object with hover"
-
-  describe "initialize" do
-    let(:input_opts) { {width: 131, height: 137} }
-    it "sets accessors" do
-      expect(flow.parent).to eq(parent)
-      expect(flow.width).to eq(131)
-      expect(flow.height).to eq(137)
-      expect(flow.blk).to eq(input_block)
-    end
-
-    describe 'margins' do
-      let(:input_opts) { {margin: 143} }
-      it 'sets the margins' do
-        expect(flow.margin).to eq([143, 143, 143, 143])
-      end
-    end
-  end
-
-  it "sets default values" do
-    f = Shoes::Flow.new(app, parent)
-    expect(f.width).to eq(app.width)
-    expect(f.height).to eq(0)
-  end
-
-  it "clears with an optional block" do
-    expect(flow).to receive(:clear) do |&blk|
-      expect(blk).to eq(input_block)
-    end
-    flow.clear(&input_block)
-  end
-
-  describe "positioning" do
-    it_behaves_like 'positioning through :_position'
-    it_behaves_like 'positions the first element in the top left'
-
-    shared_examples_for 'positioning in the same line' do
-      it 'positions an element in the same row as long as they fit' do
-        expect(element2.absolute_top).to eq(flow.absolute_top)
-      end
-
-      it 'positions it next to the other element as long as it fits' do
-        expect(element2.absolute_left).to eq(element.absolute_right + 1)
-      end
-
-      it 'has a slot height of the maximum value of the 2 elements' do
-        expect(flow.height).to eq([element.height, element2.height].max)
-      end
-    end
-
-    describe 'two elements added' do
-      include_context 'two slot children'
-      include_context 'contents_alignment'
-
-      it_behaves_like 'positioning in the same line'
-
-      describe 'exact fit' do
-        let(:input_opts) { {width: element.width + element2.width} }
-        it_behaves_like 'positioning in the same line'
-      end
-    end
-
-    describe 'when the elements dont fit next to each other' do
-      let(:input_opts) { {width: element.width + element2.width - 10} }
-      it_behaves_like 'arranges elements underneath each other'
-
-      describe 'and a third element that goes into the second line' do
-        include_context 'three slot children'
-        include_context 'contents_alignment'
-
-        it 'positions the third element right next to the second' do
-          expect(element3.absolute_left).to eq element2.absolute_right + 1
-        end
-
-        it 'positions the third element on the same height as element 2' do
-          expect(element3.absolute_top).to eq element2.absolute_top
-        end
-      end
-    end
-
-    describe 'elements dont fit next to each other and set small height' do
-      let(:input_opts) { {width: element.width + 10, height: element.height + 10} }
-      it_behaves_like 'set height and contents alignment'
-    end
-
-    describe 'elements dont fit next to each other and set big height' do
-      let(:input_opts) { { width: element.width + 10, height: 1000 } }
-      it_behaves_like 'set height and contents alignment'
-    end
-
-    describe 'with margins and two elements not fitting next to each other' do
-      let(:input_opts) { { width: element.width + 10, margin: 27 } }
-      it_behaves_like 'taking care of margin'
-    end
-  end
-
-  describe 'scrolling' do
-    include_context "scroll"
-    subject(:flow) { Shoes::Flow.new(app, parent, opts) }
-
-    context 'when scrollable' do
-      let(:scroll) { true }
-
-      it_behaves_like "scrollable slot"
-
-      context 'when content overflows' do
-        include_context "overflowing content"
-        it_behaves_like "scrollable slot with overflowing content"
-      end
-    end
-
-    context 'when slot is not scrollable' do
-      let(:scroll) { false }
-
-      its(:scroll) { should be_falsey }
-
-      it "initializes scroll_top to 0" do
-        expect(flow.scroll_top).to eq(0)
-      end
-    end
-  end
-end

data/spec/shoes/font_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-main_object = self
-
-describe Shoes::Font do
-  describe 'font method on the main object' do
-    it 'returns the name of the font loaded' do
-      result = main_object.font(Shoes::FONT_DIR + "Coolvetica" + '.ttf')
-      expect(result).to eq 'Coolvetica'
-    end
-
-    it 'calls the backend add_font method' do
-      expect(Shoes.backend::Font).to receive :add_font
-      main_object.font 'some/path'
-    end
-  end
-
-  describe '.font_paths_from_dir' do
-    it 'returns an array of the paths of the fonts in the directory' do
-      result = Shoes::Font.font_paths_from_dir(Shoes::FONT_DIR)
-
-      expect(result).to include(Shoes::FONT_DIR + 'Coolvetica.ttf',
-                                Shoes::FONT_DIR + 'Lacuna.ttf')
-    end
-
-    it 'handles sub directories' do
-      tmp_font_dir = Shoes::FONT_DIR + 'tmp/'
-      Dir.mkdir(tmp_font_dir)
-      tmp_font_path = tmp_font_dir + 'weird_font.ttf'
-      FileUtils.touch tmp_font_path
-      result = Shoes::Font.font_paths_from_dir(Shoes::FONT_DIR)
-      expect(result).to include tmp_font_path
-      FileUtils.rm_r tmp_font_dir
-    end
-  end
-end

data/spec/shoes/framework_learning_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-module Learning
-  class App
-    attr_accessor :gui
-
-    def initialize
-      @gui = gui_init
-    end
-  end
-end
-
-module TextPlugin
-  module App
-    def gui_init
-      "Peter"
-    end
-  end
-end
-
-module Learning
-  class App
-    include TextPlugin::App
-  end
-end
-
-describe "A Shoes Framework" do
-  it "should include Framework Plugins" do
-    expect(Learning::App.new.gui).to eq("Peter")
-  end
-end

data/spec/shoes/gradient_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Gradient do
-  let(:color1) { Shoes::COLORS[:honeydew] }
-  let(:color2) { Shoes::COLORS[:salmon] }
-  subject { Shoes::Gradient.new(color1, color2) }
-
-  describe "comparable" do
-    let(:new_color) { Shoes::COLORS[:limegreen] }
-
-    it "is equal when values are equal" do
-      gradient2 = Shoes::Gradient.new(color1, color2)
-      expect(subject).to eq(gradient2)
-    end
-
-    it "is not equal when color 1 is different" do
-      gradient2 = Shoes::Gradient.new(new_color, color2)
-      expect(subject).not_to eq(gradient2)
-    end
-
-    it "is not equal when color 2 is different" do
-      gradient2 = Shoes::Gradient.new(new_color, color2)
-      expect(subject).not_to eq(gradient2)
-    end
-
-    it "is not equal to just a color" do
-      gradient2 = Shoes::Gradient.new(color1, new_color)
-      expect(subject).not_to eq(gradient2)
-    end
-  end
-end

data/spec/shoes/helpers/fake_absolute_element.rb

@@ -1,31 +0,0 @@
-class Shoes
-  class FakeAbsoluteElement
-    include Common::Attachable
-    include Common::Inspect
-    include Common::Positioning
-    include Common::Remove
-    include Common::Visibility
-
-    include Shoes::DimensionsDelegations
-
-    def initialize
-      @dimensions = AbsoluteDimensions.new 0, 0, 100, 100
-    end
-
-    def add_child(_element)
-      true
-    end
-
-    def adjust_current_position(*_)
-    end
-
-    # Fake this out instead of using Common::Style to avoid things like touching
-    # app level styles, etc. that we don't need for testing purposes
-    def style
-      @style ||= {}
-      @style
-    end
-
-    attr_accessor :dimensions, :parent, :gui
-  end
-end