chronicles 0.0.1

data/config/metrics/cane.yml

@@ -0,0 +1,5 @@
+---
+abc_max: "10"
+line_length: "80"
+no_doc: "y"
+no_readme: "y"

data/config/metrics/churn.yml

@@ -0,0 +1,6 @@
+---
+ignore_files:
+- spec
+- config
+minimum_churn_count: 0
+start_date: "1 year ago"

data/config/metrics/flay.yml

@@ -0,0 +1,2 @@
+---
+minimum_score: 5

data/config/metrics/metric_fu.yml

@@ -0,0 +1,15 @@
+---
+folders: # The list of folders to be used by any metric.
+- lib
+- app
+metrics: # The list of allowed metrics. The other metrics are disabled.
+- cane
+- churn
+- flay
+- flog
+- reek
+- roodi
+- saikuro
+format: html
+output: tmp/metric_fu
+verbose: false

data/config/metrics/reek.yml

@@ -0,0 +1 @@
+---

data/config/metrics/roodi.yml

@@ -0,0 +1,24 @@
+---
+AssignmentInConditionalCheck:
+CaseMissingElseCheck:
+ClassLineCountCheck:
+  line_count: 300
+ClassNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ClassVariableCheck:
+CyclomaticComplexityBlockCheck:
+  complexity: 4
+CyclomaticComplexityMethodCheck:
+  complexity: 8
+EmptyRescueBodyCheck:
+ForLoopCheck:
+MethodLineCountCheck:
+  line_count: 20
+MethodNameCheck:
+  pattern: !ruby/regexp /^[\||\^|\&|\!]$|^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+ModuleLineCountCheck:
+  line_count: 300
+ModuleNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ParameterNumberCheck:
+  parameter_count: 5

data/config/metrics/rubocop.yml

@@ -0,0 +1,77 @@
+---
+# settings added by the 'hexx-suit' module
+# output: "tmp/rubocop"
+# format: "html"
+
+AllCops:
+  Exclude:
+    - '**/db/schema.rb'
+
+Lint/HandleExceptions:
+  Exclude:
+    - '**/*_spec.rb'
+
+Lint/RescueException:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/AccessorMethodName:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/Documentation:
+  Enabled: false
+
+Style/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/EmptyLinesAroundMethodBody:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Style/EmptyLineBetweenDefs:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Style/MethodCallParentheses:
+  Exclude:
+    - '**/updater.rb'
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Style/SingleLineMethods:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+Style/SpecialGlobalVars:
+  Exclude:
+    - '**/Gemfile'
+    - '**/*.gemspec'
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrivialAccessors:
+  Exclude:
+    - '**/*_spec.rb'

data/config/metrics/saikuro.yml

@@ -0,0 +1,3 @@
+---
+warn_cyclo:  4
+error_cyclo: 6

data/config/metrics/simplecov.yml

@@ -0,0 +1,8 @@
+---
+output: tmp/coverage
+filters: # The list of paths to be excluded from coverage checkup
+- "spec/"
+- "config/"
+groups: # The list of groups to be shown in the coverage report
+  Libraries: "lib/"
+  Application: "app/"

data/config/metrics/yardstick.yml

@@ -0,0 +1,37 @@
+---
+# Settings added by the 'hexx-suit' gem
+output: "tmp/yardstick/output.log"
+path: "lib/**/*.rb"
+rules:
+  ApiTag::Presence:
+    enabled: true
+    exclude: []
+  ApiTag::Inclusion:
+    enabled: true
+    exclude: []
+  ApiTag::ProtectedMethod:
+    enabled: true
+    exclude: []
+  ApiTag::PrivateMethod:
+    enabled: false
+    exclude: []
+  ExampleTag:
+    enabled: true
+    exclude: []
+  ReturnTag:
+    enabled: true
+    exclude: []
+  Summary::Presence:
+    enabled: true
+    exclude: []
+  Summary::Length:
+    enabled: true
+    exclude: []
+  Summary::Delimiter:
+    enabled: true
+    exclude: []
+  Summary::SingleLine:
+    enabled: true
+    exclude: []
+threshold: 100
+verbose: false

data/lib/chronicles.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+require_relative "chronicles/version"
+require_relative "chronicles/methods"
+require_relative "chronicles/updater"
+require_relative "chronicles/injector"
+
+# The module adds features to keep chronicles of object's methods calls
+module Chronicles
+
+  # @!attribute [r] chronicles
+  # Returns the array of object methods having been called
+  #
+  # @return [Array<Symbol>]
+  def chronicles
+    @chronicles ||= []
+  end
+
+  # Starts registation of calls of the selected methods of the object
+  #
+  # @example
+  #   class Test
+  #     include Chronicles
+  #   end
+  #
+  #   test = Test.new
+  #   test.start_chronicles only: :foo
+  #   test.foo
+  #   test.bar
+  #   test.baz
+  #   test.foo
+  #   test.chronicles # => [:foo, :foo]
+  #
+  # @param [Hash] options
+  #   describes the selection of methods to include to chronicles
+  # @option options [Boolean] :public (true)
+  #   whether public methods should be looked after
+  # @option options [Boolean] :protected (true)
+  #   whether protected methods should be looked after
+  # @option options [Boolean] :private (true)
+  #   whether private methods should be looked after
+  # @option options [Array<#to_sym>] :except ([])
+  #   the whitelist of methods that shouldn't be looked after
+  # @option options [Array<#to_sym>] :only ([])
+  #   the whitelist of methods that should be looked after
+  #
+  # @return [undefined]
+  def start_chronicles(**options)
+    Injector.new(self, "chronicles << __method__", options).run
+  end
+
+  # Stops registation of calls of the selected methods of the object
+  #
+  # @example
+  #   class Test
+  #     include Chronicles
+  #   end
+  #
+  #   test = Test.new
+  #   test.start_chronicles
+  #   test.foo
+  #   test.bar
+  #   test.baz
+  #   test.chronicles # => [:foo, :bar, :baz]
+  #
+  #   test.stop_chronicles except: :foo
+  #   test.foo
+  #   test.bar
+  #   test.baz
+  #   test.chronicles # => [:foo, :bar, :baz, :foo]
+  #
+  # @param  (see #start_chronicles)
+  # @option (see #start_chronicles)
+  #
+  # @return [undefined]
+  def stop_chronicles(**options)
+    Injector.new(self, options).run
+  end
+
+end # module Chronicles

