From e6b3777697f191a22a1a4a83c861667c3105bab4 Mon Sep 17 00:00:00 2001 From: Lukas Deutz Date: Mon, 21 Jun 2021 21:03:29 -0400 Subject: [PATCH] Run crystal tool format --- samples/middleware.cr | 4 +-- samples/real_world.cr | 12 ++++---- samples/sink_synchronisation.cr | 2 +- samples/testing.cr | 2 +- samples/wait.cr | 2 +- spec/buffer_sink_spec.cr | 10 +++---- spec/connect_spec.cr | 4 +-- spec/interval_sink_spec.cr | 12 ++++---- spec/middleware_spec.cr | 20 ++++++------- spec/signal_spec.cr | 50 ++++++++++++++++----------------- spec/spec_spec.cr | 6 ++-- spec/timed_buffer_sink_spec.cr | 14 ++++----- src/cute.cr | 14 ++++----- src/cute/buffer_sink.cr | 1 - src/cute/interval_sink.cr | 1 - src/cute/signal.cr | 8 +++--- src/cute/sink.cr | 18 ++++++------ src/cute/timed_buffer_sink.cr | 1 - src/spec.cr | 11 +++++--- 19 files changed, 96 insertions(+), 96 deletions(-) diff --git a/samples/middleware.cr b/samples/middleware.cr index 4f6cfb1..86b6c28 100644 --- a/samples/middleware.cr +++ b/samples/middleware.cr @@ -17,8 +17,8 @@ chat = Chat.new chat.send_message.add { |body, yielder| yielder.call(body.upcase) } # Prepend our user name -chat.send_message.add { |body, yielder| yielder.call("Alice: #{body}")} +chat.send_message.add { |body, yielder| yielder.call("Alice: #{body}") } # Send a message -chat.send_message.call("Hello") #=> 13 +chat.send_message.call("Hello") # => 13 # Prints "Sending Alice: HELLO" diff --git a/samples/real_world.cr b/samples/real_world.cr index cb1e085..c820802 100644 --- a/samples/real_world.cr +++ b/samples/real_world.cr @@ -43,7 +43,7 @@ class DataSource spawn do loop do changed.emit rand(VALUE_RANGE) # Result of a complex calculation - sleep rand(SLEEP_RANGE) # Next value will take a bit + sleep rand(SLEEP_RANGE) # Next value will take a bit end end end @@ -53,7 +53,7 @@ end class DataApplication DISPLAYS = 5 - @displays = [ ] of DataDisplay + @displays = [] of DataDisplay def initialize # We're using an interval sink, meaning, we want to get notified if anything @@ -61,19 +61,19 @@ class DataApplication @sink = Cute::IntervalSink(Nil).new(interval: 1.seconds) # If something happened, then redraw the application - @sink.on{|hits| redraw hits.size} + @sink.on { |hits| redraw hits.size } # Create something that can change - DISPLAYS.times{ @displays << create_display } + DISPLAYS.times { @displays << create_display } redraw # Don't forget to draw something initially! end private def create_display - source = DataSource.new # We have a source + source = DataSource.new # We have a source display = DataDisplay.new # And something to show incoming data # If the source gets new data, supply it to the display - source.changed.on{|value| display.data = value} + source.changed.on { |value| display.data = value } # If the display changes somehow, schedule a redraw display.changed.on(@sink) diff --git a/samples/sink_synchronisation.cr b/samples/sink_synchronisation.cr index f6963ba..785e263 100644 --- a/samples/sink_synchronisation.cr +++ b/samples/sink_synchronisation.cr @@ -23,7 +23,7 @@ sink = Cute::BufferSink(Int32).new(size: 5) 10.times do |index| # Create ten jobs thing = SomethingComplex.new(index) thing.finished.on(sink) # Connect the signal to our sink - thing.run # Run the complex calculation! + thing.run # Run the complex calculation! end # Ten jobs, at batches of five, so wait two times. diff --git a/samples/testing.cr b/samples/testing.cr index 5a48265..24c7d26 100644 --- a/samples/testing.cr +++ b/samples/testing.cr @@ -24,7 +24,7 @@ describe Button do # The signal spy inherits from an array, so verification is easy clicked_spy.size.should eq 1 - clicked_spy.first.should eq({ 4, 5 }) + clicked_spy.first.should eq({4, 5}) end end end diff --git a/samples/wait.cr b/samples/wait.cr index bee5032..35620f4 100644 --- a/samples/wait.cr +++ b/samples/wait.cr @@ -7,7 +7,7 @@ class Button end btn = Button.new -spawn{ btn.clicked.emit 5, 4 } +spawn { btn.clicked.emit 5, 4 } puts "Waiting for a click" x, y = btn.clicked.wait diff --git a/spec/buffer_sink_spec.cr b/spec/buffer_sink_spec.cr index 2640887..cc905af 100644 --- a/spec/buffer_sink_spec.cr +++ b/spec/buffer_sink_spec.cr @@ -7,24 +7,24 @@ describe Cute::BufferSink do emits = [] of Array(Int32) empty = [] of Array(Int32) - subject.on{|x| emits << x} + subject.on { |x| emits << x } subject.notify 1 subject.notify 2 subject.notify 3 Fiber.yield - emits.should eq [ [ 1, 2, 3 ] ] + emits.should eq [[1, 2, 3]] - (4..8).each{|i| subject.notify i} + (4..8).each { |i| subject.notify i } Fiber.yield - emits.should eq [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] + emits.should eq [[1, 2, 3], [4, 5, 6]] subject.notify 9 Fiber.yield - emits.should eq [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] + emits.should eq [[1, 2, 3], [4, 5, 6], [7, 8, 9]] end end end diff --git a/spec/connect_spec.cr b/spec/connect_spec.cr index 7df71bb..8dc8fc8 100644 --- a/spec/connect_spec.cr +++ b/spec/connect_spec.cr @@ -19,7 +19,7 @@ private class Listener end def on_move(x, y) - @move_data = { x, y } + @move_data = {x, y} end def on_one(msg) @@ -53,6 +53,6 @@ describe "Cute.connect" do subject = Listener.new(widget) widget.moved.emit(5, 6) - subject.move_data.should eq({ 5, 6 }) + subject.move_data.should eq({5, 6}) end end diff --git a/spec/interval_sink_spec.cr b/spec/interval_sink_spec.cr index 4b09d15..b958e96 100644 --- a/spec/interval_sink_spec.cr +++ b/spec/interval_sink_spec.cr @@ -7,28 +7,28 @@ describe Cute::IntervalSink do emits = [] of Array(Int32) empty = [] of Array(Int32) - subject.on{|x| emits << x} + subject.on { |x| emits << x } subject.notify 1 subject.notify 2 subject.notify 3 sleep 20.milliseconds - emits.should eq [ [ 1, 2, 3 ] ] + emits.should eq [[1, 2, 3]] - (4..8).each{|i| subject.notify i} + (4..8).each { |i| subject.notify i } sleep 20.milliseconds - emits.should eq [ [ 1, 2, 3 ], [ 4, 5, 6, 7, 8 ] ] + emits.should eq [[1, 2, 3], [4, 5, 6, 7, 8]] subject.notify 9 sleep 20.milliseconds - emits.should eq [ [ 1, 2, 3 ], [ 4, 5, 6, 7, 8 ], [ 9 ] ] + emits.should eq [[1, 2, 3], [4, 5, 6, 7, 8], [9]] # Emits nothing if no notifications are received sleep 20.milliseconds - emits.should eq [ [ 1, 2, 3 ], [ 4, 5, 6, 7, 8 ], [ 9 ] ] + emits.should eq [[1, 2, 3], [4, 5, 6, 7, 8], [9]] end end end diff --git a/spec/middleware_spec.cr b/spec/middleware_spec.cr index 0f88159..01ffeb0 100644 --- a/spec/middleware_spec.cr +++ b/spec/middleware_spec.cr @@ -1,7 +1,7 @@ require "./spec_helper" private class Chat - getter sent = [ ] of String + getter sent = [] of String Cute.middleware def send_message(body : String) : Int32 @sent << body @@ -17,7 +17,7 @@ describe "Cute.middleware" do describe "without arguments" do it "works fine" do chat = Chat.new - chat.ping.add{|y| y.call * 2} + chat.ping.add { |y| y.call * 2 } chat.ping.call.should eq 123 * 2 end end @@ -27,34 +27,34 @@ describe "Cute.middleware" do it "calls the method" do chat = Chat.new chat.send_message.call("Hello").should eq 5 - chat.sent.should eq [ "Hello" ] + chat.sent.should eq ["Hello"] end end context "if one middleware was added" do it "calls the middleware, then the method" do chat = Chat.new - chat.send_message.add{|m, y| y.call m.upcase} + chat.send_message.add { |m, y| y.call m.upcase } chat.send_message.call("Hello").should eq 5 - chat.sent.should eq [ "HELLO" ] + chat.sent.should eq ["HELLO"] end end context "if multiple middlewares are added" do it "calls the middlewares in order, then the method" do chat = Chat.new - chat.send_message.add{|m, y| y.call m.upcase} - chat.send_message.add{|m, y| y.call "saying #{m}"} + chat.send_message.add { |m, y| y.call m.upcase } + chat.send_message.add { |m, y| y.call "saying #{m}" } chat.send_message.call("Hello").should eq "saying HELLO".size - chat.sent.should eq [ "saying HELLO" ] + chat.sent.should eq ["saying HELLO"] end end context "if a middleware doesn't call onwards" do it "the next stage is not called" do chat = Chat.new - chat.send_message.add{|m, y| -1} - chat.send_message.add{|m, y| y.call m.upcase} + chat.send_message.add { |m, y| -1 } + chat.send_message.add { |m, y| y.call m.upcase } chat.send_message.call("Hello").should eq -1 chat.sent.empty?.should eq true end diff --git a/spec/signal_spec.cr b/spec/signal_spec.cr index 5a98105..4a235e9 100644 --- a/spec/signal_spec.cr +++ b/spec/signal_spec.cr @@ -50,13 +50,13 @@ describe "Cute.signal" do subject = Widget.new calls = Array(Int32).new - subject.closed.on{ calls << 1 } - subject.closed.on{ calls << 2 } - subject.closed.on{ calls << 3 } + subject.closed.on { calls << 1 } + subject.closed.on { calls << 2 } + subject.closed.on { calls << 3 } calls.size.should eq 0 subject.closed.emit - calls.should eq [ 1, 2, 3 ] + calls.should eq [1, 2, 3] end context "with async: true" do @@ -64,8 +64,8 @@ describe "Cute.signal" do subject = Widget.new fibers = Array(Fiber).new - subject.asynced.on{ fibers << Fiber.current } - subject.asynced.on{ fibers << Fiber.current; Fiber.yield } + subject.asynced.on { fibers << Fiber.current } + subject.asynced.on { fibers << Fiber.current; Fiber.yield } subject.asynced.emit Fiber.yield # Call slot fiber @@ -86,7 +86,7 @@ describe "Cute.signal" do widget.one.on(sink) widget.one.emit "Foo" - sink.collected.should eq [ nil ] + sink.collected.should eq [nil] end end @@ -98,7 +98,7 @@ describe "Cute.signal" do widget.moved.on(sink) widget.moved.emit 4, 5 - sink.collected.should eq [ nil ] + sink.collected.should eq [nil] end end @@ -110,7 +110,7 @@ describe "Cute.signal" do widget.closed.on(sink) widget.closed.emit - sink.collected.should eq [ nil ] + sink.collected.should eq [nil] end end @@ -123,7 +123,7 @@ describe "Cute.signal" do widget.one.emit "Foo" widget.one.emit "Bar" - sink.collected.should eq [ "Foo", "Bar" ] + sink.collected.should eq ["Foo", "Bar"] end end @@ -136,7 +136,7 @@ describe "Cute.signal" do widget.moved.emit 4, 5 widget.moved.emit 6, 7 - sink.collected.should eq [ { 4, 5 }, { 6, 7 } ] + sink.collected.should eq [{4, 5}, {6, 7}] end end end @@ -146,14 +146,14 @@ describe "Cute.signal" do subject = Widget.new calls = Array(Int32).new - subject.closed.on{ calls << 1 } - handler = subject.closed.on{ calls << 2 } - subject.closed.on{ calls << 3 } + subject.closed.on { calls << 1 } + handler = subject.closed.on { calls << 2 } + subject.closed.on { calls << 3 } calls.size.should eq 0 subject.closed.disconnect(handler) subject.closed.emit - calls.should eq [ 1, 3 ] + calls.should eq [1, 3] end end @@ -162,8 +162,8 @@ describe "Cute.signal" do subject = Widget.new calls = Array(Int32).new - subject.closed.on{ calls << 1 } - subject.closed.on{ calls << 2 } + subject.closed.on { calls << 1 } + subject.closed.on { calls << 2 } calls.empty?.should be_true subject.closed.disconnect @@ -177,7 +177,7 @@ describe "Cute.signal" do subject = Widget.new ch, handler = subject.one.new_channel - fut = future{ ch.receive } + fut = future { ch.receive } subject.one.emit "Okay" handler.should_not be_nil @@ -189,19 +189,19 @@ describe "Cute.signal" do subject = Widget.new ch, handler = subject.moved.new_channel - fut = future{ ch.receive } + fut = future { ch.receive } subject.moved.emit 4, 5 fut.completed?.should be_true handler.should_not be_nil - fut.get.should eq({ 4, 5 }) + fut.get.should eq({4, 5}) end context "with no signal arguments" do subject = Widget.new ch, handler = subject.closed.new_channel - fut = future{ ch.receive } + fut = future { ch.receive } subject.closed.emit handler.should_not be_nil @@ -213,7 +213,7 @@ describe "Cute.signal" do context "with one signal argument" do subject = Widget.new - spawn{ subject.one.emit "Okay" } + spawn { subject.one.emit "Okay" } result = subject.one.wait result.should eq "Okay" end @@ -221,15 +221,15 @@ describe "Cute.signal" do context "with many signal arguments" do subject = Widget.new - spawn{ subject.moved.emit 4, 5 } + spawn { subject.moved.emit 4, 5 } result = subject.moved.wait - result.should eq({ 4, 5 }) + result.should eq({4, 5}) end context "with no signal arguments" do subject = Widget.new - spawn{ subject.closed.emit } + spawn { subject.closed.emit } subject.closed.wait end end diff --git a/spec/spec_spec.cr b/spec/spec_spec.cr index 74a4a09..6dbf28e 100644 --- a/spec/spec_spec.cr +++ b/spec/spec_spec.cr @@ -21,7 +21,7 @@ describe Cute::SignalSpy do thing.none.emit spy.size.should eq 2 - spy.should eq [ nil, nil ] + spy.should eq [nil, nil] end end @@ -38,7 +38,7 @@ describe Cute::SignalSpy do thing.one.emit "Second" spy.size.should eq 2 - spy.should eq [ "First", "Second" ] + spy.should eq ["First", "Second"] end end @@ -55,7 +55,7 @@ describe Cute::SignalSpy do thing.many.emit false, 2 spy.size.should eq 2 - spy.should eq [ { true, 1 }, { false, 2 } ] + spy.should eq [{true, 1}, {false, 2}] end end end diff --git a/spec/timed_buffer_sink_spec.cr b/spec/timed_buffer_sink_spec.cr index 90440a0..e83e2d0 100644 --- a/spec/timed_buffer_sink_spec.cr +++ b/spec/timed_buffer_sink_spec.cr @@ -7,19 +7,19 @@ describe Cute::TimedBufferSink do emits = [] of Array(Int32) empty = [] of Array(Int32) - subject.on{|x| emits << x} + subject.on { |x| emits << x } # Both buffer and time constraints - (1..5).each{|i| subject.notify i} + (1..5).each { |i| subject.notify i } sleep 20.milliseconds - emits.should eq [ [ 1, 2, 3 ], [ 4, 5 ] ] + emits.should eq [[1, 2, 3], [4, 5]] # Time constraint - (6..7).each{|i| subject.notify i} + (6..7).each { |i| subject.notify i } sleep 20.milliseconds - emits.should eq [ [ 1, 2, 3 ], [ 4, 5 ], [ 6, 7 ] ] + emits.should eq [[1, 2, 3], [4, 5], [6, 7]] # Size constraint subject.notify 8 @@ -30,11 +30,11 @@ describe Cute::TimedBufferSink do Fiber.yield # We're not hitting the time constraint, right? (start - Time.utc).should be < 10.milliseconds - emits.should eq [ [ 1, 2, 3 ], [ 4, 5 ], [ 6, 7 ], [ 8, 9, 0 ] ] + emits.should eq [[1, 2, 3], [4, 5], [6, 7], [8, 9, 0]] # Does nothing if no notifications are received sleep 20.milliseconds - emits.should eq [ [ 1, 2, 3 ], [ 4, 5 ], [ 6, 7 ], [ 8, 9, 0 ] ] + emits.should eq [[1, 2, 3], [4, 5], [6, 7], [8, 9, 0]] end end end diff --git a/src/cute.cr b/src/cute.cr index 686fb00..1edb633 100644 --- a/src/cute.cr +++ b/src/cute.cr @@ -34,7 +34,7 @@ module Cute # # btn = Button.new # btn.clicked.on { |x, y| p x, y } - # btn.clicked.emit 5, 4 #=> Will print 5, 4 + # btn.clicked.emit 5, 4 # => Will print 5, 4 # ``` # # **Note:** You have to fully qualify all argument types to `Cute.signal`. @@ -43,7 +43,7 @@ module Cute # ``` # class MyIO # Cute.signal data_received() # With empty parantheses - # Cute.signal closed # Or without. Both are fine. + # Cute.signal closed # Or without. Both are fine. # end # ``` # @@ -61,8 +61,8 @@ module Cute # ``` # btn = Button.new # ch, handle = btn.clicked.new_channel # Create channel - # x, y = ch.retrieve # Wait for event - # btn.clicked.disconnect(handle) # Remove channel + # x, y = ch.retrieve # Wait for event + # btn.clicked.disconnect(handle) # Remove channel # ``` # # The channel will transport the signal argument, or will use a `Tuple` if the @@ -146,8 +146,8 @@ module Cute {% if handler.args.empty? %} {{ signal }}.on{ {{ handler.name }} } {% else %} - {{ signal }}.on do |{{ handler.args.map{|c| c.is_a?(Call) ? c : c.var }.splat }}| - {{ handler.name }}({{ handler.args.map{|c| c.is_a?(Call) ? c : c.var }.splat }}) + {{ signal }}.on do |{{ handler.args.map { |c| c.is_a?(Call) ? c : c.var }.splat }}| + {{ handler.name }}({{ handler.args.map { |c| c.is_a?(Call) ? c : c.var }.splat }}) end {% end %} end @@ -178,7 +178,7 @@ module Cute # chat = Chat.new # chat.send_message.add { |body, yielder| yielder.call body.upcase } # - # chat.send_message.call("Hello") #=> "Sent 5 bytes" + # chat.send_message.call("Hello") # => "Sent 5 bytes" # # Prints "Sending HELLO" # ``` # diff --git a/src/cute/buffer_sink.cr b/src/cute/buffer_sink.cr index c313431..292c86e 100644 --- a/src/cute/buffer_sink.cr +++ b/src/cute/buffer_sink.cr @@ -4,7 +4,6 @@ module Cute # # See `Sink` for documentation on the usage. class BufferSink(T) < Sink(T) - # Size of the buffer property size : Int32 diff --git a/src/cute/interval_sink.cr b/src/cute/interval_sink.cr index 055f26d..439955e 100644 --- a/src/cute/interval_sink.cr +++ b/src/cute/interval_sink.cr @@ -4,7 +4,6 @@ module Cute # # See `Sink` for documentation on the usage. class IntervalSink(T) < Sink(T) - # Check interval property interval : Time::Span diff --git a/src/cute/signal.cr b/src/cute/signal.cr index edfd4a9..b52988d 100644 --- a/src/cute/signal.cr +++ b/src/cute/signal.cr @@ -8,7 +8,7 @@ module Cute # Removes the handler with the handle *handler_hash*. def disconnect(handler_hash) - @listeners.reject!{|handler| handler.hash == handler_hash} + @listeners.reject! { |handler| handler.hash == handler_hash } end # Removes all handlers @@ -36,11 +36,11 @@ module Cute {% handler_type = "Proc(Nil)" %} {% channel_type = "Channel(Nil)" %} {% else %} - {% handler_type = "Proc(#{ call.args.map(&.type).splat }, Nil)" %} + {% handler_type = "Proc(#{call.args.map(&.type).splat}, Nil)" %} {% if call.args.size == 1 %} - {% channel_type = "Channel(#{ call.args[0].type })" %} + {% channel_type = "Channel(#{call.args[0].type})" %} {% else %} - {% channel_type = "Channel(Tuple(#{ call.args.map(&.type).splat }))" %} + {% channel_type = "Channel(Tuple(#{call.args.map(&.type).splat}))" %} {% end %} {% end %} diff --git a/src/cute/sink.cr b/src/cute/sink.cr index be16a1e..6c13c34 100644 --- a/src/cute/sink.cr +++ b/src/cute/sink.cr @@ -12,7 +12,7 @@ module Cute # btn = Button.new # sink = Cute::BufferSink(Nil).new(size: 2) # btn.clicked.on(sink) - # sink.on{ puts "Clicked twice!" } + # sink.on { puts "Clicked twice!" } # ``` # # The generic argument to the class is what the signal emits as type. The @@ -24,7 +24,7 @@ module Cute # btn = Button.new # sink = Cute::BufferSink(Tuple(Int32, Int32)).new(size: 2) # btn.clicked.on(sink) - # sink.on{|collected| puts "Clicked twice, positions: #{collected}" } + # sink.on { |collected| puts "Clicked twice, positions: #{collected}" } # ``` # # **Note**: When you're using a sink to collect from a signal passing multiple @@ -49,8 +49,8 @@ module Cute # sink = Cute::BufferSink(HttpResponse).new(size: urls.size) # Create a sink # urls.each do |url| # down = AsynchronousDownloader.new(url) - # down.progress.on{|percent| show_progress(down, percent)} # Update the UI - # down.finished.on(sink) # Once finished, notify the sink + # down.progress.on { |percent| show_progress(down, percent) } # Update the UI + # down.finished.on(sink) # Once finished, notify the sink # end # sink # And return the sink # end @@ -61,7 +61,7 @@ module Cute # # ``` # sink = download_all(the_urls) # Start the asynchronous download - # results = sink.wait # Use Signal#wait to wait + # results = sink.wait # Use Signal#wait to wait # # results will be a `Array(HttpResponse)` # pp results # Do something with the results. # ``` @@ -78,9 +78,9 @@ module Cute # For this, you can use `Sink#notify`: # ``` # sink = Cute::BufferSink(Int32).new(size: 10) # Set it up - # sink.on{|data| puts "Calculation results: #{data}"} + # sink.on { |data| puts "Calculation results: #{data}" } # - # 10.times{ sink.notify rand(1..100) } # Calculate and provide data + # 10.times { sink.notify rand(1..100) } # Calculate and provide data # ``` # # ### Creating a custom sink @@ -96,7 +96,7 @@ module Cute def initialize super() @listeners = Array(Proc(Array(T), Nil)).new - @collected = [ ] of T + @collected = [] of T end def notify(data : T) @@ -106,7 +106,7 @@ module Cute protected def emit_now list = @collected - @collected = [ ] of T + @collected = [] of T emit list end diff --git a/src/cute/timed_buffer_sink.cr b/src/cute/timed_buffer_sink.cr index 2861338..0725932 100644 --- a/src/cute/timed_buffer_sink.cr +++ b/src/cute/timed_buffer_sink.cr @@ -4,7 +4,6 @@ module Cute # # See `Sink` for documentation on the usage. class TimedBufferSink(T) < IntervalSink(T) - # Size of the buffer property size : Int32 diff --git a/src/spec.cr b/src/spec.cr index 51a9053..466694d 100644 --- a/src/spec.cr +++ b/src/spec.cr @@ -18,7 +18,10 @@ module Cute # # class Button # Cute.signal clicked(x : Int32, y : Int32) - # def click; clicked.emit(4, 5); end + # + # def click + # clicked.emit(4, 5) + # end # end # # describe Button do @@ -26,9 +29,9 @@ module Cute # it "emits #clicked" do # btn = Button.new # clicked_spy = Cute.spy btn, clicked(x : Int32, y : Int32) # Create the spy - # btn.click # Somehow emit the spied upon signal - # clicked_spy.size.should eq 1 # Verify - # clicked_spy[0].should eq({ 4, 5 }) + # btn.click # Somehow emit the spied upon signal + # clicked_spy.size.should eq 1 # Verify + # clicked_spy[0].should eq({4, 5}) # end # end # end