polishgeeks-dev-tools 1.0.0

data/lib/polishgeeks/dev-tools/command/yard.rb

@@ -0,0 +1,35 @@
+module PolishGeeks
+  module DevTools
+    module Command
+      # Command wrapper for Yard statistics
+      # @note It validates if everything is well documented
+      class Yard < Base
+        self.type = :validator
+
+        # Regexp used to match Yard output to check if there are things that
+        # are not documented or that include warnings
+        MATCH_REGEXP = /(Undocumented Objects|warn)/i
+
+        # Executes this command
+        # @return [String] command output
+        def execute
+          @output = Shell.new.execute("bundle exec yard stats #{options}")
+        end
+
+        # @return [Boolean] true if everything is documented and without warnings
+        def valid?
+          output[MATCH_REGEXP].nil?
+        end
+
+        private
+
+        # Settings for yard - they are directly taken from yardopts file in config dir
+        # @return [String] yard options that should be used to generate documentation
+        def options
+          config = File.join(DevTools.gem_root, 'config', 'yardopts')
+          File.readlines(config).join(' ').delete("\n") + ' --list-undoc'
+        end
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/command/yml_parser.rb

@@ -0,0 +1,85 @@
+module PolishGeeks
+  module DevTools
+    module Command
+      # Verifying parameters in example YAML config files
+      class YmlParser < Base
+        self.type = :validator
+
+        # Executes this command
+        # @return [Array] command output
+        def execute
+          @output = []
+          Dir[config_path].each do |file|
+            parsed_file = parse_yaml(file)
+            nil_params = check_params(parsed_file)
+            next if nil_params.empty?
+            @output << {
+              file: file,
+              lines: nil_params
+            }
+          end
+
+          @output
+        end
+
+        # @return [String] label with this validator description
+        def label
+          'Yaml parser'
+        end
+
+        # @return [String] error message
+        def error_message
+          err = 'Following yml files have nil as a value:'
+          @output.each { |row| err << file_error(row) }
+          err << "\n"
+        end
+
+        # @return [Boolean] true if all parameters in YAML files
+        # have not nil value
+        def valid?
+          @output.empty?
+        end
+
+        private
+
+        # @return [String] error message with file name and parameters which have nil value
+        def file_error(err_message)
+          err = "\n#{sanitize(err_message[:file])}:"
+          err_message[:lines].each { |line| err << "\n - Key '#{line}'" }
+          err
+        end
+
+        # @return [String] config path with all yaml files
+        def config_path
+          "#{File.expand_path(PolishGeeks::DevTools.app_root + '/config')}/**/*.yml.example"
+        end
+
+        # @param [String] file name that we want to sanitize
+        # @return [String] sanitized file name
+        # @example
+        #   file = /home/something/app/condig/settings.rb
+        #   sanitize(file) #=> settings.rb
+        def sanitize(file)
+          file.gsub!(PolishGeeks::DevTools.app_root + '/config/', '')
+          file
+        end
+
+        # @param [String] file name that we want to load
+        # @return [Hash] data serialization in YAML format
+        def parse_yaml(file)
+          YAML.load(File.open(file))
+        end
+
+        # recursion method to find key with nil value
+        # @param [Hash] hash which we want to check
+        # @return [Array] parameters with nil value
+        def check_params(hash)
+          hash.map do |k, v|
+            return k if v.nil?
+            check_params(v) if v.is_a?(::Hash)
+          end.compact.flatten
+        end
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/config.rb

