naught 0.0.2 → 0.0.3

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/naught.rb

@@ -1,14 +1,11 @@
 require "naught/version"
 require 'naught/null_class_builder'
-require 'naught/null_class_builder/commands/define_explicit_conversions'
+require 'naught/null_class_builder/commands'
 
 module Naught
   def self.build(&customization_block)
     builder = NullClassBuilder.new
     builder.customize(&customization_block)
-    unless builder.interface_defined?
-      builder.respond_to_any_message
-    end
     builder.generate_class
   end
   module NullObjectTag

data/lib/naught/null_class_builder.rb

@@ -1,9 +1,13 @@
+require 'naught/null_class_builder/conversions_module'
+
 module Naught
   class NullClassBuilder
     # make sure this module exists
     module Commands
     end
 
+    attr_accessor :base_class, :inspect_proc, :interface_defined
+
     def initialize
       @interface_defined = false
       @base_class        = BasicObject
@@ -30,56 +34,17 @@ module Naught
     end
 
     def generate_conversions_module(null_class)
-      null_equivs = null_equivalents # get a local binding
-      @conversions_module ||= Module.new do
-        define_method(:Null) do |object=:nothing_passed|
-          case object
-          when NullObjectTag then object
-          when :nothing_passed, *null_equivs
-            null_class.get(caller: caller(1))
-          else raise ArgumentError, "#{object.inspect} is not null!"
-          end
-        end
-
-        define_method(:Maybe) do |object=nil, &block|
-          object = block ? block.call : object
-          case object
-          when NullObjectTag then object
-          when *null_equivs
-            null_class.get(caller: caller(1))
-          else
-            object
-          end
-        end
-
-        define_method(:Just) do |object=nil, &block|
-          object = block ? block.call : object
-          case object
-          when NullObjectTag, *null_equivs
-            raise ArgumentError, "Null value: #{object.inspect}"
-          else
-            object
-          end
-        end
-
-        define_method(:Actual) do |object=nil, &block|
-          object = block ? block.call : object
-          case object
-          when NullObjectTag then nil
-          else
-            object
-          end
-        end
-      end
+      ConversionsModule.new(null_class, null_equivalents)
     end
 
     def generate_class
+      respond_to_any_message unless interface_defined?
       generation_mod    = Module.new
       customization_mod = customization_module # get a local binding
       builder           = self
-      @operations.each do |operation|
-        operation.call(generation_mod)
-      end
+
+      apply_operations(operations, generation_mod)
+
       null_class = Class.new(@base_class) do
         const_set :GeneratedMethods, generation_mod
         const_set :Customizations, customization_mod
@@ -89,9 +54,9 @@ module Naught
         include generation_mod
         include customization_mod
       end
-      class_operations.each do |operation|
-        operation.call(null_class)
-      end
+
+      apply_operations(class_operations, null_class)
+
       null_class
     end
 
@@ -105,9 +70,11 @@ module Naught
       end
     end
 
-    def respond_to_missing?(method_name, *args)
+    def respond_to_missing?(method_name, include_private=false)
       command_name = command_name_for_method(method_name)
       Commands.const_defined?(command_name) || super
+    rescue NameError
+      super
     end
 
     ############################################################################
@@ -115,37 +82,13 @@ module Naught
     #
     # See also the contents of lib/naught/null_class_builder/commands
     ############################################################################
-    def define_implicit_conversions
-      defer do |subject|
-        subject.module_eval do
-          def to_ary; []; end
-          def to_str; ''; end
-        end
-      end
-    end
-
-    def mimic(class_to_mimic, options={})
-      include_super = options.fetch(:include_super) { true }
-      @base_class   = root_class_of(class_to_mimic)
-      @inspect_proc = -> { "<null:#{class_to_mimic}>" }
-      defer do |subject|
-        subject.module_eval do
-          methods = class_to_mimic.instance_methods(include_super) -
-            Object.instance_methods
-          methods.each do |method_name|
-            define_method(method_name) {|*| nil}
-          end
-        end
-      end
-      @interface_defined = true
-    end
 
     def black_hole
       @stub_strategy = :stub_method_returning_self
     end
 
     def respond_to_any_message
-      defer do |subject|
+      defer(prepend: true) do |subject|
         subject.module_eval do
           def respond_to?(*)
             true
