whisperer 0.0.1

data/lib/whisperer/config.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+
+module Whisperer
+  # This config class is used only for Rake tasks.
+  # The puspose of it is to allow third users to defile options in Yaml file
+  # for generating cassettes and then it will be picked up
+  # while generating cassettes.
+  class Config
+    include Virtus.model
+
+    attribute :path_to_builders,  String, default: 'spec/cassette_builders'
+
+    attribute :generate_to,       String, default: 'spec/cassettes'
+    attribute :factories_matcher, String, default: './spec/factories/**/*.rb'
+    attribute :builders_matcher,  String, default: -> (c, attr) { "./#{c.path_to_builders}/**/*.rb" }
+
+    def self.load(file_name = nil)
+      raw_config = {}
+
+      if file_name && File.exists?(file_name)
+        raw_config = YAML.load(File.read(file_name)) || {}
+      end
+
+      config = new(raw_config)
+
+      VCR.configure do |c|
+        c.cassette_library_dir = config.generate_to
+      end
+
+      config
+    end
+
+    # Returns yaml record with configuration options.
+    def to_yml
+      "generate_to:       '#{generate_to}'\n" <<
+      "builders_matcher:  '#{builders_matcher}'\n" <<
+      "factories_matcher: '#{factories_matcher}'"
+    end
+  end # class Config
+end # module Whisperer

data/lib/whisperer/convertors/hash.rb

@@ -0,0 +1,39 @@
+require 'active_support/core_ext/string/inflections'
+
+module Whisperer
+  module Convertors
+    class Hash
+      extend Helpers
+
+      add_builder :convert
+
+      def initialize(obj)
+        @obj = obj
+      end
+
+      # Converts the current object with all related objects to hash
+      def convert
+        to_hash(@obj)
+      end
+
+      private
+        def to_hash(val)
+          new_attrs, attrs = {}, val.to_hash
+
+          attrs.each do |attr, val|
+            new_attrs[prepare_key(attr)] = if val.respond_to?(:to_hash)
+              to_hash(val)
+            else
+              val
+            end
+          end
+
+          new_attrs
+        end
+
+        def prepare_key(key)
+          key.to_s
+        end
+    end # class Hash
+  end # module Convertors
+end # module Whisperer

data/lib/whisperer/convertors/interaction.rb

@@ -0,0 +1,21 @@
+module Whisperer
+  module Convertors
+
+    # Converts
+    class Interaction
+      extend Helpers
+
+      add_builder :convert
+
+      def initialize(container)
+        @container = container
+      end
+
+      def convert
+        hash = Whisperer::Convertors::Hash.convert(@container)
+
+        VCR::HTTPInteraction.from_hash(hash)
+      end
+    end
+  end
+end

data/lib/whisperer/dsl.rb

@@ -0,0 +1,19 @@
+require_relative 'dsl/base'
+
+require_relative 'record'
+
+module Whisperer
+  class Dsl < BaseDsl
+    link_container_class Whisperer::Record
+
+    link_dsl 'request'
+    link_dsl 'response'
+
+    add_writer 'recorded_at'
+
+    add_writer 'sub_path'
+  end # class Dsl
+end # module Whisperer
+
+require 'whisperer/dsl/request'
+require 'whisperer/dsl/response'

data/lib/whisperer/dsl/base.rb

@@ -0,0 +1,47 @@
+module Whisperer
+  class BaseDsl
+    class << self
+      attr_reader :container_class
+
+      def link_dsl(name)
+        define_method(name) do |&block|
+          class_name = Whisperer::Dsl.const_get(name.capitalize)
+
+          sub_dsl = class_name.new(
+            @container.public_send(name)
+          )
+
+          sub_dsl.instance_eval &block
+        end
+      end
+
+      def link_container_class(val)
+        @container_class = val
+      end
+
+      def build
+        if self.container_class
+          new(
+            self.container_class.new
+          )
+        else
+          raise ArgumentError.new(
+            'You should associate a container (model) with this dsl class, before building it'
+          )
+        end
+      end
+
+      def add_writer(name)
+        define_method(name) do |val|
+          @container.public_send("#{name}=", val)
+        end
+      end
+    end
+
+    attr_reader :container
+
+    def initialize(container)
+      @container = container
+    end
+  end # class BaseDsl
+end # module Whisperer

