shoes-core 4.0.0.pre3 → 4.0.0.pre4

data/lib/shoes/slot_contents.rb

@@ -33,12 +33,12 @@ class Shoes
       @contents.clear
     end
 
-    def inspect
-      super.insert(-2, " @size=#{size} @prepending=#{@prepending} @prepending_index=#{@prepending_index}")
-    end
-
     private
 
+    def inspect_details
+      " @size=#{size} @prepending=#{@prepending} @prepending_index=#{@prepending_index}"
+    end
+
     def append_element(element)
       @contents << element
     end

data/lib/shoes/star.rb

@@ -1,17 +1,15 @@
 class Shoes
   class Star
     include Common::UIElement
+    include Common::Fill
+    include Common::Stroke
     include Common::Style
     include Common::Clickable
 
-    attr_reader :app, :parent, :dimensions, :gui
     style_with :angle, :art_styles, :common_styles, :dimensions, :inner, :outer, :points
-    STYLES = { angle: 0 }
-
-    def initialize(app, parent, left, top, points, outer, inner, styles = {}, blk = nil)
-      @app = app
-      @parent = parent
+    STYLES = { angle: 0, fill: Shoes::COLORS[:black] }
 
+    def create_dimensions(left, top, points, outer, inner)
       # Don't use param defaults as DSL explicit passes nil for missing params
       points ||= 10
       outer  ||= 100.0
@@ -28,16 +26,9 @@ class Shoes
       inner_dimensions = AbsoluteDimensions.new 0, 0, inner * 2, 0
 
       # Get actual outer/inner from the dimension to handle relative values
-      outer = @dimensions.width / 2
-      inner = inner_dimensions.width / 2
-
-      # Now set style using adjust outer and inner
-      style_init(styles, inner: inner, outer: outer, points: points)
-
-      @parent.add_child self
-      @gui = Shoes.backend_for self
-
-      register_click blk
+      style[:outer]  = @dimensions.width / 2
+      style[:inner]  = inner_dimensions.width / 2
+      style[:points] = points
     end
 
     def in_bounds?(x, y)

data/lib/shoes/text.rb

@@ -14,11 +14,13 @@ class Shoes
     end
 
     def app
-      @parent.app
+      parent && parent.app
     end
 
-    def inspect
-      super.insert(-2, %( "#{self}"))
+    private
+
+    def inspect_details
+      " \"#{self}\""
     end
   end
 end

data/lib/shoes/text_block.rb

@@ -8,24 +8,21 @@ class Shoes
     include Common::Clickable
     include TextBlockDimensionsDelegations
 
-    attr_reader :gui, :parent, :text, :contents, :app, :text_styles, :dimensions
+    attr_reader :text, :contents, :text_styles
     attr_accessor :cursor, :textcursor
+
     style_with :common_styles, :dimensions, :text_block_styles
-    STYLES = { font: "Arial" } # used in TextBlock specs only
+    STYLES = { font: DEFAULT_TEXTBLOCK_FONT } # used in TextBlock specs only
+
+    def create_dimensions(*_)
+      @dimensions = TextBlockDimensions.new @parent, @style
+    end
 
-    def initialize(app, parent, text, styles = {})
-      @parent = parent
-      @app = app
-      style_init styles
-      @dimensions = TextBlockDimensions.new parent, @style
+    def after_initialize(text)
       handle_styles @style
-      @gui = Shoes.backend_for self
-      @parent.add_child self
 
       # Important to use accessor and do this after the backend exists!
       self.text = Array(text)
-
-      register_click
     end
 
     def in_bounds?(*args)
@@ -37,6 +34,12 @@ class Shoes
     end
 
     def replace(*texts)
+      opts = texts.pop if texts.last.is_a?(Hash)
+      if opts
+        style(opts)
+        handle_styles(opts)
+      end
+
       # Order here matters as well--backend#replace shouldn't rely on DSL state
       # but the texts that it's passed if it needs information at this point.
       @gui.replace(*texts)
@@ -62,7 +65,7 @@ class Shoes
       @textcursor ||= app.textcursor(line_height)
     end
 
