br-approvals 0.0.22

data/ext/mkrf_conf.rb

@@ -0,0 +1,22 @@
+require 'rubygems/dependency_installer'
+
+# This is how we can depend on a different version of the same gem for
+# different Ruby versions.
+# See https://en.wikibooks.org/wiki/Ruby_Programming/RubyGems
+
+installer = Gem::DependencyInstaller.new
+
+begin
+  if RUBY_VERSION >= '2.0'
+    installer.install 'json', '~> 2.0'
+  else
+    installer.install 'json', '~> 1.8'
+  end
+rescue
+  exit(1)
+end
+
+# Write fake Rakefile for rake since Makefile isn't used
+File.open(File.join(File.dirname(__FILE__), 'Rakefile'), 'w') do |f|
+  f.write("task :default\n")
+end

data/lib/approvals.rb

@@ -0,0 +1,33 @@
+require 'json'
+require 'fileutils'
+require 'nokogiri'
+require 'approvals/version'
+require 'approvals/configuration'
+require 'approvals/approval'
+require 'approvals/dsl'
+require 'approvals/error'
+require 'approvals/system_command'
+require 'approvals/scrubber'
+require 'approvals/dotfile'
+require 'approvals/executable'
+require 'approvals/reporters'
+require 'approvals/filter'
+require 'approvals/writer'
+require 'approvals/namers/default_namer'
+
+module Approvals
+  extend DSL
+
+  class << self
+
+    def project_dir
+      @project_dir ||= FileUtils.pwd
+    end
+
+    def reset
+      Dotfile.reset
+    end
+  end
+end
+
+Approvals.reset

data/lib/approvals/approval.rb

@@ -0,0 +1,144 @@
+require 'erb' # It is referenced on line 69
+module Approvals
+  class Approval
+    class << self
+      attr_accessor :namer
+    end
+
+    attr_reader :subject, :namer, :failure
+    def initialize(subject, options = {})
+      @subject = subject
+      @namer = options[:namer] || default_namer(options[:name])
+      @format = options[:format] || identify_format
+    end
+
+    def default_namer(name)
+      Approvals::Approval.namer || Namers::DefaultNamer.new(name)
+    end
+
+    # Add a Proc that tests if subject is a kind of format
+    IDENTITIES = {
+      hash: Proc.new(){|subject|subject.respond_to? :each_pair},
+      array: Proc.new(){|subject|subject.respond_to? :each_with_index},
+    }
+
+    def identify_format
+      IDENTITIES.each_pair do |format, id_test|
+        return format if id_test.call(subject)
+      end
+      # otherwise
+      return :txt
+    end
+
+    def writer
+      @writer ||= Writer.for(@format)
+    end
+
+    def verify
+      unless File.exist?(namer.output_dir)
+        FileUtils.mkdir_p(namer.output_dir)
+      end
+
+      writer.write(subject, received_path)
+
+      unless approved?
+        fail_with "Approval file \"#{approved_path}\" not found."
+      end
+
+      @approved_content, @received_content = read_content
+
+      unless received_matches?
+        fail_with "Received file does not match approved:\n"+
+          "#{received_path}\n#{approved_path}\n#{diff_preview}"
+      end
+
+      success!
+    end
+
+    def diff_preview
+      approved, received = diff_lines
+      return unless approved and received
+      diff_index =
+          approved.each_char.with_index.find_index do |approved_char, i|
+            approved_char != received[i]
+          end
+      "approved fragment: #{approved[diff_index - 10 .. diff_index + 30]}\n"+
+      "received fragment: #{received[diff_index - 10 .. diff_index + 30]}"
+    end
+
+    def diff_lines
+      approved = @approved_content.split("\n")
+      received = @received_content.split("\n")
+      approved.each_with_index do |line, i|
+        return line, received[i] unless line == received[i]
+      end
+    end
+
+    def success!
+      File.delete received_path
+    end
+
+    def approved?
+      File.exist? approved_path
+    end
+
+    BINARY_FORMATS = [:binary]
+
+    def read_content
+      if BINARY_FORMATS.include?(@format) # Read without ERB
+        [IO.read(approved_path).chomp,
+         IO.read(received_path).chomp]
+      else
+        [ERB.new(IO.read(approved_path).chomp).result,
+         ERB.new(IO.read(received_path).chomp).result]
+      end
+    end
+
+    def received_matches?
+      @approved_content == @received_content
+    end
+
+    def fail_with(message)
+      Dotfile.append(diff_path)
+
+      if subject.respond_to?(:on_failure)
+        subject.on_failure.call(approved_text) if approved?
+        subject.on_failure.call(received_text)
+      end
+
+      error = ApprovalError.new("Approval Error: #{message}")
+      error.approved_path = approved_path
+      error.received_path = received_path
+
+      raise error
+    end
+
+    def diff_path
+      "#{approved_path} #{received_path}"
+    end
+
+    def full_path(state)
+      "#{namer.output_dir}#{namer.name}.#{state}.#{writer.extension}"
+    end
+
+    def name
+      namer.name
+    end
+
+    def approved_path
+      full_path('approved')
+    end
+
+    def received_path
+      full_path('received')
+    end
+
+    def approved_text
+      File.read(approved_path).chomp
+    end
+
+    def received_text
+      File.read(received_path).chomp
+    end
+  end
+end

