dudegl 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 629bfb1702e517a1bf3f5f52fbf5b3c8eb7e82919cd122aadee7ffa494f35979
-  data.tar.gz: fa4395ff7d805a91016f9a384cb2928d7c777e84600e3ff473ff562c02eda072
+  metadata.gz: b805c21a8942542341dbd1b2acf7c532aeabd85c595f301f0c0e6818cb6aebd3
+  data.tar.gz: 11759902d63ae4308573cce8a8a17d4c12a4eb6f3913e4719e4811378184400a
 SHA512:
-  metadata.gz: a4531659105ee4b4e53cb098ddae20c75eb51bfc5175ace477dc2c705c8f435d2102c91347d789b45534f8dea6d12433130f929f51849094eb387a8b2196d76a
-  data.tar.gz: f2a4f167a1b012c647056ab937029eb9887c34184be036ce7d382f5235999b799ff97fc34f71602808420a4bc0620ca0fa9b174ff14e596610d8941a9938fcd3
+  metadata.gz: d2496e62b966bccbbfa3413b1f7895e1380eff5d75cbe8563ce9e9fedade4c65b73f7ee2ca5a38f10cd98166e3f26a552363c638cd074d473d4eac78e1b8ade1
+  data.tar.gz: 02afdc8b0225d67eee097552c43b9c26fb696f2a33fbd90f26c54afd5377014aa0d9cd477e552eee79b9084c5b08f3d93f54018a7d796837487d708d03a53fd2

data/lib/compose/arms.rb

@@ -9,13 +9,36 @@ class Arms < Limbs
     super
     divide_arms
 
-    @left_arms_num.times do |i|
-      @limbs << Arm.new(@left_arms[i], @body.body_left_x, hy(i), :left)
+    @left_arms_num.times { |i| draw_arms_on_side(@left_arms[i], i, :left) }
+    @right_arms_num.times { |i| draw_arms_on_side(@right_arms[i], i, :right) }
+  end
+
+  def draw_arms_on_side(side_arms, i, body_side)
+    body_side == :left ? body_x = @body.body_left_x : body_x = @body.body_right_x
+
+    if arm_size_changed?(side_arms[:length])
+      side_arms_initial = side_arms.dup
+      side_arms[:length] = side_arms[:length].first
+      side_arms[:name] = change_arm_name_param(side_arms[:name], 1)
+      @limbs << Arm.new(side_arms, body_x, hy(i), body_side: body_side, body_color: @body_color)
+
+      side_arms = side_arms_initial
+      side_arms[:name] = change_arm_name_param(side_arms[:name], -1)
+      side_arms[:length] = side_arms[:length].first - side_arms[:length].last
+      @limbs << Arm.new(side_arms, body_x, hy_same_arm(i), body_side: body_side, body_color: @body_color)
+    else
+      side_arms[:length] = arm_length_value(side_arms[:length])
+      @limbs << Arm.new(side_arms, body_x, hy(i), body_side: body_side, body_color: @body_color)
     end
+  end
 
-    @right_arms_num.times do |i|
-       @limbs << Arm.new(@right_arms[i], @body.body_right_x, hy(i), :right)
+  def change_arm_name_param(name, param)
+    if name.class == Array
+      name[1] = param
+      return name
     end
+
+    return [name, value]
   end
 
   def draw_parameters
@@ -38,4 +61,28 @@ class Arms < Limbs
   def hy(i)
     (1.05 * @body.body_left_top_y + i * @arms_step).round
   end
+
+  def hy_same_arm(i)
+    (1.05 * @body.body_left_top_y + (i + 1) * 0.5 * @arms_step).round
+  end
+
+  def arm_length_value(item)
+    return item.first if item.class == Array
+    return item
+  end
+
+  def arm_size_changed?(length_params)
+    if length_params.class == Array
+      current_length = length_params.first
+      delta = length_params.last
+
+      current_length_short = current_length <= Config::METHOD_LENGTH_OK_MAX
+      previous_length_short = current_length - delta <= Config::METHOD_LENGTH_OK_MAX
+      changed = (current_length_short != previous_length_short)
+
+      return changed
+    end
+
+    return false
+  end
 end

data/lib/compose/body.rb

