Build2Spec 0.1.0

data/doc/README

@@ -0,0 +1,2 @@
+== This is a Really Cool Ruby Thing
+=== ( That deserves better documentation than this. )

data/doc/Specifications

@@ -0,0 +1,36 @@
+
+The Builder class
+- should produce 0 arg method text
+- should produce 1 arg method text
+- should produce 1..3 arg method text, with a block
+
+The Builder class
+- should create a standin for Kernel
+
+A covered class
+- should return instances of itself from ::new
+- should have an associated StandIn
+- should collect methods from explicit calls
+- should collect methods from #should calls
+- should return false from query? methods
+
+An UnknownType
+- should return instances of itself from ::new
+- should guess nil without method calls
+- should not guess nil with method calls
+
+The Kernel module
+- should be a legitimate target of method creation
+
+An UnknownStandIn
+- should not produce module body even without methods
+- should not produce module body if type guessed
+
+A StandIn
+- should not produce module body without methods
+- should produce module body when instance method recorded
+- should produce module body when class method recorded
+
+Finished in 0.01738 seconds
+
+18 specifications, 0 failures

data/lib/build2spec.rb

@@ -0,0 +1,585 @@
+require "spec"
+
+END { Build2Spec::Builder.build unless $UNDER_SPEC }
+
+unless $UNDER_SPEC
+require "interpose/lib/spec/expectations"
+require "interpose/lib/spec/runner/specification"
+require "interpose/lib/spec/runner/context_eval"
+  module Kernel
+    alias b2s_original_require require
+    def require(path)
+      Build2Spec::Builder::register_file(nil, path)
+      Build2Spec::Builder::cover_for_modules(path)
+    end
+
+    alias b2s_original_autoload autoload
+    def autoload(mod, filename)
+      Build2Spec::Builder::register_file(mod, filename)
+      b2s_original_autoload(mod, filename)
+      Build2Spec::Builder::cover_for_modules(filename)
+    end
+
+    def create_files_in(path)
+      Build2Spec::Builder.create_files_in(path)
+    end
+  end
+
+
+  class Module
+    def const_missing(name)
+      Build2Spec::Builder.create_covered_module(name, self)
+    end
+  end
+
+  class Object
+    def self.const_missing(name)
+      Build2Spec::Builder.create_covered_module(name, self)
+    end
+  end
+end
+
+module Build2Spec
+  class Builder
+    @module_homes = Hash.new {|h,k| h.has_key?(nil) ? h[nil] : nil }
+    @create_files_in = nil
+
+    class UnresolvedPath
+      def initialize(path)
+        @path = path
+      end
+
+      def resolve(directory)
+        unless /.rb$/ =~ @path
+          @path += ".rb"
+        end
+        return File::join(directory, @path)
+      end
+    end
+
+    @standins = {}
+
+    class << self
+      attr_accessor :module_homes
+      attr_accessor :standins
+
+      def create_files_in(path)
+        @create_files_in = path
+      end
+
+      def cover_for_modules(path)
+        existing_modules = all_modules
+        begin
+          b2s_original_require(path)
+        rescue LoadError
+          return
+        end
+
+        new_modules = all_modules - existing_modules
+        new_modules,contexts = new_modules.partition{|m| m.include?(Kernel)}
+        new_modules.sort!{|l, r| l.name.delete("^:").length <=> r.name.delete("^:").length}
+
+        new_modules.each do |mod|
+          cover_for_module(mod)
+        end
+      end
+
+      def all_modules
+        list = []
+        ObjectSpace.each_object(Module){|m| list << m} 
+        list
+      end
+
+      def register_file(mod, file)
+        module_homes[mod] = resolve_path(file)
+      end
+
+      def resolve_path(file)
+        $:.each do |lib_path|
+          path = File::expand_path(File::join(lib_path, file))
+          unless /.rb$/ =~ path
+            path += ".rb"
+          end
+          if File::exists?(path) and File::file?(path)
+            return path
+          end
+        end
+
+        return UnresolvedPath.new(file)
+      end
+
+      def build
+        create_in = @create_files_in || $:.first
+
+        FakingMethods::unknown_types.each do |type|
+          type.guess!
+        end
+
+        @module_homes.each_pair do |mod, path|
+          if path.respond_to? :resolve
+            @module_homes[mod] = path.resolve(create_in)
+          end
+        end
+
+        if @module_homes.values.empty?
+          raise "No files designated to generate code into.  Use require or autoload to designate code destinations!"
+        end
+
+        @standins.each_value do |standin|
+          unless File::exists?(@module_homes[standin.name])
+            puts "Creating new code file: #{@module_homes[standin.name]}"
+          end
+          File::open(@module_homes[standin.name], "a") do |file|
+            file.write(standin.mod_text + "\n")
+          end
+        end
+      end
+
+      def add_standin(nesting_path, name, standin)
+        nesting_path = nesting_path.name.to_s if Module === nesting_path
+        list = standin_location(nesting_path)
+        list[name] = standin
+      end
+
+      def standin_for(nesting_path)
+        nesting_path = nesting_path.name.to_s if Module === nesting_path
+        m = /(?:(.*)::)?(.*)/.match nesting_path
+        list = standin_location(m[1])
+        list[m[2]]
+      end
+
+      def standin_location(nesting_path)
+        list = @standins
+        return list if nesting_path.nil?
+        classpath = nesting_path.split("::")
+        create_missing_under = ::Object
+        classpath.each do |klass|
+          unless list.has_key?(klass)
+            unless create_missing_under.const_defined?(klass.intern)
+              raise RuntimeError, "Missing #{klass} in #{classpath}"
+            end
+            list[klass] = StandIn.new(create_missing_under.const_get(klass.intern))
+          end
+          create_missing_under = list[klass].covering_for
+          list = list[klass].nested
+        end
+        return list
+      end
+
+      def cover_for_module(klass)
+        m = /(?:(.*)::)?(.*)/.match klass.name.to_s
+        nesting = m[1] || ""
+        class_name = m[2]
+        klass.class_eval { include CoveredModule }
+        class_name = klass.name.to_s.sub(/.*::/, "")
+        Build2Spec::Builder::add_standin(nesting, class_name, StandIn.new(klass))
+      end
+
+      def create_covered_module(name, nesting, superclass=::Object)
+        classes = name.to_s.split("::")
+        class_name = classes.pop
+        classes.each do |nest|
+          unless nesting.const_defined?(nest)
+            create_covered_module(nest, nesting)
+          end
+          nesting = nesting.const_get(nest)
+        end
+        klass = Class.new(superclass)
+        nesting.const_set(class_name, klass)
+        UnknownType::add_guess_entry(klass, "#{nesting}::#{name}.new")
+        cover_for_module(klass)
+        return klass
+      end
+    end
+  end
+
+  class StandIn
+    def initialize(klass)
+      @covering_for = klass
+      @faked_instance_methods = {}
+      @faked_module_methods = {}
+      @nested = {}
+      @i_am_module = nil
+    end
+
+    attr_reader :covering_for, :faked_instance_methods, :faked_module_methods, :nested
+
+    Indent=" " * 2
+
+    def method_text(name, spec, indent)
+      args = argument_text(spec)
+
+      result = spec[2].inspect
+      if spec[2].respond_to?(:guess)
+        result = spec[2].guess
+      end
+
+      return "def #{name}#{args}\n#{indent}return #{result}\nend\n"
+    end
+
+    def argument_text(spec)
+      required = spec[0].begin > 0 ? Range.new("a",(?a + spec[0].begin - 1).chr).to_a : []
+      optional = spec[0].end - spec[0].begin > 0 ? 
+        Range.new((?a + spec[0].begin).chr,(?a + spec[0].end - 1).chr).to_a.map{|a| "#{a}=nil"} : []
+
+      args = required + optional
+      if spec[1]
+        args << "&block"
+      end
+      return args.length > 0 ? "( #{args.join(", ")} )" : ""
+    end
+
+    def is_module
+      @i_am_module = "module"
+    end
+
+    def is_class
+      @i_am_module = "class"
+    end
+
+    def mod_text(nesting="")
+      return "" if empty?
+      body = body_text(nesting)
+
+      text = mod_opener(nesting)
+      text << body
+      text << "end\n"
+    end
+
+    def nest_standin(other)
+      @nested[other] = nil
+    end
+
+    def name
+      covering_for.name
+    end
+
+    def empty?
+      return faked_instance_methods.values.empty? &&
+        faked_module_methods.values.empty? &&
+        nested.empty?
+    end
+
+    protected
+
+    def body_text(nesting)
+      spacer( mod_methods_text, 
+             nested_module_text(nesting_at(nesting), nested), 
+             instance_methods_text)
+    end
+
+    def spacer(*args)
+      args.delete_if{|a| /\A\s*\Z/ =~ a}
+      return args.join("\n")
+    end
+
+    def indent
+      string = yield
+      string = string.split("\n").map do |line|
+        Indent + line
+      end.join("\n")
+      unless string.empty?
+        string << "\n" 
+      end
+      string
+    end
+
+    def name_at(nesting)
+      name = @covering_for.name
+      if not nesting.empty?
+        if /^#{nesting}::/ =~ name
+          name.sub!(/^#{nesting}::/,"")
+        else
+          name = "::" + name
+        end
+      end
+      return name
+    end
+
+    def nesting_at(nesting)
+      name = name_at(nesting)
+      return name if %r"^::" =~ name or nesting.empty?
+      return [nesting, name].join("::")
+    end
+
+    def mod_opener(nesting)
+      supertext = ""
+
+      if @covering_for.class != Module and @covering_for.superclass != Object
+        supertext = " < #{@covering_for.superclass.name}"
+      end
+
+      is_module if @covering_for.class == Module
+
+      type = @i_am_module || "class"
+      return "#{type} #{name_at(nesting)}#{supertext}\n"
+    end
+
+    def mod_methods_text
+      return "" if @faked_module_methods.empty?
+      indent do
+        "class << self\n" + indent do
+          @faked_module_methods.map do |name, spec|
+            method_text(name, spec, Indent)
+          end.delete_if{|m| m == ""}.join("\n") + "\n"
+        end + "end"
+      end
+    end
+
+    def instance_methods_text
+      return "" if @faked_instance_methods.empty?
+      indent do
+        @faked_instance_methods.map do |name, spec|
+          method_text(name, spec, Indent)
+        end.delete_if{|m| m == ""}.join("\n")
+      end
+    end
+
+    def nested_module_text(nesting, nested)
+      return "" if nested.empty?
+      indent do
+        mods = nested.values.map do |mod|
+          mod.mod_text(nesting)
+        end.delete_if{|m| m == ""}.join("\n")
+      end
+    end
+  end
+
+  class UnknownType; end
+
+  module FakingMethods
+    def initialize(*args, &block)
+      return FakingMethods::record_method_spec(return_type_nesting, faked_methods, FakingMethods.current_method, args, block)
+    end
+
+    @@unknown_types = []
+    def self.unknown_types
+      return @@unknown_types
+    end
+
+    def self.current_method
+      called_from = caller.grep(/in `/)[1]
+      if (m = /in `([^']*)/.match called_from)
+        return m[1].intern
+      else
+        raise RuntimeError, called_from
+      end
+    end
+
+    def self.record_method_spec(nesting, faked_methods, name, args, block)
+      method_spec = []
+      if (method_spec = faked_methods[name]).nil?
+        arity = args.length
+
+        result = UnknownType.create(nesting)
+        if name == :initialize
+          result = nil
+        elsif /\?$/ =~ name.to_s
+          result = false
+        end
+
+        if UnknownType === result
+          @@unknown_types << result
+        end
+
+        method_spec = [arity..arity, (not block.nil?), result]
+        faked_methods[name] = method_spec
+      else
+        unless (method_spec[0].include? args.length)
+          if(method_spec[0].begin > args.length)
+            method_spec[0] = args.length..method_spec[0].end
+          else
+            method_spec[0] = method_spec[0].begin..args.length
+          end
+        end
+
+        method_spec[1] ||= !(block.nil?)
+      end
+
+      #p [:rms, name, method_spec]
+
+      return method_spec[2]
+    end
+
+    def method_missing(name, *args, &block)
+      retval = FakingMethods::record_method_spec(return_type_nesting, faked_methods, name, args, block)
+
+      if Module === self
+        define_method(name, instance_method(:initialize))
+      else
+        self.class.class_eval do 
+          define_method(name, self.instance_method(:initialize))
+        end
+      end
+
+      return retval
+    end
+  end
+
+  module FakingModules
+    def const_missing(name)
+      Build2Spec::Builder::create_covered_module(name, self)
+    end
+  end
+
+  module CoveredModule
+    def self.included(sub)
+      sub.module_eval do
+        def self.faked_methods
+          Build2Spec::Builder::standin_for(self).faked_module_methods
+        end
+
+        def self.return_type_nesting
+          self.name.to_s
+        end
+
+        include FakingMethods
+      end
+
+      sub.extend FakingMethods
+      sub.extend FakingModules
+    end
+
+    def faked_methods
+      Build2Spec::Builder::standin_for(self.class).faked_instance_methods
+    end
+
+    def return_type_nesting
+      self.class.name.to_s.sub(/(::)?[^:]*$/, "")
+    end
+  end
+
+  class UnknownStandIn < StandIn
+    def name_at(nesting)
+      @covering_for.name || "Build2Spec::UnknownType"
+    end
+
+    def mod_text(nesting="")
+      return "" if @covering_for.guessed?
+      super
+    end
+  end
+
+  class UnknownType
+    include FakingMethods
+
+    @@name_suffix = "A"
+
+    @@guessing_table = [
+      [Fixnum, '42'],
+      [String, '"wrong answer"'],
+      [Array, '[]'],
+      [Hash, '{}'],
+      [Object, "Object.new"],
+      [Class, @name],
+    ]
+
+    def self.add_guess_entry(klass, exemplar)
+      @@guessing_table.unshift [klass, exemplar]
+    end
+
+    def self.create(nesting, name = nil)
+      type = self.allocate
+      type.setup(nesting, name)
+      type
+    end
+
+    def superclass
+      Object
+    end
+
+    def setup(nesting, name)
+      @standin = UnknownStandIn.new(self)
+      @guess = nil
+      @name = name || "UnknownType#{@@name_suffix}"
+      @nesting = nesting
+      @@name_suffix.succ!
+      Builder::add_standin(nesting, @name, @standin)
+    end
+
+    def inspect
+      "<Build2Spec Dummy Return Value>"
+    end
+
+    attr_reader :standin, :name
+
+    def guess!
+      return if faked_methods.empty?
+      return if guessed?
+
+      @@guessing_table.each do |klass, exemplar|
+        faked = faked_methods.map{|f| f[0].to_s}
+        klass.instance_methods.each do |real|
+          faked.delete(real)
+        end
+        if(faked.empty?)
+          @guess = exemplar
+          return
+        end
+      end
+    end
+
+    def guessed?
+      not @guess.nil?
+    end
+
+    def guess
+      if @guess.nil? 
+        if standin.empty?
+          return "nil" 
+        else
+          init_spec = @standin.faked_instance_methods[:initialize]
+          if init_spec.nil?
+            return "#@name.new"
+          else
+            return "#@name.new#{@standin.argument_text(init_spec)}"
+          end
+        end
+      else
+        return @guess
+      end
+    end
+
+    def new(*args, &block)
+      instance = im_a_module
+      instance.initialize(*args, &block)
+      return instance
+    end
+
+    def im_a_module
+      return @instance_type unless @instance_type.nil?
+      module_standin = UnknownStandIn.new(self)
+      @standin.faked_instance_methods.each_pair do |k,v|
+        module_standin.faked_module_methods[k] = v
+      end
+      @standin = module_standin
+      class << self
+        def faked_methods
+          @standin.faked_module_methods
+        end
+
+        def guess!
+        end
+      end
+
+      @instance_type = UnknownType.create(@nesting, @name)
+
+      @name += "Class"
+      @guess = nil
+
+      return @instance_type
+    end
+
+    def faked_methods
+      @standin.faked_instance_methods
+    end
+
+    def return_type_nesting
+      @nesting
+    end
+  end
+
+  Builder::add_standin(nil, "Kernel", StandIn.new(Kernel))
+end
+
+

data/lib/interpose/lib/spec/expectations.rb

@@ -0,0 +1,28 @@
+
+
+module Spec
+  module Expectations
+    @errors = []
+    
+    class << self
+
+      def clear_errors
+        @errors.clear
+      end
+
+      def first_error
+        return if @errors.empty?
+        raise @errors.first
+      end
+
+      alias b2s_fail_with fail_with
+      def fail_with(message, expected=nil, target=nil)
+        begin
+          b2s_fail_with(message, expected, target)
+        rescue Spec::Expectations::ExpectationNotMetError => seenme
+          @errors << seenme
+        end
+      end
+    end
+  end
+end

data/lib/interpose/lib/spec/runner/context_eval.rb

@@ -0,0 +1,39 @@
+module Spec
+  module Runner
+    module ContextEval
+      module ModuleMethods
+
+        def derive_execution_context_class_from_context_superclass
+          @execution_context_class = Class.new(context_superclass)
+          @execution_context_class.class_eval do
+            def const_missing
+              ::Build2Spec::Builder.create_covered_module(name, Object)
+            end
+
+            def self.faked_methods
+              ::Build2Spec::Builder::standin_for(Kernel).faked_module_methods
+            end
+
+            def faked_methods
+              ::Build2Spec::Builder::standin_for(Kernel).faked_instance_methods
+            end
+
+            def self.return_type_nesting
+              ""
+            end
+
+            def return_type_nesting
+              ""
+            end
+
+            include ::Build2Spec::FakingMethods
+            include ::Spec::Runner::ExecutionContext::InstanceMethods
+
+            extend ::Build2Spec::FakingMethods
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/interpose/lib/spec/runner/specification.rb

@@ -0,0 +1,17 @@
+module Spec
+  module Runner
+    class Specification
+      def execute_spec(execution_context, errors)
+        begin
+          Spec::Expectations::clear_errors
+          execution_context.instance_eval(&spec_block)
+          Spec::Expectations::first_error
+          return true
+        rescue Exception => e
+          errors << e
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/spec_x_example.rb

@@ -0,0 +1,51 @@
+class SpecXExample
+  class Generator
+    class << self
+      def instance
+        return UnknownTypeA.new
+      end
+    end
+  
+    class UnknownTypeA
+      def initialize
+        return nil
+      end
+      
+      def contexts
+        return nil
+      end
+    end
+  end
+end
+
+module Kernel
+  def eg( &block )
+    return nil
+  end
+end
+
+class SpecXExample
+  class Generator
+  end
+end
+
+class SpecXExample
+  class Generator
+  end
+end
+
+class SpecXExample
+  class Generator
+  end
+end
+
+class SpecXExample
+  class Generator
+  end
+end
+
+class SpecXExample
+  class Generator
+  end
+end
+

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: Build2Spec
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-04-03 00:00:00 -07:00
+summary: Rapidly produce code skeletons from rspec specifications
+require_paths: 
+- lib
+email: judson@redfivellc.com
+homepage: 
+rubyforge_project: 
+description: Any automated testing should save you effort.  Use the work you did writing your specs first to produce  the skeleton of new projects or even just new features.  Makes BDD discipline effortless to maintain.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: Another tidy package brought to you by the cheerful folks at Red Five
+authors: 
+- Judson Lester
+files: 
+- lib/build2spec.rb
+- lib/spec_x_example.rb
+- lib/interpose
+- lib/interpose/lib
+- lib/interpose/lib/spec
+- lib/interpose/lib/spec/runner
+- lib/interpose/lib/spec/expectations.rb
+- lib/interpose/lib/spec/runner/specification.rb
+- lib/interpose/lib/spec/runner/context_eval.rb
+- doc/README
+- doc/Specifications
+test_files: []
+
+rdoc_options: 
+- --diagram
+- --inline-source
+- --main
+- Build2Spec
+- --title
+- Build2Spec
+extra_rdoc_files: 
+- doc/README
+- doc/Specifications
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.0
+    version: