shoes 3.0.1 → 4.0.0.pre1

data/lib/shoes/dimensions.rb

@@ -0,0 +1,194 @@
+# Dimensions is a central class that most Shoes classes use to represent their
+# dimensions, e.g. where they are and how much space they are taking up there.
+# All the different position types might be confusing. So here is a little list:
+#
+# Position (left, top, right, bottom)
+# plain (left, top, right, bottom)
+#   An offset relative to the parent (parents mostly are slots e.g. 
+#   flows/stacks), e.g it isn't fully positioned/doesn't flow anymore when set
+#
+# absolute (absolute_left, absolute_top, absolute_right, absolute_bottom)
+#   The absolute position of an element in the app, set by positioning code (in 
+#   slot.rb). Might not be the beginning of the element as it also takes margins
+#   into account, so it could be the beginning of the margin. Is also used in
+#   the positioning code.
+#
+# element_* (element_left, element_top, element_right, element_bottom)
+# Derived from absolute_* but shows the real position of the object, e.g. it
+# adds the margins to absolute_* (mostly used by backend drawing code).
+#
+# Space taken up (width/height)
+# plain (width, height)
+#   The whole space taken up by this element with margins and everything. Used
+#   for positioning/by the user.
+#
+# element_* (element_width, element_height)
+#   Just the space taken up by the element itself without margins.
+#   Used by drawing.
+#
+# Note that this is NOT how margins work in the CSS box model. We derive for
+# reasons mentioned in this comment/thread: 
+# https://github.com/shoes/shoes4/pull/467#issuecomment-27655355
+
+class Shoes
+  class Dimensions
+    extend RenamedDelegate
+
+    attr_writer   :width, :height, :margin_left, :margin_right, :margin_top,
+                  :margin_bottom, :top, :left, :right, :bottom
+    attr_reader   :parent, :x_dimension, :y_dimension
+    attr_accessor :absolute_left, :absolute_top,
+                  :displace_left, :displace_top
+    protected :parent # we shall not mess with parent,see #495
+
+
+    # in case you wonder about the -1... it is used to adjust the right and
+    # bottom values. Because right is not left + width but rather left + width -1
+    # Let me give you an example:
+    # Say left is 20 and we have a width of 100 then the right must be 119,
+    # because you have to take pixel number 20 into account so 20..119 is 100
+    # while 20..120 is 101. E.g.:
+    # (20..119).size => 100
+    PIXEL_COUNTING_ADJUSTMENT = -1
+
+    def initialize(parent, left_or_hash = nil, top = nil, width = nil,
+                   height = nil, opts = {})
+      @parent = parent
+      if hash_as_argument?(left_or_hash)
+        init_with_hash(left_or_hash)
+      else
+        init_with_arguments(left_or_hash, top, width, height, opts)
+      end
+    end
+
+    def absolute_x_position?
+      x_dimension.absolute_position?
+    end
+
+    def absolute_y_position?
+      y_dimension.absolute_position?
+    end
+
+    def absolutely_positioned?
+      absolute_x_position? || absolute_y_position?
+    end
+
+    def positioned?
+      x_dimension.positioned? && y_dimension.positioned?
+    end
+
+    def in_bounds?(x, y)
+      x_dimension.in_bounds?(x) && y_dimension.in_bounds?(y)
+    end
+
+    def margin
+      [margin_left, margin_top, margin_right, margin_bottom]
+    end
+
+    def margin=(margin)
+      margin = [margin, margin, margin, margin] unless margin.is_a? Array
+      self.margin_left, self.margin_top,
+      self.margin_right, self.margin_bottom =  margin
+    end
+
+    # used by positioning code in slot and there to be overwritten if something
+    # does not need to be positioned like a background or so
+    def needs_to_be_positioned?
+      true
+    end
+
+    def takes_up_space?
+      true
+    end
+
+    def self.setup_delegations
+      methods_to_rename = Dimension.public_instance_methods false
+      renamed_delegate_to :x_dimension, methods_to_rename, 'start'  => 'left',
+                                                           'end'    => 'right',
+                                                           'extent' => 'width'
+      renamed_delegate_to :y_dimension, methods_to_rename, 'start'  => 'top',
+                                                           'end'    => 'bottom',
+                                                           'extent' => 'height'
+    end
+
+    setup_delegations
+
+    private
+    def hash_as_argument?(left)
+      left.respond_to? :fetch
+    end
+
+    def init_with_hash(hash)
+      init_with_arguments hash.fetch(:left, nil), hash.fetch(:top, nil),
+                          hash.fetch(:width, nil), hash.fetch(:height, nil),
+                          hash
+    end
+
+    def init_with_arguments(left, top, width, height, opts)
+      @left_top_as_center = opts.fetch(:center, false)
+      init_x_and_y_dimensions
+      general_options opts # order important for redrawing
+      self.displace_left = opts.fetch(:displace_left, nil)
+      self.displace_top  = opts.fetch(:displace_top, nil)
+      self.left          = left
+      self.top           = top
+      self.width         = width
+      self.height        = height
+    end
+
+    def init_x_and_y_dimensions
+      parent_x_dimension = @parent? @parent.x_dimension : nil
+      parent_y_dimension = @parent? @parent.y_dimension : nil
+      @x_dimension = Dimension.new parent_x_dimension, @left_top_as_center
+      @y_dimension = Dimension.new parent_y_dimension, @left_top_as_center
+    end
+
+    def general_options(opts)
+      self.right =  opts[:right]
+      self.bottom = opts[:bottom]
+      init_margins opts
+    end
+
+    def init_margins(opts)
+      self.margin        = opts[:margin]
+      self.margin_left   = opts.fetch(:margin_left, margin_left)
+      self.margin_top    = opts.fetch(:margin_top, margin_top)
+      self.margin_right  = opts.fetch(:margin_right, margin_right)
+      self.margin_bottom = opts.fetch(:margin_bottom, margin_bottom)
+    end
+  end
+
+  # for objects that do not depend on their parent (get 1.04 as real values)
+  class AbsoluteDimensions < Dimensions
+    def initialize(*args)
+      super(nil, *args)
+    end
+  end
+
+  # for objects that are more defined by their parents, delegates method calls
+  # to crucial methods to the parent if the instance variable isn't set
+  class ParentDimensions < Dimensions
+    def init_x_and_y_dimensions
+      @x_dimension = ParentDimension.new @parent.x_dimension,
+                                         @left_top_as_center
+      @y_dimension = ParentDimension.new @parent.y_dimension,
+                                         @left_top_as_center
+    end
+  end
+
+  # depends on a #dimensions method being present that returns a Dimensions object
+  module DimensionsDelegations
+    extend Forwardable
+
+    DELEGATED_METHODS = Dimensions.public_instance_methods false
+
+    def_delegators :dimensions, *DELEGATED_METHODS
+  end
+
+  # depends on a #dsl method to forward to (e.g. for backend objects)
+  module BackendDimensionsDelegations
+    extend Forwardable
+
+    def_delegators :dsl, *DimensionsDelegations::DELEGATED_METHODS
+  end
+end