data/lib/whisperer/dsl/body.rb

@@ -0,0 +1,33 @@
+require_relative 'base'
+
+module Whisperer
+  class Dsl
+    class Body < BaseDsl
+      add_writer 'encoding'
+      add_writer 'string'
+
+      def factory(name, *args)
+        model = FactoryGirl.build(name)
+
+        raw_data(model, *args)
+      end
+
+      def factories(names, *args)
+        models = names.map do |name|
+          FactoryGirl.build(name)
+        end
+
+        raw_data(models, *args)
+      end
+
+      def raw_data(data_obj, options = {})
+        @container.data_obj        = data_obj
+        @container.serializer_opts = options
+      end
+
+      def serializer(name)
+        @container.serializer = name.to_sym
+      end
+    end # class Body
+  end # class Dsl
+end # module Whisperer

data/lib/whisperer/dsl/headers.rb

@@ -0,0 +1,20 @@
+require_relative 'base'
+
+module Whisperer
+  class Dsl
+    class Headers < BaseDsl
+      def respond_to?(meth_id)
+        @container.respond_to?(meth_id)
+      end
+
+      protected
+        def method_missing(meth_id, *args)
+          unless @container.respond_to?(meth_id)
+            @container.attribute(meth_id, String)
+          end
+
+          @container.public_send("#{meth_id}=", *args)
+        end
+    end # class Header
+  end # class Dsl
+end # module Whisperer

data/lib/whisperer/dsl/request.rb

@@ -0,0 +1,15 @@
+require_relative 'base'
+require_relative 'headers'
+require_relative 'body'
+
+module Whisperer
+  class Dsl
+    class Request < BaseDsl
+      link_dsl 'headers'
+      link_dsl 'body'
+
+      add_writer 'uri'
+      add_writer 'method'
+    end # class Request
+  end # module Dsl
+end # module Whisperer

data/lib/whisperer/dsl/response.rb

@@ -0,0 +1,15 @@
+require_relative 'base'
+
+require_relative 'headers'
+require_relative 'body'
+require_relative 'response/status'
+
+module Whisperer
+  class Dsl
+    class Response < BaseDsl
+      link_dsl 'headers'
+      link_dsl 'body'
+      link_dsl 'status'
+    end # class Response
+  end # class Dsl
+end # module Whisperer

data/lib/whisperer/dsl/response/status.rb

@@ -0,0 +1,10 @@
+require_relative '../base'
+
+module Whisperer
+  class Dsl
+    class Status < BaseDsl
+      add_writer 'message'
+      add_writer 'code'
+    end # class Status
+  end # class Dsl
+end # module Whisperer

data/lib/whisperer/generator.rb

@@ -0,0 +1,43 @@
+module Whisperer
+  class Generator
+    extend Helpers
+
+    add_builder 'generate'
+
+    attr_reader :record
+
+    def initialize(record, name)
+      @record, @name = record, name
+    end
+
+    def generate
+      Preprocessors.process!(record)
+
+      interaction = Convertors::Interaction.convert(record)
+
+      self.uniq_cassette!
+
+      cassette = VCR::Cassette.new("#{record.sub_path}/#{@name}")
+      cassette.record_http_interaction(
+        interaction
+      )
+
+      cassette.eject
+
+      File.read(path_to_cassette)
+    end
+
+    protected
+      def path_to_cassette
+        "#{VCR.configuration.cassette_library_dir}/#{record.sub_path}/#{@name}.yml"
+      end
+
+      def uniq_cassette!
+        if File.exists?(path_to_cassette)
+          File.unlink(
+            path_to_cassette
+          )
+        end
+      end
+  end
+end

data/lib/whisperer/helpers.rb

