fun_with_gems 0.0.3 → 0.0.8

data/lib/fun_with/gems/gem_api.rb

@@ -9,84 +9,106 @@ module FunWith
       # 
       # Configurable options:
       # While all these things are handled by default, some things can be overridden
-      # :main_lib_file => use a different filepath to calculate the root
-      #
       # :root => or render :main_lib_file moot by declaring a different root.
       # 
       # :version => Declare a different version string for the gem.
       # 
       # :require => false (avoids requiring the default lib/fun_with dir.)
       # :require => filepath or array of filepaths   (require these things instead (note: not in addition to))
+      # :core_extensions => false           (don't autoload Gem::CoreExtension modules)
+      #                                     (note that it still checks to see if the module's already been included)
+      #
+      # :main_lib_file => use a different filepath to calculate the root (defaults to <GEM_ROOT>/)
+      # :configuration => nil (tries to load configuration from <GEM_ROOT>/config/gem_config.rb, if such a file exists)
+      #                   (String) --> assumes it's been given a filename
+      #                   (Hash) --> converts to a FunWith::Configurations::Config
+      #                   (Config) --> uses as the configuration
+      #                   :skip --> don't bother installing a configuration
+      #
+      #                   If successful, the configuration will be accessible from <GEM_CONST>.config
       def make_gem_fun( gem_const, opts = {} )
         @caller_file = caller.first.gsub(/:\d+:.*/,'').fwf_filepath
         @opts = opts
-        set_gem_const( gem_const )
+        
+        
+        
+        @gem_const = build_gem_const( gem_const )
         @gem_const.extend( FunGemAPI )
-        set_gem_root
-        set_gem_version
-        require_libs
-        extend_constant_with_gem_api
+        set_gem_root                   unless @opts[:set_root] == false
+        set_gem_version                unless @opts[:set_version] == false
         @gem_const.gem_verbose = opts[:verbose]
+        
+        # false to skip requiring entirely
+        # an array to load both
+        require_libs                   unless @opts[:require] == false
+        
+        extend_constant_with_gem_api   unless @opts[:gem_api] == false  
+        
         @gem_const.load_external_tasks  # Nothing happens unless 'rake' gem is active
+        
+        include_core_extensions        unless @opts[:core_extensions] == false
+        
+        # GemName.config.{configuration_settings} if applicable
+        # Only runs if "fun_with_configurations" is required prior to
+        # calling files.  Really starting to wonder about that.  Should fwc 
+        # stop depending on
+        install_gem_configuration      unless @opts[:configuration] == :skip
+        
+        extend_test_case
+        
+        @gem_const 
+      end
+      
+      def inclusionize( base )
+        FunWith::Gems::Inclusionizer.inclusionize( base )
       end
       
       protected
-      def set_gem_const( gem_const )
-        # Create new modules for this fun, fun gem, if necessary.
-        if gem_const.is_a?( String )
-          #create the module
-          const = Object
-          full_const_name = ""
-          gem_const.split("::").each do |module_name|
-            full_const_name << "::" unless full_const_name.fwf_blank?
-            full_const_name << module_name
-            
-            if eval( "defined?(#{full_const_name})")
-              const = eval( full_const_name )
-            else
-              const = const.const_set( module_name, Module.new )
-            end
-          end
-        
-          @gem_const = eval( gem_const )
-        else
-          @gem_const = gem_const
-        end
+      def build_gem_const( gem_const )
+        ConstantBuilder.build_constant( gem_const )
       end
       
       def set_gem_root
-        return if @opts[:set_root] == false
-        
-        # Hence, the "make_gem_fun()" directive should be called in the lib/gem_name.rb file.
-        main_lib_file = @opts[:main_lib_file] || @caller_file
-        root = @opts[:root] || main_lib_file.fwf_filepath.expand.dirname.up
-        
-        Files::RootPath.rootify( @gem_const, root )
+        RootSetter.set_root( @gem_const, @caller_file, @opts )
       end
-
+      
       def set_gem_version
-        return if @opts[:set_version] == false
-        if @opts[:version]
-          VersionStrings.versionize( @gem_const, @opts[:version] )
-        else
-          VersionStrings.versionize( @gem_const )
-        end
+        Versionizer.versionize( @gem_const, @opts[:version] )
       end
       
       def require_libs
