dudity 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2f4f733d0f1d5e557bf7a80436baa2a66a3fe8d689a313f0eed01b728ac3d65d
+  data.tar.gz: 945da3f26fcaa3656824de52f471731fe091d5fe7c991ff81d45af46cfb0b8db
+SHA512:
+  metadata.gz: 272d70947283eb90ebcd0248d7a2813b5fcb26b88e750d735c788cb6176ca41acf9cdd209dfc732dc3e3d723b2f2d7dd9f3eba5bbe54dea90033917f9b2b83cb
+  data.tar.gz: 33a6432c3575142ecea4d6de618748f3c94762b838e105e0037ed6a775138f6d0ac2707c35f2fc04ce795ec1eb9a72306ca3b23c5714de5da1750f3020d074c6

data/lib/download_service.rb

@@ -0,0 +1,10 @@
+require 'open-uri'
+
+class DownloadService
+  def self.call(url, mode = :default)
+    begin
+      mode == :read_by_line ? open(url).readlines : open(url).read
+    rescue OpenURI::HTTPError
+    end
+  end
+end

data/lib/dudes.rb

@@ -0,0 +1,82 @@
+# this module was created by Victor Shepelev (zverok) https://github.com/zverok
+require 'fast'
+
+module Dudes
+  class Calculator
+    using(Module.new do
+      refine Astrolabe::Node do
+        def fast(path)
+          Fast.search(path, self)
+        end
+
+        # Lot of chunks of code parsed as (:foo, ...) if it is a single statement,
+        # or (:begin, (:foo, ...), (:bar, ...)) if it is several independent statements.
+        # Robustly make it an array of nodes
+        def arrayify
+          type == :begin ? children : [self]
+        end
+      end
+    end)
+
+    def initialize(code)
+      @ast = Fast.ast(code)
+    end
+
+    def call
+      return [] unless @ast
+      @ast.arrayify.map(&method(:calc_class)).compact
+    end
+
+    private
+
+    def calc_class(node)
+      return unless node.type == :class
+
+      name, parent, body = *node
+      {
+        name: name.children.compact.join(':'),
+        methods: body&.arrayify&.map(&method(:calc_method))&.compact || [],
+        references: extract_references(body)
+      }
+    end
+
+    def extract_references(node)
+      return [] unless node
+
+      node.fast('(const {nil _} )').map { |n| n.children.compact.join('::') }.sort.uniq
+    end
+
+    def calc_method(node)
+      return unless node.type == :def
+
+      name, args, body = *node
+
+      return empty_body(name, args) if body.nil?
+
+      {
+        name: name,
+        args: args.children.count,
+        length: count_statements(body.arrayify),
+        conditions: count_conditions(body),
+      }
+    end
+
+    def empty_body(name, args)
+      {
+        name: name,
+        args: args.children.count,
+        length: 0,
+        conditions: 0,
+      }
+    end
+
+    # FIXME: This is kinda naive... But maybe appropriate enough
+    def count_statements(nodes)
+      nodes.sum { |n| n.each_node.count }
+    end
+
+    def count_conditions(node)
+      node.fast('({if case} _)').count
+    end
+  end
+end

data/lib/dudity.rb