@@ -156,69 +99,43 @@ module Naught
       @interface_defined = true
     end
 
-    def mimic(class_to_mimic, options={})
-      include_super = options.fetch(:include_super) { true }
-      @base_class   = root_class_of(class_to_mimic)
-      @inspect_proc = -> { "<null:#{class_to_mimic}>" }
-      defer do |subject|
-        methods = class_to_mimic.instance_methods(include_super) -
-          Object.instance_methods
-        methods.each do |method_name|
-          stub_method(subject, method_name)
-        end
+    def defer(options={}, &deferred_operation)
+      list = options[:class] ? class_operations : operations
+      if options[:prepend]
+        list.unshift(deferred_operation)
+      else
+        list << deferred_operation
       end
-      @interface_defined = true
     end
 
-    def impersonate(class_to_impersonate, options={})
-      mimic(class_to_impersonate, options)
-      @base_class = class_to_impersonate
+    def stub_method(subject, name)
+      send(@stub_strategy, subject, name)
     end
 
-    def traceable
-      defer do |subject|
-        subject.module_eval do
-          attr_reader :__file__, :__line__
+    private
 
-          def initialize(options={})
-            backtrace = options.fetch(:caller) { Kernel.caller(4) }
-            @__file__, line, _ = backtrace[0].split(':')
-            @__line__ = line.to_i
-          end
-         end
-      end
+    def define_basic_methods
+      define_basic_instance_methods
+      define_basic_class_methods
     end
 
-    def defer(options={}, &deferred_operation)
-      if options[:class]
-        class_operations << deferred_operation
-      else
-        operations << deferred_operation
+    def apply_operations(operations, module_or_class)
+      operations.each do |operation|
+        operation.call(module_or_class)
       end
     end
 
-    def singleton
-      defer(class: true) do |subject|
-        require 'singleton'
-        subject.module_eval do
-          include Singleton
-          def self.get(*)
-            instance
-          end
-        end
-      end
-    end
-
-    def define_basic_methods
+    def define_basic_instance_methods
       defer do |subject|
-        # make local variable to be accessible to Class.new block
-        inspect_proc = @inspect_proc
-        subject.module_eval do
+        subject.module_exec(@inspect_proc) do |inspect_proc|
           define_method(:inspect, &inspect_proc)
           def initialize(*)
           end
         end
       end
+    end
+
+    def define_basic_class_methods
       defer(class: true) do |subject|
         subject.module_eval do
           class << self
@@ -230,8 +147,6 @@ module Naught
       end
     end
 
-    private
-
     def class_operations
       @class_operations ||= []
     end
@@ -240,10 +155,6 @@ module Naught
       @operations ||= []
     end
 
-    def stub_method(subject, name)
-      send(@stub_strategy, subject, name)
-    end
-
     def stub_method_returning_nil(subject, name)
       subject.module_eval do
         define_method(name) {|*| nil }
@@ -257,18 +168,7 @@ module Naught
     end
 
     def command_name_for_method(method_name)
-      command_name = method_name.to_s.
-        gsub(/_(\w)/){ $1.upcase }.
-        gsub(/\A(\w)/){ $1.upcase }
-    end
-
-    def root_class_of(klass)
-      if klass.ancestors.include?(Object)
-        Object
-      else
-        BasicObject
-      end
+      method_name.to_s.gsub(/(?:^|_)([a-z])/) { $1.upcase }
     end
-
   end
 end

data/lib/naught/null_class_builder/command.rb

@@ -0,0 +1,20 @@
+module Naught
+  class NullClassBuilder
+    class Command
+      attr_reader :builder
+
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def call
+        raise NotImplementedError,
+              "Method #call should be overriden in child classes"
+      end
+
+      def defer(options={}, &block)
+        @builder.defer(options, &block)
+      end
+    end
+  end
+end

data/lib/naught/null_class_builder/commands.rb

@@ -0,0 +1,8 @@
+require 'naught/null_class_builder/commands/define_explicit_conversions'
+require 'naught/null_class_builder/commands/define_implicit_conversions'
+require 'naught/null_class_builder/commands/pebble'
+require 'naught/null_class_builder/commands/predicates_return'
+require 'naught/null_class_builder/commands/singleton'
+require 'naught/null_class_builder/commands/traceable'
+require 'naught/null_class_builder/commands/mimic'
+require 'naught/null_class_builder/commands/impersonate'

