speq 0.3.0 → 0.4.0

data/lib/speq/recruit.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Some characters you can recruit for your tests
+module Recruit
+  module_function
+
+  def duck(**mapping)
+    Duck.new(**mapping)
+  end
+
+  def spy(proxy_target = nil, permit_all_methods = false)
+    Spy.new(proxy_target, permit_all_methods)
+  end
+
+  # Mostly just quacks like one
+  class Duck
+    def initialize(**mapping)
+      mapping.each do |method_name, value|
+        if mapping[method_name].respond_to?(:call)
+          define_singleton_method(method_name, value)
+        else
+          define_singleton_method(method_name, &-> { mapping[method_name] })
+          define_singleton_method(
+            "#{method_name}=".to_sym,
+            &->(val) { mapping[method_name] = val }
+          )
+        end
+      end
+    end
+  end
+
+  # Lets you can keep an eye on your ducks
+  class Spy
+    def initialize(proxy_target = nil, permit_all_methods = false)
+      @report = Hash.new { |hash, key| hash[key] = [] }
+      @proxy_target = proxy_target
+      @permit_all_methods = permit_all_methods
+    end
+
+    def respond_to_missing?(method_name, *)
+      permit_all_methods ? true : @proxy_target&.respond_to?(method_name) || super
+    end
+
+    def method_missing(method_name, *args, &block)
+      @report[method_name] << [args, block]
+      if @proxy_target&.respond_to?(method_name)
+        @proxy_target.send(method_name, *args, &block)
+      else
+        super
+      end
+    rescue NoMethodError => e
+      @permit_all_methods ? nil : e
+    end
+  end
+
+  # It's the same thing, except cheaper and not very useful
+  # def dupe(target, **_mapping)
+  #   klass = target.is_a?(Class) ? target : target.class
+
+  #   Class.new do
+  #     target.public_methods.each do |method_name|
+  #       define_singleton_method(
+  #         method_name,
+  #         *klass.method(method_name).parameters
+  #       )
+  #     end
+  #   end
+  # end
+
+  # Will let you claim `fake('Lies').equal?(Lies)`
+  def fake(
+    class_name = 'Fake',
+    super_class: Object,
+    namespace: Object,
+    avoid_collisions: false,
+    &block
+  )
+    if avoid_collisions && namespace.const_defined?(class_name)
+      throw NameError(
+        "constant '#{class_name}' already defined for #{namespace}"
+      )
+    end
+
+    namespace.const_set(class_name, Class.new(super_class, &block))
+  end
+end

