# frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'rubycritic_small_badge/configuration'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # :nodoc:
          
        
      
        

          

            1
            

            

            module RubyCriticSmallBadge
          
        
      
        

          

            1
            

            

              @configuration = Configuration.new
          
        
      
        

          

            1
            

            

              def self.configure
          
        
      
        

          

            2
            

            

                yield config
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def self.config
          
        
      
        

          

            8
            

            

                @configuration
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            $LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
          
        
      
        

          

            1
            

            

            require 'rubycritic_small_badge/version'
          
        
      
        

          

            1
            

            

            require 'rubycritic_small_badge/report'
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module RubyCriticSmallBadge
          
        
      
        

          

            
            

            

              # Class to keep all the valid documentations that are required to build the
          
        
      
        

          

            
            

            

              # badge
          
        
      
        

          

            1
            

            

              class Configuration
          
        
      
        

          

            
            

            

                # Set up config variables.
          
        
      
        

          

            
            

            

                # rubocop:disable Metrics/MethodLength
          
        
      
        

          

            1
            

            

                def self.options
          
        
      
        

          

            5
            

            

                  {
          
        
      
        

          

            
            

            

                    with_analysers: false,
          
        
      
        

          

            
            

            

                    background: '#fff',
          
        
      
        

          

            
            

            

                    title_prefix: 'rubycritic',
          
        
      
        

          

            
            

            

                    title_background: '#555',
          
        
      
        

          

            
            

            

                    title_font: 'Verdana,sans-serif',
          
        
      
        

          

            
            

            

                    title_font_color: '#fff',
          
        
      
        

          

            
            

            

                    score_background_bad: '#ff0000',
          
        
      
        

          

            
            

            

                    score_background_unknown: '#cccc00',
          
        
      
        

          

            
            

            

                    score_background_good: '#4dc71f',
          
        
      
        

          

            
            

            

                    score_font: 'Verdana,sans-serif',
          
        
      
        

          

            
            

            

                    score_font_color: '#fff',
          
        
      
        

          

            
            

            

                    font: 'Verdana,sans-serif',
          
        
      
        

          

            
            

            

                    font_size: 11,
          
        
      
        

          

            
            

            

                    badge_height: 20,
          
        
      
        

          

            
            

            

                    badge_width: 200,
          
        
      
        

          

            
            

            

                    filename_prefix: 'rubycritic_badge',
          
        
      
        

          

            
            

            

                    output_path: 'badges',
          
        
      
        

          

            
            

            

                    rounded_border: true,
          
        
      
        

          

            
            

            

                    rounded_edge_radius: 3,
          
        
      
        

          

            
            

            

                    minimum_score: nil
          
        
      
        

          

            
            

            

                  }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                # rubocop:enable Metrics/MethodLength
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # set up class variables and getters/setters
          
        
      
        

          

            1
            

            

                options.each_key do |opt|
          
        
      
        

          

            26
            

            

                  define_method(opt) { instance_variable_get "@#{opt}" }
          
        
      
        

          

            41
            

            

                  define_method("#{opt}=") { |val| instance_variable_set("@#{opt}", val) }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def initialize(**opts)
          
        
      
        

          

            
            

            

                  RubyCriticSmallBadge::Configuration
          
        
      
        

          

            21
            

            

                    .options.merge(opts).each { |opt, v| send(:"#{opt}=", v) }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def to_hash
          
        
      
        

          

            6
            

            

                  hash = {}
          
        
      
        

          

            6
            

            

                  instance_variables.each do |var|
          
        
      
        

          

            120
            

            

                    hash[var.to_s.delete('@').to_sym] = instance_variable_get(var)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            6
            

            

                  hash
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'repo_small_badge/image'
          
        
      
        

          

            1
            

            

            require 'rubycritic_small_badge/configuration'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module RubyCriticSmallBadge
          
        
      
        

          

            
            

            

              # Basic Badge Formater Class that creates the badges.
          
        
      
        

          

            1
            

            

              class Report
          
        
      
        

          

            1
            

            

                def initialize(analysed_modules)
          
        
      
        

          

            3
            

            

                  @config = RubyCriticSmallBadge.config
          
        
      
        

          

            3
            

            

                  @analysed_modules = analysed_modules
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def generate_report
          
        
      
        

          

            3
            

            

                  mk_output_dir!
          
        
      
        

          

            3
            

            

                  score =  @analysed_modules.score
          
        
      
        

          

            3
            

            

                  @image = RepoSmallBadge::Image.new(map_image_config(state(score)))
          
        
      
        

          

            3
            

            

                  badge('score', 'score', score)
          
        
      
        

          

            3
            

            

                  true
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def max_score
          
        
      
        

          

            3
            

            

                  100.0
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def mk_output_dir!
          
        
      
        

          

            3
            

            

                  FileUtils.mkdir_p(@config.output_path)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def badge(name, title, score)
          
        
      
        

          

            3
            

            

                  value_txt = score_text(score)
          
        
      
        

          

            3
            

            

                  @image.config_merge(map_image_config(state(score)))
          
        
      
        

          

            3
            

            

                  @image.badge(name, title, value_txt)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def score_text(score)
          
        
      
        

          

            3
            

            

                  "#{score}/#{max_score}"
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def state(value)
          
        
      
        

          

            6
            

            

                  if @config.minimum_score&.positive?
          
        
      
        

          

            4
            

            

                    if value >= @config.minimum_score
          
        
      
        

          

            2
            

            

                      'good'
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            2
            

            

                      'bad'
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  else
          
        
      
        

          

            2
            

            

                    'unknown'
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def map_image_config(state)
          
        
      
        

          

            6
            

            

                  hash = {}
          
        
      
        

          

            6
            

            

                  @config.to_hash.map do |key, value|
          
        
      
        

          

            120
            

            

                    key = key
          
        
      
        

          

            
            

            

                          .to_s.sub(/^score_background_#{state}/, 'value_background')
          
        
      
        

          

            
            

            

                          .to_sym
          
        
      
        

          

            120
            

            

                    key = key.to_s.sub(/^score_/, 'value_').to_sym
          
        
      
        

          

            120
            

            

                    hash[key] = value
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            6
            

            

                  hash
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'spec_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe RubyCriticSmallBadge::Report do
          
        
      
        

          

            1
            

            

              include TestRubyCriticSmallBadge::Mocks
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#generate_report' do
          
        
      
        

          

            1
            

            

                context 'bad result' do
          
        
      
        

          

            2
            

            

                  subject { described_class.new(mock_analysed_modules(50.0)) }
          
        
      
        

          

            1
            

            

                  it do
          
        
      
        

          

            1
            

            

                    allow(RubyCriticSmallBadge.config).to receive(:minimum_score)
          
        
      
        

          

            
            

            

                      .and_return(90.0)
          
        
      
        

          

            1
            

            

                    mock_repo_badge_image(score: '50.0/100.0', state: 'bad')
          
        
      
        

          

            1
            

            

                    expect(subject.generate_report).to be_truthy
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'good result' do
          
        
      
        

          

            2
            

            

                  subject { described_class.new(mock_analysed_modules(100.0)) }
          
        
      
        

          

            1
            

            

                  it do
          
        
      
        

          

            1
            

            

                    allow(RubyCriticSmallBadge.config).to receive(:minimum_score)
          
        
      
        

          

            
            

            

                      .and_return(90.0)
          
        
      
        

          

            1
            

            

                    mock_repo_badge_image(score: '100.0/100.0')
          
        
      
        

          

            1
            

            

                    expect(subject.generate_report).to be_truthy
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'unknown result' do
          
        
      
        

          

            2
            

            

                  subject { described_class.new(mock_analysed_modules(100.0)) }
          
        
      
        

          

            1
            

            

                  it do
          
        
      
        

          

            1
            

            

                    mock_repo_badge_image(score: '100.0/100.0', state: 'unknown')
          
        
      
        

          

            1
            

            

                    expect(subject.generate_report).to be_truthy
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'spec_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe RubyCriticSmallBadge do
          
        
      
        

          

            1
            

            

              describe '#configure' do
          
        
      
        

          

            1
            

            

                context 'set config' do
          
        
      
        

          

            1
            

            

                  it do
          
        
      
        

          

            1
            

            

                    described_class.configure do |config|
          
        
      
        

          

            1
            

            

                      config.score_font = 'TestFont'
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            1
            

            

                    expect(described_class.config.score_font).to eq 'TestFont'
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'wrong config' do
          
        
      
        

          

            1
            

            

                  it do
          
        
      
        

          

            1
            

            

                    expect do
          
        
      
        

          

            1
            

            

                      described_class.configure do |config|
          
        
      
        

          

            1
            

            

                        config.wrong_value = 'test12'
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end.to raise_error(NoMethodError)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module RubyCritic
          
        
      
        

          

            1
            

            

              class Rating
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module TestRubyCriticSmallBadge
          
        
      
        

          

            1
            

            

              module Mocks
          
        
      
        

          

            
            

            

                # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize
          
        
      
        

          

            1
            

            

                def mock_repo_badge_image(score: 100, name: 'score',
          
        
      
        

          

            
            

            

                                          title: 'score',
          
        
      
        

          

            
            

            

                                          state: 'good',
          
        
      
        

          

            
            

            

                                          config: {},
          
        
      
        

          

            
            

            

                                          mock: instance_double('Image'))
          
        
      
        

          

            3
            

            

                  config = map_config_options(config, state)
          
        
      
        

          

            3
            

            

                  allow(RepoSmallBadge::Image).to receive(:new)
          
        
      
        

          

            
            

            

                    .with(config).and_return(mock)
          
        
      
        

          

            3
            

            

                  allow(mock).to receive(:config_merge).with(config).and_return(config)
          
        
      
        

          

            3
            

            

                  allow(mock).to receive(:badge).with(name, title, score)
          
        
      
        

          

            3
            

            

                  mock
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                # rubocop:enable Metrics/ParameterLists, Metrics/AbcSize
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def map_config_options(config_hash, state)
          
        
      
        

          

            3
            

            

                  hash = {}
          
        
      
        

          

            
            

            

                  RubyCriticSmallBadge::Configuration.options.merge(config_hash)
          
        
      
        

          

            3
            

            

                                                     .map do |key, value|
          
        
      
        

          

            60
            

            

                    key = key.to_s
          
        
      
        

          

            
            

            

                             .sub(/^score_background_#{state}/, 'value_background')
          
        
      
        

          

            
            

            

                             .to_sym
          
        
      
        

          

            60
            

            

                    key = key.to_s.sub(/^score_/, 'value_').to_sym
          
        
      
        

          

            60
            

            

                    hash[key] = value
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            3
            

            

                  hash
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def mock_analysed_modules(score = 100.0)
          
        
      
        

          

            3
            

            

                  analysed_mod_double = instance_double('RubyCritic::AnalysedModules')
          
        
      
        

          

            3
            

            

                  allow(analysed_mod_double)
          
        
      
        

          

            
            

            

                    .to receive('score')
          
        
      
        

          

            
            

            

                    .and_return(score)
          
        
      
        

          

            3
            

            

                  analysed_mod_double
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end