blood_contracts 0.2.1 → 1.0.0

data/lib/blood_contracts/storages/base_backend.rb

@@ -1,59 +0,0 @@
-require 'nanoid'
-
-module BloodContracts
-  module Storages
-    class BaseBackend
-      extend Dry::Initializer
-      extend Forwardable
-
-      param :storage
-      param :example_name
-      option :name, default: -> do
-        BloodContracts.run_name || ::Nanoid.generate(size: 10)
-      end
-      def_delegators :@storage, :input_writer, :output_writer,
-                     :input_serializer, :output_serializer, :meta_serializer
-
-
-      def sample_exists?(sample_name)
-        raise NotImplementedError
-      end
-
-      def find_all_samples(run, tag, sample)
-        raise NotImplementedError
-      end
-
-      def load_sample(_sample_name)
-        %i(input output meta).map do |type|
-          load_sample_chunk(type, _sample_name)
-        end
-      end
-
-      def load_sample_chunk(_dump_type, _sample_name)
-        raise NotImplementedError
-      end
-
-      def describe_sample(_tag, _options, _context)
-        raise NotImplementedError
-      end
-
-      def serialize_sample(tag, options, context)
-        %i(input output meta).each do |type|
-          serialize_sample_chunk(type, tag, options, context)
-        end
-      end
-
-      def serialize_sample_chunk(_type, _tag, _option, _context)
-        raise NotImplementedError
-      end
-
-      def suggestion
-        raise NotImplementedError
-      end
-
-      def unexpected_suggestion
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/blood_contracts/storages/file_backend.rb

@@ -1,108 +0,0 @@
-module BloodContracts
-  module Storages
-    class FileBackend < BaseBackend
-      option :root, default: -> { Rails.root.join(path) }
-
-      def suggestion
-        "#{path}/*/*"
-      end
-
-      def unexpected_suggestion
-        "#{path}/#{Storage::UNDEFINED_RULE}/*"
-      end
-
-      def default_path
-        "./tmp/contract_tests/"
-      end
-
-      def timestamp
-        @timestamp ||= Time.current.to_s(:usec)[8..-3]
-      end
-
-      def reset_timestamp!
-        @timestamp = nil
-      end
-
-      def parse_sample_name(sample_name)
-        path_items = sample_name.split("/")
-        sample = path_items.pop
-        tag = path_items.pop
-        path_str = path_items.join("/")
-        run_n_example_str = path_str.sub(default_path, '')
-        if run_n_example_str.end_with?('*')
-          [
-            run_n_example_str.chomp("*"),
-            tag,
-            sample
-          ]
-        elsif run_n_example_str.end_with?(example_name)
-          [
-            run_n_example_str.chomp(example_name),
-            tag,
-            sample
-          ]
-        else
-          %w(__no_match__ __no_match__ __no_match__)
-        end
-      end
-
-      def find_all_samples(sample_name)
-        run, tag, sample = parse_sample_name(sample_name)
-        run_path = path(run_name: run)
-        files = Dir.glob("#{run_path}/#{tag.to_s}/#{sample}*")
-        files.select { |f| f.end_with?(".output") }
-             .map { |f| f.chomp(".output") }
-      end
-
-      def path(run_name: name)
-        File.join(default_path, run_name, example_name.to_s)
-      end
-
-      def sample_name(tag, run_path: root, sample: timestamp)
-        File.join(run_path, tag.to_s, sample)
-      end
-
-      def sample_exists?(sample_name)
-        run, tag, sample = parse_sample_name(sample_name)
-        name = sample_name(tag, run_path: path(run_name: run), sample: sample)
-        File.exist?("#{name}.input")
-      end
-
-      def load_sample_chunk(dump_type, sample_name)
-        run, tag, sample = parse_sample_name(sample_name)
-        name = sample_name(tag, run_path: path(run_name: run), sample: sample)
-        send("#{dump_type}_serializer")[:load].call(
-          File.read("#{name}.#{dump_type}.dump")
-        )
-      end
-
-      def write(writer, cntxt, options)
-        writer = cntxt.method(writer) if cntxt && writer.respond_to?(:to_sym)
-        writer.call(options).encode(
-          "UTF-8", invalid: :replace, undef: :replace, replace: "?",
-        )
-      end
-
-      def describe_sample(tag, options, context)
-        FileUtils.mkdir_p File.join(root, tag.to_s)
-
-        reset_timestamp!
-        name = sample_name(tag)
-        File.open("#{name}.input", "w+") do |f|
-          f << write(input_writer, context, options)
-        end
-        File.open("#{name}.output", "w+") do |f|
-          f << write(output_writer, context, options)
-        end
-      end
-
-      def serialize_sample_chunk(type, tag, options, context)
-        return unless (dump_proc = send("#{type}_serializer")[:dump])
-        name, data = sample_name(tag), options.send(type)
-        File.open("#{name}.#{type}.dump", "w+") do |f|
-          f << write(dump_proc, context, data)
-        end
-      end
-    end
-  end
-end

data/lib/blood_contracts/storages/serializer.rb

@@ -1,38 +0,0 @@
-module BloodContracts
-  module Storages
-    class Serializer
-      extend Dry::Initializer
-
-      param :serializer
-
-      def self.call(*args)
-        new(*args).call
-      end
-
-      def call
-        return object_serializer_to_hash if object_serializer?
-        return serializer.to_hash if hash_serializer?
-
-        raise "Both #dump and #load methods should be defined for serialization"
-      end
-
-      private
-
-      def object_serializer?
-        serializer.respond_to?(:dump) && serializer.respond_to?(:load)
-      end
-
-      def object_serializer_to_hash
-        {
-          load: serializer.method(:load),
-          dump: serializer.method(:dump),
-        }
-      end
-
-      def hash_serializer?
-        return unless serializer.respond_to?(:to_hash)
-        (%i[dump load] - serializer.to_hash.keys).empty?
-      end
-    end
-  end
-end