-        unless @opts[:require] == false
-          @opts[:require] ||= @gem_const.root( "lib" ).glob(:all, :recursive => false) - [ @caller_file ]
-          @opts[:require] = [ @opts[:require] ] unless @opts[:require].is_a?(Array)
-        
-          @opts[:require].each do |req_dir|
-            req_dir.fwf_filepath.expand.requir
-          end
-        end
+        opts = just_options( @opts, :require, :main_lib_file ).merge( :caller => @caller_file )
+        LibraryRequirer.require( @gem_const, opts )
       end
       
       def extend_constant_with_gem_api
-        if defined?( @gem_const::GemAPI )
-          @gem_const.extend( @gem_const::GemAPI )
+        ApiExtender.extend_with_api( @gem_const )
+      end
+      
+      # Files in <GEM_ROOT>/lib/core_extensions get included in their corresponding core class?
+      def include_core_extensions
+        CoreExtender.extend_core( @gem_const )
+      end
+      
+      # Install a configuration given as an argument,
+      # or install the default config/gem_config.rb if such a file exists
+      def install_gem_configuration
+        opts = just_options( @opts, :configuration )
+        ConfigurationInstaller.install_configuration( @gem_const, opts )
+      end
+      
+      # @gem_const::Testing::TestCaseExtensions should already be loaded
+      # if it exists.  Uses it to extend FunWith::Testing::TestCase
+      def extend_test_case
+        TestCaseExtender.extend_test_case( @gem_const )
+      end
+      
+      protected
+      def just_options( opts, *args )
+        {}.tap do |return_opts|
+          for arg in args
+            return_opts[arg] = opts[arg].dup if opts.has_key?( arg )
+          end
         end
       end
     end

data/lib/fun_with/gems/inclusionizer.rb

@@ -0,0 +1,34 @@
+module FunWith
+  module Gems
+    module Inclusionizer
+      def self.inclusionize( base )
+        base.send( :include, self )
+      end
+      
+      def self.included( base )
+        # overwrite the base class's self.included()
+        base.send( :extend, self::SelfIncludedMethod )
+      end
+
+      module SelfIncludedMethod
+        def included( base )
+          __self = self
+
+          if base.is_a?(Module)
+            base.module_eval do
+              extend  __self::ClassMethods     if defined?( __self::ClassMethods )
+              include __self::InstanceMethods  if defined?( __self::InstanceMethods )
+              include __self::Constants        if defined?( __self::Constants )
+            end
+          elsif base.is_a?(Class)
+            base.class_eval do
+              extend  __self::ClassMethods     if defined?( __self::ClassMethods )
+              include __self::InstanceMethods  if defined?( __self::InstanceMethods )
+              include __self::Constants        if defined?( __self::Constants )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/gems/library_requirer.rb

@@ -0,0 +1,54 @@
+# Create new modules if necessary.
+module FunWith
+  module Gems
+    class LibraryRequirer
+      def self.require( *args, &block )
+        self.new.require( *args, &block )
+      end
+      
+      def require( const, opts )
+        caller_file = opts[:caller] || guess_caller_file_name( const )
+        files_to_require = const.root( "lib" ).glob(:all, :recursive => false) - [ caller_file ]
+        files_to_require.flatten!
+        
+        for file in files_to_require
+          file.requir
+        end
+      end
+      
+      def guess_caller_file( const )
+        if const.respond_to?(:root)
+          const_name = constant_name_to_filename( const.name )
+          "lib/" + const_name
+        else
+          false
+        end
+      end
+      
+      # We're guessing.  It doesn't have to be perfect, but perfect 99% of the time would be nice
+      def constant_name_to_filename( cname )
+        cname.split("::").map{ |chunk|
+          buffer = []
+          chunk.length.times do |i|
+            char = chunk[i]
+            next_char = chunk[i+1] || :eof
+            
+            cap_letter = char == char.upcase
+            next_cap_letter = next_char == next_char.upcase
+            
+            if cap_letter && ! next_cap_letter && i > 0
+              buffer << "_"
+            end
+            
+            buffer << char
+          end
+          
+                    # chunk.gsub( /(.)([A-Z])/ ){ $1 + "_" + $2 }.downcase
+          buffer.join("").downcase
+                    
+        }.join("/") + ".rb"
+          
+      end
+    end
+  end
+end