@@ -0,0 +1,91 @@
+module PolishGeeks
+  module DevTools
+    # Configurator for enabling specific command runners
+    # @note No commands are enabled by default
+    # @example Enable only rubocop
+    # Config.configure do |conf|
+    #   conf.rubocop = true
+    # end
+    class Config
+      class << self
+        attr_accessor :config
+
+        # @return [PolishGeeks::DevTools::Config] config for dev tools
+        # @note We check if it initialized, because if user wants to use it
+        #   with all the commands enabled and without any changes, he won't create
+        #   a polishgeeks_dev_tools.rb initializer file so we need to configure it
+        #   with defaults
+        def config
+          @config || setup {}
+        end
+      end
+
+      attr_accessor :simplecov_threshold
+      attr_accessor :rspec_files_structure_ignored
+      attr_accessor :expires_in_files_ignored
+
+      # Available commands
+      # All commands will be executed in this order (first rubocop, then rspec, etc)
+      COMMANDS = %i(
+        readme
+        expires_in
+        brakeman
+        rubocop
+        haml_lint
+        allowed_extensions
+        yml_parser
+        rspec_files_names
+        rspec_files_structure
+        tasks_files_names
+        rspec
+        simplecov
+        coverage
+        yard
+        examples_comparator
+        rubycritic
+      )
+
+      COMMANDS.each do |attr_name|
+        attr_accessor attr_name
+
+        # @return [Boolean] is given command enabled
+        define_method :"#{attr_name}?" do
+          public_send(attr_name) == true
+        end
+      end
+
+      # Initializes configuration and turn on by default
+      # all the commands
+      def initialize
+        COMMANDS.each do |attr_name|
+          public_send(:"#{attr_name}=", true)
+        end
+
+        self.simplecov_threshold = 100
+      end
+
+      # Configurating method
+      def self.setup(&block)
+        self.config = new
+
+        config.detect_framework
+
+        block.call(config)
+        config.freeze
+      end
+
+      # Detects if we use Rails, Sinatra or nothing
+      # We need to set it because some of the commands might work only for Rails
+      # or Sinatra (like brakeman for example - only Rails)
+      def detect_framework
+        define_singleton_method :rails? do
+          !defined?(Rails).nil?
+        end
+
+        define_singleton_method :sinatra? do
+          !defined?(App).nil?
+        end
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/hash.rb

@@ -0,0 +1,24 @@
+module PolishGeeks
+  module DevTools
+    # Hash extensions required only by rake tasks in this rake file
+    # No need to add them to app itself
+    # We don't put it directly into hash, since it won't be used outside of
+    # this gem
+    class Hash < ::Hash
+      # @param other [Hash] different hash that we want to compare with
+      # @return [Boolean] true if both hashes have same keys and same keys structure
+      def same_key_structure?(other)
+        return false unless keys == other.keys &&
+            keys.all? { |inside| inside.is_a?(Symbol) || inside.is_a?(String) }
+
+        keys.all? do |inside|
+          if self[inside].is_a?(::Hash)
+            self.class.new.merge(self[inside]).same_key_structure?(other[inside])
+          else
+            !other[inside].is_a?(::Hash)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/logger.rb

@@ -0,0 +1,63 @@
+module PolishGeeks
+  module DevTools
+    # Basic logger used to print output from commands
+    class Logger
+      # Regexp used to get only the class name without module names
+      CLASS_NAME_REGEXP = /^.*::/
+
+      # Raised when it is a type of task that we don't recognize
+      class UnknownTaskType < StandardError; end
+      # Raised when any of tasks fail
+      class RequirementsError < StandardError; end
+
+      # Method will print appropriate output with colors and comments
+      # @param [PolishGeeks::DevTools::Command::Base] task that was executed
+      # @raise [PolishGeeks::DevTools::Logger::RequirementsError] raised when task
+      #   has failed
+      # @example Log output of a current_task
+      #   PolishGeeks::DevTools::Logger.new.log(current_task) #=> console output
+      def log(task)
+        if task.class.generator? || task.valid?
+          info(task)
+        else
+          fatal(task)
+          fail RequirementsError
+        end
+      end
+
+      private
+
+      # Will print message when task didn't fail while running
+      # @note Handles also generators that never fail
+      # @param [PolishGeeks::DevTools::Command::Base] task that was executed
+      # @raise [PolishGeeks::DevTools::Logger::UnknownTaskType] raised when task type is
+      #   not supported (we don't know how to handle it)
+      def info(task)
+        msg = 'GENERATED' if task.class.generator?
+        msg = 'OK' if task.class.validator?
+
+        fail UnknownTaskType unless msg
+
+        printf('%-40s %2s', "#{label(task)} ", "\e[32m#{msg}\e[0m\n")
+      end
+
+      # Will print message when task did fail while running
+      # @param [PolishGeeks::DevTools::Command::Base] task that was executed
+      def fatal(task)
+        printf('%-30s %20s', "#{label(task)} ", "\e[31mFAILURE\e[0m\n\n")
+        puts task.error_message + "\n"
+      end
+
+      # Generates a label describing a given task
+      # @note Will use a task class name if task doesn't respond to label method
+      # @param [PolishGeeks::DevTools::Command::Base] task that was executed
+      # @return [String] label describing task
+      # @example Get label for a current_task task
+      #   label(current_task) #=> 'Rubocop'
+      def label(task)
+        label = task.label if task.respond_to?(:label)
+        label || task.class.to_s.gsub(CLASS_NAME_REGEXP, '')
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/output_storer.rb

