stationery 0.10.0 → 0.11.0

data/lib/stationery/rich/renderer/boxes.rb

@@ -4,8 +4,9 @@ module Stationery
   module Rich
     class Renderer
       # What a block's CSS style becomes around the block: margins as spacers,
-      # a background and padding as a box, page-break rules as page breaks and
-      # kept-together groups, borders and widths as table options.
+      # a background and padding as a box, a column count as columns,
+      # page-break rules as page breaks and kept-together groups, borders and
+      # widths as table options.
       module Boxes
         PADDING = { padding_top: 0, padding_right: 1, padding_bottom: 2, padding_left: 3 }.freeze
 
@@ -16,7 +17,16 @@ module Stationery
         def styled(style, &)
           return yield if style.empty?
 
-          spaced(style) { boxed(style, &) }
+          spaced(style) { boxed(style) { columned(style, &) } }
+        end
+
+        # The block's content poured through balanced columns.
+        def columned(style, &)
+          count = style[:columns]
+          return yield unless count && count > 1
+
+          gap = style[:column_gap]
+          @component.columns(count:, **({ gap: } if gap), &)
         end
 
         # Page breaks and margins around the block, and the rule that keeps it
@@ -69,6 +79,18 @@ module Stationery
 
         def aligned(style) = style[:align] ? { align: style[:align] } : {}
 
+        # Where an image goes: floated to a side, its CSS margins (else
+        # `styles[:img][:float_margin]`) kept around it, or aligned.
+        def placed(style)
+          return aligned(style) unless style[:float]
+
+          margin = style[:margin]&.dup
+          margin ||= [0, 0, 0, 0] if style[:margin_top] || style[:margin_bottom]
+          margin[0] = style[:margin_top] if style[:margin_top]
+          margin[2] = style[:margin_bottom] if style[:margin_bottom]
+          { float: style[:float], margin: margin || @styles[:img][:float_margin] }
+        end
+
         def border_options(border)
           return {} unless border
           return { borders: [] } if border[:width].zero?

data/lib/stationery/rich/renderer.rb

@@ -79,7 +79,9 @@ module Stationery
       end
 
       def blockquote(quote)
-        @component.box(role: :blockquote, **@styles[:blockquote], **box_options(quote.style)) { group(quote.blocks) }
+        @component.box(role: :blockquote, **@styles[:blockquote], **box_options(quote.style)) do
+          columned(quote.style) { group(quote.blocks) }
+        end
       end
 
       def list(list)
@@ -94,7 +96,7 @@ module Stationery
       def code(block)
         font = @styles[:code][:font]
         @component.box(**@styles[:pre], **box_options(block.style)) do
-          @component.text(block.text, **({ font: } if font))
+          columned(block.style) { @component.text(block.text, **({ font: } if font)) }
         end
       end
 
@@ -117,7 +119,7 @@ module Stationery
         return unless source
 
         loaded = Images.load(source)
-        @component.image(loaded, alt: node.alt, **aligned(node.style), **dimensions(node, loaded))
+        @component.image(loaded, alt: node.alt, **placed(node.style), **dimensions(node, loaded))
       rescue UnsupportedImage => e
         skip(node.src, e.message)
       end

data/lib/stationery/rich/styles.rb

@@ -21,7 +21,7 @@ module Stationery
         ul: {},
         ol: {},
         li: {},
-        img: { max_width: nil }
+        img: { max_width: nil, float_margin: 8 }
       }.freeze
 
       module_function

