pinspec 0.1.0 → 0.3.0

data/lib/pinspec/types.rb

@@ -1,19 +1,10 @@
 # frozen_string_literal: true
 
 module Pinspec
-  PARAM_KINDS = %i[req opt rest keyreq key keyrest].freeze
 
   OPTIONAL_PARAM_KINDS   = %i[opt key rest keyrest].freeze
   POSITIONAL_PARAM_KINDS = %i[req opt rest].freeze
 
-  CONSTRUCTION_KINDS = %i[
-    new
-    class_method
-    interactor
-    dry_initializer
-    struct
-    model_instance
-  ].freeze
 
   Param = Data.define(:name, :kind, :default_source, :type_hint) do
     def positional?
@@ -49,7 +40,8 @@ module Pinspec
     :takes_block,
     :source_range,
     :referenced_constants,
-    :clock_sites
+    :clock_sites,
+    :construction_source
   ) do
     def singleton?
       construction_kind == :class_method
@@ -365,38 +357,6 @@ module Pinspec
     def dsl_module
       legacy_dsl ? "FactoryGirl" : "FactoryBot"
     end
-
-    def traits_for(name)
-      ancestry(name).flat_map(&:traits)
-    end
-
-    def ancestry(name)
-      chain = []
-      seen  = []
-      current = factory(name)
-
-      while current && !seen.include?(current.name)
-        seen << current.name
-        chain.unshift(current)
-        current = current.parent && factory(current.parent)
-      end
-
-      chain
-    end
-
-    def attributes_for(name, traits: [])
-      chain = ancestry(name)
-      merged = {}
-
-      chain.each { |f| f.attributes.each { |a| merged[a.name] = a } }
-
-      Array(traits).each do |trait_name|
-        found = chain.reverse.filter_map { |f| f.trait(trait_name) }.first
-        found&.attributes&.each { |a| merged[a.name] = a }
-      end
-
-      merged.values
-    end
   end
 
   Column = Data.define(
@@ -450,13 +410,7 @@ module Pinspec
   end
 
   SkippedStatement = Data.define(:kind, :table, :column, :references, :file, :line, :relevant) do
-    def relevant?
-      relevant == true
-    end
 
-    def tables_touched
-      ([table] + Array(references)).compact.uniq
-    end
 
     def to_s
       subject = column ? "#{table}.#{column}" : table
@@ -486,12 +440,5 @@ module Pinspec
       tables.flat_map { |t| t.columns.select(&:unknown_type?).map { |c| [t.name, c] } }
     end
 
-    def annotate_relevance(planned_tables)
-      wanted = Array(planned_tables).map(&:to_s)
-
-      with(skipped_statements: skipped_statements.map do |statement|
-        statement.with(relevant: statement.tables_touched.any? { |t| wanted.include?(t) })
-      end)
-    end
   end
 end

data/lib/pinspec/verify/verifier.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fileutils"
+require "pathname"
 require "json"
 require "open3"
 
@@ -8,6 +10,8 @@ module Pinspec
     class Verifier
       CONFIGS = %i[isolated hostile neighbored].freeze
 
+      NEIGHBOUR_DIR = "tmp/pinspec"
+
       HOSTILE_TZ_CANDIDATES = ["Etc/GMT+8", "Etc/GMT-6"].freeze
 
       Outcome = Data.define(:config, :status, :diagnosis, :detail, :examples, :failures) do
@@ -52,6 +56,7 @@ module Pinspec
       def run(config)
         args, extra_env = arguments_for(config)
         stdout, stderr, _status = Open3.capture3(environment.merge(extra_env), *args, chdir: @app_root)
+        FileUtils.rm_f(@neighbour) if @neighbour
 
         summary = parse(stdout)
         return failure(config, stdout, stderr, summary) if summary.nil? || summary["failure_count"].to_i.positive?
@@ -72,7 +77,7 @@ module Pinspec
       end
 
       def arguments_for(config)
-        relative = @spec_path.sub("#{@app_root}/", "")
+        relative = relative_spec_path
         base = ["bundle", "exec", "rspec", "--format", "json"]
 
         case config
@@ -81,18 +86,48 @@ module Pinspec
         when :hostile
           [base + ["--seed", "7", relative], { "TZ" => hostile_tz, "LANG" => "C", "LC_ALL" => "C" }]
         when :neighbored
-          [base + [relative, relative], {}]
+          # A COPY alongside the original, because RSpec loads a given path once
+          # however many times it is named - so passing it twice re-ran nothing, and
+          # this configuration silently checked exactly what :isolated checks.
+          [base + [relative, neighbour_of(relative)], {}]
         end
       end
 
+      # Pathname does this properly: a string sub leaves an absolute path untouched
+      # when it does not start with the app root, which is exactly the case when
+      # someone runs `pinspec verify spec/foo_spec.rb` from inside their app.
+      def relative_spec_path
+        Pathname.new(File.expand_path(@spec_path))
+                .relative_path_from(Pathname.new(File.expand_path(@app_root)))
+                .to_s
+      rescue ArgumentError
+        @spec_path
+      end
+
+      # Written into the app's tmp, with its relative requires rewritten to point back
+      # at the support files the original sits beside. Removed again after the run -
+      # pinspec does not leave files in somebody's repository.
+      def neighbour_of(relative)
+        source = File.expand_path(relative, @app_root)
+        target = File.join(@app_root, NEIGHBOUR_DIR, "neighbour_#{File.basename(relative)}")
+        support = File.dirname(source)
+
+        FileUtils.mkdir_p(File.dirname(target))
+        File.write(target, Analyzer::Source.read(source)
+                                           .gsub('require_relative "support/', %(require_relative "#{support}/support/)))
+        @neighbour = target
+
+        File.join(NEIGHBOUR_DIR, File.basename(target))
+      end
+
       def hostile_tz
         HOSTILE_TZ_CANDIDATES.find { |zone| zone != @captured_tz } || HOSTILE_TZ_CANDIDATES.first
       end
 
       def environment
-        Runner::Sandbox::SCRUBBED_ENV
-          .merge("RAILS_ENV" => "test", "DISABLE_SPRING" => "1", "TZ" => @captured_tz)
-          .merge(@env)
+        Runner::Runtime.for(@app_root).env
+                       .merge("RAILS_ENV" => "test", "DISABLE_SPRING" => "1", "TZ" => @captured_tz)
+                       .merge(@env)
       end
 
       def parse(stdout)

data/lib/pinspec/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Pinspec
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 
   PROBE_VERSION      = 3
   SERIALIZER_VERSION = 3

data/templates/factory_build.rb

@@ -4,12 +4,16 @@
 module PinspecFactory
   MAX_ATTEMPTS = 8
 
-  def self.attempts
-    @attempts ||= {}
-  end
-
-  def self.reset_attempts!
-    @attempts = {}
+  # factory_bot sequences are process-global and monotonic, so a pin whose world uses
+  # one is only reproducible while nothing else in the process built that factory
+  # first. Running the same pin twice in one process produced INV-1 then INV-2 and the
+  # second run failed against its own snapshot. Both hosts rewind before every case,
+  # so a case always sees the same sequence values.
+  def self.reset_sequences!
+    mod = defined?(FactoryBot) ? FactoryBot : (defined?(FactoryGirl) ? FactoryGirl : nil)
+    return unless mod.respond_to?(:rewind_sequences)
+
+    mod.rewind_sequences
   end
 
   def self.default_module
@@ -31,7 +35,6 @@ module PinspecFactory
                    factory_module.create(name.to_sym, attrs)
                  end
 
-        attempts[name.to_s] = attempt
         return record
       rescue StandardError => e
         raise unless retryable?(e)
@@ -40,7 +43,6 @@ module PinspecFactory
       end
     end
 
-    attempts[name.to_s] = MAX_ATTEMPTS
     raise last_error
   end
 
@@ -48,7 +50,4 @@ module PinspecFactory
     defined?(ActiveRecord::RecordInvalid) && error.is_a?(ActiveRecord::RecordInvalid)
   end
 
-  def self.fragile
-    attempts.select { |_name, count| count > 1 }
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pinspec
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Rehan Munir
@@ -75,13 +75,15 @@ files:
 - exe/pinspec
 - lib/pinspec.rb
 - lib/pinspec/analyzer/app_profile_reader.rb
+- lib/pinspec/analyzer/discovery.rb
 - lib/pinspec/analyzer/factory_registry.rb
 - lib/pinspec/analyzer/inflector.rb
 - lib/pinspec/analyzer/schema_reader.rb
 - lib/pinspec/analyzer/source.rb
 - lib/pinspec/analyzer/target_parser.rb
+- lib/pinspec/batch.rb
 - lib/pinspec/cli.rb
-- lib/pinspec/emit/namer.rb
+- lib/pinspec/config.rb
 - lib/pinspec/emit/spec_writer.rb
 - lib/pinspec/emit/stability_filter.rb
 - lib/pinspec/errors.rb
@@ -94,6 +96,7 @@ files:
 - lib/pinspec/report/summary.rb
 - lib/pinspec/runner/capture.rb
 - lib/pinspec/runner/probe_generator.rb
+- lib/pinspec/runner/runtime.rb
 - lib/pinspec/runner/sandbox.rb
 - lib/pinspec/setup/context_builder.rb
 - lib/pinspec/setup/dependency_resolver.rb

data/lib/pinspec/emit/namer.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Pinspec
-  module Emit
-    class Namer
-      MAX_DESCRIPTION = 120
-
-      Facts = Data.define(:case_id, :origin, :outcome, :method_name, :class_name, :parameters)
-
-      def initialize(target:, enabled: false, client: nil)
-        @target = target
-        @enabled = enabled
-        @client = client
-      end
-
-      def enabled?
-        @enabled && !@client.nil?
-      end
-
-      def describe(cases)
-        facts = cases.map { |input_case, observation| facts_for(input_case, observation) }
-        fallback = facts.to_h { |fact| [fact.case_id, deterministic(fact)] }
-
-        return fallback unless enabled?
-
-        improved = request(facts)
-        fallback.merge(sanitize(improved, fallback))
-      rescue StandardError
-        fallback
-      end
-
-      def payload(facts)
-        {
-          "task" => "Describe each characterization test case in one short phrase.",
-          "constraints" => [
-            "Describe only the INPUTS and the kind of outcome.",
-            "Never invent or state a concrete expected value.",
-            "One phrase per case, at most #{MAX_DESCRIPTION} characters."
-          ],
-          "cases" => facts.map do |fact|
-            {
-              "id" => fact.case_id,
-              "origin" => fact.origin.to_s,
-              "outcome_kind" => fact.outcome.to_s,
-              "method" => fact.method_name.to_s,
-              "class" => fact.class_name.to_s,
-              "parameter_names" => fact.parameters.map(&:to_s)
-            }
-          end
-        }
-      end
-
-      private
-
-      def facts_for(input_case, observation)
-        Facts.new(
-          case_id: input_case.id,
-          origin: input_case.origin,
-          outcome: observation["status"] == "raised" ? :raises : :returns,
-          method_name: @target.method_name,
-          class_name: @target.class_name,
-          parameters: @target.input_params.map(&:name)
-        )
-      end
-
-      def deterministic(fact)
-        verb = fact.outcome == :raises ? "raises" : "returns the pinned value"
-
-        "#{fact.method_name} #{verb} (#{fact.case_id}, #{fact.origin})"
-      end
-
-      def request(facts)
-        response = @client.call(payload(facts))
-
-        parsed = response.is_a?(String) ? JSON.parse(response) : response
-        Array(parsed["cases"]).to_h { |entry| [entry["id"], entry["description"]] }
-      end
-
-      def sanitize(improved, fallback)
-        improved.each_with_object({}) do |(case_id, description), out|
-          next unless fallback.key?(case_id)
-          next unless description.is_a?(String)
-
-          text = description.strip
-          next if text.empty? || text.length > MAX_DESCRIPTION
-          next if suspicious?(text)
-
-          out[case_id] = "#{text} (#{case_id})"
-        end
-      end
-
-      def suspicious?(text)
-        return true if text.match?(/=>|\{"t"|\bexpect\b|\beq\(/)
-        return true if text.match?(/\d{3,}/)
-        return true if text.count('"') > 2
-
-        false
-      end
-    end
-  end
-end