-    def has_textcursor?
+    def textcursor?
       @textcursor
     end
 
@@ -71,9 +74,7 @@ class Shoes
     end
 
     def links
-      return [] unless @contents
-
-      @contents.select do |element|
+      contents.to_a.select do |element|
         element.is_a?(Shoes::Link)
       end
     end
@@ -135,7 +136,7 @@ class Shoes
     "Inscription" => { size: 10 }
   }.each do |name, styles|
     clazz = Class.new(TextBlock) do
-      const_set("STYLES", { font: "Arial", fill: nil }.merge(styles))
+      const_set("STYLES", { font: DEFAULT_TEXTBLOCK_FONT, fill: nil }.merge(styles))
     end
     Shoes.const_set(name, clazz)
   end

data/lib/shoes/text_block_dimensions.rb

@@ -31,7 +31,7 @@ class Shoes
 
     # This is the width the text block initially wants to try and fit into.
     def desired_width(containing = containing_width)
-      parent.absolute_left + containing - absolute_left
+      parent.absolute_left + containing - absolute_left - margin_left - margin_right
     end
 
     # If an explicit width's set, use that when asking how much space we need.

data/lib/shoes/ui/cli.rb

@@ -5,7 +5,11 @@ class Shoes
   class CLI
     attr_reader :packager
 
-    def initialize
+    def initialize(backend)
+      $LOAD_PATH.unshift(Dir.pwd)
+      backend_const = Shoes.load_backend(backend)
+      backend_const.initialize_backend
+
       @packager = Shoes::Packager.new
     end
 
@@ -33,6 +37,12 @@ Usage: #{opts.program_name} [-h] [-p package] file
           exit
         end
 
+        opts.on('-b', '--backend [BACKEND]', 'Select a Shoes backend') do |backend|
+          require 'shoes/ui/picker'
+          Shoes::UI::Picker.new.run(ENV["SHOES_BIN_DIR"], backend)
+          exit
+        end
+
         opts.separator @packager.help(opts.program_name)
       end
 
@@ -43,9 +53,8 @@ Usage: #{opts.program_name} [-h] [-p package] file
     # Execute a shoes app.
     #
     # @param [String] app the location of the app to run
+    # @param [String] backend name of backend to load with the app
     def execute_app(app)
-      $LOAD_PATH.unshift(Dir.pwd)
-      require 'shoes/swt'
       load app
     end
 

data/lib/shoes/ui/picker.rb

@@ -3,38 +3,83 @@ class Shoes
     # This class is used for interactively (if necessary) picking the Shoes
     # backend that the user will run their Shoes app with.
     class Picker
-      def run
+      def initialize(input=STDIN, output=STDOUT)
+        @input  = input
+        @output = output
+      end
+
+      def run(bin_dir, desired_backend=nil)
         bundle
-        generator_file = select_generator
-        write_backend(generator_file)
+        generator_file = select_generator(desired_backend)
+        write_backend(generator_file, bin_dir)
       end
 
       # Only bundle if we find a local Gemfile.  This allows us to work properly
-      # running from source without finding gem-nstalled backends.
+      # running from source without finding gem-installed backends.
       def bundle
-        if File.exist?("Gemfile")
-          require 'bundler/setup'
-          Bundler.require
-        end
+        return unless File.exist?("Gemfile")
+
+        # Only need bundler/setup to get our paths right--we don't need to
+        # actually require the gems, since we find the generate-backend.rb's
+        # and just require them directly.
+        require 'bundler/setup'
       end
 
-      def select_generator
-        puts "Selecting Shoes backend to use. This is a one-time operation."
-        candidates = Gem.find_files("shoes/**/generate-backend.rb")
-        if candidates.one?
-          generator_file = candidates.first
+      def select_generator(desired_backend=nil)
+        candidates = find_candidates(desired_backend)
+
+        if candidates.empty?
+          raise ArgumentError.new("No gems found matching '#{desired_backend}'")
+        elsif candidates.one?
+          candidate = candidates.first
+          @output.puts "Selecting #{name_for_candidate(candidate)} backend to use. This is a one-time operation."
+          candidate
         else