@@ -5,17 +5,19 @@ class Body
   include Utils
 
   attr_reader :body_right_x, :body_right_top_y,
-              :body_left_x, :body_left_top_y, :draw_data
+              :body_left_x, :body_left_top_y, :draw_data, :color
 
-  def initialize(name, offsets)
+  def initialize(name, offsets, renamed = [])
     @name = name
     @draw_data = []
     @offset_x = offsets[:offset_x]
     @offset_y = offsets[:offset_y]
+    @renamed = renamed
     draw_body
   end
 
   def draw_body
+    @dude_name, @color = process_item(@name)
     # head center
     head_center_x = 0.5 * Config::DUDE_FRAME_SIZE + @offset_x
     head_center_y = 0.3 * Config::DUDE_FRAME_SIZE + @offset_y
@@ -27,25 +29,23 @@ class Body
                                                      Config::HEAD_RADIUS,
                                                      Config::BODY_CENTER - Config::SLIM_FACTOR)
 
-    @draw_data << {
-      circle: {
-      cx: head_center_x,
-      cy: head_center_y,
-      r: Config::HEAD_RADIUS
-      }
-    }
+    @draw_data << draw_circle(head_center_x, head_center_y, Config::HEAD_RADIUS, @color)
 
     @draw_data << draw_line(@body_right_x, @body_right_top_y,
-                            @body_right_x, @body_right_top_y + Config::BODY_LENGTH)
+                            @body_right_x, @body_right_top_y + Config::BODY_LENGTH, @color)
     # left part of a body
     @draw_data << draw_line(@body_left_x, @body_left_top_y,
-                            @body_left_x, @body_left_top_y + Config::BODY_LENGTH)
+                            @body_left_x, @body_left_top_y + Config::BODY_LENGTH, @color)
     # bottom
     @draw_data << draw_line(@body_right_x, @body_right_top_y + Config::BODY_LENGTH,
-                            @body_left_x, @body_left_top_y + Config::BODY_LENGTH)
+                            @body_left_x, @body_left_top_y + Config::BODY_LENGTH, @color)
 
-    @draw_data << draw_caption(@name, head_center_x - Config::HEAD_RADIUS,
+    @draw_data << draw_caption(@dude_name, head_center_x - Config::HEAD_RADIUS,
                                head_center_y - 1.1 * Config::HEAD_RADIUS,
-                               font_size: 10)
+                               14, :lr, @color)
+  end
+
+  def changed?
+    return true if @color == :green || @color == :red
   end
 end

data/lib/compose/limbs.rb

@@ -3,10 +3,11 @@ require_relative '../config'
 class Limbs
   attr_reader :limbs
 
-  def initialize(params, body)
+  def initialize(params, body, opts = {})
     @params = params
     @body = body
     @limbs = []
+    opts.key?(:body_color) ? @body_color = opts[:body_color] : @body_color = nil
 
     draw_parameters
     draw if @limbs_num.positive?
@@ -17,7 +18,7 @@ class Limbs
   def draw; end
 
   def draw_parameters
-    @params_methods = @params[:methods].select { |param| param[:args].public_send(select_operator, 0) }
+    @params_methods = @params[:methods]
     @limbs_num = @params_methods.size
     return true if @limbs_num == 0
   end

data/lib/diff_params.rb