@@ -0,0 +1,155 @@
+require 'dudegl'
+require 'open-uri'
+
+Dir[File.dirname(__FILE__) + '/**/*.rb'].each {|file| require_relative file }
+
+class Dudity
+  class << self
+    def visualise(path, opt = {})
+      @path = path
+      opt.key?(:except) ? except = opt[:except] : except = nil
+      opt.key?(:only) ? only = opt[:only] : only = nil
+      opt.key?(:ignore_classes) ? ignore_classes = opt[:ignore_classes] : ignore_classes = nil
+      opt.key?(:only_classes) ? only_classes = opt[:only_classes] : only_classes = nil
+      opt.key?(:filename_suffix) ? filename_suffix = opt[:filename_suffix] : filename_suffix = ''
+
+      project_files = ScanApp.call(@path, except, only)
+      app_name = @path.split('/').last
+
+      @params_list = []
+      project_files.each { |project_file| process_item(project_file) }
+
+      @params_list = @params_list.flatten.compact
+      exclude_classes(ignore_classes) if ignore_classes
+      include_classes(only_classes) if only_classes
+
+      dudes = DudeGl.new @params_list, dudes_per_row_max: 4
+      dudes.render
+      dudes.save "#{app_name}#{filename_suffix}"
+    end
+
+    def visualise_diff(path_to_diff, opt = {})
+      @params1 = []
+      @params2 = []
+
+      # path to the dir where diff file is stored
+      @path = path_to_diff.split('/').take(path_to_diff.split('/').size - 1).join('/')
+
+      opt.key?(:as) ? file_type = opt[:as] : file_type = :svg
+      opt.key?(:pull_branch) ? @pull_branch = opt[:pull_branch] : return
+
+      diff = open(path_to_diff).readlines
+      @diff_data = GitDiffService.call(diff)
+
+      return generate_svg if file_type == :svg
+      return generate_html_report if file_type == :html
+    end
+
+    def visualise_pr(public_pr_link, opt = {})
+      @params1 = []
+      @params2 = []
+
+      @path = public_pr_link
+      diff_url = "#{public_pr_link}.diff"
+
+      opt.key?(:as) ? file_type = opt[:as] : file_type = :svg
+      opt.key?(:pull_branch) ? @pull_branch = opt[:pull_branch] : return
+
+      diff = DownloadService.call(diff_url, :read_by_line)
+      @diff_data = GitDiffService.call(diff)
+
+      return generate_svg if file_type == :svg
+      return generate_html_report if file_type == :html
+    end
+
+    private
+
+    # generate name based on pull request data. Example: DudesHub_pull_5
+    def fname
+      @path.split('/')[-3, 3].join('_')
+    end
+
+    # generate html report title based on repo data, make each word capitalized
+    def report_title
+      @path.split('/')[-3, 3].map(&:capitalize).join(' ')
+    end
+
+    def generate_svg
+      analyze_code(@diff_data)
+    end
+
+    def generate_html_report
+      separate_code
+      analyze_by_category
+
+      html = open('templates/dudes_report.html').read
+      html = html.sub('[dudes_report_title]', report_title)
+      @report_file_path = "#{fname}.html"
+      File.open(@report_file_path, 'w') { |file| file.write(html) }
+    end
+
+    def separate_code
+      @diff_data_controllers = []
+      @diff_data_models = []
+      @diff_data_others = []
+
+      @diff_data.each do |item|
+        if item[:old_name]&.start_with?("app/controllers") || item[:new_name]&.start_with?("app/controllers")
+          @diff_data_controllers << item
+        elsif item[:old_name]&.start_with?("app/models") || item[:new_name]&.start_with?("app/models")
+          @diff_data_models << item
+        else
+          @diff_data_others << item
+        end
+      end
+    end
+
+    def analyze_by_category
+      analyze_code(@diff_data_controllers, :controllers) if !@diff_data_controllers.empty?
+      analyze_code(@diff_data_models, :models) if !@diff_data_models.empty?
+      analyze_code(@diff_data_others, :others) if !@diff_data_others.empty?
+    end
+
+    def analyze_code(diff_data, label = nil)
+      @params1 = []
+      @params2 = []
+      local = !@path.start_with?('http')
+      local ? suffix = '_local' : suffix = ''
+
+      diff_data.map { |item| process_item_for_diff(item, local) }
+
+      renamed = diff_data.select { |item| item[:status] == :renamed_class }
+
+      return false if params_empty?
+
+      dudes = DudeGl.new [@params1.flatten.compact, @params2.flatten.compact],
+                          dudes_per_row_max: 4, renamed: renamed, diff: true
+      dudes.render
+
+      label ? dudes.save("#{label}#{suffix}") : dudes.save("#{fname}#{suffix}")
+    end
+
+    def process_item(project_file)
+      code = open(project_file).read
+      @params_list << Dudes::Calculator.new(code).call
+    end
+
+    def process_item_for_diff(item, local = false)
+      processed_code = ProcessCodeService.new(@path, @pull_branch, item, local = local).call
+      @params1 << processed_code.first
+      @params2 << processed_code.last
+    end
+
+    def params_empty?
+      @params1.empty? || @params2.empty?
+    end
+
+    def exclude_classes(classes)
+      @params_list = @params_list.reject { |param| classes.any? { |item| param[:name] == item } }
+    end
+
+    def include_classes(classes)
+      @params_list = @params_list.select { |param| classes.any? { |item| param[:name] == item } }
+    end
+  end
+end

data/lib/git_diff_service.rb