data/lib/shoes/download.rb

@@ -0,0 +1,117 @@
+class Shoes
+  class HttpResponse
+    # Struct might be better?
+    attr_accessor :headers, :body, :status
+    def initalize
+      @headers = {}
+      @body = ''
+      @status = []
+    end
+  end
+
+  class Download
+
+    attr_reader :progress, :response, :content_length, :gui, :transferred
+    UPDATE_STEPS = 100
+
+    def initialize(app, parent, url, opts = {}, &blk)
+      @opts = opts
+      @blk = blk
+      @gui = Shoes.configuration.backend_for(self)
+
+      @response = HttpResponse.new
+      @finished = false
+      @transferred = 0
+      @content_length = 1 # non zero initialized to avoid Zero Div Errors
+      start_download url
+    end
+
+    def started?
+      @started
+    end
+
+    def finished?
+      @finished
+    end
+
+    # needed for the specs (jay multi threading and specs)
+    def join_thread
+      @thread.join
+    end
+
+    def percent
+      @transferred * 100 / @content_length
+    end
+
+    def abort
+      @thread.exit if @thread
+    end
+
+    # shoes 3 compatibility
+    def length
+      @content_length
+    end
+
+    private
+    def start_download(url)
+      require 'open-uri'
+      @thread = Thread.new do
+        uri_opts = {}
+        uri_opts[:content_length_proc] = content_length_proc
+        uri_opts[:progress_proc] = progress_proc if @opts[:progress]
+
+        open url, uri_opts do |download_data|
+          @response.body = download_data.read
+          @response.status = download_data.status
+          @response.headers = download_data.meta
+          save_to_file(@opts[:save]) if @opts[:save]
+          finish_download download_data
+        end
+      end
+    end
+
+    def content_length_proc
+      lambda do |content_length|
+        download_started(content_length)
+        eval_block(@opts[:progress], self) if @opts[:progress]
+      end
+    end
+
+    def progress_proc
+      lambda do |size|
+        if !content_length.nil? &&
+          (size - self.transferred) > (content_length / UPDATE_STEPS) &&
+          !@gui.busy?
+            @gui.busy = true
+            eval_block(@opts[:progress], self)
+            @transferred = size
+        end
+      end
+    end
+
+    def finish_download(download_data)
+      @finished = true
+
+      #In case backend didn't catch the 100%
+      @transferred = @content_length
+      eval_block(@opts[:progress], self) if @opts[:progress]
+
+      #:finish and block are the same
+      eval_block(@blk, self) if @blk
+      eval_block(@opts[:finish], self) if @opts[:finish]
+    end
+
+    def eval_block(blk, result)
+      @gui.eval_block(blk, result)
+    end
+
+    def save_to_file(file_path)
+      open(file_path, 'wb') { |fw| fw.print @response.body }
+    end
+
+    def download_started(content_length)
+      @content_length = content_length
+      @started        = true
+    end
+  end
+end