data/lib/speq/string_fmt.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'colorize'
+
+module Speq
+  class TestBlock
+    def inspect
+      "block in '#{@parent.description}'"
+    end
+  end
+
+  class Group
+    def report
+      outcome.report
+    end
+
+    def indent
+      parent ? parent.indent + '  ' : ''
+    end
+
+    def newline
+      "\n#{indent}"
+    end
+  end
+
+  class Test < Group
+    def title
+      "#{outcome} #{description}"
+    end
+
+    def to_s
+      [newline, title, units.join(''), parent ? '' : newline + report].join('')
+    end
+  end
+
+  class Expression < Group
+    def indent
+      parent.indent
+    end
+
+    def to_s
+      "#{newline}  #{outcome} #{context} #{units.join('; ')}."
+    end
+  end
+
+  class Question
+    def to_s
+      "#{phrase}#{outcome.fail? ? " (result = #{result.inspect})" : ''}"
+        .send(outcome.pass? ? :green : :red)
+    end
+  end
+
+  class Outcome
+    def report
+      "pass: #{pass_count}, fail: #{fail_count}, errors: #{error_count}"
+    end
+
+    def to_s
+      pass? ? '✔'.green : 'x'.red
+    end
+  end
+
+  class Arguments
+    def to_s
+      arg_str = args.map(&:inspect).join(', ')
+      sep = args.empty? && block ? '' : ', '
+      block_str = block ? "#{sep}&{ ... }" : ''
+      "#{arg_str}#{block_str}"
+    end
+  end
+
+  class SomeValue
+    def to_s
+      description || value.inspect
+    end
+  end
+
+  class Message < SomeValue
+    def to_s
+      extra = description ? " (#{description})" : nil
+      "#{value}#{extra}"
+    end
+  end
+
+  class Context
+    def to_s
+      [arguments && !message ? "with #{arguments}" : nil,
+       arguments && message ? "#{message}(#{arguments})" : message,
+       message && subject ? 'on' : nil,
+       subject].reject(&:nil?).join(' ')
+    end
+  end
+end

data/lib/speq/values.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Speq
+  # Encodes the outcome of a group or individual test
+  class Outcome
+    def self.error
+      Outcome.new([0, 0, 1])
+    end
+
+    def self.pass
+      Outcome.new([1, 0, 0])
+    end
+
+    def self.fail
+      Outcome.new([0, 1, 0])
+    end
+
+    def self.aggregate(outcomes)
+      Outcome.new(
+        [outcomes.map(&:pass?).count(true),
+         outcomes.map(&:fail?).count(true),
+         outcomes.map(&:error?).count(true)]
+      )
+    end
+
+    attr_accessor :values
+    def initialize(values)
+      @values = values
+    end
+
+    def pass_count
+      values[0]
+    end
+
+    def fail_count
+      values[1]
+    end
+
+    def error_count
+      values[2]
+    end
+
+    def ==(other)
+      other.values == values
+    end
+
+    def pass?
+      fail_count.zero? && error_count.zero?
+    end
+
+    def fail?
+      !pass? && !error?
+    end
+
+    def error?
+      error_count.positive?
+    end
+  end
+
+  # Holds arguments to be passed to something later
+  class Arguments
+    attr_reader :args, :block
+    def initialize(*args, &block)
+      @args = args
+      @block = block if block_given?
+    end
+  end
+
+  # Holds any value allowing for a distiction between Some(nil) and None
+  class SomeValue
+    attr_reader :value
+    attr_accessor :description
+
+    def initialize(value, description = nil)
+      @value = value
+      @description = description
+    end
+  end
+
+  class Subject < SomeValue; end
+  class Message < SomeValue; end
+
+  # Carries expression context for evaluation
+  class Context
+    attr_accessor :subject, :message, :arguments
+
+    def initialize(subject: nil, message: nil, arguments: nil)
+      @subject = subject
+      @message = message
+      @arguments = arguments
+    end
+
+    def merge(context)
+      Context.new(to_h.merge(context.to_h))
+    end
+
+    def to_h
+      output = {}
+      %i[subject message arguments].each do |val|
+        output[val] = send(val) if send(val)
+      end
+      output
+    end
+
+    def evaluate
+      obj = subject&.value
+      msg = message&.value
+      args = arguments&.args
+      block = arguments&.block
+
+      val = get_value(obj, msg, args, block)
+
+      SomeValue.new(val)
+    rescue StandardError => e
+      SomeValue.new(e)
+    end
+
+    def get_value(obj, msg, args, block)
+      if !msg
+        obj
+      elsif !args
+        obj&.public_send(msg) || send(msg)
+      elsif !block
+        obj&.public_send(msg, *args) || send(msg, *args)
+      else
+        obj&.public_send(msg, *args, &block) || send(msg, *args, &block)
+      end
+    end
+  end
+end

data/lib/speq/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Speq
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'
 end

data/lib/speq.rb

@@ -1,44 +1,165 @@
-require 'speq/version'
-require 'speq/test'
-require 'speq/matcher'
-require 'speq/report'
-require 'speq/unit'
-require 'speq/fake'
-require 'speq/action'
-require 'speq/cli'
+# frozen_string_literal: true
 
+require 'speq/recruit'
+require 'speq/values'
+require 'speq/string_fmt'
+require 'speq/question'
+
+def speq(description, &block)
+  Speq::Test.new(description, &block)
+end
+
+# Build specs with fewer words
 module Speq
-  @tests = [Test.new]
-  @descriptions = { Object => nil }
+  # Test code executes within the context of this class
+  class TestBlock
+    METHODS = %i[speq on does with of is].freeze
 
-  def self.test(&block)
-    self << Test.new
-    module_exec(&block)
-  end
+    def initialize(parent, &block)
+      @outer_scope = eval('self', block.binding)
+      @parent = parent
+      instance_eval(&block)
+    end
 
-  def self.<<(test)
-    @tests << test
-  end
+    def speq(description, &block)
+      @parent.speq(description, &block)
+    end
 
-  def self.descriptions
-    @descriptions
+    def method_missing(method_name, *args, &block)
+      if METHODS.include?(method_name) ||
+         @parent.context && Question.question?(method_name)
+        Expression.new(@parent).send(method_name, *args, &block)
+      elsif @outer_scope.respond_to?(method_name)
+        @outer_scope.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, *)
+      METHODS.include?(method_name) ||
+        @outer_scope.respond_to?(method_name) ||
+        super
+    end
   end
 