data/lib/fun_with/gems/rake_class_methods.rb

@@ -26,8 +26,7 @@ module FunWith
       end
       
       def run_bundler_setup
-        jeweler_requirements
-        rake_requirements
+        all_requirements
         
         begin
           Bundler.setup(:default, :development)
@@ -39,14 +38,14 @@ module FunWith
       end
       
       def specification &block
-        Jeweler::Tasks.new do |gem|
+        Juwelier::Tasks.new do |gem|
           yield gem
         end
       end
       
       def setup_gem_boilerplate
         run_in_rakefile do
-          Jeweler::RubygemsDotOrgTasks.new
+          Juwelier::RubygemsDotOrgTasks.new
 
           Rake::TestTask.new(:test) do |test|
             test.libs << 'lib' << 'test'
@@ -73,14 +72,14 @@ module FunWith
         end
       end
       
-      def jeweler_requirements
-        require 'rake'
-        require 'jeweler'
-      end
-      
-      def rake_requirements
-        require 'rdoc/task'
-        require 'rake/testtask'
+      def all_requirements
+        run_in_rakefile do
+          require 'rake'
+          require 'juwelier'
+          require 'rdoc/task'
+          require 'rake/testtask'
+          require 'bundler'
+        end
       end
       
       def run_in_rakefile &block
@@ -89,9 +88,23 @@ module FunWith
         elsif ! block_given?
           raise ArgumentError.new("Block must be given")
         else
-          @rake_main.instance_eval &block
+          @rake_main.instance_eval( &block )
         end
       end
+      
+      def gem_files( *args, &block )
+        Dir.glob( File.join( ".", "lib", "**", "*.rb" ) ) +
+                    Dir.glob( File.join( ".", "test", "**", "*.*" ) ) +
+                    [ "Gemfile",
+                      "Rakefile",
+                      "LICENSE.txt",
+                      "README.rdoc",
+                      "VERSION"
+                    ]
+
+
+        
+      end
     end
   end
 end

data/lib/fun_with/gems/rakefile.rb

@@ -1,6 +1,114 @@
 module FunWith
   module Gems
     module Rakefile
+      attr_accessor :gem
+      
+      def rakefile_setup this_gem   # , rake_main
+        self.gem = this_gem
+        
+        # set_rake_main  rake_main
+        run_bundler_setup
+        
+        # Internal tasks are set up in the Rakefile.  
+        # External tasks (visible to the gems that depend on your fungem) are setup during the normal gem setup, if the 'rake' gem is present.
+        self.gem.load_internal_tasks     
+      end
+      
+      # def set_rake_main m
+      #   @rake_main = m
+      # end
+      
+      def run_bundler_setup
+        all_requirements
+        
+        begin
+          Bundler.setup(:default, :development)
+        rescue Bundler::BundlerError => e
+          $stderr.puts e.message
+          $stderr.puts "Run `bundle install` to install missing gems"
+          exit e.status_code
+        end
+      end
+      
+      def gem_specification &block
+        Juwelier::Tasks.new do |gem|
+          yield gem
+        end
+      end
+      
+      
+      def setup_gem_boilerplate
+        # run_in_rakefile do
+          Juwelier::RubygemsDotOrgTasks.new
+
+          Rake::TestTask.new(:test) do |test|
+            test.libs << 'lib' << 'test'
+            test.pattern = 'test/**/test_*.rb'
+            test.verbose = true
+          end
+
+          desc "Code coverage detail"
+          task :simplecov do
+            ENV['COVERAGE'] = "true"
+            Rake::Task['test'].execute
+          end
+
+          task :default => :test
+
+          Rake::RDocTask.new do |rdoc|
+            version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+            rdoc.rdoc_dir = 'rdoc'
+            rdoc.title = "fun_with_gems #{version}"
+            rdoc.rdoc_files.include('README*')
+            rdoc.rdoc_files.include('lib/**/*.rb')
+          end
+          # end
+      end
+      
+      def all_requirements
+        # run_in_rakefile do
+          require 'rake'
+          require 'juwelier'
+          
+          begin
+            require 'rdoc/task'
+          rescue ArgumentError
+            # warn( "what's up with this error when loading RDoc?" )
+            require 'rdoc'
+            require 'rdoc/task'
+          end
+          
+          require 'rake/testtask'
+          require 'bundler'
+      end
+      
+      
+      def add_specification_files( gem_specification, *args )
+        root = "".fwf_filepath
+        
+        for arg in args
+          case arg
+          when :default
+            files = []
+            files += root.join( :bin ).glob
+            files += root.join( :config ).glob
+            files += root.join( :examples ).glob
+            files += [ "Gemfile", "Rakefile", "VERSION" ]
+            files += root.join( :lib ).glob( :all, :ext => :rb )
+            files += root.join( :lib ).glob( :all, :ext => :rake )
+            files += root.join( :test ).glob
+            files += root.entries.select{|p| p.path =~ /^LICENSE\./ }
+            files += root.entries.select{|p| p.path =~ /^CHANGELOG\./ }
+            files += root.entries.select{|p| p.path =~ /^README\./ }
+            files += root.entries.select{|p| p.path =~ /^CODE_OF_CONDUCT\./ }
+            
+            gem_specification.files += files.flatten.compact
+          else
+            gem_specification.files += root.glob( arg )
+          end
+        end
+      end
     end
   end