@@ -0,0 +1,17 @@
+require 'ostruct'
+
+module PolishGeeks
+  module DevTools
+    # Class used to store output from every executed command
+    # We store this data because it might be used by other commands
+    class OutputStorer < OpenStruct
+      # Creates a result storer instance
+      def initialize
+        init = {}
+        Config::COMMANDS.each { |command| init[command] = '' }
+
+        super(init)
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/runner.rb

@@ -0,0 +1,27 @@
+module PolishGeeks
+  module DevTools
+    # Class used to execute appropriate commands based on config settings
+    class Runner
+      # Executes the whole tool
+      # @param logger [PolishGeeks::DevTools::Logger] logger instance
+      # @example Run all defined elements
+      #   PolishGeeks::DevTools::Runner.new.execute(
+      #     PolishGeeks::DevTools::Logger.new
+      #   )
+      def execute(logger)
+        output = OutputStorer.new
+
+        Config::COMMANDS.each do |command|
+          next unless DevTools.config.public_send(:"#{command}?")
+
+          klass = command.to_s.gsub(/(?<=_|^)(\w)/) { |el| el.upcase }.gsub(/(?:_)(\w)/, '\1')
+          cmd = Object.const_get("PolishGeeks::DevTools::Command::#{klass}").new
+          cmd.stored_output = output
+          cmd.execute
+          output.public_send(:"#{command}=", cmd.output)
+          logger.log(cmd)
+        end
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/shell.rb

@@ -0,0 +1,16 @@
+module PolishGeeks
+  module DevTools
+    # Class wrapping shell commands executing
+    class Shell
+      # Executes a given command in a system shell and returns its output
+      # @param [String] command that should be executed
+      # @return [String] executed command output
+      # @example Run 'ls' command and assing the output
+      #   ls = PolishGeeks::DevTools::Shell.new.execute('ls')
+      #   print ls #=> 'app app.rb Capfile ...'
+      def execute(command)
+        `#{command}`
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/tasks/dev-tools.rake

@@ -0,0 +1,15 @@
+require 'rake'
+
+namespace :polishgeeks do
+  namespace :'dev-tools' do
+    desc 'Executed all tests and checks for given project'
+    task :check do
+      # Load Rails framework if it's Rails app
+      Rake::Task[:environment].invoke if Rake::Task.task_defined?(:environment)
+
+      PolishGeeks::DevTools::Runner.new.execute(
+        PolishGeeks::DevTools::Logger.new
+      )
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/version.rb

@@ -0,0 +1,8 @@
+# Module encapsulating PolishGeeks specific code
+module PolishGeeks
+  # Dev Tools for PolishGeeks developers
+  module DevTools
+    # Current version of dev tools
+    VERSION = '1.0.0'
+  end
+end

data/polishgeeks_dev_tools.gemspec

@@ -0,0 +1,36 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'rake'
+require 'polishgeeks/dev-tools/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'polishgeeks-dev-tools'
+  s.version     = PolishGeeks::DevTools::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Maciej Mensfeld']
+  s.email       = ['maciej@mensfeld.pl']
+  s.homepage    = ''
+  s.summary     = %q(Set of tools used when developing Ruby based apps)
+  s.description = %q(Set of tools used when developing Ruby based apps)
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+
+  s.add_dependency 'simplecov'
+  s.add_dependency 'rubycritic', '1.2.1'
+  s.add_dependency 'pry'
+  s.add_dependency 'yard'
+  s.add_dependency 'faker'
+  s.add_dependency 'shoulda'
+  s.add_dependency 'rspec'
+  s.add_dependency 'rubocop'
+  s.add_dependency 'timecop'
+  s.add_dependency 'brakeman'
+  s.add_dependency 'haml-lint'
+  s.add_dependency 'mongoid-rspec'
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = %w( lib )
+end

data/spec/lib/polishgeeks-dev-tools_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools do
+  subject { described_class }
+
+  describe '.gem_root' do
+    context 'when we want to get gem root path' do
+      let(:path) { Dir.pwd }
+      it do
+        expect(subject.gem_root).to eq path
+      end
+    end
+  end
+
+  describe '.app_root' do
+    context 'when we want to get app root path' do
+      before do
+        expect(ENV).to receive(:[]).with('BUNDLE_GEMFILE').and_return('/')
+      end
+
+      it { expect(subject.app_root).to eq '/' }
+    end
+  end
+
+  describe '.setup' do
+    let(:config_block) { ->{} }
+
+    it 'should pass it to Config setup method' do
+      expect(described_class::Config)
+        .to receive(:setup)
+
+      subject.setup(&config_block)
+    end
+  end
+end