@@ -0,0 +1,144 @@
+# require 'byebug'
+
+class DiffParams
+  class << self
+    def call(params_list, renamed = nil)
+      @params_list1 = params_list.first
+      @params_list2 = params_list.last
+      @renamed = renamed
+      @diff_params = []
+
+      manage_renamed if !renamed.nil?
+      compare_params_lists
+
+      @diff_params#.flatten!
+    end
+
+    private
+
+    def compare_params_lists
+      new_params_names,
+      removed_params_names,
+      unchanged_params_names = items_diff(@params_list1, @params_list2)
+
+      @diff_params << label_items(@params_list2, new_params_names, 1)
+      @diff_params << label_items(@params_list1, removed_params_names, -1)
+
+      unchanged_params_names.each do |params_name|
+        @diff = { name: params_name, :methods=> [] }
+        @params1 = find_item(@params_list1, params_name)
+        @params2 = find_item(@params_list2, params_name)
+
+        compare
+
+        @diff[:name] = [@diff[:name], 0]
+        @diff_params << @diff
+      end
+      remove_empty_params
+    end
+
+    def label_params(params, label)
+      params[:name] = [params[:name], label]
+    end
+
+    def compare
+      new_methods_names,
+      removed_methods_names,
+      unchanged_methods_names = items_diff(@params1[:methods], @params2[:methods])
+
+      new_methods = label_items(@params2[:methods], new_methods_names, 1)
+      removed_methods = label_items(@params1[:methods], removed_methods_names, -1)
+
+      @diff[:methods] << new_methods
+      @diff[:methods] << removed_methods
+      process_unchanged_methods(unchanged_methods_names)
+
+      remove_empty_methods
+      @diff[:methods].flatten!
+    end
+
+    # returns hash with method2 params and diff (e.g. args2 - args1)
+    def compare_methods(method1, method2)
+      args_diff = method2[:args] - method1[:args]
+      length_diff = method2[:length] - method1[:length]
+      conditions_diff = method2[:conditions] - method1[:conditions]
+      { name: [method1[:name], 0],
+        args: [method2[:args], args_diff],
+        length: [method2[:length], length_diff],
+        conditions: [method2[:conditions], conditions_diff] }
+    end
+
+    def items_diff(items1, items2)
+      items_names1 = items_names(items1)
+      items_names2 = items_names(items2)
+
+      new_items = items_names2 - items_names1
+      removed_items = items_names1 - items_names2
+      unchanged_items = items_names2 - new_items
+
+      [new_items, removed_items, unchanged_items]
+    end
+
+    def items_names(items)
+      items.map { |item| item[:name] }
+    end
+
+    def find_item(items, name)
+      item = items.select { |item| item[:name] == name }
+      item.first unless item.nil?
+    end
+
+    # 0 - unchanged, -1 - removed, 1 - new
+    def label_item(items, item_name, label)
+      item = find_item(items, item_name)
+      item[:name] = [item[:name], label]
+      item
+    end
+
+    def label_items(items, items_names, label)
+      items_names.map { |item_name| label_item(items, item_name, label) }
+    end
+
+    def process_unchanged_methods(unchanged_methods_names)
+      unchanged_methods_names.each do |method_name|
+        method1 = find_item(@params1[:methods], method_name)
+        method2 = find_item(@params2[:methods], method_name)
+        @diff[:methods] << compare_methods(method1, method2)
+      end
+
+      unchanged_methods = label_items(@params1[:methods], unchanged_methods_names, 0)
+    end
+
+    def remove_empty_methods
+      @diff[:methods].select! { |item| item != [] }
+    end
+
+    def remove_empty_params
+      @diff_params.select! { |item| item != [] }
+    end
+
+    def manage_renamed
+      @renamed.each do |names|
+        rename_items(@params_list1, names, :old)
+        rename_items(@params_list2, names, :new)
+      end
+    end
+
+    def renamed_name(names)
+      "#{names[:old_name]} > #{names[:new_name]}"
+    end
+
+    def rename_old_item(param_list, names)
+      param_list[:name] = renamed_name(names) if param_list[:name] == names[:old_name]
+    end
+
+    def rename_new_item(param_list, names)
+      param_list[:name] = renamed_name(names) if param_list[:name] == names[:new_name]
+    end
+
+    def rename_items(params_list, names, type)
+      return params_list.each { |item| rename_old_item(item, names) } if type == :old
+      return params_list.each { |item| rename_new_item(item, names) } if type == :new
+    end
+  end
+end

data/lib/dudegl.rb

@@ -1,11 +1,19 @@
-require 'byebug'
+# require 'byebug'
 # require all filder from current dir and subdirectories
 Dir[File.dirname(__FILE__) + '/**/*.rb'].each {|file| require_relative file }
 
 class DudeGl
-  def initialize(params_list, dudes_per_row_max = nil)
-    @params_list = params_list
+  def initialize(params_list, opts = {})
+    opts.key?(:dudes_per_row_max) ? dudes_per_row_max = opts[:dudes_per_row_max] : dudes_per_row_max = nil
+    opts.key?(:renamed) ? @renamed = opts[:renamed] : @renamed = nil
+
+    if opts.key?(:diff) && opts[:diff] == true
+      @params_list = DiffParams.call(params_list, @renamed)
+    else
+      @params_list = params_list
+    end
     @dudes = []