-end
+end

data/lib/fun_with/gems/root_setter.rb

@@ -0,0 +1,19 @@
+module FunWith
+  module Gems
+    class RootSetter
+      def self.set_root( *args, &block )
+        self.new.set_root( *args, &block )
+      end
+      
+      def set_root( gem_const, caller_file, opts = {} )
+        # Hence, the "make_gem_fun()" directive should be called in the lib/gem_name.rb file.
+        main_lib_file = opts[:main_lib_file] || caller_file
+        root = opts.fetch(:root){ main_lib_file.fwf_filepath.expand.dirname.up }
+        
+        Files::RootPath.rootify( gem_const, root )
+      end
+    end
+  end
+end
+
+        

data/lib/fun_with/gems/test_case_extender.rb

@@ -0,0 +1,27 @@
+module FunWith
+  module Gems
+    # If the gem has a ::Testing::TestCaseExtensions module, (<GEM_ROOT>/lib/<GEM_NAME>/testing/test_case_extensions.rb)
+    # include the module in FunWith::Testing::TestCase
+    #
+    # Best practice: reserve the TestCaseExtensions module for methods that you want to be available to any gem that
+    # includes the gem being extended.  
+    class TestCaseExtender
+      def self.extend_test_case( *args, &block )
+        self.new.extend_test_case( *args, &block )
+      end
+      
+      # If the caller doesn't specify a class to be extended, 
+      # assumes the target is FunWith::Testing::TestCase
+      def extend_test_case( gem_const, test_case_class = nil )
+        if test_case_class.nil?
+          return false unless defined?( FunWith::Testing::TestCase )
+          test_case_class = FunWith::Testing::TestCase
+        end
+        
+        if defined?( gem_const::Testing::TestCaseExtensions )
+          test_case_class.extend( gem_const::Testing::TestCaseExtensions )
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/gems/testing/assertions.rb

@@ -0,0 +1,22 @@
+module FunWith
+  module Gems
+    module Testing
+      module Assertions
+        # Puts a gem through its paces
+        def assert_gem_is_fine( gem )
+          flunk
+        end
+        
+        def assert_fun_gem( gem )
+          assert_kind_of( Module, gem )
+          assert_respond_to gem, :is_fun_gem?
+          assert gem.is_fun_gem?
+        end
+        
+        def assert_version( gem, version )
+          
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/gems/testing/gem_to_test_methods.rb