data/lib/stationery/shaper.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Stationery
+  # The hook for complex-script shaping. Stationery maps characters to glyphs
+  # one by one, with the font's ligatures and pair kerning; it does not shape
+  # Arabic, Indic or Thai text and does not reorder right-to-left text. An
+  # application that has a native shaper (HarfBuzz) plugs it in here:
+  #
+  #   class Invoice < Stationery::Document
+  #     shaper MyShaper
+  #   end
+  #
+  #   Invoice.new.to_pdf(shaper: MyShaper)
+  #
+  # A shaper is any object answering
+  #
+  #   call(text, font, size:, features:, language:) # => [Shaper::Glyph, …] or nil
+  #
+  # and should take `**options`, so an option added later does not break it.
+  #
+  # `text` is one stretch of a line in one font and style (see below);
+  # `font` is a Shaper::Face. `size:` is the size drawn at in points,
+  # `features:` a frozen Hash of OpenType feature tags to switches
+  # (`{ "kern" => true, "liga" => false, "smcp" => true }`: `kern` and `liga`
+  # are always there and follow the style's `kerning:` and `ligatures:`, the
+  # rest are its `features:`), `language:` the document's `metadata lang:` or
+  # nil. Direction and script are not passed, stationery knows neither: the
+  # shaper works them out from the text.
+  #
+  # The answer is the glyphs in visual order, left to right, each a
+  # Shaper::Glyph (or a Hash of its fields). Answering nil declines: the text
+  # is then drawn as it is without a shaper.
+  #
+  # What is shaped: line breaking measures each word and each stretch of
+  # spaces on its own, so it needs no more than the advances; every line is
+  # then cut where the font or the style changes, and each of those stretches
+  # is shaped whole, measured and drawn from that one answer. The shaper
+  # reorders within the stretch it is given and nowhere else.
+  module Shaper
+    # One glyph of a shaper's answer. `gid` is the glyph id in the font,
+    # `advance` how far the pen moves after it and `x_offset`/`y_offset` where
+    # it is drawn from the pen (to the right and up), all in font units;
+    # `cluster` is the index in `text`, in characters, of the first character
+    # the glyph stands for. The glyphs of one cluster stand together for its
+    # characters: those from `cluster` up to the next cluster in the answer.
+    Glyph = Data.define(:gid, :advance, :x_offset, :y_offset, :cluster) do
+      def initialize(gid:, advance:, cluster:, x_offset: 0, y_offset: 0)
+        super
+      end
+    end
+
+    # The font a shaper is asked to shape with. `data` is the font program as
+    # stationery read it (an sfnt: a WOFF is already unpacked) and `index` the
+    # face in it when it is a collection; `path` is the file it came from, or
+    # nil when it was not read from one.
+    Face = Data.define(:path, :index, :data, :units_per_em, :postscript_name, :glyph_count) do
+      def inspect = "#<#{self.class} #{postscript_name} index=#{index} glyphs=#{glyph_count}>"
+    end
+
+    METRICS = %i[advance x_offset y_offset].freeze
+
+    module_function
+
+    # `shaper` when it can be called, nil for none.
+    def check(shaper)
+      return shaper if shaper.nil? || shaper.respond_to?(:call)
+
+      raise ArgumentError, "shaper must answer call(text, font, **options), got #{shaper.inspect}"
+    end
+
+    # A shaper's answer for `text` as Glyphs, or a ShaperError naming what is
+    # wrong with it.
+    def glyphs(answer, text, face)
+      return answer.map { |glyph| glyph(glyph, text, face) } if answer.is_a?(Array)
+
+      raise ShaperError, "shaper must answer an Array of glyphs or nil, got #{answer.inspect}"
+    end
+
+    def glyph(value, text, face)
+      glyph = value.is_a?(Hash) ? from_hash(value) : value
+      raise ShaperError, "shaper answered #{value.inspect}, not a Stationery::Shaper::Glyph" unless glyph.is_a?(Glyph)
+
+      within(glyph, :gid, face.glyph_count, "the font has #{face.glyph_count} glyphs")
+      within(glyph, :cluster, text.length, "the text has #{text.length} characters")
+      METRICS.each { |field| finite(glyph, field) }
+      glyph
+    end
+
+    def from_hash(fields)
+      Glyph.new(**fields)
+    rescue ArgumentError => e
+      raise ShaperError, "shaper answered #{fields.inspect}: #{e.message}"
+    end
+
+    def within(glyph, field, count, limit)
+      value = glyph.public_send(field)
+      return if value.is_a?(Integer) && value >= 0 && value < count
+
+      raise ShaperError, "shaper answered #{field} #{value.inspect}: #{limit}"
+    end
+
+    def finite(glyph, field)
+      value = glyph.public_send(field)
+      return if value.is_a?(Integer) || (value.is_a?(Float) && value.finite?)
+
+      raise ShaperError, "shaper answered #{field} #{value.inspect}, not a number of font units"
+    end
+  end
+end

