rails_dt 0.1.4 → 1.2.0

data/lib/dt/config.rb

@@ -0,0 +1,74 @@
+
+require "pathname"
+
+require_relative "../dt"
+
+module DT
+  class Config
+    attr_writer :env, :rails
+
+    def initialize(attrs = {})
+      attrs.each { |k, v| public_send("#{k}=", v) }
+    end
+
+    # A copy of <tt>ENV</tt> for value-reading purposes.
+    # @return [Hash] Default is <tt>ENV.to_h</tt>.
+    def env
+      @env ||= ENV.to_h
+    end
+
+    # Top-level Rails module or substitute value.
+    # @return [Module] <tt>Rails</tt>.
+    # @return [nil]
+    def rails
+      if instance_variable_defined?(k = :@rails)
+        instance_variable_get(k)
+      else
+        instance_variable_set(k, (Rails if defined? Rails))
+      end
+    end
+
+    # @!attribute root_path
+    # @return [Pathname]
+    def root_path
+      @root_path ||= begin
+        # 1. Fetch "raw" value, suitable as `Pathname` argument.
+        s = if rails
+          # Rails project.
+          rails.root
+        else
+          # Non-Rails project, attempt to guess.
+          if (fn = env["BUNDLE_GEMFILE"])
+            # The project has a Gemfile, hook it up.
+            File.expand_path("..", fn)
+          else
+            # Default to pwd otherwise.
+            Dir.pwd
+          end
+        end
+
+        # 2. Attempt to absolutize raw path, but in a non-fatal way.
+        begin
+          # See "Implementation notes".
+          Pathname(s).realpath
+        rescue Errno::ENOENT
+          Pathname(s)
+        end
+      end
+    end
+
+    def root_path=(s)
+      @root_path = if s.is_a? Pathname
+        s
+      else
+        Pathname(s)
+      end
+    end
+  end
+end
+
+#
+# Implementation notes:
+#
+# * We call `Pathname` as `Pathname` to be able to stub them as own methods during testing. Other
+#   than that we should be using `Kernel.Pathname` which is also usable, but is more ugly.

data/lib/dt/instance.rb

@@ -0,0 +1,117 @@
+
+require_relative "../dt"
+
+module DT
+  class Instance
+    attr_writer \
+      :conf,
+      :dt_logger,
+      :is_rails_console,
+      :rails_logger,
+      :stderr
+
+    def initialize(attrs = {})
+      attrs.each { |k, v| public_send("#{k}=", v) }
+    end
+
+    # The configuration object.
+    # @return [Config] <tt>DT.conf</tt>.
+    def conf
+      # NOTE: See "Implementation notes".
+      @conf ||= DT.conf
+    end
+
+    # File logger, an instance of Ruby's <tt>Logger</tt>.
+    # @return [Logger] Default is a <tt>Logger</tt> writing to <tt>log/dt.log</tt>.
+    def dt_logger
+      if instance_variable_defined?(k = :@dt_logger)
+        instance_variable_get(k)
+      else
+        instance_variable_set(k, begin
+          Logger.new(conf.root_path + "log/dt.log")
+        rescue Errno::ENOENT
+          nil
+        end)
+      end
+    end
+
+    # <tt>true</tt> if running in Rails console.
+    # @return [Boolean]
+    def is_rails_console
+      if instance_variable_defined?(k = :@is_rails_console)
+        instance_variable_get(k)
+      else
+        instance_variable_set(k, conf.rails && conf.rails.const_defined?(:Console))
+      end
+    end
+    alias_method :rails_console?, :is_rails_console
+
+    # An object to use as log in Rails mode.
+    # @return [ActiveSupport::Logger] Default is <tt>conf.rails.logger</tt>.
+    def rails_logger
+      if instance_variable_defined?(k = :@rails_logger)
+        instance_variable_get(k)
+      else
+        instance_variable_set(k, conf.rails && conf.rails.logger)
+      end
+    end
+
+    # A writable IO stream to print to. Default is <tt>STDERR</tt>.
+    # @return [IO]
+    def stderr
+      @stderr ||= STDERR
+    end
+
+    #--------------------------------------- Actions
+
+    # Lower level implementation of <tt>p</tt>.
+    #
+    # * Print to {#dt_logger} if one is available.
+    # * Print to {#rails_logger} if one is available.
+    # * Print to {#stderr} if not running in {#rails_console?}.
+    #
+    # @param caller [Array<Array<file, line>>]
+    # @return nil
+    # @see DT.p
+    def _p(caller, *args)
+      file, line = caller[0].split(":")
+      file_rel = begin
+        Pathname(file).relative_path_from(conf.root_path)
+      rescue ArgumentError
+        # If `file` is "" or other non-path, `relative_path_from` will raise an error.
+        # Fall back to original value then.
+        file
+      end
+
+      args.each do |arg|
+        value = case arg
+        when String
+          arg
+        else
+          arg.inspect
+        end
+
+        msg = "[DT #{file_rel}:#{line}] #{value}"
+
+        # Fire!
+        dt_logger.debug(msg) if dt_logger
+        if rails_logger
+          rails_logger.debug(msg)
+          stderr.puts(msg) if stderr && !rails_console?
+        else
+          stderr.puts(msg) if stderr
+        end
+      end
+
+      # Be like `puts`.
+      nil
+    end
+  end
+end
+
+#
+# Implementation notes:
+#
+# * `DT.conf` acts as a subsystem-wide global, all instance copies point to the same object. The
+#   reason for that is that it's possible that certain configuration options will be added in the
+#   future.