data/lib/blood_contracts/suite.rb

@@ -1,41 +0,0 @@
-module BloodContracts
-  class Suite
-    extend Dry::Initializer
-
-    option :contract, ->(v) { Hashie::Mash.new(v) }
-    option :data_generator, optional: true
-
-    option :input_writer,  optional: true
-    option :output_writer, optional: true
-
-    option :input_serializer,  optional: true
-    option :output_serializer, optional: true
-    option :meta_serializer, optional: true
-
-    option :storage_backend, optional: true
-    option :storage, default: -> { default_storage }
-
-    def data_generator=(generator)
-      raise ArgumentError unless generator.respond_to?(:call)
-      @data_generator = generator
-    end
-
-    def input_writer=(writer)
-      storage.input_writer = writer
-    end
-
-    def output_writer=(writer)
-      storage.output_writer = writer
-    end
-
-    def default_storage
-      Storage.new(
-        input_writer:  input_writer,
-        output_writer: output_writer,
-        input_serializer:  input_serializer,
-        output_serializer: output_serializer,
-        meta_serializer:   meta_serializer,
-      )
-    end
-  end
-end

data/lib/blood_contracts/version.rb

@@ -1,3 +0,0 @@
-module BloodContracts
-  VERSION = "0.2.1".freeze
-end

data/lib/extensions/string.rb

@@ -1,31 +0,0 @@
-class String
-  # See gem Facets String#pathize
-
-  # Transforms a namespace, i.e. a class or module name, into a viable
-  # file path.
-  #
-  #   "ExamplePathize".pathize           #=> "example_pathize"
-  #   "ExamplePathize::Example".pathize  #=> "example_pathize/example"
-  #
-  # Compare this method to {String#modulize) and {String#methodize).
-  #
-  def pathize
-    gsub(/([A-Z]+)([A-Z])/,'\1_\2').
-    gsub(/([a-z])([A-Z])/,'\1_\2').
-    gsub('__','/').
-    gsub('::','/').
-    gsub(/\s+/, '').                # spaces are bad form
-    gsub(/[?%*:|"<>.]+/, '').   # reserved characters
-    downcase
-  end
-
-  # Compare to Rails definition:
-  #
-  #    gsub(/__/, '/').
-  #    gsub(/::/, '/').
-  #    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-  #    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-  #    tr("-", "_").
-  #    downcase
-  #
-end

data/lib/rspec/meet_contract_matcher.rb

@@ -1,106 +0,0 @@
-module RSpec
-  module MeetContractMatcher
-    extend RSpec::Matchers::DSL
-    Runner = ::BloodContracts::Runner
-    Debugger = ::BloodContracts::Debugger
-
-    matcher :meet_contract_rules do |args|
-      match do |subject|
-        runner = ENV["debug"] ? Debugger : Runner
-
-        @_contract_runner = runner.new(
-          subject,
-          context: self,
-          suite: build_suite(args || subject),
-          iterations: @_iterations,
-          time_to_run: @_time_to_run,
-          stop_on_unexpected: @_halt_on_unexpected,
-        )
-        @_contract_runner.call
-      end
-
-      def build_suite(args)
-        suite = nil
-        if args.respond_to?(:to_contract_suite)
-          suite = args.to_contract_suite(name: _example_name_to_path)
-        elsif args.respond_to?(:to_h) && args.to_h.fetch(:contract) { false }
-          ::BloodContracts::Suite.new(
-            storage: new_storage,
-            contract: args[:contract]
-          )
-        else
-          raise "Matcher arguments is not a Blood Contract"
-        end
-        suite.data_generator = @_generator if @_generator
-        suite
-      end
-
-      def new_storage
-        storage = Storage.new(contract_name: _example_name_to_path)
-        storage.input_writer  = _input_writer  if _input_writer
-        storage.output_writer = _output_writer if _output_writer
-        if @_input_serializer
-          storage.input_serializer  = @_input_serializer
-        end
-        if @_output_serializer
-          storage.output_serializer = @_output_serializer
-        end
-        storage
-      end
-
-      def _example_name_to_path
-        method_missing(:class)
-          .name
-          .sub("RSpec::ExampleGroups::", "")
-          .pathize
-      end
-
-      def _input_writer
-        input_writer = @_writers.to_h[:input]
-        input_writer ||= :input_writer if defined? self.input_writer
-        input_writer
-      end
-
-      def _output_writer
-        output_writer = @_writers.to_h[:output]
-        output_writer ||= :output_writer if defined? self.output_writer
-        output_writer
-      end
-
-      supports_block_expectations
-
-      failure_message { @_contract_runner.failure_message }
-
-      description { @_contract_runner.description }
-
-      chain :using_generator do |generator|
-        if generator.respond_to?(:to_sym)
-          @_generator = method(generator.to_sym)
-        else
-          raise ArgumentError unless generator.respond_to?(:call)
-          @_generator = generator
-        end
-      end
-
-      chain :during_n_iterations_run do |iterations|
-        @_iterations = Integer(iterations)
-      end
-
-      chain :during_n_seconds_run do |time_to_run|
-        @_time_to_run = Float(time_to_run)
-      end
-
-      chain :halt_on_unexpected do
-        @_halt_on_unexpected = true
-      end
-
-      chain :serialize_input do |serializer|
-        @_input_serializer = serializer
-      end
-
-      chain :serialize_output do |serializer|
-        @_output_serializer = serializer
-      end
-    end
-  end
-end