data/lib/stationery/testing/marked_text.rb

@@ -16,6 +16,8 @@ module Stationery
                  set_character_spacing set_word_spacing set_text_rise set_horizontal_text_scaling
                  set_text_rendering_mode].freeze
 
+      UTF16_BOM = "\xFE\xFF".b
+
       def_delegators :@state, *STATE
 
       # { MCID => text } and the strings shown outside marked content.
@@ -31,20 +33,30 @@ module Stationery
         @unmarked = []
       end
 
+      # A sequence with ActualText reads as that text, whatever it shows.
       def begin_marked_content_with_pl(_tag, properties)
-        @open << (properties[:MCID] if properties.is_a?(Hash))
+        properties = {} unless properties.is_a?(Hash)
+        @open << properties[:MCID]
+        return unless properties[:ActualText]
+
+        @actual = decode(properties[:ActualText])
+        @actual_depth = @open.size
       end
 
       def begin_marked_content(_tag) = @open << nil
-      def end_marked_content = @open.pop
+
+      def end_marked_content
+        @actual = nil if @actual_depth && @open.size <= @actual_depth
+        @open.pop
+      end
+
       def show_text(string) = append(string)
       def show_text_with_positioning(params) = params.grep(String).each { |string| append(string) }
 
       private
 
       def append(string)
-        font = @state.current_font
-        text = font.unpack(string).map { |code| font.to_utf8(code) }.join
+        text = shown(string)
         return @unmarked << text if @open.empty?
 
         mcid = @open.compact.last
@@ -55,6 +67,24 @@ module Stationery
         @texts[mcid] = "#{@texts[mcid]}#{separator}#{text}"
         @baselines[mcid] = baseline
       end
+
+      # The characters a string shows: its ActualText once, when it has one.
+      def shown(string)
+        if @actual
+          text = @actual
+          @actual = ""
+          return text
+        end
+
+        font = @state.current_font
+        font.unpack(string).map { |code| font.to_utf8(code) }.join
+      end
+
+      def decode(text)
+        return text.dup.force_encoding(Encoding::UTF_8) unless text.b.start_with?(UTF16_BOM)
+
+        text.b.byteslice(2..).force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8)
+      end
     end
   end
 end

data/lib/stationery/text/exclusions.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    # The room floats take from the lines beside them: bands from `top` to
+    # `bottom` below the top of whatever is laid out (a paragraph, a flow),
+    # each taking `left` points from the left edge and `right` from the right.
+    # Compared by its bands, so a paragraph wrapped around the same floats is
+    # wrapped once.
+    Exclusions = Data.define(:bands) do
+      def self.of(bands) = bands.empty? ? nil : new(bands)
+
+      # [left, right]: what a line from `top` to `top + height` gives up on
+      # each side; a band it only touches takes nothing.
+      def insets(top, height)
+        left = right = 0
+        bands.each do |band|
+          next unless band.top < top + height - Exclusions::EPSILON && band.bottom > top + Exclusions::EPSILON
+
+          left = band.left if band.left > left
+          right = band.right if band.right > right
+        end
+        [left, right]
+      end
+    end
+
+    class Exclusions
+      EPSILON = 0.0001
+      Band = Data.define(:top, :bottom, :left, :right)
+    end
+  end
+end

data/lib/stationery/text/line.rb

@@ -9,12 +9,17 @@ module Stationery
     # One laid-out line. Vertical metrics come from its tallest fragment (or
     # from the paragraph's base style when the line is empty). A soft-wrapped
     # line is justifiable; the last line and one ended by a newline are not.
+    # Beside a float it starts `offset` points into the paragraph and has
+    # `available` points of width; anywhere else that is 0 and nil, the
+    # paragraph's own width.
     class Line
-      attr_reader :fragments, :width, :ascent, :descent, :height
+      attr_reader :fragments, :width, :ascent, :descent, :height, :offset, :available
 
-      def initialize(fragments, fallback, justifiable: false)
+      def initialize(fragments, fallback, justifiable: false, offset: 0, available: nil)
         @fragments = fragments
         @justifiable = justifiable