+
     @locations = DudesLocation.new(@params_list, dudes_per_row_max)
 
     build_dudes
@@ -21,6 +29,10 @@ class DudeGl
     File.open("images/#{file_name}.svg", 'w') { |file| file.write(@svg.contents) }
   end
 
+  def save_to_string
+    @svg.contents
+  end
+
   private
 
   def build_dudes
@@ -28,13 +40,15 @@ class DudeGl
   end
 
   def build_dude(params, index)
-    body = Body.new(params[:name], offsets = @locations.offsets[index])
+    params = params.first if params.class == Array
+    body = Body.new(params[:name], offsets = @locations.offsets[index], @renamed)
 
-    arms = Arms.new(params, body).limbs
+    body.changed? ? body_color = body.color : body_color = nil
+    # draw all methods as arms, keep legs for something else...
+    arms = Arms.new(params, body, body_color: body_color).limbs
     arms_draw_params = arms.map { |arm| arm.draw_data }
 
-    legs = Legs.new(params, body).limbs
-    legs_draw_params = legs.map { |leg| leg.draw_data }
+    legs_draw_params = []
 
     (body.draw_data + arms_draw_params + legs_draw_params).flatten
   end

data/lib/limbs/arm.rb

@@ -1,12 +1,6 @@
 require_relative 'limb'
 
 class Arm < Limb
-  attr_reader :body_side
-
-  def initialize(params, x0, y0, body_side)
-    @body_side = body_side
-    super(params, x0, y0)
-  end
 
   private
 
@@ -14,19 +8,27 @@ class Arm < Limb
     super
     @end_x = @x0 + @limb_length
 
-    if @params[:conditions].positive?
+    @condition_colors = process_item_set(@params[:conditions])
+    @conditions = @condition_colors.size
+    @condition_colors = set_additional_colors(@conditions, @condition_colors)
+
+    if @conditions.positive?
       draw_conditions
     else
-      @draw_data << draw_line(@x0, @y0, @x0 + @limb_length, @y0)
+      @draw_data << draw_line(@x0, @y0, @x0 + @limb_length, @y0, @color_limb)
     end
 
-    @draw_data << draw_caption(@params[:name], (@end_x - 20).round, (@y0 - 10).round)
-    draw_fingers(@params[:args])
+    @draw_data << draw_caption(@name, (@end_x - 20).round, (@y0 - 10).round, 10, :lr, @color_limb)
+
+    @color_fingers = process_item_set(@params[:args])
+    @args = @color_fingers.size
+    @color_fingers = set_additional_colors(@args, @color_fingers)
+    draw_fingers
   end
 
   def draw_conditions
-    @lines_num = @params[:conditions] + 1
-    @line_length = ((@limb_length.abs - @params[:conditions] * Config::ELLIPSE_LENGTH) / @lines_num).round
+    @lines_num = @conditions + 1
+    @line_length = ((@limb_length.abs - @conditions * Config::ELLIPSE_LENGTH) / @lines_num).round
 
     @x1 = @x0 + @line_length * orientation
 
@@ -34,39 +36,38 @@ class Arm < Limb
   end
 
   def draw_condition(i)
-    @draw_data << draw_line(@x0, @y0, @x1, @y0)
+    @draw_data << draw_line(@x0, @y0, @x1, @y0, @color_limb)
 
-    @draw_data << { ellipse: {
-                    cx: (@x1 + Config::ELLIPSE_LENGTH * orientation / 2).round,
-                    cy: @y0, rx: (Config::ELLIPSE_LENGTH / 2).round,
-                    ry: (Config::ELLIPSE_LENGTH / 4).round }} if i < @lines_num - 1
+    @draw_data << draw_ellipse(cx = (@x1 + Config::ELLIPSE_LENGTH * orientation / 2), cy = @y0,
+                              rx = (Config::ELLIPSE_LENGTH / 2),
+                              ry = (Config::ELLIPSE_LENGTH / 4), @condition_colors[i]) if i < @lines_num - 1
 
     @x0 += (@line_length + Config::ELLIPSE_LENGTH) * orientation
     @x1 = @x0 + @line_length * orientation
   end
 