@@ -0,0 +1,119 @@
+class GitDiffService
+  class << self
+    PATTERN_MATCH = /^diff --git\s/
+    # restrict scope: for Rails app exclude autogenerated code and omit any files except .rb
+    EXCLUDE_ROOT_FOLDERS = ['db/', 'spec/', 'config/']
+    ALLOWED_EXTENSION = '.rb'
+
+    def call(diff_lines, exclude_folders = [])
+      @diff_lines = diff_lines
+      # TO-DO: support @only_folders
+      @exclude_folders = exclude_folders + EXCLUDE_ROOT_FOLDERS
+
+      patch_pos_start = lines_with_file_paths.map { |line| patch_start_pos(line) }
+      # array with start and end positions for each patch
+      @patches_pos = patch_pos_start.zip(patch_end_pos(patch_pos_start))
+      slice_diff
+      @patches = @patches.select { |patch| allowed_patch?(patch) }
+      @diff_data = @patches.map { |patch| fname_diff(patch) }
+      @diff_data += @patches.map { |patch| class_diff(patch) }
+      @diff_data.compact
+    end
+
+    private
+
+    # split diff lines into separate patches for each file
+    def slice_diff
+      @patches = @patches_pos.map { |pos| @diff_lines[pos.first..pos.last] }
+    end
+
+    def allowed_patch?(patch)
+      fname_string = patch.first
+      extension_allowed = extract_file_paths(fname_string).last.end_with?(ALLOWED_EXTENSION)
+      folder_allowed = !extract_file_paths(fname_string).last.start_with?(*@exclude_folders)
+
+      extension_allowed && folder_allowed
+    end
+
+    def new_file?(patch)
+      patch.select { |line| line.start_with?('new file mode ') }.any?
+    end
+
+    def deleted_file?(patch)
+      patch.select { |line| line.start_with?('deleted file mode ') }.any?
+    end
+
+    def renamed_file?(patch)
+      patch.select { |line| line.start_with?('rename from ') }.any?
+    end
+
+    def class_renamed?(patch)
+      patch.select { |line| line.start_with?('-class') }.any? &&
+          patch.select { |line| line.start_with?('+class') }.any?
+    end
+
+    def old_class_name(patch)
+      res = patch.select { |line| line.start_with?('-class') }
+      return if res.empty?
+      line = res.first
+      line.split(' ').last.strip
+    end
+
+    def new_class_name(patch)
+      res = patch.select { |line| line.start_with?('+class') }
+      return if res.empty?
+      line = res.first
+      line.split(' ').last.strip
+    end
+
+    def fname_diff(patch)
+      # first line in patch contains info about file path
+      file_path_line = patch.first
+      return { old_name: extract_file_paths(file_path_line).first,
+               new_name: extract_file_paths(file_path_line).last, status: :renamed } if renamed_file?(patch)
+      return { old_name: nil, new_name: extract_file_paths(file_path_line).last,
+               status: :new } if new_file?(patch)
+      return { old_name: extract_file_paths(file_path_line).first,
+               new_name: nil,  status: :deleted } if deleted_file?(patch)
+      # changed file without renaming
+      return { old_name: extract_file_paths(file_path_line).first,
+               new_name: extract_file_paths(file_path_line).last,  status: :changed }
+    end
+
+    def class_diff(patch)
+      return { old_name: old_class_name(patch),
+                         new_name: new_class_name(patch), status: :renamed_class } if class_renamed?(patch)
+    end
+
+    # end line index for current patch
+    def patch_end_pos(patch_pos_start)
+      end_line_pos = patch_pos_start.size - 1
+      pos_end = patch_pos_start.map.with_index do |pos, i|
+        i == patch_pos_start.size - 1 ? @diff_lines.size - 1 : patch_pos_start[i + 1] - 1
+      end
+
+      pos_end
+    end
+
+    def lines_with_file_paths
+      @diff_lines.select { |line| line.scan(PATTERN_MATCH).any? }
+    end
+
+    def patch_start_pos(line)
+      @diff_lines.index(line)
+    end
+
+    def extract_file_paths(line)
+      # diff --git a/project_v1/README.md b/project_v2/README2.md
+      line = line.delete_prefix('diff --git ')
+      path1, path2 = line.split(' ')
+      [path1, path2].map! { |path| file_path(path) }
+    end
+
+    def file_path(str)
+      # a/project_v1/README.md -> project_v1/README.md
+      prefix, *path_parts = str.split('/')
+      path_parts.join('/')
+    end
+  end
+end

data/lib/process_code_service.rb