data/lib/chronicles/injector.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Chronicles
+
+  # Injects the code to object methods selected by options
+  #
+  # @private
+  class Injector
+
+    attr_reader :object, :code, :list
+
+    def initialize(object, code = nil, **options)
+      @object = object
+      @code   = code
+      @list   = Methods.new(object, options)
+    end
+
+    def updaters
+      list.map { |name| Updater.new(object, name, code) }
+    end
+
+    def run
+      updaters.each(&:run)
+    end
+
+  end # class Injector
+
+end # module Chronicles

data/lib/chronicles/methods.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Chronicles
+
+  # Array of object methods selected by options
+  #
+  # @private
+  class Methods < Array
+
+    def initialize(object, **options)
+      @object  = object
+      @options = options
+      super(whitelist.empty? ? list : list & whitelist)
+    end
+
+    private
+
+    attr_reader :object, :options
+
+    def list
+      [public_list, protected_list, private_list].flatten.compact - blacklist
+    end
+
+    def whitelist
+      Array(options[:only]).map(&:to_sym)
+    end
+
+    def blacklist
+      Array(options[:except]).map(&:to_sym)
+    end
+
+    def public_list
+      return if options[:public].equal?(false)
+      object.public_methods - Object.public_instance_methods - own_list
+    end
+
+    def own_list
+      %i(chronicles start_chronicles stop_chronicles)
+    end
+
+    def protected_list
+      return if options[:protected].equal?(false)
+      object.protected_methods
+    end
+
+    def private_list
+      return if options[:private].equal?(false)
+      object.private_methods - Object.private_instance_methods
+    end
+
+  end # class Methods
+
+end # module Chronicles

data/lib/chronicles/updater.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Chronicles
+
+  # Reloads object method
+  #
+  # @private
+  class Updater
+
+    def initialize(object, name, code = nil)
+      @object = object
+      @name   = name
+      @code   = code
+      type
+    end
+
+    attr_reader :object, :name, :code
+
+    def type
+      @type ||= %w(public private protected).detect do |item|
+        object.public_send("#{ item }_methods").include? name
+      end
+    end
+
+    def klass
+      object.singleton_class
+    end
+
+    def run
+      redefine_method
+      protect_method
+    end
+
+    private
+
+    def redefine_method
+      code = code()
+      klass.__send__ :define_method, name do |*args|
+        instance_eval(code) if code
+        super(*args)
+      end
+    end
+
+    def protect_method
+      klass.instance_eval "#{ type } :#{ name }"
+    end
+
+  end # class Updater
+
+end # module Chronicles

data/lib/chronicles/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module Chronicles
+
+  # The semantic version of the module.
+  # @see http://semver.org/ Semantic versioning 2.0
+  VERSION = "0.0.1".freeze
+
+end # module Chronicles

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+begin
+  require "hexx-suit"
+  Hexx::Suit.load_metrics_for(self)
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.load_metrics_for(self)
+end
+
+# Loads the code under test
+require "chronicles"

data/spec/tests/chronicles/injector_spec.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+describe Chronicles::Injector do
+
+  let(:object)  { double foo: nil, bar: nil, baz: nil       }
+  let(:options) { { only: %i(foo bar), private: false }     }
+  let(:code)    { "chronicles << __method__"                }
+  subject       { described_class.new object, code, options }
+
+  describe "#object" do
+
+    it "is initialized" do
+      expect(subject.object).to eq object
+    end
+
+  end # describe #object
+
+  describe "#list" do
+
+    let(:list) { Chronicles::Methods.new(object, options).to_a }
+
+    it "is initialized" do
+      expect(subject.list).to eq list
+    end
+
+  end # describe #list
+
+  describe "#code" do
+
+    it "is initialized" do
+      expect(subject.code).to eq code
+    end
+
+    it "can be nil" do
+      subject = described_class.new object, options
+      expect(subject.code).to be_nil
+    end
+
+  end # describe #code
+
+  describe "#updaters" do
+
+    let(:list) { %i(foo bar baz) }
+    before     { allow(subject).to receive(:list).and_return list }
+
+    it "returns updaters" do
+      subject.updaters.each do |updater|
+        expect(updater).to be_kind_of Chronicles::Updater
+      end
+    end
+
+    it "constructed for #object" do
+      subject.updaters.each do |updater|
+        expect(updater.object).to eq subject.object
+      end
+    end
+
+    it "constructed for #list of methods" do
+      expect(subject.updaters.map(&:name)).to eq subject.list
+    end
+
+    it "constructed for #code" do
+      subject.updaters.each do |updater|
+        expect(updater.code).to eq subject.code
+      end
+    end
+
+  end # describe #updaters
+
+  describe ".run" do
+
+    let(:updaters) { 2.times.map { double run: nil } }
+    before { allow(subject).to receive(:updaters).and_return updaters }
+
+    it "runs updaters" do
+      updaters.each { |updater| expect(updater).to receive(:run) }
+      subject.run
+    end
+
+  end # describe .run
+
+end # describe Chronicles::Injector