+        @offset = offset
+        @available = available
         @width = fragments.sum(&:width)
         metrics = fragments.empty? ? [fallback] : fragments.map { |f| [f.font, f.style.render_size] }
         @ascent = metrics.map { |font, size| font.ascender(size) }.max

data/lib/stationery/text/paragraph.rb

@@ -3,20 +3,42 @@
 module Stationery
   module Text
     # Wrapped lines of runs at a width, ready to measure, split across pages
-    # and draw.
+    # and draw. Beside floats (`exclusions:`) every line has its own width
+    # and offset; the lines a split carries over are wrapped again without
+    # the floats, which stay on the page the first lines are on.
+    #
+    # A piece of a split paragraph keeps the runs of the whole and knows
+    # where it starts: after `skipped` lines of a wrap that was free of the
+    # floats from line `free_from`. The piece that holds the end of the text
+    # (`last`) can so be wrapped again at another width (#at).
     class Paragraph
       MIN_SHRINK_SIZE = 4
 
-      attr_reader :runs, :lines, :width, :align, :leading
+      attr_reader :runs, :lines, :width, :align, :leading, :exclusions
 
-      def initialize(runs, book:, width:, align: :left, leading: 0, lines: nil, fallback_style: nil)
+      def initialize(runs, book:, width:, align: :left, leading: 0, lines: nil, fallback_style: nil, exclusions: nil,
+                     skipped: 0, free_from: nil, last: true)
         @runs = lines ? runs : book.fallback(runs)
         @book = book
         @width = width
         @align = align
         @leading = leading
         @fallback_style = fallback_style || runs.first&.style
-        @lines = lines || Wrapper.new(book).wrap(@runs, width, fallback_style: @fallback_style)
+        @exclusions = exclusions
+        @skipped = skipped
+        @free_from = free_from
+        @last = last
+        @lines = lines || wrap
+      end
+
+      # This paragraph where the width is another: what it has left of its
+      # text, wrapped again. At its own width, and for a piece whose end a
+      # split cut off, that is the paragraph itself.
+      def at(width)
+        return self if !@last || (width - @width).abs <= Wrapper::EPSILON
+
+        (@others ||= {})[width] ||= self.class.new(left, book: @book, width:, align: @align, leading: @leading,
+                                                         fallback_style: @fallback_style)
       end
 
       def height
@@ -31,7 +53,7 @@ module Stationery
         return [self, nil] if count == @lines.size
         return [nil, self] if count.zero?
 
-        [with_lines(@lines.first(count)), with_lines(@lines.drop(count))]
+        [with_lines(@lines.first(count), last: false), rest_from(count)]
       end
 
       # [first `count` lines, the rest]; nil for an empty side.
@@ -39,7 +61,7 @@ module Stationery
         return [nil, self] if count <= 0
         return [self, nil] if count >= @lines.size
 
-        [with_lines(@lines.first(count)), with_lines(@lines.drop(count))]
+        [with_lines(@lines.first(count), last: false), rest_from(count)]
       end
 
       # A paragraph that fits `max_height`: truncated to whole lines, shrunk
@@ -58,7 +80,7 @@ module Stationery
         canvas.tag_runs(tag) do |mark|
           top = y
           @lines.each do |line|
-            offset = x + Geometry.align_offset(@align, @width, line.width)
+            offset = x + line.offset + Geometry.align_offset(@align, line.available || @width, line.width)
             extra = word_spacing(line)
             spaces = 0
             line.fragments.each do |fragment|
@@ -90,9 +112,30 @@ module Stationery
         end.size
       end
 
-      def with_lines(lines)
+      def wrap(free_from: @free_from)
+        Wrapper.new(@book).wrap(@runs, @width, fallback_style: @fallback_style, exclusions: @exclusions,
+                                               leading: @leading, free_from:)
+      end
+
+      # The runs of the text from this piece's first line on.
+      def left
+        Wrapper.new(@book).rest(@runs, @width, @skipped, fallback_style: @fallback_style, exclusions: @exclusions,
+                                                         leading: @leading, free_from: @free_from)
+      end
+
+      # The lines after the first `count`, wrapped again when a float is
+      # beside any of them.
+      def rest_from(count)
+        rest = @lines.drop(count)
+        from = @skipped + count
+        return with_lines(rest, skipped: from) unless rest.any? { |line| line.available && line.available < @width }
+
+        with_lines(wrap(free_from: from).drop(from), skipped: from, free_from: from)
+      end
+
+      def with_lines(lines, skipped: @skipped, free_from: @free_from, last: @last)
         self.class.new(@runs, book: @book, width: @width, align: @align, leading: @leading, lines:,
-                              fallback_style: @fallback_style)
+                              fallback_style: @fallback_style, exclusions: @exclusions, skipped:, free_from:, last:)
       end
 
       def shrink(max_height)