-  def draw_fingers(args_num)
-    if body_side == :left
+  def draw_fingers
+    if @opts[:body_side] == :left
       finger_angle_start = Config::FINGER_ANGLE_START
       finger_angle_end = finger_angle_start + Config::FINGERS_RANGE
-      finger_angle_step = calc_fingers_range(Config::FINGERS_RANGE, args_num)
+      finger_angle_step = calc_fingers_range
     else
       finger_angle_start = - Config::FINGER_ANGLE_START + Math::PI
       finger_angle_end = finger_angle_start - Config::FINGERS_RANGE
-      finger_angle_step = - calc_fingers_range(Config::FINGERS_RANGE, args_num)
+      finger_angle_step = - calc_fingers_range
     end
 
-    args_num.times do |i|
+    @args.times do |i|
       finger_end_x, finger_end_y = circle_rotate(end_x, end_y, Config::FINGER_LENGTH,
                                                  finger_angle_start + finger_angle_step * i)
 
-      @draw_data << draw_line(end_x, end_y, finger_end_x, finger_end_y)
+      @draw_data << draw_line(end_x, end_y, finger_end_x, finger_end_y, @color_fingers[i])
     end
   end
 
-  def calc_fingers_range(fingers_range, args_num)
-    return fingers_range / (args_num - 1).to_f if args_num > 1
-    return fingers_range / args_num.to_f if args_num == 1
+  def calc_fingers_range
+    return Config::FINGERS_RANGE / (@args - 1).to_f if @args > 1
+    return Config::FINGERS_RANGE / @args.to_f if @args == 1
     return 0
   end
 end

data/lib/limbs/leg.rb

@@ -30,10 +30,9 @@ class Leg < Limb
   def draw_condition(i)
     @draw_data << draw_line(@x0, @y0, @x0, @y1)
 
-    @draw_data << { ellipse: {
-      cx: @x0, cy: (@y1 + Config::ELLIPSE_LENGTH / 2).round ,
-      rx: (Config::ELLIPSE_LENGTH / 4).round, ry: (Config::ELLIPSE_LENGTH / 2).round
-      }} if i < @lines_num - 1
+    @draw_data << draw_ellipse(cx = @x0, cy = (@y1 + Config::ELLIPSE_LENGTH / 2),
+                              rx = (Config::ELLIPSE_LENGTH / 4),
+                              ry = (Config::ELLIPSE_LENGTH / 2)) if i < @lines_num - 1
 
     @y0 += @line_length + Config::ELLIPSE_LENGTH
     @y1 = @y0 + @line_length

data/lib/limbs/limb.rb

@@ -5,11 +5,15 @@ class Limb
 
   attr_reader :end_x, :end_y, :draw_data
 
-  def initialize(params, x0, y0)
+  def initialize(params, x0, y0, opts = {})
     @params = params
     @x0 = x0
     @end_y = @y0 = y0
     @draw_data = []
+    @opts = opts
+    @name, @color_limb = process_item(params[:name])
+    body_color = apply_body_color(@opts[:body_color]) if @opts.key?(:body_color)
+    @color_limb = body_color unless body_color.nil? || body_color == :black
 
     draw
   end
@@ -25,9 +29,18 @@ class Limb
   end
 
   def orientation
-    return 1 if @body_side.nil?
-    @body_side == :left ? -1 : 1
+    return 1 if @opts[:body_side].nil?
+    @opts[:body_side] == :left ? -1 : 1
   end
 
   def draw_conditions; end
+
+  def set_additional_colors(items, value)
+    return [@color_limb] * items if @color_limb == :green || @color_limb == :red
+    return value
+  end
+
+  def apply_body_color(body_color)
+    return body_color if body_color == :green || body_color == :red
+  end
 end

data/lib/render.rb

@@ -3,8 +3,12 @@ require_relative 'config'
 class Render
   attr_reader :contents
 