-          fail NotImplementedError("Currently can't interactively select a backend. See #929")
+          candidates.sort!
+          output_candidates(candidates)
+          prompt_for_candidate(candidates)
         end
+      end
 
-        generator_file
+      def find_candidates(desired_backend)
+        search_string = "shoes/**/#{desired_backend}/generate-backend.rb"
+        search_string.gsub!("//", "/")
+        Gem.find_files(search_string)
       end
 
-      def write_backend(generator_file)
-        require generator_file
+      def output_candidates(candidates)
+        @output.puts
+        @output.puts "Enter a number to select a Shoes backend (This is a one-time operation):"
 
-        # On Windows getting odd paths with trailing double-quote
-        bin_dir = ARGV[0].gsub('"', '')
+        candidates.each_with_index do |candidate, index|
+          @output.puts " #{index + 1}. #{name_for_candidate(candidate)}"
+        end
+
+        @output.print "> "
+      end
+
+      def prompt_for_candidate(candidates)
+        candidate = nil
+
+        until candidate
+          entered_index = @input.readline.to_i
+          if entered_index > 0
+            candidate = candidates[entered_index - 1]
+            break if candidate
+          end
+          @output.puts "Invalid selection. Try again with a number from 1 to #{candidates.size}."
+        end
+
+        candidate
+      end
+
+      def name_for_candidate(candidate)
+        /.*lib\/shoes\/(.*)\/generate-backend.rb/.match(candidate)
+        return "shoes-#{$1.gsub("/", "-")}"
+      end
+
+      def write_backend(generator_file, bin_dir)
+        require generator_file
 
         File.open(File.expand_path(File.join(bin_dir, "shoes-backend")), "w") do |file|
           # Contract with backends is to define generate_backend method that we

data/lib/shoes/version.rb

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

data/shoes-core.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   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.summary     = 'The best little DSL for the best little GUI toolkit for Ruby.'
+  s.description = "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($/)

data/spec/shoes/animation_spec.rb

@@ -37,7 +37,7 @@ describe Shoes::Animation do
   let(:opts) { {} }
   let(:block) { double('block') }
   let(:bound_block) { double('bound block') }
-  subject { Shoes::Animation.new( app, opts, block ) }
+  subject { Shoes::Animation.new(app, opts, block) }
 
   before :each do
     expect(app).to receive(:gui) { app_gui }

data/spec/shoes/app_spec.rb

@@ -58,7 +58,7 @@ describe Shoes::App do
         end
 
         it "shows title in #inspect" do
