prawnx 0.1.1

data/lib/prawn/svg/elements/path.rb

@@ -0,0 +1,294 @@
+class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
+  include Prawn::SVG::Calculators::ArcToBezierCurve
+  include Prawn::SVG::Pathable
+
+  INSIDE_SPACE_REGEXP = /[ \t\r\n,]*/.freeze
+  OUTSIDE_SPACE_REGEXP = /[ \t\r\n]*/.freeze
+  INSIDE_REGEXP = /#{INSIDE_SPACE_REGEXP}(?>([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:(?<=[0-9])[eE][+-]?[0-9]+)?))/.freeze
+  FLAG_REGEXP = /#{INSIDE_SPACE_REGEXP}([01])/.freeze
+  COMMAND_REGEXP = /^#{OUTSIDE_SPACE_REGEXP}([A-Za-z])((?:#{INSIDE_REGEXP})*)#{OUTSIDE_SPACE_REGEXP}/.freeze
+
+  A_PARAMETERS_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{FLAG_REGEXP}#{FLAG_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/.freeze
+  ONE_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}/.freeze
+  TWO_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}/.freeze
+  FOUR_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/.freeze
+  SIX_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/.freeze
+
+  COMMAND_MATCH_MAP = {
+    'A' => A_PARAMETERS_REGEXP,
+    'C' => SIX_PARAMETER_REGEXP,
+    'H' => ONE_PARAMETER_REGEXP,
+    'L' => TWO_PARAMETER_REGEXP,
+    'M' => TWO_PARAMETER_REGEXP,
+    'Q' => FOUR_PARAMETER_REGEXP,
+    'S' => FOUR_PARAMETER_REGEXP,
+    'T' => TWO_PARAMETER_REGEXP,
+    'V' => ONE_PARAMETER_REGEXP,
+    'Z' => //
+  }.freeze
+
+  PARAMETERLESS_COMMANDS = COMMAND_MATCH_MAP.select { |_, v| v == // }.map(&:first)
+
+  FLOAT_ERROR_DELTA = 1e-10
+
+  attr_reader :commands
+
+  def parse
+    require_attributes 'd'
+
+    @commands = []
+    @last_point = nil
+
+    data = attributes['d'].gsub(/#{OUTSIDE_SPACE_REGEXP}$/, '')
+
+    matched_commands = match_all(data, COMMAND_REGEXP)
+    raise SkipElementError, 'Invalid/unsupported syntax for SVG path data' if matched_commands.nil?
+
+    matched_commands.each do |(command, parameters)|
+      regexp = COMMAND_MATCH_MAP[command.upcase] or break
+      matched_values = match_all(parameters, regexp) or break
+      values = matched_values.map { |value| value.map(&:to_f) }
+      break if values.empty? && !PARAMETERLESS_COMMANDS.include?(command.upcase)
+
+      parse_path_command(command, values)
+    end
+  end
+
+  def apply
+    apply_commands
+    apply_markers
+  end
+
+  protected
+
+  def parse_path_command(command, values)
+    upcase_command = command.upcase
+    relative = command != upcase_command
+
+    case upcase_command
+    when 'M' # moveto
+      x, y = values.shift
+
+      if relative && @last_point
+        x += @last_point.first
+        y += @last_point.last
+      end
+
+      @subpath_initial_point = [x, y]
+      push_command Prawn::SVG::Pathable::Move.new(@subpath_initial_point)
+
+      return parse_path_command(relative ? 'l' : 'L', values) if values.any?
+
+    when 'Z' # closepath
+      push_command Prawn::SVG::Pathable::Close.new(@subpath_initial_point) if @subpath_initial_point
+
+    when 'L' # lineto
+      while values.any?
+        x, y = values.shift
+        if relative && @last_point
+          x += @last_point.first
+          y += @last_point.last
+        end
+
+        push_command Prawn::SVG::Pathable::Line.new([x, y])
+      end
+
+    when 'H' # horizontal lineto
+      while values.any?
+        x = values.shift.first
+        x += @last_point.first if relative && @last_point
+        push_command Prawn::SVG::Pathable::Line.new([x, @last_point.last])
+      end
+
+    when 'V' # vertical lineto
+      while values.any?
+        y = values.shift.first
+        y += @last_point.last if relative && @last_point
+        push_command Prawn::SVG::Pathable::Line.new([@last_point.first, y])
+      end
+
+    when 'C' # curveto
+      while values.any?
+        x1, y1, x2, y2, x, y = values.shift
+
+        if relative && @last_point
+          x += @last_point.first
+          x1 += @last_point.first
+          x2 += @last_point.first
+          y += @last_point.last
+          y1 += @last_point.last
+          y2 += @last_point.last
+        end
+
+        @previous_control_point = [x2, y2]
+        push_command Prawn::SVG::Pathable::Curve.new([x, y], [x1, y1], [x2, y2])
+      end
+
+    when 'S' # shorthand/smooth curveto
+      while values.any?
+        x2, y2, x, y = values.shift
+
+        if relative && @last_point
+          x += @last_point.first
+          x2 += @last_point.first
+          y += @last_point.last
+          y2 += @last_point.last
+        end
+
+        if @previous_control_point
+          x1 = (2 * @last_point.first) - @previous_control_point.first
+          y1 = (2 * @last_point.last) - @previous_control_point.last
+        else
+          x1, y1 = @last_point
+        end
+
+        @previous_control_point = [x2, y2]
+        push_command Prawn::SVG::Pathable::Curve.new([x, y], [x1, y1], [x2, y2])
+      end
+
+    when 'Q', 'T' # quadratic curveto
+      while values.any?
+        if (shorthand = upcase_command == 'T')
+          x, y = values.shift
+        else
+          x1, y1, x, y = values.shift
+        end
+
+        if relative && @last_point
+          x += @last_point.first
+          x1 += @last_point.first if x1
+          y += @last_point.last
+          y1 += @last_point.last if y1
+        end
+
+        if shorthand
+          if @previous_quadratic_control_point
+            x1 = (2 * @last_point.first) - @previous_quadratic_control_point.first
+            y1 = (2 * @last_point.last) - @previous_quadratic_control_point.last
+          else
+            x1, y1 = @last_point
+          end
+        end
+
+        # convert from quadratic to cubic
+        cx1 = @last_point.first + ((x1 - @last_point.first) * 2 / 3.0)
+        cy1 = @last_point.last + ((y1 - @last_point.last) * 2 / 3.0)
+        cx2 = cx1 + ((x - @last_point.first) / 3.0)
+        cy2 = cy1 + ((y - @last_point.last) / 3.0)
+
+        @previous_quadratic_control_point = [x1, y1]
+
+        push_command Prawn::SVG::Pathable::Curve.new([x, y], [cx1, cy1], [cx2, cy2])
+      end
+
+    when 'A'
+      return unless @last_point
+
+      while values.any?
+        rx, ry, phi, fa, fs, x2, y2 = values.shift
+
+        x1, y1 = @last_point
+
+        return if rx.zero? && ry.zero?
+
+        if relative
+          x2 += x1
+          y2 += y1
+        end
+
+        # Normalise values as per F.6.2
+        rx = rx.abs
+        ry = ry.abs
+        phi = (phi % 360) * 2 * Math::PI / 360.0
+
+        # F.6.2: If the endpoints (x1, y1) and (x2, y2) are identical, then this is equivalent to omitting the elliptical arc segment entirely.
+        return if within_float_delta?(x1, x2) && within_float_delta?(y1, y2)
+
+        # F.6.2: If rx = 0 or ry = 0 then this arc is treated as a straight line segment (a "lineto") joining the endpoints.
+        if within_float_delta?(rx, 0) || within_float_delta?(ry, 0)
+          push_command Prawn::SVG::Pathable::Line.new([x2, y2])
+          return
+        end
+
+        # We need to get the center co-ordinates, as well as the angles from the X axis to the start and end
+        # points.  To do this, we use the algorithm documented in the SVG specification section F.6.5.
+
+        # F.6.5.1
+        xp1 = (Math.cos(phi) * ((x1 - x2) / 2.0)) + (Math.sin(phi) * ((y1 - y2) / 2.0))
+        yp1 = (-Math.sin(phi) * ((x1 - x2) / 2.0)) + (Math.cos(phi) * ((y1 - y2) / 2.0))
+
+        # F.6.6.2
+        r2x = rx * rx
+        r2y = ry * ry
+        hat = (xp1 * xp1 / r2x) + (yp1 * yp1 / r2y)
+        if hat > 1
+          rx *= Math.sqrt(hat)
+          ry *= Math.sqrt(hat)
+        end
+
+        # F.6.5.2
+        r2x = rx * rx
+        r2y = ry * ry
+        square = ((r2x * r2y) - (r2x * yp1 * yp1) - (r2y * xp1 * xp1)) / ((r2x * yp1 * yp1) + (r2y * xp1 * xp1))
+        square = 0 if square.negative? && square > -FLOAT_ERROR_DELTA # catch rounding errors
+        base = Math.sqrt(square)
+        base *= -1 if fa == fs
+        cpx = base * rx * yp1 / ry
+        cpy = base * -ry * xp1 / rx
+
+        # F.6.5.3
+        cx = (Math.cos(phi) * cpx) + (-Math.sin(phi) * cpy) + ((x1 + x2) / 2)
+        cy = (Math.sin(phi) * cpx) + (Math.cos(phi) * cpy) + ((y1 + y2) / 2)
+
+        # F.6.5.5 - compute the eccentric anomaly (eta) of the start point
+        vx = (xp1 - cpx) / rx
+        vy = (yp1 - cpy) / ry
+        eta_1 = Math.atan2(vy, vx)
+
+        # F.6.5.6 - compute the sweep angle between start and end points
+        ux = vx
+        uy = vy
+        vx = (-xp1 - cpx) / rx
+        vy = (-yp1 - cpy) / ry
+
+        d_eta = Math.atan2((ux * vy) - (uy * vx), (ux * vx) + (uy * vy))
+
+        # Adjust range
+        if fs.zero?
+          d_eta -= 2 * Math::PI if d_eta.positive?
+        elsif d_eta.negative?
+          d_eta += 2 * Math::PI
+        end
+
+        eta_2 = eta_1 + d_eta
+
+        calculate_bezier_curve_points_for_arc(cx, cy, rx, ry, eta_1, eta_2, phi).each do |points|
+          push_command Prawn::SVG::Pathable::Curve.new(points[:p2], points[:q1], points[:q2])
+        end
+      end
+    end
+
+    @previous_control_point = nil unless %w[C S].include?(upcase_command)
+    @previous_quadratic_control_point = nil unless %w[Q T].include?(upcase_command)
+  end
+
+  def within_float_delta?(a, b)
+    (a - b).abs < FLOAT_ERROR_DELTA
+  end
+
+  # regexp must start with ^
+  def match_all(string, regexp)
+    result = []
+    while string != ''
+      matches = string.match(regexp) or return
+      result << matches.captures
+      string = matches.post_match
+    end
+    result
+  end
+
+  def push_command(command)
+    @commands << command
+    @last_point = command.destination
+  end
+end

data/lib/prawn/svg/elements/pattern.rb

@@ -0,0 +1,150 @@
+class Prawn::SVG::Elements::Pattern < Prawn::SVG::Elements::Base
+  attr_reader :parent_pattern
+
+  def parse
+    raise SkipElementQuietly if attributes['id'].nil?
+
+    @parent_pattern = document.gradients[href_attribute[1..]] if href_attribute && href_attribute[0] == '#'
+
+    set_display_none
+
+    document.gradients[attributes['id']] = self
+  end
+
+  def container?
+    true
+  end
+
+  def pattern_arguments(element)
+    bbox = element.bounding_box
+    units = derive_attribute('patternUnits') || 'objectBoundingBox'
+    content_units = derive_attribute('patternContentUnits') || 'userSpaceOnUse'
+    view_box_attr = derive_attribute('viewBox')
+    par_attr = derive_attribute('preserveAspectRatio')
+
+    tile = compute_tile(units, bbox)
+    return nil unless tile
+
+    tile_x, tile_y_bottom, tile_w, tile_h = tile
+
+    transform = Matrix.identity(3)
+    if (transform_attr = derive_attribute('patternTransform'))
+      transform = parse_transform_attribute(transform_attr, space: :svg)
+    end
+
+    content_calls = build_content_calls(content_units, view_box_attr, par_attr, tile_w, tile_h, bbox, units, tile_x, tile_y_bottom)
+    return nil if content_calls.nil?
+
+    {
+      tile_x:      tile_x,
+      tile_y:      tile_y_bottom,
+      tile_width:  tile_w,
+      tile_height: tile_h,
+      transform:   transform,
+      calls:       content_calls
+    }
+  end
+
+  def derive_attribute(name)
+    attributes[name] || parent_pattern&.derive_attribute(name)
+  end
+
+  private
+
+  def compute_tile(units, bbox)
+    if units == 'objectBoundingBox'
+      return nil unless bbox
+
+      x_frac = percentage_or_proportion(derive_attribute('x'), 0.0)
+      y_frac = percentage_or_proportion(derive_attribute('y'), 0.0)
+      w_frac = percentage_or_proportion(derive_attribute('width'), 0.0)
+      h_frac = percentage_or_proportion(derive_attribute('height'), 0.0)
+
+      return nil if w_frac <= 0 || h_frac <= 0
+
+      bbox_left, bbox_top, bbox_right, bbox_bottom = *bbox
+      bbox_w = bbox_right - bbox_left
+      bbox_h = bbox_top - bbox_bottom
+
+      tile_w = w_frac * bbox_w
+      tile_h = h_frac * bbox_h
+      tile_x = bbox_left + (x_frac * bbox_w)
+      tile_y_top = bbox_top - (y_frac * bbox_h)
+      tile_y_bottom = tile_y_top - tile_h
+
+    else
+      tile_x = x_pixels(derive_attribute('x') || '0')
+      tile_y_svg = y_pixels(derive_attribute('y') || '0')
+      tile_w = x_pixels(derive_attribute('width') || '0')
+      tile_h = y_pixels(derive_attribute('height') || '0')
+
+      return nil if tile_w <= 0 || tile_h <= 0
+
+      tile_y_bottom = document.sizing.output_height - tile_y_svg - tile_h
+
+    end
+    [tile_x, tile_y_bottom, tile_w, tile_h]
+  end
+
+  def build_content_calls(content_units, view_box_attr, par_attr, tile_w, tile_h, bbox, units, tile_x, tile_y_bottom)
+    if view_box_attr
+      build_viewbox_content_calls(view_box_attr, par_attr, tile_w, tile_h)
+    elsif content_units == 'objectBoundingBox'
+      return nil unless bbox
+
+      build_object_bounding_box_calls(bbox, content_source)
+    else
+      calls = content_source_calls
+      shift_content_to_tile_origin(calls, units, tile_x, tile_y_bottom, tile_h)
+    end
+  end
+
+  def build_viewbox_content_calls(view_box_attr, par_attr, tile_w, tile_h)
+    vb_values = view_box_attr.strip.split(COMMA_WSP_REGEXP).map(&:to_f)
+    return content_source_calls if vb_values.length != 4
+
+    vb_x, vb_y, vb_w, vb_h = vb_values
+    return content_source_calls if vb_w <= 0 || vb_h <= 0
+
+    aspect = Prawn::SVG::Calculators::AspectRatio.new(par_attr, [tile_w, tile_h], [vb_w, vb_h])
+
+    x_scale = aspect.width / vb_w
+    y_scale = aspect.height / vb_h
+
+    calls = []
+    calls << ['transformation_matrix', [x_scale, 0, 0, y_scale, 0, 0], {}, []]
+    calls << ['transformation_matrix', [1, 0, 0, 1, -vb_x + (aspect.x / x_scale), vb_y - (aspect.y / y_scale)], {}, []]
+    calls.concat(content_source_calls)
+    calls
+  end
+
+  # SVG spec: pattern content coordinates have their origin at the pattern's (x,y).
+  # Since prawn-svg processes children in document coordinates, we shift the content
+  # to the tile origin so it fills the pattern BBox correctly.
+  def shift_content_to_tile_origin(calls, units, tile_x, tile_y_bottom, tile_h)
+    if units == 'userSpaceOnUse'
+      tile_y_svg = document.sizing.output_height - tile_y_bottom - tile_h
+      return calls if tile_x.zero? && tile_y_svg.zero?
+
+      [['transformation_matrix', [1, 0, 0, 1, tile_x, -tile_y_svg], {}, calls]]
+    else
+      calls
+    end
+  end
+
+  def content_source
+    if parent_pattern && source.elements.none? { |e| ['', SVG_NAMESPACE].include?(e.namespace) }
+      parent_pattern.send(:content_source)
+    else
+      source
+    end
+  end
+
+  def content_source_calls
+    if parent_pattern && base_calls.empty?
+      duplicate_calls(parent_pattern.base_calls)
+    else
+      duplicate_calls(base_calls)
+    end
+  end
+end

data/lib/prawn/svg/elements/polygon.rb

@@ -0,0 +1,25 @@
+class Prawn::SVG::Elements::Polygon < Prawn::SVG::Elements::Base
+  include Prawn::SVG::Pathable
+
+  def parse
+    require_attributes('points')
+    @points = parse_points(attributes['points'])
+  end
+
+  def apply
+    apply_commands
+    apply_markers
+  end
+
+  protected
+
+  def commands
+    @commands ||= [
+      Prawn::SVG::Pathable::Move.new(@points[0])
+    ] + @points[1..].map do |point|
+      Prawn::SVG::Pathable::Line.new(point)
+    end + [
+      Prawn::SVG::Pathable::Close.new(@points[0])
+    ]
+  end
+end

data/lib/prawn/svg/elements/polyline.rb

@@ -0,0 +1,23 @@
+class Prawn::SVG::Elements::Polyline < Prawn::SVG::Elements::Base
+  include Prawn::SVG::Pathable
+
+  def parse
+    require_attributes('points')
+    @points = parse_points(attributes['points'])
+  end
+
+  def apply
+    apply_commands
+    apply_markers
+  end
+
+  protected
+
+  def commands
+    @commands ||= [
+      Prawn::SVG::Pathable::Move.new(@points[0])
+    ] + @points[1..].map do |point|
+      Prawn::SVG::Pathable::Line.new(point)
+    end
+  end
+end

data/lib/prawn/svg/elements/rect.rb

@@ -0,0 +1,64 @@
+class Prawn::SVG::Elements::Rect < Prawn::SVG::Elements::Base
+  include Prawn::SVG::Calculators::ArcToBezierCurve
+
+  def parse
+    require_attributes 'width', 'height'
+
+    @x = x(attributes['x'] || '0')
+    @y = y(attributes['y'] || '0')
+    @width = x_pixels(attributes['width'])
+    @height = y_pixels(attributes['height'])
+
+    require_positive_value @width, @height
+
+    raw_rx = x_pixels(attributes['rx'])
+    raw_ry = y_pixels(attributes['ry'])
+
+    if raw_rx || raw_ry
+      @rx = (raw_rx || raw_ry).clamp(0, @width / 2.0)
+      @ry = (raw_ry || raw_rx).clamp(0, @height / 2.0)
+    end
+  end
+
+  def apply
+    if @rx && @ry
+      if @rx == @ry
+        add_call 'rounded_rectangle', [@x, @y], @width, @height, @rx
+      else
+        apply_elliptical_rounded_rectangle
+      end
+    else
+      add_call 'rectangle', [@x, @y], @width, @height
+    end
+  end
+
+  def bounding_box
+    [@x, @y, @x + @width, @y - @height]
+  end
+
+  private
+
+  def apply_elliptical_rounded_rectangle
+    x1 = @x
+    y1 = @y
+    x2 = @x + @width
+    y2 = @y - @height
+
+    add_call 'move_to', [x1 + @rx, y1]
+    add_call 'line_to', [x2 - @rx, y1]
+    add_arc x2 - @rx, y1 - @ry, Math::PI / 2, 0
+    add_call 'line_to', [x2, y2 + @ry]
+    add_arc x2 - @rx, y2 + @ry, 0, -Math::PI / 2
+    add_call 'line_to', [x1 + @rx, y2]
+    add_arc x1 + @rx, y2 + @ry, -Math::PI / 2, -Math::PI
+    add_call 'line_to', [x1, y1 - @ry]
+    add_arc x1 + @rx, y1 - @ry, Math::PI, Math::PI / 2
+    add_call 'close_path'
+  end
+
+  def add_arc(cx, cy, start_angle, end_angle)
+    calculate_bezier_curve_points_for_arc(cx, cy, @rx, @ry, start_angle, end_angle, 0).each do |points|
+      add_call 'curve_to', points[:p2], bounds: [points[:q1], points[:q2]]
+    end
+  end
+end

data/lib/prawn/svg/elements/root.rb

@@ -0,0 +1,22 @@
+class Prawn::SVG::Elements::Root < Prawn::SVG::Elements::Base
+  def initialize(document, source = document.root, parent_calls = [], state = ::Prawn::SVG::State.new)
+    super
+  end
+
+  def parse
+    state.viewport_sizing = @document.sizing
+  end
+
+  def apply
+    if [nil, 'inherit'].include?(properties.fill) || properties.fill.none? || properties.fill.color == :currentcolor
+      add_call 'fill_color', Prawn::SVG::Color.default_color(@document.color_mode).value
+    end
+
+    add_call 'transformation_matrix', @document.sizing.x_scale, 0, 0, @document.sizing.y_scale, 0, 0
+    add_call 'transformation_matrix', 1, 0, 0, 1, -@document.sizing.x_offset, @document.sizing.y_offset
+  end
+
+  def container?
+    true
+  end
+end

data/lib/prawn/svg/elements/switch.rb

@@ -0,0 +1,92 @@
+class Prawn::SVG::Elements::Switch < Prawn::SVG::Elements::Base
+  FEATURE_PREFIX = 'http://www.w3.org/TR/SVG11/feature#'.freeze
+
+  SUPPORTED_FEATURES = Set.new(
+    %w[
+      SVG
+      SVG-static
+      CoreAttribute
+      Structure
+      BasicStructure
+      ConditionalProcessing
+      Image
+      Style
+      Shape
+      Text
+      BasicText
+      PaintAttribute
+      BasicPaintAttribute
+      OpacityAttribute
+      BasicGraphicsAttribute
+      Marker
+      Gradient
+      Pattern
+      Clip
+      BasicClip
+      Mask
+      Hyperlinking
+      XlinkAttribute
+    ].map { |name| "#{FEATURE_PREFIX}#{name}" }
+  ).freeze
+
+  def container?
+    true
+  end
+
+  def process_child_elements
+    return unless source
+
+    elem = svg_child_elements.find do |e|
+      passes_conditional_processing?(e) && Prawn::SVG::Elements::TAG_CLASS_MAPPING[e.name.to_sym]
+    end
+
+    return unless elem
+
+    element_class = Prawn::SVG::Elements::TAG_CLASS_MAPPING[elem.name.to_sym]
+    add_call 'save'
+    child = element_class.new(@document, elem, @calls, state.dup)
+    child.process
+    add_call 'restore'
+  end
+
+  private
+
+  def passes_conditional_processing?(element)
+    passes_required_features?(element) &&
+      passes_required_extensions?(element) &&
+      passes_system_language?(element)
+  end
+
+  def passes_required_features?(element)
+    value = element.attributes['requiredFeatures']
+    return true if value.nil?
+
+    features = value.strip.split(/\s+/)
+    return false if features.empty?
+
+    features.all? { |feature| SUPPORTED_FEATURES.include?(feature) }
+  end
+
+  def passes_required_extensions?(element)
+    value = element.attributes['requiredExtensions']
+    return true if value.nil?
+
+    # We don't support any extensions
+    false
+  end
+
+  def passes_system_language?(element)
+    value = element.attributes['systemLanguage']
+    return true if value.nil?
+
+    languages = value.strip.split(/\s*,\s*/)
+    return false if languages.empty? || languages == ['']
+
+    user_language = (document.instance_variable_get(:@options)[:language] || 'en').downcase
+
+    languages.any? do |lang|
+      lang = lang.strip.downcase
+      user_language == lang || lang.start_with?("#{user_language}-")
+    end
+  end
+end