data/lib/rails_dt.rb

@@ -1,2 +1,3 @@
-# A bridge between names.
-require File.join(File.dirname(__FILE__), "dt")
+
+# Main gem require. Load all libraries.
+Dir[File.expand_path("../**/*.rb", __FILE__)].each { |fn| require fn }

data/lib/rails_dt/version.rb

@@ -0,0 +1,4 @@
+
+module RailsDt
+  VERSION = "1.2.0"
+end

data/rails_dt.gemspec

@@ -1,56 +1,18 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
 
-Gem::Specification.new do |s|
-  s.name = %q{rails_dt}
-  s.version = "0.1.4"
+# TODO: Finalize.
+#require_relative ""
+require File.expand_path("../lib/rails_dt/version", __FILE__)
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+Gem::Specification.new do |s|
+  s.name = "rails_dt"
+  s.version = RailsDt::VERSION
   s.authors = ["Alex Fortuna"]
-  s.date = %q{2011-07-13}
-  s.description = %q{Rails Debug Toolkit}
-  s.email = %q{alex.r@askit.org}
-  s.extra_rdoc_files = [
-    "README.html",
-    "README.md"
-  ]
-  s.files = [
-    "MIT-LICENSE",
-    "README.html",
-    "README.md",
-    "Rakefile",
-    "VERSION.yml",
-    "generators/rails_dt/USAGE",
-    "generators/rails_dt/WARNING",
-    "generators/rails_dt/rails_dt_generator.rb",
-    "generators/rails_dt/templates/INSTALL",
-    "generators/rails_dt/templates/dt.css",
-    "generators/rails_dt/templates/dt.rb",
-    "init.rb",
-    "lib/dt.rb",
-    "lib/dt/action_controller_extensions.rb",
-    "lib/generators/rails_dt/USAGE",
-    "lib/generators/rails_dt/rails_dt_generator.rb",
-    "lib/generators/rails_dt/templates/INSTALL",
-    "lib/generators/rails_dt/templates/dt.css",
-    "lib/generators/rails_dt/templates/dt.rb",
-    "lib/rails_dt.rb",
-    "rails_dt.gemspec"
-  ]
-  s.homepage = %q{http://github.com/dadooda/rails_dt}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.2}
-  s.summary = %q{Rails Debug Toolkit}
+  s.email = ["fortunadze@gmail.com"]
+  s.homepage = "http://github.com/dadooda/rails_dt"
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
+  s.summary = "Ruby/Rails debug toolkit"
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
 end
-

data/spec/lib/dt/config_spec.rb

@@ -0,0 +1,76 @@
+
+module DT
+  RSpec.describe Config do
+    use_custom_let(:let_a, :attrs)
+
+    let(:instance) { described_class.new(attrs) }
+
+    subject { instance.send(m) }
+
+    describe "#env" do
+      let_m
+      it { is_expected.to eq ENV.to_h }
+    end
+
+    describe "#rails" do
+      let_m
+      let_a(:rails)
+      # NOTE: We can't reliably test for constant probing since `defined?` is a language keyword.
+      context_when rails: :signature do
+        it { is_expected.to eq :signature }
+      end
+    end
+
+    describe "#root_path" do
+      let_m
+      let(:pathname_double) { double "Pathname(raw_path)" }
+      let_a(:env)
+      let_a(:rails)
+
+      before :each do
+        expect(instance).to receive(:Pathname).with(raw_path).once.and_return(pathname_double)
+        expect(pathname_double).to receive(:realpath).once.and_return(:signature)
+      end
+
+      context "when Rails" do
+        let(:raw_path) { Pathname("/path/to/project") }
+        let_a(:rails) { double "rails" }
+        it do
+          expect(rails).to receive(:root).once.and_return(raw_path)
+          is_expected.to eq :signature
+        end
+      end
+
+      context_when rails: nil do
+        context do
+          let(:bundle_gemfile) { self.class.bundle_gemfile }
+          let(:raw_path) { self.class.raw_path }
+
+          define_singleton_method(:raw_path) { "/path/to/project" }
+          define_singleton_method(:bundle_gemfile) { "#{raw_path}/Gemfile"}
+
+          context_when env: {"BUNDLE_GEMFILE" => bundle_gemfile } do
+            it { is_expected.to eq :signature }
+          end
+        end
+
+        context_when env: {} do
+          let(:raw_path) { Dir.pwd }
+          it do
+            subject
+          end
+        end
+      end
+    end # describe "#root_path"
+
+    describe "#root_path=" do
+      let_a(:root_path)
+
+      subject { instance.root_path }
+
+      context_when root_path: "/some/path" do
+        it { is_expected.to eq Pathname("/some/path") }
+      end
+    end
+  end
+end

data/spec/lib/dt/instance_spec.rb

@@ -0,0 +1,173 @@
+
+module DT
+  RSpec.describe Instance do
+    use_custom_let(:let_a, :attrs)
+
+    let(:instance) { described_class.new(attrs) }
+
+    subject { instance.send(m) }
+
+    describe "attributes" do
+      describe "#conf" do
+        let_m
+        it do
+          expect(DT).to receive(:conf).once.and_return(:signature)
+          is_expected.to eq :signature
+        end
+      end
+
+      describe "#dt_logger" do
+        let_m
+        it do
+          expect(Logger).to receive(:new).and_return(:signature)
+          expect(subject).to eq :signature
+        end
+      end
+
+      describe "#is_rails_console" do
+        let_m
+        let_a(:conf) { double "conf" }
+        let(:rails_double) { double "rails" }
+
+        before :each do
+          expect(conf).to receive(:rails).at_least(:once).and_return(rails_double)
+          expect(rails_double).to receive(:const_defined?).with(:Console).and_return(is_const_defined)
+        end
+
+        context_when is_const_defined: true do
+          it { is_expected.to be true }
+        end
+
+        context_when is_const_defined: false do
+          it { is_expected.to be false }
+        end
+      end
+
+      describe "#rails_logger" do
+        let_m
+        let_a(:conf) { double "conf" }
+
+        context "when Rails mode" do
+          let(:rails_double) { double "rails" }
+
+          it do
+            expect(conf).to receive(:rails).at_least(:once).and_return(rails_double)
+            expect(rails_double).to receive(:logger).and_return(:signature)
+            expect(subject).to eq :signature
+          end
+        end
+
+        context "when non-Rails mode" do
+          it do
+            expect(conf).to receive(:rails).at_least(:once).and_return(nil)
+            expect(subject).to be nil
+          end
+        end
+      end
+
+      describe "#stderr" do
+        let_m
+        it { is_expected.to eq STDERR }
+      end
+
+      it { expect(instance).to alias_method(:rails_console?, :is_rails_console) }
+    end # describe "attributes"
+
+    describe "actions" do
+      describe "#_p" do
+        let_m
+
+        let_a(:conf) { Config.new(root_path: "/some/path") }
+        let_a(:is_rails_console)
+
+        # Output channels.
+        let_a(:dt_logger) { double "dt_logger" }        # "1".
+        let_a(:rails_logger) { double "rails_logger" }  # "2".
+        let_a(:stderr) { double "stderr" }      # This one is a "backup" output channel which pairs with `rails_logger`.
+
+        let(:args) { ["Message", {kk: 12}] }
+        let(:caller) do
+          [
+            "/some/path/lib/file2:20 in `method2'",
+            "/some/path/lib/file1:10 in `method1'",
+          ]
+        end
+        let(:msg1) { "#{pfx} Message" }
+        let(:msg2) { "#{pfx} {:kk=>12}"}
+        let(:pfx) { "[DT lib/file2:20 in `method2']" }
+
+        subject { instance.send(m, caller, *args) }
+
+        # Disable output channels in combos to leave out just one.
+        # Order: dt_logger, rails_logger, stdout (via `is_rails_console`).
+
+        def expect_to_dt
+          expect(dt_logger).to receive(:debug).once.with(msg1)
+          expect(dt_logger).to receive(:debug).once.with(msg2)
+        end
+
+        def expect_to_rails
+          expect(rails_logger).to receive(:debug).once.with(msg1)
+          expect(rails_logger).to receive(:debug).once.with(msg2)
+        end
+
+        def expect_to_stderr
+          expect(stderr).to receive(:puts).once.with(msg1)
+          expect(stderr).to receive(:puts).once.with(msg2)
+        end
+
+        # Disable 1.
+        context_when dt_logger: nil do
+          context_when is_rails_console: true do
+            it do
+              expect_to_rails
+              subject
+            end
+          end
+
+          it do
+            expect_to_rails
+            expect_to_stderr
+            subject
+          end
+        end
+
+        # Disable 2.
+        context_when rails_logger: nil do
+          it do
+            expect_to_dt
+            expect_to_stderr
+            subject
+          end
+        end
+
+        # Disable 1 and 2.
+        context_when dt_logger: nil, rails_logger: nil do
+          it do
+            expect_to_stderr
+            subject
+          end
+        end
+
+        # Disable all.
+        context_when dt_logger: nil, rails_logger: nil, stderr: nil do
+          it "generally works" do
+            # Just expect nothing to crash by using `nil`.
+            # RSpec negative expectations are warned against (which I think is right).
+            subject
+          end
+        end
+
+        # Generic case, all channels enabled.
+        context_when is_rails_console: false do
+          it do
+            expect_to_dt
+            expect_to_rails
+            expect_to_stderr
+            subject
+          end
+        end
+      end
+    end
+  end
+end