-          expect(subject.inspect).to match("(Shoes::App:#{shoes_object_id_pattern} \"#{defaults.fetch :title}\")")
+          expect(subject.inspect).to match(/\(Shoes::App:#{shoes_object_id_pattern} "#{defaults.fetch :title}"\)/)
         end
       end
     end
@@ -81,8 +81,8 @@ describe Shoes::App do
 
       it 'initializes a flow with the right parameters' do
         expect(Shoes::Flow).to receive(:new).with(anything, anything,
-                                                  {width:  opts[:width],
-                                                   height: opts[:height]}).
+                                                  width:  opts[:width],
+                                                  height: opts[:height]).
                                                   and_call_original
         subject
       end
@@ -283,25 +283,6 @@ describe Shoes::App do
     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
@@ -319,7 +300,7 @@ describe Shoes::App do
       it "returns the enclosing slot" do
         my_parent = nil
         my_stack  = nil
-        app = Shoes.app do
+        Shoes.app do
           my_stack = stack do
             flow do
               my_parent = parent

data/spec/shoes/color_spec.rb

@@ -238,6 +238,17 @@ describe Shoes::Color do
         expect(green).to eq green
       end
 
+      # shoes 3 compatibility behavior
+      describe 'different colors' do
+        it 'takes the total of rgb values to compare, less is less' do
+          expect(create_rgb 100, 200, 0).to be < create_rgb(50, 100, 151)
+        end
+
+        it 'takes the total of rgb values to compare, more is more' do
+          expect(create_rgb 0, 200, 200).to be > create_rgb(150, 150, 99)
+        end
+      end
+
       context "same rgb values" do
         let(:color_2) { Shoes::Color.new(255, 69, 0, 254) }
         it "is less than when less opaque" do
@@ -250,6 +261,10 @@ describe Shoes::Color do
       end
     end
   end
+
+  def create_rgb(r, g, b)
+    Shoes::Color.new r, g, b
+  end
 end
 
 describe "Shoes built-in colors" do
@@ -284,7 +299,7 @@ describe "Shoes built in gray" do
   end
 
   specify "float parameters should be normalised" do
-    expect(app.gray(1.0, 0.5)).to eq(Shoes::Color.new( 255, 255, 255, 128 ))
+    expect(app.gray(1.0, 0.5)).to eq(Shoes::Color.new(255, 255, 255, 128))
   end
 
   it 'hangles 0.93 right as well' do

data/spec/shoes/common/style_normalizer_spec.rb

@@ -13,7 +13,7 @@ describe Shoes::Common::StyleNormalizer do
     expected = {fill: Shoes::Color.new(255, 255, 255)}
     expect(subject.normalize input).to eq expected
   end
-  
+
   it 'turns hexcodes for stroke into colors' do
     input = {stroke: 'ffffff'}
     expected = {stroke: Shoes::Color.new(255, 255, 255)}
@@ -23,6 +23,6 @@ describe Shoes::Common::StyleNormalizer do
   it 'does not modify the original hash' do
     input = {stroke: '333333'}
     subject.normalize input
-    expect(input).to eq({stroke: '333333'})
+    expect(input).to eq(stroke: '333333')
   end
-end
+end

data/spec/shoes/common/style_spec.rb

@@ -5,15 +5,22 @@ describe Shoes::Common::Style do
   let(:blue) { Shoes::COLORS[:blue] }
 
   class StyleTester
+    include Shoes::Common::Visibility
+    include Shoes::DimensionsDelegations
     include Shoes::Common::Style
-    attr_accessor :left
+
+    attr_reader :dimensions
     style_with :key, :left, :click, :strokewidth, :fill
+
     STYLES = {fill: Shoes::COLORS[:blue]}
 
     def initialize(app, styles = {})
       @app = app #needed for style init
+      @dimensions = Shoes::Dimensions.new(@app, left: 15)
+
+      # Would normally be done by Common::Initialization
       style_init(styles, key: 'value')
-      @left = 15
+      update_dimensions
     end
 
     def click(&arg)
@@ -23,17 +30,21 @@ describe Shoes::Common::Style do
     def click_blk
       @click
     end
+
+    def update_visibility
+    end
   end
+
   subject {StyleTester.new(app)}
 
-  its(:style) { should eq (initial_style) }
-  let(:initial_style) { {key: 'value', left: 15, click: nil, strokewidth: 1, fill: blue} }
+  its(:style) { should eq(initial_style) }
+  let(:initial_style) { {key: 'value', left: 15, click: nil, strokewidth: 1, fill: blue,
+      margin: [0,0,0,0], margin_left: 0, margin_top: 0, margin_right: 0, margin_bottom: 0 } }
 
   describe 'reading and writing through #style(hash)' do
     let(:input_proc) { Proc.new {} }
     let(:changed_style) { {key: 'changed value'} }
 
-
     before :each do
       subject.style changed_style
     end
@@ -57,6 +68,16 @@ describe Shoes::Common::Style do
       expect(subject.left).to eq 200
     end
 
+    it 'reads visibility' do
+      subject.hide
+      expect(subject.style[:hidden]).to be true
+    end
+
+    it 'writes visibility' do
+      subject.style(hidden: true)
+      expect(subject.hidden?).to be true
+    end
+
     it 'sets click' do
       subject.style(click: input_proc)
       expect(subject.click_blk).to eq input_proc
@@ -117,6 +138,7 @@ describe Shoes::Common::Style do
 
   describe "style priorities" do
     subject {StyleTester.new(app, key: 'pumpkin')}
+    let(:green) { Shoes::COLORS[:green] }
 
     it 'uses arguments-styles over element-styles' do
       expect(subject.key).to eq 'pumpkin'
@@ -126,6 +148,21 @@ describe Shoes::Common::Style do
       expect(subject.fill).to eq blue
     end
 
+    describe "with app level styles applied" do
+      let(:app) { Shoes::App.new}
+
+      it "should override class level defaults with app level styles provided those app styles are supported by the class" do
+        app.style(fill: green)
+        expect(app.line(0, 0, 10, 10).fill).to eq green
+      end
+
+      it "should not override class level defaults with app level styles for already instanciated objects" do
+        line_instance = app.line(0, 0, 10, 10)
+        app.style(fill: green)
+        expect(line_instance.fill).not_to eq green
+      end
+    end
+
     #related priority specs are tested individually in spec/shared_examples/style
   end
 

data/spec/shoes/dimension_spec.rb

@@ -307,9 +307,8 @@ describe Shoes::Dimension do
     it {is_expected.to be_in_bounds 105}
     it {is_expected.to be_in_bounds 20.021}
     it {is_expected.not_to be_in_bounds absolute_end + ONE_PIXEL}
-    it {is_expected.not_to be_in_bounds absolute_start - ONE_PIXEL
-    }
-    it {is_expected.not_to be_in_bounds -5}
+    it {is_expected.not_to be_in_bounds absolute_start - ONE_PIXEL }
+    it {is_expected.not_to be_in_bounds(-5)}
     it {is_expected.not_to be_in_bounds 0}
     it {is_expected.not_to be_in_bounds 150}
     it {is_expected.not_to be_in_bounds 123178}
@@ -334,12 +333,12 @@ describe Shoes::Dimension do
 
     it 'parses negative values' do
       subject.start = '-13'
-      expect(subject.start).to eq -13
+      expect(subject.start).to eq(-13)
     end
 
     it 'even parses negative values with px' do
       subject.start = '-22px'
-      expect(subject.start).to eq -22
+      expect(subject.start).to eq(-22)
     end
 
     it 'returns nil for unknown values' do
@@ -397,7 +396,7 @@ describe Shoes::Dimension do
 
       it 'can still handle special values like a negative extent' do
         subject.extent = -10
-        expect(subject.extent).to eq (parent_extent - 2 * margin) - 10
+        expect(subject.extent).to eq(parent_extent - 2 * margin - 10)
       end
 
       it 'can also still handle special values like relative values' do
@@ -430,4 +429,3 @@ describe Shoes::Dimension do
   end
 
 end
-

data/spec/shoes/dimensions_spec.rb

@@ -211,10 +211,10 @@ describe Shoes::Dimensions do
         let(:parent_height) {300}
         subject {Shoes::Dimensions.new parent, "- 100", "-20px", "- 50px", "- 80"}
 
-        its(:left) {should eq -100}
-        its(:top) {should eq -20}
-        its(:width) {should eq (parent_width - 50)}
-        its(:height) {should eq (parent_height - 80)}
+        its(:left) {should eq(-100)}
+        its(:top) {should eq(-20)}
+        its(:width) {should eq(parent_width - 50)}
+        its(:height) {should eq(parent_height - 80)}
       end
     end
 
@@ -553,12 +553,12 @@ describe Shoes::Dimensions do
         subject.margin_right = 7
         expect(subject.margin).to eq([margin, margin, 7, margin])
       end
-      
+
       it 'adapts margins when margin is changed with single value' do
         subject.margin = 7
         expect(subject.margin).to eq([7, 7, 7, 7])
       end
-      
+
       it 'adapts margin when margin is changed with array' do
         subject.margin = [7, 7, 7, 7]
         expect(subject.margin).to eq([7, 7, 7, 7])
@@ -759,7 +759,7 @@ describe Shoes::Dimensions do
 
       it 'can also still handle special values like a negative width' do
         subject.width = -10
-        expect(subject.width).to eq (parent.width - 10)
+        expect(subject.width).to eq(parent.width - 10)
       end
 
       it 'can also still handle special values like a relative height' do