@@ -114,7 +157,7 @@ module Stationery
       def word_spacing(line)
         return 0 unless @align == :justify && line.justifiable? && line.space_count.positive?
 
-        [(@width - line.width) / line.space_count, 0].max
+        [((line.available || @width) - line.width) / line.space_count, 0].max
       end
 
       def draw_fragment(canvas, fragment, offset, top, line, word_spacing, link: nil)
@@ -132,12 +175,28 @@ module Stationery
       end
 
       def count_missing(fragment)
+        return count_shaped(fragment) if @book.shaper
+
         fragment.text.each_char do |char|
           next if Fonts::Fallback.carried?(char) || fragment.font.glyph?(char)
 
           @book.warnings.missing_glyph(char, fragment.style.family)
         end
       end
+
+      # With a shaper a missing glyph is one the shaper answered glyph 0 for;
+      # text it declined is drawn, and so counted, without it.
+      def count_shaped(fragment)
+        style = fragment.style
+        run = fragment.font.shaped(fragment.text, style.render_size, letter_spacing: style.letter_spacing,
+                                                                     kerning: style.kerning,
+                                                                     ligatures: style.ligatures,
+                                                                     features: style.features)
+        chars = run ? run.missing : fragment.text.each_char.reject { |char| covered?(fragment.font, char) }
+        chars.each { |char| @book.warnings.missing_glyph(char, style.family) }
+      end
+
+      def covered?(font, char) = Fonts::Fallback.carried?(char) || font.glyph?(char)
     end
   end
 end

data/lib/stationery/text/wrapper/remainder.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    class Wrapper
+      # What is left to wrap after the first lines of a paragraph: the text a
+      # page break carries over to a place of another width, where it is
+      # wrapped again. Found by wrapping as before and stopping after those
+      # lines, so a word broken at the stop hands on the part that did not
+      # fit, soft hyphens and all.
+      module Remainder
+        # The runs left after the first `count` lines of `wrap` with the same arguments.
+        def rest(runs, max_width, count, **)
+          return runs if count.zero?
+
+          @stop = count
+          carried = catch(:stopped) do
+            wrap(runs, max_width, **)
+            return []
+          end
+          runs_of(carried + @ahead.flat_map { |item| segments_of(item, carried.last || @ahead.first) })
+        ensure
+          @stop = nil
+        end
+
+        private
+
+        def place_all(items)
+          return items.each { |item| place(item) } unless @stop
+
+          items.each_with_index do |item, index|
+            @ahead = items.drop(index + 1)
+            place(item)
+          end
+        end
+
+        # A newline and a zero-width space are items without a segment; they
+        # go on in the style of the text around them.
+        def segments_of((kind, segments), neighbour)
+          return segments unless kind == :newline || segments.empty?
+
+          [Segment.new(kind == :newline ? "\n" : ZERO_WIDTH_SPACE, style_of(neighbour))]
+        end
+
+        def style_of(neighbour)
+          return neighbour.style if neighbour.is_a?(Segment)
+
+          neighbour[1]&.first&.style || @fallback
+        end
+
+        def runs_of(segments)
+          segments.chunk_while { |a, b| a.style == b.style }.map do |group|
+            Run.new(group.map(&:text).join, group.first.style)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stationery/text/wrapper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "wrapper/remainder"
+
 module Stationery
   module Text
     # Greedy line breaking over styled runs. Breaks at spaces (the space is
@@ -10,7 +12,16 @@ module Stationery
     # is broken between characters. A word that changes style midway
     # ("<b>Tot</b>al") is still one word. Soft hyphens are never measured or
     # drawn: a broken word draws "-" at the break and nothing otherwise.