@@ -0,0 +1,37 @@
+module FunWith
+  module Gems
+    module Testing
+      module GemToTestMethods
+        # TODO: should use Inclusionizer?
+        def self.included( klass )
+          klass.extend( ClassMethods )
+          klass.extend( Constants )
+          klass.send( :include, InstanceMethods )
+        end
+      
+      
+        module ClassMethods
+          # What FunWith::Gems - derived gem is being tested?  check as far up the class tree as needed.
+          def gem_to_test
+            @gem_to_test ||= nil
+            rval = @gem_to_test
+            rval = self.superclass.gem_to_test if !rval && self.superclass.respond_to?( :gem_to_test )
+            rval
+          end
+          
+          attr_writer :gem_to_test
+        end
+      
+        module InstanceMethods
+          def gem_to_test
+            self.class.gem_to_test
+          end
+        end
+      
+        module Constants
+          GEM_TO_TEST_METHODS_LOADED = true
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/gems/testing/test_case_extensions.rb

@@ -0,0 +1,39 @@
+module FunWith
+  module Gems
+    module Testing
+      # Extensions to the FunWith::Testing::TestCase class.  
+      module TestCaseExtensions
+        # config options
+        #    :factory_bot => true   : load FactoryBot factory definitions from the places FactoryBot expects them to live.
+        #    :include => true       : include the namespace of the gem being tested.
+        def make_testing_fun( testable_gem, config = {} )
+          include GemToTestMethods
+          install_basic_assertions           # The assertions included by FunWith::Testing
+          install_gem_assertions             # The assertions included by FunWith::Gems
+          install_yet_more_assertions( testable_gem )
+          
+          self.gem_to_test = testable_gem
+        
+          self.add_factorybot_support if config[:factory_bot] == true
+          self.send( :include, self.gem_to_test ) if config[:include] == true
+        end
+      
+        def install_gem_assertions
+          include FunWith::Gems::Testing::Assertions
+        end
+        
+        def install_yet_more_assertions( testable_gem )
+          if testable_gem.respond_to?( :root )
+            f = testable_gem.root( :test, "assertions.rb" )
+            
+            require f if f.file?
+          end
+          
+          if defined?( testable_gem::Testing::Assertions )
+            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/gems/testing/test_results.rb

@@ -0,0 +1,40 @@
+module FunWith
+  module Gems
+    module Testing
+      class TestResults
+        TEST_SUITE_DATA_REGEX = /(?<tests>\d+) (?:tests|runs), (?<assertions>\d+) assertions, (?<failures>\d+) failures, (?<errors>\d+) errors, (?<skips>\d+) skips/
+      
+        attr_accessor :output, :test_results_found, :gem_const, :fail_count
+      
+        def initialize g
+          self.gem_const = g
+        end
+      
+        def passed?
+          self.scan_test_results
+          self.test_results_found? && no_failures_or_errors?
+        end
+      
+        def test_results_found?
+          self.test_results_found
+        end
+      
+        def no_failures_or_errors?
+          fail_count == 0
+        end
+      
+        def scan_test_results
+          raise "No output to scan!" if self.output.nil?
+        
+          if m = self.output.match( TEST_SUITE_DATA_REGEX )
+            self.test_results_found = true
+            self.fail_count = m[:failures].to_i + m[:errors].to_i
+          else
+            self.fail_count = -1
+            self.test_results_found = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/gems/testing/test_setup.rb

@@ -0,0 +1,22 @@
+module FunWith
+  module Gems
+    module Testing
+      class TestSetup
+        def self.setup( gem )
+          gem.gem_test_mode = true
+          require_test_libs( gem )
+        end
+      
+        def self.require_test_libs( gem )
+          return false unless gem.respond_to?(:root)
+          groot = gem.root
+          return false unless groot.is_a?( FunWith::Files::FilePath )
+          
+          test_lib_dir = groot / :test / :lib
+          test_lib_dir.requir if test_lib_dir.directory?
+        end
+      end
+    end
+  end
+end
+          

data/lib/fun_with/gems/testing/test_suite_runner.rb

@@ -0,0 +1,28 @@
+module FunWith
+  module Gems
+    module Testing
+      class TestSuiteRunner
+        attr_accessor :gem_const
+      
+        def initialize fwgem
+          self.gem_const = fwgem
+        end
+      
+        def passes_tests?
+          result = self.run_tests
+          result.passed?
+        end
+      
+        def run_tests
+          filepath = self.gem_const.root
+        
+          results = TestResults.new( self.gem_const )
+        
+          puts "running tests on #{self.gem_const} from #{filepath}"
+          results.output = `cd #{filepath} && rake test`
+          results
+        end
+      end
+    end
+  end
+end