data/lib/approvals/cli.rb

@@ -0,0 +1,36 @@
+# don't require the approvals library here, as it will reset the dotfile.
+# or find a better way to reset the dotfile before a run.
+module Approvals
+  class CLI < Thor
+
+    desc "verify", "Go through all failing approvals with a diff tool"
+    method_option :diff, :type => :string, :default => 'diff -N', :aliases => '-d', :desc => 'The difftool to use. e.g. opendiff, vimdiff, etc.'
+    method_option :ask, :type => :boolean, :default => true, :aliases => "-a", :desc => 'Offer to approve the received file for you.'
+    def verify
+      approvals = File.read('.approvals').split("\n")
+
+      rejected = []
+      approvals.each do |approval|
+        approved, received = approval.split(/\s+/)
+        if received.include?(".approved.")
+          received, approved = approved, received
+        end
+
+        diff_command = "#{options[:diff]} #{approved} #{received}"
+        puts diff_command
+        system(diff_command)
+
+        if options[:ask] && yes?("Approve? [y/N] ")
+          system("mv #{received} #{approved}")
+        else
+          rejected << approval
+        end
+      end
+
+      File.open('.approvals', 'w') do |f|
+        f.write rejected.join("\n")
+      end
+    end
+
+  end
+end

data/lib/approvals/configuration.rb

@@ -0,0 +1,29 @@
+require 'singleton'
+
+module Approvals
+
+  class << self
+    def configure(&block)
+      block.call Approvals::Configuration.instance
+    end
+
+    def configuration
+      Approvals::Configuration.instance
+    end
+  end
+
+  class Configuration
+    include Singleton
+
+    attr_writer :approvals_path
+    attr_writer :excluded_json_keys
+
+    def approvals_path
+      @approvals_path ||= 'fixtures/approvals/'
+    end
+
+    def excluded_json_keys
+      @excluded_json_keys ||= {}
+    end
+  end
+end

data/lib/approvals/dotfile.rb

@@ -0,0 +1,33 @@
+module Approvals
+
+  class Dotfile
+    class << self
+
+      def reset
+        File.truncate(path, 0) if File.exist?(path)
+      end
+
+      def append(text)
+        unless includes?(text)
+          write text
+        end
+      end
+
+      private
+
+      def path
+        File.join(Approvals.project_dir, '.approvals')
+      end
+
+      def includes?(text)
+        system("cat #{path} 2> /dev/null | grep -q \"^#{text}$\"")
+      end
+
+      def write(text)
+        File.open(path, 'a+') do |f|
+          f.write "#{text}\n"
+        end
+      end
+    end
+  end
+end

data/lib/approvals/dsl.rb

@@ -0,0 +1,7 @@
+module Approvals
+  module DSL
+    def verify(object, options = {})
+      Approval.new(object, options).verify
+    end
+  end
+end

data/lib/approvals/error.rb