@@ -0,0 +1,87 @@
+# use source code of gems to simplify their code editing (if improvements are needed or bugs are found)
+# in the final version of app gems will be used
+require '/Users/dmkp/Documents/code/ruby/dudes/zverok_dudes_fork2/dudes/lib/dudes.rb'
+
+class ProcessCodeService
+  # path is link to pr or treated as local path if local = true
+  def initialize(path, pull_branch, file_data, local = false)
+    @path = path
+    @pull_branch = pull_branch
+    @file_data = file_data
+    @local = local
+  end
+
+  def call
+    process_code_file
+
+    [@params1, @params2]
+  end
+
+  private
+
+  def process_code_file
+    download_master_code
+    download_pull_request_code
+  end
+
+  def download_master_code
+    return unless [:deleted, :changed, :renamed].include?(@file_data[:status])
+    code_master = get_code(code_master_branch_path)
+    # code_master = DownloadService.call(code_master_branch_path)
+    code_hash = Dudes::Calculator.new(code_master).call
+    @params1 = code_hash.first unless code_hash.empty?
+  end
+
+  def download_pull_request_code
+    return unless [:new, :changed, :renamed].include?(@file_data[:status])
+    code_pull_request = get_code(code_pull_request_branch_path)
+    # code_pull_request = DownloadService.call(code_pull_request_branch_path)
+    code_hash = Dudes::Calculator.new(code_pull_request).call
+    @params2 = code_hash.first unless code_hash.empty?
+  end
+
+  def get_code(path)
+    return open(path).read if @local
+    return DownloadService.call(path)
+  end
+
+  def code_master_branch_path
+    code_path = extract_code_path(:master)
+    return "#{@path}/#{repo_full_name}-master/#{code_path}" if @local
+    return "https://raw.githubusercontent.com/#{repo_full_name}/master/#{code_path}"
+  end
+
+  def code_pull_request_branch_path
+    code_path = extract_code_path(:pull)
+    return "#{@path}/#{repo_full_name}-#{@pull_branch}/#{code_path}" if @local
+    return "https://raw.githubusercontent.com/#{repo_full_name}/#{@pull_branch}/#{code_path}"
+  end
+
+  def repo_full_name
+    return @path.split('/').last if @local
+    return @path.split('/')[-4, 2].join('/')
+  end
+
+  def extract_code_path(branch)
+    return @file_data[:old_name] if deleted?
+    return @file_data[:new_name] if new? || changed?
+    return renamed?(branch)
+  end
+
+  def deleted?
+    @file_data[:status] == :deleted
+  end
+
+  def new?
+    @file_data[:status] == :new
+  end
+
+  def changed?
+    @file_data[:status] == :changed
+  end
+
+  def renamed?(branch)
+    return @file_data[:old_name] if branch == :master
+    return @file_data[:new_name] if branch == :pull
+  end
+end

data/lib/scan_app.rb

@@ -0,0 +1,42 @@
+class ScanApp
+  class << self
+    EXCLUDE_FOLDERS = ['db/', 'spec/', 'config/']
+    ALLOWED_EXTENSIONS = ['.rb']
+
+    def call(path, except, only)
+      @except = except
+      @only = only
+      # list of all files from app dir recursively
+      @project_files = Dir.glob("#{path}/**/*")
+
+      filter_by_extension
+      exclude_default
+
+      exclude_files if @except
+      include_only_files if @only
+      @project_files
+    end
+
+    private
+
+    def exclude_default
+      @project_files = @project_files.reject { |project_file| match?(project_file, EXCLUDE_FOLDERS) }
+    end
+
+    def filter_by_extension
+      @project_files = @project_files.select { |project_file| project_file.end_with?(*ALLOWED_EXTENSIONS) }
+    end
+
+    def exclude_files
+      @project_files = @project_files.reject { |project_file| match?(project_file, @except) }
+    end
+
+    def include_only_files
+      @project_files = @project_files.select { |project_file| match?(project_file, @only) }
+    end
+
+    def match?(string, matches)
+      matches.any? { |item| string.include?(item) }
+    end
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: dudity
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dmitry Khramtsov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-11 00:00:00.000000000 Z
+dependencies: []
+description: Try DudeGL code visualization in your Rails projects
+email:
+- dp@khramtsov.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/download_service.rb
+- lib/dudes.rb
+- lib/dudity.rb
+- lib/git_diff_service.rb
+- lib/process_code_service.rb
+- lib/scan_app.rb
+homepage: https://github.com/dmikhr/Dudity
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Analyze Rails code with stick dudes
+test_files: []