rails_dt 0.1.4 → 1.2.0

data/spec/lib/dt_spec.rb

@@ -0,0 +1,14 @@
+
+RSpec.describe DT do
+  subject { described_class.public_send(m) }
+
+  describe ".conf" do
+    let_m
+    it { is_expected.to be_a described_class::Config }
+  end
+
+  describe ".instance" do
+    let_m
+    it { is_expected.to be_a described_class::Instance }
+  end
+end

data/spec/lib/rails_dt_spec.rb

@@ -0,0 +1,6 @@
+
+describe RailsDt do
+  describe "VERSION" do
+    it { expect(described_class::VERSION).to eq "1.2.0" }
+  end
+end

data/spec/lib/spec/alias_method_matcher_spec.rb

@@ -0,0 +1,16 @@
+
+RSpec.describe "`alias_method` matcher" do
+  describe "klass" do
+    let(:klass) do
+      Class.new do
+        def is_one
+        end
+        alias_method :one?, :is_one
+      end
+    end
+
+    subject { klass.new }
+
+    it { is_expected.to alias_method(:one?, :is_one) }
+  end
+end

data/spec/lib/spec/context_when_spec.rb

@@ -0,0 +1,32 @@
+
+require "json"
+
+RSpec.describe ".context_when" do
+  context "when default" do
+    context_when a: 1, "b" => 2, x: "y" do
+      description = self.description
+      it { expect(description).to eq 'when {a: 1, "b"=>2, x: "y"}' }
+      it { expect { c }.to raise_error(NameError, /^undefined local variable or method `c'/) }
+      it { expect([a, b, x]).to eq [1, 2, "y"] }
+    end
+  end
+
+  context "when customized" do
+    context_when({a: 1, x: "y"}, format_proc: ->(h) { "when #{h.to_json}" }) do
+      description = self.description
+      it { expect(description).to eq 'when {"a":1,"x":"y"}' }
+      it { expect([a, x]).to eq [1, "y"] }
+    end
+  end
+
+  context "with `def` in the block" do
+    context_when a: 1 do
+      def ar
+        [a, 2]
+      end
+
+      it { expect(a).to eq 1 }
+      it { expect(ar).to eq [1, 2] }
+    end
+  end
+end

data/spec/lib/spec/let_m_spec.rb

@@ -0,0 +1,104 @@
+
+RSpec.describe ".let_m" do
+  describe "describe/it scope" do
+    describe "#some_method" do
+      let_m
+      self_m = m
+      it { expect(self_m).to eq :some_method }
+      it { expect(m).to eq :some_method }
+    end
+  end
+
+  describe "`let` argument handling" do
+    describe "#some_method" do
+      let_m(:x)
+      self_x = x
+      it { expect(self_x).to eq :some_method }
+      it { expect(x).to eq :some_method }
+    end
+  end
+
+  context "when invalid argument like ..." do
+    def self.doit
+      # OPTIMIZE: There's a more optimal implementation of this in `extract_to_spec.rb`.
+      begin; let_m; rescue ArgumentError => e; let(:message) { e.message }; end
+    end
+
+    describe "#some_method!!" do
+      doit
+      it { expect(message).to eq "Unknown description format: \"#some_method!!\"" }
+    end
+
+    describe "#some method" do
+      doit
+      it { expect(message).to eq "Unknown description format: \"#some method\"" }
+    end
+
+    describe "method" do
+      doit
+      it { expect(message).to eq "Unknown description format: \"method\"" }
+    end
+  end
+
+  context "when valid argument like ..." do
+    describe "#some_method" do
+      let_m
+      it { expect(m).to eq :some_method }
+    end
+
+    describe "#some_method?" do
+      let_m
+      it { expect(m).to eq :some_method? }
+    end
+
+    describe "#some_method!" do
+      let_m
+      it { expect(m).to eq :some_method! }
+    end
+
+    describe ".some_method" do
+      let_m
+      it { expect(m).to eq :some_method }
+    end
+
+    describe "::some_method" do
+      let_m
+      it { expect(m).to eq :some_method }
+    end
+
+    describe "#[]" do
+      let_m
+      it { expect(m).to eq :[] }
+    end
+
+    describe ".[]" do
+      let_m
+      it { expect(m).to eq :[] }
+    end
+
+    describe "::[]" do
+      let_m
+      it { expect(m).to eq :[] }
+    end
+
+    describe "GET some_action" do
+      let_m
+      it { expect(m).to eq :some_action }
+    end
+
+    describe "POST some_action" do
+      let_m
+      it { expect(m).to eq :some_action }
+    end
+
+    describe "PUT some_action" do
+      let_m
+      it { expect(m).to eq :some_action }
+    end
+
+    describe "DELETE some_action" do
+      let_m
+      it { expect(m).to eq :some_action }
+    end
+  end
+end

data/spec/lib/spec/use_custom_let_spec.rb

@@ -0,0 +1,46 @@
+
+RSpec.describe ".use_custom_let" do
+  use_custom_let(:let_a, :attrs)
+
+  describe "straight usage" do
+    describe "attrs" do
+      let_a(:name) { "Joe" }
+      let_a(:age) { 25 }
+      let(:gender) { :male }
+      it do
+        expect(name).to eq "Joe"
+        expect(age).to eq 25
+        expect(attrs).to eq(name: "Joe", age: 25)
+        expect(attrs(include: [:gender])).to eq(name: "Joe", age: 25, gender: :male)
+      end
+    end
+  end
+
+  describe "declarative (no block) usage" do
+    let_a(:name)
+
+    subject { attrs }
+
+    context "when no other `let` value" do
+      it { is_expected.to eq({}) }
+    end
+
+    context "when `let`" do
+      let(:name) { "Joe" }
+      it { is_expected.to eq(name: "Joe") }
+    end
+
+    context "when `let_a`" do
+      let_a(:name) { "Joe" }
+      it { is_expected.to eq(name: "Joe") }
+    end
+
+    context_when name: "Joe" do
+      context_when name: "Moe" do
+        it { is_expected.to eq(name: "Moe") }
+      end
+
+      it { is_expected.to eq(name: "Joe") }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+
+# Self.
+require "rails_dt"
+
+# Load support files. Sorted alphabetically for greater control.
+Dir[File.expand_path("support/**/*.rb", __dir__)].sort.each { |fn| require fn }

data/spec/support/00extend_x.rb

@@ -0,0 +1,23 @@
+
+#
+# Convenience methods to extend RSpec metalanguage.
+# This file must be loaded before other support files.
+#
+
+module Kernel
+  def extend_describe(&block)
+    raise ArgumentError, "Code block must be given" unless block
+
+    ::RSpec.configure do |config|
+      config.extend Module.new(&block)
+    end
+  end
+
+  def extend_it(&block)
+    raise ArgumentError, "Code block must be given" unless block
+
+    ::RSpec.configure do |config|
+      config.include Module.new(&block)
+    end
+  end
+end

data/spec/support/alias_method_matcher.rb

@@ -0,0 +1,20 @@
+
+#
+# Method alias matcher.
+#
+#   describe User do
+#     it { is_expected.to alias_method(:admin?, :is_admin) }
+#   end
+#
+# Originally from: https://gist.github.com/1950961, but heavily reworked consistency-wise.
+#
+
+RSpec::Matchers.define :alias_method do |new_name, old_name|
+  match do |subject|
+    expect(subject.method(new_name)).to eq subject.method(old_name)
+  end
+
+  description do
+    "have #{new_name.inspect} aliased to #{old_name.inspect}"
+  end
+end

data/spec/support/context_when.rb

@@ -0,0 +1,39 @@
+
+extend_describe do
+  # Create a `context "when ..."`, with a set of let variables defined.
+  #
+  #   context_when a: 1, x: "y" do
+  #     it { expect(a).to eq 1 }      # Success.
+  #     it { expect(x).to eq "y" }    # Success.
+  #   end
+  #
+  # , is identical to:
+  #
+  #   context "when {a: 1, x: \"y\"}" do
+  #     let(:a) { 1 }
+  #     let(:x) { "y" }
+  #     ...
+  #
+  # @param h [Hash]
+  # @param format_proc [Proc]
+  # @return [void]
+  def context_when(h, format_proc: context_when_default_format_proc, &block)
+    context format_proc[h] do
+      h.each do |k, v|
+        let(k) { v }
+      end
+      class_eval(&block)
+    end
+  end
+
+  # Default <tt>format_proc</tt> for {.context_when}.
+  # @return [Proc]
+  # @see .context_when
+  def context_when_default_format_proc
+    ->(h) do
+      # Primitive readability hack. Might screw string values, too.
+      inspected = h.inspect.gsub(/:(\w+)=>/, "\\1: ")
+      "when #{inspected}"
+    end
+  end
+end

data/spec/support/let_m.rb

@@ -0,0 +1,27 @@
+
+extend_describe do
+  # Add a variable, named <tt>m</tt> by default, containing the symbolized method name from the
+  # description. Example:
+  #
+  #   describe "#some_method" do
+  #     let_m
+  #
+  # , is identical to:
+  #
+  #   describe "#some_method" do
+  #     let(:m) { :some_method }
+  #     def self.m; :some_method; end
+  #
+  # @param let [Symbol] Name of the variable to create.
+  # @return [void]
+  def let_m(let = :m)
+    if (mat = (description = self.description).match(/^(?:(?:#|\.|::)(\w+(?:\?|!|)|\[\])|(?:DELETE|GET|PUT|POST) (\w+))$/))
+      s = mat[1] || mat[2]
+      sym = s.to_sym
+      let(let) { sym }
+      define_singleton_method(let) { sym }
+    else
+      raise ArgumentError, "Unknown description format: #{description.inspect}"
+    end
+  end
+end

data/spec/support/use_custom_let.rb

@@ -0,0 +1,80 @@
+
+extend_describe do
+  # Define methods to manage of <tt>let</tt> variables which act as a distinct subset.
+  #
+  #   RSpec.describe SomeKlass do
+  #     use_custom_let(:let_a, :attrs)      # (1)
+  #     use_custom_let(:let_p, :params)     # (2)
+  #     ...
+  #
+  # In above examples, (1) provides our suite with:
+  #
+  #   def self.let_a(let, &block)
+  #   def attrs(include: [])
+  #
+  # , thus this now becomes possible:
+  #
+  #   describe "attrs" do
+  #     let_a(:name) { "Joe" }
+  #     let_a(:age) { 25 }
+  #     let(:gender) { :male }
+  #     it do
+  #       expect(name).to eq "Joe"
+  #       expect(age).to eq 25
+  #       expect(attrs).to eq(name: "Joe", age: 25)
+  #       expect(attrs(include: [:gender])).to eq(name: "Joe", age: 25, gender: :male)
+  #     end
+  #   end
+  #
+  # By not providing a block it's possible to <b>declare</b> a custom <tt>let</tt> variable
+  # and be able to redefine it later via regular <tt>let</tt>. This will work:
+  #
+  #   describe "declarative (no block) usage" do
+  #     let_a(:name)
+  #
+  #     subject { attrs }
+  #
+  #     context "when no other `let` value" do
+  #       it { is_expected.to eq({}) }
+  #     end
+  #
+  #     context "when `let`" do
+  #       let(:name) { "Joe" }
+  #       it { is_expected.to eq(name: "Joe") }
+  #     end
+  #   end
+  #
+  # NOTE: At the moment the feature only works if <tt>use_custom_let</tt> is invoked from a
+  # top-level (<tt>RSpec.describe</tt>) context. Correct usage in sub-context is yet not possible.
+  def use_custom_let(let_method, collection_method)
+    class_eval %{
+      def self.#{let_method}(let, &block)
+        #{let_method}_keys << let
+        let(let, &block) if block
+      end
+
+      def self.#{let_method}_keys
+        @#{let_method}_keys ||= []
+      end
+
+      # OPTIMIZE: Consider removing `include:` altogether as we've got declarative mode now.
+      def #{collection_method}(include: [])
+        # NOTE: We don't store computation in a @variable since we have an argument. The result
+        #   may vary.
+        begin
+          keys, klass = include, self.class
+          begin
+            keys += klass.#{let_method}_keys
+          end while (klass = klass.superclass) < RSpec::Core::ExampleGroup
+          # NOTE: `< RSpec::Core::ExampleGroup` is probably the reason why we can't use this in
+          #   sub-contexts. The need for such use is highly questionable since this feature in
+          #   effect extends RSpec syntax.
+
+          {}.tap do |_|
+            keys.uniq.each { |k| begin; _[k] = public_send(k); rescue NoMethodError; end }
+          end
+        end
+      end
+    } # class_eval
+  end
+end

metadata

@@ -1,77 +1,68 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rails_dt
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.1.4
+version: !ruby/object:Gem::Version
+  version: 1.2.0
 platform: ruby
-authors: 
+authors:
 - Alex Fortuna
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-07-13 00:00:00 +04:00
-default_executable: 
+date: 2018-03-23 00:00:00.000000000 Z
 dependencies: []
-
-description: Rails Debug Toolkit
-email: alex.r@askit.org
+description: 
+email:
+- fortunadze@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README.html
-- README.md
-files: 
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".yardopts"
+- Gemfile
 - 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/dt/config.rb
+- lib/dt/instance.rb
 - lib/rails_dt.rb
+- lib/rails_dt/version.rb
 - rails_dt.gemspec
-has_rdoc: true
+- spec/lib/dt/config_spec.rb
+- spec/lib/dt/instance_spec.rb
+- spec/lib/dt_spec.rb
+- spec/lib/rails_dt_spec.rb
+- spec/lib/spec/alias_method_matcher_spec.rb
+- spec/lib/spec/context_when_spec.rb
+- spec/lib/spec/let_m_spec.rb
+- spec/lib/spec/use_custom_let_spec.rb
+- spec/spec_helper.rb
+- spec/support/00extend_x.rb
+- spec/support/alias_method_matcher.rb
+- spec/support/context_when.rb
+- spec/support/let_m.rb
+- spec/support/use_custom_let.rb
 homepage: http://github.com/dadooda/rails_dt
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 2.5.2
 signing_key: 
-specification_version: 3
-summary: Rails Debug Toolkit
+specification_version: 4
+summary: Ruby/Rails debug toolkit
 test_files: []
-