-  module_function
+  # Common interface for all for Test and Expression
+  class Group
+    attr_reader :units, :context, :parent
 
-  def method_missing(method_name, *args, &block)
-    if Action.instance_methods.include?(method_name)
-      Action.new(@tests.last).send(method_name, *args, &block)
-    else
-      super
+    def initialize(parent = nil)
+      @parent = parent
+      @context = Context.new
+      @units = []
+    end
+
+    def outcome
+      Outcome.aggregate(units.map(&:outcome))
+    end
+
+    def pass?
+      outcome.pass?
+    end
+
+    def fail?
+      outcome.fail?
+    end
+
+    def error?
+      outcome.error?
+    end
+
+    def <<(unit)
+      units << unit
+    end
+
+    def full_context
+      parent ? context.merge(parent.full_context) : context
     end
   end
 
-  def report
-    Report.new(@tests).print_report
+  # A test group is a collection of tests with a description
+  class Test < Group
+    attr_reader :description
+
+    def initialize(description, parent = nil)
+      super(parent)
+      @description = description
+      run(&proc) if block_given?
+    end
+
+    def run(&block)
+      TestBlock.new(self, &block)
+    end
+
+    def speq(description, &block)
+      self << Test.new(description, self, &block)
+    end
   end
 
-  def fake(**mapping)
-    Fake.new(mapping)
+  # An expression group carries context for evaluation and associated questions
+  class Expression < Group
+    attr_reader :result
+
+    def initialize(parent)
+      super(parent)
+      @result = nil
+    end
+
+    def result=(val)
+      @result = val unless result
+    end
+
+    def evaluate_result
+      self.result = full_context.evaluate
+    end
+
+    def speq(description = "#{context}...", &block)
+      parent << Test.new(description, self, &block)
+    end
+
+    def on(val, description = nil)
+      context.subject = Subject.new(val, description)
+      speq(&proc) if block_given?
+      self
+    end
+
+    def does(val, description = nil)
+      context.message = Message.new(val, description)
+      speq(&proc) if block_given?
+      self
+    end
+
+    def with(*args, &block)
+      context.arguments = Arguments.new(*args, &block)
+      self
+    end
+
+    alias of with
+
+    def is(thing, description = nil, &block)
+      if thing.is_a?(Symbol)
+        does(thing, description, &block)
+      else
+        on(thing, description, &block)
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      if Question.question?(method_name)
+        if result.nil?
+          parent << self
+          evaluate_result
+        end
+        self << Question.for(result.value, method_name, *args, &block)
+        self
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, *)
+      Question.question?(method_name) || super
+    end
   end
 end

data/speq.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'speq/version'
@@ -13,7 +15,9 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
   end
 
   spec.bindir        = 'exe'
@@ -21,8 +25,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'pry', '~> 0.11.3'
+  spec.add_development_dependency 'rake', '~> 10.0'
 
   spec.add_dependency 'colorize', '~> 0.8.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: speq
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - zaniar moradian
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-28 00:00:00.000000000 Z
+date: 2019-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,33 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.16'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 0.11.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 0.11.3
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.3
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.3
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
@@ -75,22 +75,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - exe/speq
 - lib/speq.rb
-- lib/speq/action.rb
 - lib/speq/cli.rb
-- lib/speq/fake.rb
-- lib/speq/matcher.rb
-- lib/speq/report.rb
-- lib/speq/test.rb
-- lib/speq/unit.rb
+- lib/speq/question.rb
+- lib/speq/recruit.rb
+- lib/speq/string_fmt.rb
+- lib/speq/values.rb
 - lib/speq/version.rb
 - speq.gemspec
 homepage: https://github.com/znrm/speq
@@ -112,8 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A tiny library to build specs with fewer words.

data/Gemfile.lock

@@ -1,28 +0,0 @@
-PATH
-  remote: .
-  specs:
-    speq (0.3.0)
-      colorize (~> 0.8.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    coderay (1.1.2)
-    colorize (0.8.1)
-    method_source (0.9.0)
-    pry (0.11.3)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rake (10.5.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.16)
-  pry (~> 0.11.3)
-  rake (~> 10.0)
-  speq!
-
-BUNDLED WITH
-   1.16.6