@@ -0,0 +1,21 @@
+module Approvals
+  class ApprovalError < Exception
+    attr_accessor :received_path, :approved_path
+
+    def received_exists?
+      received_path && File.exist?(received_path)
+    end
+
+    def received_text
+      received_exists? && IO.read(received_path)
+    end
+
+    def approved_exists?
+      approved_path && File.exist?(approved_path)
+    end
+
+    def approved_text
+      approved_exists? && IO.read(approved_path)
+    end
+  end
+end

data/lib/approvals/executable.rb

@@ -0,0 +1,18 @@
+module Approvals
+  class Executable
+
+    attr_accessor :command, :on_failure
+    def initialize(command, &block)
+      self.command = command
+      self.on_failure = block
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      command
+    end
+  end
+end

data/lib/approvals/extensions/rspec.rb

@@ -0,0 +1,13 @@
+if defined? RSpec
+  require 'approvals/extensions/rspec/dsl'
+  require 'approvals/namers/rspec_namer'
+  require 'approvals/namers/directory_namer'
+
+  RSpec.configure do |c|
+    c.include Approvals::RSpec::DSL
+    c.add_setting :approvals_path, :default => 'spec/fixtures/approvals/'
+    c.add_setting :approvals_namer_class, :default => Approvals::Namers::DirectoryNamer
+    c.add_setting :diff_on_approval_failure, :default => false
+    c.add_setting :approvals_default_format, :default => nil
+  end
+end

data/lib/approvals/extensions/rspec/dsl.rb

@@ -0,0 +1,44 @@
+require 'rspec/expectations'
+
+module Approvals
+  module RSpec
+    module DSL
+      def executable(command, &block)
+        Approvals::Executable.new(command, &block)
+      end
+
+      def verify(options = {}, &block)
+        # Workaround to support both Rspec 2 and 3
+        # RSpec.current_example is the Rspec 3 way
+        fetch_current_example = ::RSpec.respond_to?(:current_example) ? proc { ::RSpec.current_example } : proc { |context| context.example }
+        # /Workaround
+
+        group = eval "self", block.binding
+        namer = ::RSpec.configuration.approvals_namer_class.new(fetch_current_example.call(group))
+        defaults = {
+          :namer => namer
+        }
+        format = ::RSpec.configuration.approvals_default_format
+        defaults[:format] = format if format
+        Approvals.verify(block.call, defaults.merge(options))
+      rescue ApprovalError => e
+        if diff_on_approval_failure?
+          ::RSpec::Expectations.fail_with(e.message, e.approved_text, e.received_text)
+        else
+          raise e
+        end
+      end
+
+      private
+
+      def diff_on_approval_failure?
+        # Workaround to support both RSpec 2 and 3
+        fetch_current_example = ::RSpec.respond_to?(:current_example) ? proc { ::RSpec.current_example } : proc { |context| context.example }
+        # /Workaround
+
+        ::RSpec.configuration.diff_on_approval_failure? ||
+          fetch_current_example.call(self).metadata[:diff_on_approval_failure]
+      end
+    end
+  end
+end

data/lib/approvals/filter.rb

@@ -0,0 +1,45 @@
+module Approvals
+  class Filter
+    attr_reader :filters
+
+    def initialize(filters)
+      @filters = filters
+      @placeholder = {}
+    end
+
+    def apply hash_or_array
+      if @filters.any?
+        censored(hash_or_array)
+      else
+        hash_or_array
+      end
+    end
+
+    def censored value, key=nil
+      if value.nil?
+        nil
+      elsif key && placeholder_for(key)
+        "<#{placeholder_for(key)}>"
+      else
+        case value
+          when Array
+            value.map { |item| censored(item) }
+          when Hash
+            Hash[value.map { |inner_key, inner_value| [inner_key, censored(inner_value, inner_key)] }]
+          else
+            value
+        end
+      end
+    end
+
+    def placeholder_for key
+      return @placeholder[key] if @placeholder.key? key
+
+      applicable_filters = filters.select do |placeholder, pattern|
+        pattern && key.match(pattern)
+      end
+
+      @placeholder[key] = applicable_filters.keys.last
+    end
+  end
+end