data/lib/shoes/dsl.rb

@@ -0,0 +1,478 @@
+class Shoes
+  # Methods for creating and manipulating Shoes elements
+  #
+  # Requirements
+  #
+  # Including classes must provide:
+  #
+  #   @__app__
+  #
+  #   which provides
+  #     #style:          a hash of styles
+  #     #element_styles: a hash of {Class => styles}, where styles is
+  #                      a hash of default styles for elements of Class,
+  module DSL
+    include Common::Style
+    include Color::DSLHelpers
+
+    # Set default style for elements of a particular class, or for all
+    # elements, or return the current defaults for all elements
+    #
+    # @overload style(klass, styles)
+    #   Set default style for elements of a particular class
+    #   @param [Class] klass a Shoes element class
+    #   @param [Hash] styles default styles for elements of klass
+    #   @example
+    #     style Para, :text_size => 42, :stroke => green
+    #
+    # @overload style(styles)
+    # Set default style for all elements
+    #   @param [Hash] styles default style for all elements
+    #   @example
+    #     style :stroke => alicewhite, :fill => black
+    #
+    # @overload style()
+    #   @return [Hash] the default style for all elements
+    def style(klass_or_styles = nil, styles = {})
+      if klass_or_styles.kind_of? Class
+        klass = klass_or_styles
+        @__app__.element_styles[klass] = styles
+      else
+        @__app__.style(klass_or_styles)
+      end
+    end
+
+    private
+
+    def style_normalizer
+      @style_normalizer ||= Common::StyleNormalizer.new
+    end
+
+    def pop_style(opts)
+      opts.last.class == Hash ? opts.pop : {}
+    end
+
+    # Default styles for elements of klass
+    def style_for_element(klass, styles = {})
+      @__app__.element_styles.fetch(klass, {}).merge(styles)
+    end
+
+    def normalize_style_for_element(clazz, texts)
+      style = style_normalizer.normalize(pop_style(texts))
+      style_for_element(clazz, style)
+    end
+
+    def create(element, *args, &blk)
+      element.new(@__app__, @__app__.current_slot, *args, &blk)
+    end
+
+    public
+
+    def image(path, opts={}, &blk)
+      create Shoes::Image, path, opts, blk
+    end
+
+    def border(color, opts = {}, &blk)
+      create Shoes::Border, pattern(color), opts, blk
+    end
+
+    def background(color, opts = {}, &blk)
+      create Shoes::Background, pattern(color), style_normalizer.normalize(opts), blk
+    end
+
+    def edit_line(*args, &blk)
+      style = pop_style(args)
+      text  = args.first || ''
+      create Shoes::EditLine, text, style, blk
+    end
+
+    def edit_box(*args, &blk)
+      style = pop_style(args)
+      text  = args.first || ''
+      create Shoes::EditBox, text, style, blk
+    end
+
+    def progress(opts = {}, &blk)
+      create Shoes::Progress, opts, blk
+    end
+
+    def check(opts = {}, &blk)
+      create Shoes::Check, opts, blk
+    end
+
+    def radio(*args, &blk)
+      style = pop_style(args)
+      group = args.first
+      create Shoes::Radio, group, style, blk
+    end
+
+    def list_box(opts = {}, &blk)
+      create Shoes::ListBox, opts, blk
+    end
+
+    def flow(opts = {}, &blk)
+      create Shoes::Flow, opts, &blk
+    end
+
+    def stack(opts = {}, &blk)
+      create Shoes::Stack, opts, &blk
+    end
+
+    def button(text, opts={}, &blk)
+      create Shoes::Button, text, opts, blk
+    end
+
+    # Creates an animation that runs the given block of code.
+    #
+    # @overload animate &blk
+    #   @param [Proc] blk Code to run for each animation frame
+    #   @return [Shoes::Animation]
+    #   Defaults to framerate of 24 frames per second
+    #   @example
+    #     # 24 frames per second
+    #     animate do
+    #       # animation code
+    #     end
+    # @overload animate(framerate, &blk)
+    #   @param [Integer] framerate Frames per second
+    #   @param [Proc] blk Code to run for each animation frame
+    #   @return [Shoes::Animation]
+    #   @example
+    #     # 10 frames per second
+    #     animate 10 do
+    #       # animation code
+    #     end
+    # @overload animate(opts = {}, &blk)
+    #   @param [Hash] opts Animation options
+    #   @param [Proc] blk Code to run for each animation frame
+    #   @option opts [Integer] :framerate Frames per second
+    #   @return [Shoes::Animation]
+    #   @example
+    #     # 10 frames per second
+    #     animate :framerate => 10 do
+    #       # animation code
+    #     end
+    #
+    def animate(opts = {}, &blk)
+      opts = {:framerate => opts} unless opts.is_a? Hash
+      Shoes::Animation.new @__app__, opts, blk
+    end
+
+    def every(n=1, &blk)
+      animate 1.0/n, &blk
+    end
+
+    def timer(n=1, &blk)
+      n *= 1000
+      Timer.new @__app__, n, &blk
+    end
+
+    # similar controls as Shoes::Video (#video)
+    def sound(soundfile, opts = {}, &blk)
+      Shoes::Sound.new @__app__, soundfile, opts, &blk
+    end
+
+    # Creates an arc at (left, top)
+    #
+    # @param [Integer] left the x-coordinate of the top-left corner
+    # @param [Integer] top the y-coordinate of the top-left corner
+    # @param [Integer] width width of the arc's ellipse
+    # @param [Integer] height height of the arc's ellipse
+    # @param [Float] angle1 angle in radians marking the beginning of the arc segment
+    # @param [Float] angle2 angle in radians marking the end of the arc segment
+    # @param [Hash] opts Arc style options
+    # @option opts [Boolean] wedge (false)
+    # @option opts [Boolean] center (false) is (left, top) the center of the rectangle?
+    def arc(left, top, width, height, angle1, angle2, opts = {})
+      arc_style = style_normalizer.normalize(opts)
+      create Shoes::Arc, left, top, width, height, angle1, angle2, style.merge(arc_style)
+    end
+
+    # Draws a line from point A (x1,y1) to point B (x2,y2)
+    #
+    # @param [Integer] x1 The x-value of point A
+    # @param [Integer] y1 The y-value of point A
+    # @param [Integer] x2 The x-value of point B
+    # @param [Integer] y2 The y-value of point B
+    # @param [Hash] opts Style options
+    def line(x1, y1, x2, y2, opts = {})
+      create Shoes::Line, Shoes::Point.new(x1, y1), Shoes::Point.new(x2, y2), style.merge(opts)
+    end
+
+    # Creates an oval at (left, top)
+    #
+    # @overload oval(left, top, diameter)
+    #   Creates a circle at (left, top), with the given diameter
+    #   @param [Integer] left the x-coordinate of the top-left corner
+    #   @param [Integer] top the y-coordinate of the top-left corner
+    #   @param [Integer] diameter the diameter
+    # @overload oval(left, top, width, height)
+    #   Creates an oval at (left, top), with the given width and height
+    #   @param [Integer] left the x-coordinate of the top-left corner
+    #   @param [Integer] top the y-coordinate of the top-left corner
+    #   @param [Integer] width the width
+    #   @param [Integer] height the height
+    # @overload oval(styles)
+    #   Creates an oval using values from the styles Hash.
+    #   @param [Hash] styles
+    #   @option styles [Integer] left (0) the x-coordinate of the top-left corner
+    #   @option styles [Integer] top (0) the y-coordinate of the top-left corner
+    #   @option styles [Integer] width (0) the width
+    #   @option styles [Integer] height (0) the height
+    #   @option styles [Integer] top (0) the y-coordinate of the top-left corner
+    #   @option styles [Boolean] center (false) is (left, top) the center of the oval
+    def oval(*opts, &blk)
+      oval_style = style_normalizer.normalize pop_style(opts)
+      case opts.length
+        when 3
+          left, top, width = opts
+          height = width
+        when 4
+          left, top, width, height = opts
+        when 0
+          left = oval_style[:left] || 0
+          top = oval_style[:top] || 0
+          width = oval_style[:diameter] || oval_style[:width] ||
+                  (oval_style[:radius] || 0) * 2
+          height = oval_style[:height] || width
+        else
+          message = <<EOS
+Wrong number of arguments. Must be one of:
+  - oval(left, top, diameter, [opts])
+  - oval(left, top, width, height, [opts])
+  - oval(styles)
+EOS
+          raise ArgumentError, message
+      end
+      create Shoes::Oval, left, top, width, height, style.merge(oval_style), &blk
+    end
+
+    # Creates a rectangle
+    #
+    # @overload rect(left, top, side, styles)
+    #   Creates a square at (left, top), with sides of the given length
+    #   @param [Integer] left the x-coordinate of the top-left corner
+    #   @param [Integer] top the y-coordinate of the top-left corner
+    #   @param [Integer] side the length of a side
+    # @overload rect(left, top, width, height, rounded = 0, styles)
+    #   Creates a rectangle at (left, top), with the given width and height
+    #   @param [Integer] left the x-coordinate of the top-left corner
+    #   @param [Integer] top the y-coordinate of the top-left corner
+    #   @param [Integer] width the width
+    #   @param [Integer] height the height
+    # @overload rect(styles)
+    #   Creates a rectangle using values from the styles Hash.
+    #   @param [Hash] styles
+    #   @option styles [Integer] left (0) the x-coordinate of the top-left corner
+    #   @option styles [Integer] top (0) the y-coordinate of the top-left corner
+    #   @option styles [Integer] width (0) the width
+    #   @option styles [Integer] height (0) the height
+    #   @option styles [Integer] top (0) the y-coordinate of the top-left corner
+    #   @option styles [Boolean] center (false) is (left, top) the center of the rectangle?
+    def rect(*args, &blk)
+      opts = style_normalizer.normalize pop_style(args)
+      case args.length
+      when 3
+        left, top, width = args
+        height = width
+        opts[:curve] ||= 0
+      when 4
+        left, top, width, height = args
+        opts[:curve] ||= 0
+      when 5
+        left, top, width, height, opts[:curve] = args
+      when 0
+        left = opts[:left] || 0
+        top = opts[:top] || 0
+        width = opts[:width] || 0
+        height = opts[:height] || width
+        opts[:curve] ||= 0
+      else
+        message = <<EOS
+Wrong number of arguments. Must be one of:
+  - rect(left, top, side, [opts])
+  - rect(left, top, width, height, [opts])
+  - rect(left, top, width, height, curve, [opts])
+  - rect(styles)
+EOS
+        raise ArgumentError, message
+      end
+      create Shoes::Rect, left, top, width, height, style.merge(opts), &blk
+    end
+
+    def star(left, top, points = 10, outer = 100.0, inner = 50.0, opts = {}, &blk)
+      opts = style_normalizer.normalize opts
+      create Shoes::Star, left, top, points, outer, inner, opts, &blk
+    end
+
+    # Creates a new Shoes::Shape object
+    def shape(shape_style = {}, &blk)
+      Shoes::Shape.new(@__app__, @__app__.style.merge(shape_style), blk)
+    end
+
+    # Sets the current stroke color
+    #
+    # Arguments
+    #
+    # color - a Shoes::Color
+    def stroke(color)
+      @__app__.style[:stroke] = pattern(color)
+    end
+
+    def nostroke
+      @__app__.style[:stroke] = nil
+    end
+
+    # Sets the stroke width, in pixels
+    def strokewidth(width)
+      @__app__.style[:strokewidth] = width
+    end
+
+    # Sets the current fill color
+    #
+    # @param [Shoes::Color,Shoes::Gradient] pattern the pattern to set as fill
+    def fill(pattern)
+      @__app__.style[:fill] = pattern(pattern)
+    end
+
+    def nofill
+      @__app__.style[:fill] = nil
+    end
+
+    # Sets the current line cap style
+    def cap(line_cap)
+      @__app__.style[:cap] = line_cap
+    end
+
+
+
+    # Text blocks
+    # normally constants belong to the top, I put them here because they are
+    # only used here.
+    FONT_SIZES = {
+      banner:       48,
+      title:        34,
+      subtitle:     26,
+      tagline:      18,
+      caption:      14,
+      para:         12,
+      inscription:  10
+    }.freeze
+
+    %w[banner title subtitle tagline caption para inscription].each do |method|
+      define_method method do |*texts|
+        opts = texts.last.class == Hash ? texts.pop : {}
+        klass = Shoes.const_get(method.capitalize)
+        create klass, texts, FONT_SIZES[method.to_sym], style_for_element(klass, opts)
+      end
+    end
+
+    TEXT_STYLES = {
+      code: { font: "Lucida Console" },
+      del: { strikethrough: true },
+      em: { emphasis: true },
+      ins: { underline: true },
+      sub: { rise: -10, size_modifier: 0.8 },
+      sup: { rise: 10, size_modifier: 0.8 },
+      strong: { weight: true },
+    }
+
+    TEXT_STYLES.keys.each do |method|
+      define_method method do |*texts|
+        style = style_normalizer.normalize(pop_style(texts))
+        opts = TEXT_STYLES[method].merge(style)
+        Shoes::Span.new texts, opts
+      end
+    end
+
+    def fg(*texts, color)
+      Shoes::Span.new texts, { stroke: pattern(color) }
+    end
+
+    def bg(*texts, color)
+      Shoes::Span.new texts, { fill: pattern(color) }
+    end
+
+    def link(*texts, &blk)
+      opts = normalize_style_for_element(Shoes::Link, texts)
+      create Shoes::Link, texts, opts, &blk
+    end
+
+    def span(*texts)
+      opts = normalize_style_for_element(Shoes::Span, texts)
+      Shoes::Span.new texts, opts
+    end
+
+    def mouse
+      [@__app__.mouse_button, @__app__.mouse_pos[0], @__app__.mouse_pos[1]]
+    end
+
+    def motion(&blk)
+      @__app__.mouse_motion << blk
+    end
+
+    def resize(&blk)
+      @__app__.add_resize_callback blk
+    end
+
+    # hover and leave just delegate to the current slot as hover and leave
+    # are just defined for slots but self is always the app.
+    def hover(&blk)
+      @__app__.current_slot.hover(blk)
+    end
+
+    def leave(&blk)
+      @__app__.current_slot.leave(blk)
+    end
+
+    def keypress(&blk)
+      Shoes::Keypress.new @__app__, &blk
+    end
+
+    def keyrelease(&blk)
+      Shoes::Keyrelease.new @__app__, &blk
+    end
+
+    def append(&blk)
+      blk.call if blk
+    end
+
+    def visit(url)
+      match_data = nil
+      url_data = Shoes::URL.urls.find {|page, _| match_data = page.match url}
+      if url_data
+        action_proc = url_data[1]
+        url_argument = match_data[1]
+        clear do
+          @__app__.location = url
+          action_proc.call self, url_argument
+        end
+      end
+      timer(0.01) { @__app__.top_slot.contents_alignment }
+    end
+
+    def scroll_top
+      @__app__.scroll_top
+    end
+
+    def scroll_top=(n)
+      @__app__.scroll_top = n
+    end
+
+    def clipboard
+      @__app__.clipboard
+    end
+
+    def clipboard=(str)
+      @__app__.clipboard = str
+    end
+
+    def download(name, args={}, &blk)
+      create Shoes::Download, name, args, &blk
+    end
+
+    def gutter
+      @__app__.gutter
+    end
+  end
+end