@@ -0,0 +1,16 @@
+module Whisperer
+  module Helpers
+    def add_builder(meth_id)
+      mod = Module.new
+
+      mod.instance_eval do
+        define_method(meth_id) do |*args|
+          obj = new(*args)
+          obj.public_send(meth_id)
+        end
+      end
+
+      extend mod
+    end
+  end
+end

data/lib/whisperer/placeholder.rb

@@ -0,0 +1,14 @@
+# This class is a fake model to define factories
+# since FactoryGirl requires a module.
+#
+# Example:
+#
+#   FactoryGirl.define do
+#     factory :ned_stark, class: Placeholder do
+#       first_name 'Ned'
+#       last_name  'Stark'
+#       group      'member'
+#     end
+#   end
+#
+Placeholder = Class.new(OpenStruct)

data/lib/whisperer/preprocessors.rb

@@ -0,0 +1,19 @@
+module Whisperer
+  module Preprocessors
+    @preprocessors = ThreadSafe::Hash.new
+
+    class << self
+      attr_reader :preprocessors
+
+      def register(name, class_name)
+        preprocessors[name] = class_name
+      end
+
+      def process!(container)
+        preprocessors.each do |name, class_names|
+          class_names.process(container)
+        end
+      end
+    end
+  end
+end

data/lib/whisperer/preprocessors/base.rb

@@ -0,0 +1,13 @@
+module Whisperer
+  module Preprocessors
+    class Base
+      extend Helpers
+
+      add_builder :process
+
+      def initialize(record)
+        @record = record
+      end
+    end
+  end
+end

data/lib/whisperer/preprocessors/content_length.rb

@@ -0,0 +1,17 @@
+require_relative 'base'
+
+# This class calculates a content length for a response body
+# if it is not defined in a cassette record.
+module Whisperer
+  module Preprocessors
+    class ContentLength < Base
+      def process
+        headers = @record.response.headers
+
+        if headers.content_length.nil?
+          headers.content_length = @record.response.body.string.size
+        end
+      end
+    end # class ContentLength
+  end # module Preprocessors
+end # module Whisperer

data/lib/whisperer/preprocessors/response_body.rb

@@ -0,0 +1,23 @@
+require_relative 'base'
+
+module Whisperer
+  module Preprocessors
+    class ResponseBody < Base
+      def process
+        body = @record.response.body
+
+        unless body.data_obj.nil?
+          body.string = serializer_class(body.serializer).serialize(
+            body.data_obj,
+            body.serializer_opts
+          )
+        end
+      end
+
+      protected
+        def serializer_class(name)
+          Whisperer.serializer(name)
+        end
+    end
+  end
+end

data/lib/whisperer/record.rb

@@ -0,0 +1,48 @@
+require_relative 'record/request'
+require_relative 'record/response'
+
+module Whisperer
+  class Record
+    include Virtus.model
+
+    attribute :request,      Whisperer::Request,  default: proc { Whisperer::Request.new }
+    attribute :response,     Whisperer::Response, default: proc { Whisperer::Response.new }
+    attribute :http_version, String, default: ''
+    attribute :recorded_at,  String, default: proc { Time.now.httpdate }
+    attribute :sub_path,     String
+
+    def merge!(model)
+      merge_attrs(model, self)
+    end
+
+    protected
+      def merge_attrs(item, container)
+        item.attributes.each do |attr, val|
+          if val.respond_to?(:attributes)
+            merge_attrs(val, container[attr])
+          else
+            # We need to make sure that such attribute is declared
+            # for a record, otherwise, it cannot be written.
+            if container.class.attribute_set[attr].nil?
+              container.attribute(attr, item.class.attribute_set[attr])
+            end
+
+            attr_info = container.class.attribute_set[attr]
+
+            is_default = false
+
+            unless attr_info.nil?
+              def_val = attr_info.default_value
+              def_val = def_val.call if def_val.respond_to?(:call)
+
+              is_default = def_val == container[attr]
+            end
+
+            if container[attr].nil? || is_default
+              container[attr] = val
+            end
+          end
+        end
+      end
+  end # class Record
+end # module Whisperer