data/lib/naught/null_class_builder/commands/define_explicit_conversions.rb

@@ -1,28 +1,17 @@
+require 'naught/null_class_builder/command'
 
-module Naught
-  class NullClassBuilder
-    module Commands
-      class DefineExplicitConversions
-        def initialize(builder)
-          @builder = builder
-        end
-
-        def call
-          defer do |subject|
-            subject.module_eval do
-              def to_s; ""; end
-              def to_i; 0; end
-              def to_f; 0.0; end
-              def to_c; 0.to_c; end
-              def to_r; 0.to_r; end
-              def to_a; []; end
-              def to_h; {}; end
-            end
-          end
-        end
-
-        def defer(&block)
-          @builder.defer(&block)
+module Naught::NullClassBuilder::Commands
+  class DefineExplicitConversions < ::Naught::NullClassBuilder::Command
+    def call
+      defer do |subject|
+        subject.module_eval do
+          def to_s; ""; end
+          def to_i; 0; end
+          def to_f; 0.0; end
+          def to_c; 0.to_c; end
+          def to_r; 0.to_r; end
+          def to_a; []; end
+          def to_h; {}; end
         end
       end
     end

data/lib/naught/null_class_builder/commands/define_implicit_conversions.rb

@@ -0,0 +1,14 @@
+require 'naught/null_class_builder/command'
+
+module Naught::NullClassBuilder::Commands
+  class DefineImplicitConversions < ::Naught::NullClassBuilder::Command
+    def call
+      defer do |subject|
+        subject.module_eval do
+          def to_ary; []; end
+          def to_str; ''; end
+        end
+      end
+    end
+  end
+end

data/lib/naught/null_class_builder/commands/impersonate.rb

@@ -0,0 +1,9 @@
+module Naught::NullClassBuilder::Commands
+  class Impersonate < Naught::NullClassBuilder::Commands::Mimic
+    def initialize(builder, class_to_impersonate, options={})
+      super
+
+      builder.base_class   = class_to_impersonate
+    end
+  end
+end

data/lib/naught/null_class_builder/commands/mimic.rb

@@ -0,0 +1,40 @@
+require 'naught/null_class_builder/command'
+
+module Naught::NullClassBuilder::Commands
+  class Mimic < Naught::NullClassBuilder::Command
+    attr_reader :class_to_mimic, :include_super
+
+    def initialize(builder, class_to_mimic, options={})
+      super(builder)
+
+      @class_to_mimic = class_to_mimic
+      @include_super = options.fetch(:include_super) { true }
+
+      builder.base_class   = root_class_of(class_to_mimic)
+      builder.inspect_proc = -> { "<null:#{class_to_mimic}>" }
+      builder.interface_defined = true
+    end
+
+    def call
+      defer do |subject|
+        methods_to_stub.each do |method_name|
+          builder.stub_method(subject, method_name)
+        end
+      end
+    end
+
+    private
+
+    def root_class_of(klass)
+      if klass.ancestors.include?(Object)
+        Object
+      else
+        BasicObject
+      end
+    end
+
+    def methods_to_stub
+      class_to_mimic.instance_methods(include_super) - Object.instance_methods
+    end
+  end
+end

data/lib/naught/null_class_builder/commands/pebble.rb

@@ -0,0 +1,36 @@
+require 'naught/null_class_builder/command'
+
+module Naught
+  class NullClassBuilder
+    module Commands
+      class Pebble < ::Naught::NullClassBuilder::Command
+
+        def initialize(builder, output=$stdout)
+          @builder = builder
+          @output = output
+        end
+
+        def call
+          defer do |subject|
+            subject.module_exec(@output) do |output|
+
+              define_method(:method_missing) do |method_name, *args, &block|
+                pretty_args = args.map(&:inspect).join(", ").gsub("\"", "'")
+                output.puts "#{method_name}(#{pretty_args}) from #{parse_caller}"
+                self
+              end
+
+              private
+
+              def parse_caller
+                caller = Kernel.caller(2).first
+                method_name = caller.match(/\`([\w\s]+(\(\d+\s\w+\))?[\w\s]*)/)
+                method_name ? method_name[1] : caller
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end