+  HEADER = %Q[<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">]
+
   def initialize(elements, width = Config::DUDE_FRAME_SIZE, height = Config::DUDE_FRAME_SIZE)
     code = []
+    code << HEADER
     code << %Q[<svg width="#{width}" height="#{height}" style="background:white" xmlns="http://www.w3.org/2000/svg">]
     elements.each { |element| code << hash_to_svg(element) }
     code << %Q[</svg>]
@@ -24,7 +28,7 @@ class Render
       <line x1="#{params[:x1]}" y1="#{params[:y1]}"
       x2="#{params[:x2]}"
       y2="#{params[:y2]}"
-      style="stroke:black; stroke-width:1"/>
+      style="stroke:#{params[:color]}; stroke-width:1"/>
     LINE
   end
 
@@ -33,7 +37,7 @@ class Render
       <circle cx="#{params[:cx]}"
       cy="#{params[:cy]}"
       r="#{params[:r]}"
-      fill="white" style="stroke:black; stroke-width:1"/>
+      fill="white" style="stroke:#{params[:color].to_s}; stroke-width:1"/>
     CIRCLE
   end
 
@@ -43,7 +47,7 @@ class Render
       cy="#{params[:cy]}"
       rx="#{params[:rx]}"
       ry="#{params[:ry]}"
-      style="stroke:black; stroke-width:1" fill="white"/>
+      style="stroke:#{params[:color].to_s}; stroke-width:1" fill="white"/>
     ELLIPSE
   end
 
@@ -52,7 +56,7 @@ class Render
       <text x="#{params[:x]}"
       y="#{params[:y]}"
       font-family="arial" font-size="#{params[:font_size]}"
-      fill="black" style="writing-mode:
+      fill="#{params[:color].to_s}" style="writing-mode:
       #{params[:orientation].to_s}">#{params[:caption]}</text>
     TEXT
   end

data/lib/utils.rb

@@ -1,3 +1,5 @@
+# require_relative 'config'
+
 module Utils
   def circle_rotate(center_x, center_y, r, rotation)
     x_rotated = center_x + r * Math.cos(rotation)
@@ -5,11 +7,55 @@ module Utils
     return [x_rotated, y_rotated]
   end
 
-  def draw_line(x1, y1, x2, y2)
-    { line: { x1: x1, y1: y1, x2: x2, y2: y2 } }
+  def draw_line(x1, y1, x2, y2, color = :black)
+    { line: { x1: x1, y1: y1, x2: x2, y2: y2, color: color } }
+  end
+
+  def draw_caption(caption, x, y, font_size = 9, orientation = :lr, color = :black)
+    { text: { x: x, y: y, caption: caption, font_size: font_size, orientation: orientation, color: color } }
+  end
+
+  def draw_circle(head_center_x, head_center_y, r, color = :black)
+    { circle: { cx: head_center_x, cy: head_center_y, r: r, color: color } }
+  end
+
+  def draw_ellipse(cx, cy, rx, ry, color = :black)
+    { ellipse: { cx: cx, cy: cy, rx: rx, ry: ry, color: color } }
   end
 
-  def draw_caption(caption, x, y, font_size = 9, orientation = :lr)
-    { text: { x: x, y: y, caption: caption, font_size: font_size, orientation: orientation } }
+  def set_color(color_id)
+    return :red if color_id == -1
+    return :green if color_id == 1
+    return :black
+  end
+
+  def process_item(item)
+    # for item like ['new_method', 1]
+    if item.class == Array
+      name = item.first
+      color = set_color(item.last)
+
+      return [name, color]
+    end
+    # 'new_method'
+    return [item, :black]
+  end
+
+  def process_item_set(item)
+    return [:black] * item unless item.class == Array
+
+    current_num = item.first
+    delta = item.last
+    return [:black] * current_num if delta == 0
+
+    if delta > 0
+      colors_changed = [:green] * delta
+      colors_unchanged = [:black] * (current_num - delta)
+    elsif delta < 0
+      colors_changed = [:red] * delta.abs
+      colors_unchanged = [:black] * current_num
+    end
+
+    return colors_changed + colors_unchanged
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dudegl
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Dmitry Khramtsov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-26 00:00:00.000000000 Z
+date: 2020-02-22 00:00:00.000000000 Z
 dependencies: []
 description: 'Anthropomorphic UML: visualization of code and OOP concepts in a form
   of human body.'
@@ -25,6 +25,7 @@ files:
 - lib/compose/legs.rb
 - lib/compose/limbs.rb
 - lib/config.rb
+- lib/diff_params.rb
 - lib/dudegl.rb
 - lib/limbs/arm.rb
 - lib/limbs/leg.rb