+    #
+    # Beside floats (`exclusions:`) every line has the width left at its own
+    # top, found from the heights of the lines above it and the `leading`
+    # between them; how tall the line will be is not known before it is
+    # filled, so it is taken to be as tall as a line of the base style. The
+    # lines from `free_from` on are wrapped as if the floats were gone: what
+    # is left of a paragraph after a page break.
     class Wrapper
+      include Remainder
+
       TOKEN = /\n|[ \t]+|[^ \t\n-]*-+|[^ \t\n-]+/
       SOFT_HYPHEN = "­"
       ZERO_WIDTH_SPACE = Breaks::ZERO_WIDTH_SPACE
@@ -22,14 +33,15 @@ module Stationery
         @book = book
       end
 
-      def wrap(runs, max_width, fallback_style: runs.first&.style)
+      def wrap(runs, max_width, fallback_style: runs.first&.style, exclusions: nil, leading: 0, free_from: nil)
         @max = max_width
         @lines = []
         @current = []
         @pending_space = []
         @fallback = fallback_style
         @widths = {}.compare_by_identity
-        items(runs).each { |item| place(item) }
+        beside(exclusions, max_width, leading, free_from) if exclusions
+        place_all(items(runs))
         finish unless @current.empty? && @lines.any? && !@ended_with_newline
         @lines
       end
@@ -116,10 +128,10 @@ module Stationery
           @current.concat(@pending_space, word)
         elsif (head, tail = hyphenated(word, @max - line_width - width(@pending_space)))
           @current.concat(@pending_space, head)
-          finish(wrapped: true)
+          finish(wrapped: true, carry: tail)
           return place_word(tail, explicit:)
         else
-          finish(wrapped: true)
+          finish(wrapped: true, carry: word)
           @current.concat(word)
         end
         @pending_space = []
@@ -133,7 +145,7 @@ module Stationery
           head, tail = hyphenated(@current, @max)
           if head
             @current = head
-            finish(wrapped: true)
+            finish(wrapped: true, carry: tail)
             @current = tail
           else
             break_long_word
@@ -190,21 +202,53 @@ module Stationery
       end
 
       def keep_overflow(fitting, piece)
-        rest = remaining_after(fitting.size)
+        rest = [piece, *remaining_after(fitting.size).drop(1)]
         @current = fitting
-        finish(wrapped: true)
-        @current = [piece, *rest.drop(1)]
+        finish(wrapped: true, carry: rest)
+        @current = rest
       end
 
       def remaining_after(count)
         @current.flat_map { |segment| segment.text.chars.map { |char| Segment.new(char, segment.style) } }.drop(count)
       end
 
-      def finish(wrapped: false)
+      # `carry` is what the word broken at the end of the line has left.
+      def finish(wrapped: false, carry: nil)
         segments = wrapped ? @current : @current + @pending_space
-        @lines << Line.new(fragments(trim_trailing(segments)), fallback_metrics, justifiable: wrapped)
+        @lines << line(fragments(trim_trailing(segments)), wrapped)
+        throw :stopped, carry.to_a if @stop == @lines.size
         @current = []
         @pending_space = []
+        next_line if @exclusions
+      end
+
+      def line(fragments, wrapped)
+        return Line.new(fragments, fallback_metrics, justifiable: wrapped) unless @exclusions
+
+        Line.new(fragments, fallback_metrics, justifiable: wrapped, offset: @offset, available: @max)
+      end
+
+      def beside(exclusions, width, leading, free_from)
+        @exclusions = exclusions
+        @full = width
+        @leading = leading
+        @free_from = free_from
+        @top = 0
+        font, size = fallback_metrics
+        @probe = font.line_height(size)
+        start_line
+      end
+
+      def next_line
+        @top += @lines.last.height + @leading
+        start_line
+      end
+
+      # The width and the offset of the line about to be filled.
+      def start_line
+        left, right = @free_from && @lines.size >= @free_from ? [0, 0] : @exclusions.insets(@top, @probe)
+        @offset = left
+        @max = [@full - left - right, 0].max
       end
 
       def trim_trailing(segments)

data/lib/stationery/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Stationery
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end