fun_with_gems 0.0.2 → 0.0.8

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MWQ2MWFiMGFiMjIzYWZiYmJjM2UzZDZlZTIxZDZlZDZhNGIxNzc1YQ==
-  data.tar.gz: !binary |-
-    ZWU1MTRmMDBjMzIzMTZlZjJlYzFhMGMxMWNjNTlmZjQ3MWZkNWQ0OA==
+SHA256:
+  metadata.gz: 047eb9c496f911ffcd7b0b94617cfee8cbc735525adf3058a71bbd26ef01447b
+  data.tar.gz: df363108b13235a078b5100409bc2d7e7884dbcc2bb86ec5cd7a9f76bf8805ce
 SHA512:
-  metadata.gz: !binary |-
-    NzYxZDVhYzVmNWMxZGE2NWRmYjZjNmRiYzg2YWZmYTg2NzdmYjMzOTFhNjVm
-    MDczNWE3NGUyNzZkY2NkNGI2MjQwZDBjMTEyNDgzNDc1ZmNmZTI5NzFiZjkz
-    NzkzY2E1MDZhODkyYjIyNmQwMDk3NzJlMWM2MDY4Nzc2NGEzODY=
-  data.tar.gz: !binary |-
-    NzQyMTZkZWYxMDI4N2RlYzY3ZjEzODQyZDUwODVmMzQ4NWQ2MDc5NGVlNjBl
-    ZjMzMTU0OTZjOWFmYzA5ZTczNGZlNDYwOGI0NGRhMWE3NzRiNTlkOWJmNzAy
-    MDU4MTAxYTcyOWE0MjQzMGEwMjMxOWZkNDM5MjYxZDk5MDUzZDc=
+  metadata.gz: 7c7070b49f2736547ed9f8a5238742078b266226eeeb57130e64dbb5d1446c3bc9a05948a2a61270abb3dc153ba0e233a22a75ed135929ad209e6b20d9cfe718
+  data.tar.gz: ef5c76523965a3049a8a97d0b6fb4606ba1a0c557282ffb14ec27fdd02e521f7566509e47a3bfc1bc99f86c6f0be9b1fe2787d7d938fada0fd8865369abd868b

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/CHANGELOG.markdown

@@ -1,11 +1,40 @@
 CHANGELOG
 =========
 
+v0.0.7
+------
+
+Separating some functionality into other gems. Or not?  I think this is an old comment.  The idea was to break off a bunch of gems and have FWG bring them in as dependencies.  But I never got around to it.  Requirements gem might be a good candidate.  
+
+Maybe keep the gem monolithic, but figure out how to let users do `require "fun_with_gems/inclusionizer"` or something.
+
+Consider also moving the testing/assertions into the test/lib directory for new gems, since only the test suite needs to see them.
+
+v0.0.6
+------
+
+* Simpler Rakefile, using expectations about which folders/files should be included.  `add_specification_files()`
+* Added auto-loading of Gem::Name::CoreExtension modules to base classes.
+* FunWith::Gems::Inclusionizer provides a useful, opinionated way to organize your code for mixins.
+
+v0.0.5
+------
+
+Moved all "test the gem" code to a separate `fun_with_gemdev` gem.
+
+v0.0.3
+------
+
+Moved some of the standard Rakefile boilerplate into FunWith::Gems::Rakefile.  Goal is to simplify rakefiles, add a set of fun_with:gems: rake tasks, etc.
+Removed Mechanic (seemed pretty useless)
+
+
 v0.0.2
 ------
 
 Dependent on `fun_with_testing` and `fun_with_files`, even `fun_with_version_strings`.  It's all very silly, really.
 
+
 0.0.1
 -----
 

data/Gemfile

@@ -6,16 +6,11 @@ source "http://rubygems.org"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  # gem "shoulda", "~> 3.5"
-  # gem "rdoc", "~> 3.12"
-  # gem "bundler", "~> 1.0"
-  # gem "jeweler", "~> 2.0"
-  # gem "simplecov", "~> 0", ">= 0.8"
-
-  # Should be safe to add.  By default, none of the assert functions get added to Test::Unit::TestCase
-  gem "fun_with_testing", "~> 0.0"
+  gem "fun_with_testing", "~> 0.0", ">= 0.0.8"
 end
 
-gem "fun_with_files", "~> 0.0", ">= 0.0.7"
-gem "fun_with_version_strings", "~> 0.0", ">= 0.0.3"
-
+gem "juwelier"
+gem "rake"
+gem "fun_with_files", "~> 0.0", ">= 0.0.17"             
+gem "fun_with_version_strings", "~> 0.0", ">= 0.0.4"
+gem "sorted_set"   # why is it even asking for this?

data/README.rdoc

@@ -1,5 +1,129 @@
 = fun_with_gems
 
+Opinionated Ruby gems with a consistent file schema.  Gems made easy.
+
+FunWith::Gems assumes turns one of the modules defined in your gem folder to be "the fun gem."
+
+You define the gem in the file lib/<gem_initialization_file>.rb  by putting the following contents in it:
+
+    require 'fun_with_gems'
+    FunWith::Gems.make_gem_fun( "MyNeatoGem" )
+    
+Doing this has the following effects:
+
+* Identifies the gem as being a 'fun gem' (`MyNeatoGem.is_fun_gem? => true`)
+* learns where the gem's root directory is (you can find this info by calling `MyNeatoGem.root`)
+* loads the "VERSION" file at the root of the directory (get via `MyNeatoGem.version`, `MyNeatoGem.version.(major|minor|patch)`)
+    * .version returns a subclass of string, but one that understands that "0.2" < "0.12", making version comparisons sensible.
+* loads every file in the `<ROOT>/lib/<GEM_NAME>` directory.  Don't expect them to be loaded in any specific order.
+* If there is a file `lib/my_neato_gem/gem_api.rb`, we expect it to define MyNeatoGem::GemAPI, which is used to extend MyNeatoGem with callable methods.  
+
+  
+
+
+
+
+Should also:
+
+* TODO: Check for API modules and attach them to their apis.  For example, if there's a lib/my_neato_gem/api.rb, and it defines a module MyNeatoGem::API, the MyNeatoGem module should be extended with the module 
+
+
+Testing!
+
+Simplifies your Rakefile
+
+
+
+
+
+
+
+
+Testing
+-------
+
+
+
+
+
+
+
+
+
+
+Where to put things and what those things do
+---------------------------------------------
+
+Let's say your gem is called Cobbler.  It... cobbles... um, things.  It lives in a folder called `cobbler`.
+
+    cobbler/                     Cobbler.root() should return the location of this directory in the filespace
+      ↳ bin/
+        cobbler                  An executable that should maybe somehow be available from the command line.
+                                 Multiple executables might live here.
+                                 
+      ↳ config/                  Anything you could think of as "gem configuration" would go in this folder.
+        ↳ gem_config.rb          Alternately, could be a YAML file (.yml or .yaml)
+                                 Either way, it gets loaded into a FunWith::Configurations::Config object
+                                 that can be accessed through Cobbler.config
+      ↳ cache/                   Might make more sense to use the ~/.cache/cobbler_gem directory?
+      ↳ lib/
+        ↳ cobbler.rb             Where the gem initialization stuff lives (including invoking make_gem_fun())
+        ↳ cobbler/
+          ↳ core_extensions/
+            ↳ string.rb
+            ↳ nil_class.rb       Cobbler::CoreExtensions::NilClass gets included in nil, making nil more useful
+            ↳ integer.rb         Cobbler::CoreExtensions::Integer extends the Integer class
+            
+            ↳ gem_api.rb          Cobbler::GemAPI 
+            ↳ testing/
+              ↳ assertions.rb              This is where you put testing assertions that you want to be available
+                                           to gems that include Cobbler as a dependency
+              ↳ test_case_extensions.rb    ????
+              
+        ↳ fun_with/                        Example: Anything that would extend a FunWith gem
+        ↳ active_record/                   Example: Anything you'd use to extend/override something in ActiveRecord
+                                           It might not be good to encourage gem authors to do this sort of thing.
+          
+      ↳ test/
+        ↳ data/                          Data that the tests can test against.  For example, if your gem plays with
+                                         ebooks, this might be a place to put compiled ebooks and source directory
+                                         trees.  If it plays with images, sample images would go here.
+        ↳ fixtures/                      (not implemented)
+        ↳ lib/
+          useful_testing_class.rb        Classes that you can use in testing.  Everything in the directory gets
+                                         require'd before the tests run.
+      ↳ VERSION                 The file contains a simple string, like 12.3.11
+                                calling Cobbler.version returns a VersionString object (a string that also responds
+                                to major(), minor(), patch() etc, and comparisons between version strings actually
+                                work as you'd hope)
+                                
+      ↳ Rakefile                
+      ↳ Gemfile                          
+                              
+      
+For local settings, FunWith::Gems tries to loosely follow the XDG guidelines, which can be found at https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html .
+
+(proposed) 
+
+    ~/.config/cobbler.gem/gem_config.(rb/yml)     # if present, the configuration can override and extend gem configurations
+    ~/.cache/cobbler.gem/                         # data caches and whatnot
+  
+This could be improved further by checking for the $XDG_ environment variables
+
+How much use is there for both a gem cache and a user cache?
+
+
+
+
+
+
+Features:
+
+* Version...ing?
+
+
+
+
 Description goes here.
 
 == Contributing to fun_with_gems
@@ -14,6 +138,6 @@ Description goes here.
 
 == Copyright
 
-Copyright (c) 2014 Bryce Anderson. See LICENSE.txt for
+Copyright (c) 2020 Bryce Anderson. See LICENSE.txt for
 further details.
 

data/ROADMAP.md

@@ -0,0 +1,6 @@
+It might not be the absolute best idea, but I also want FW::Gems to become a Juweiler/hoe/etc. gem manager, drawing on ideas from the others.
+
+Maybe https://github.com/postmodern/rubygems-tasks is the right approach.  The gem you build and the gem you use to publish it really shouldn't have anything to do with each other.
+
+I've got that FunWith::Templates gem template directory.  That could use a lot of polish (pardon the pun).
+

data/Rakefile

@@ -1,55 +1,24 @@
 # encoding: utf-8
 
-require 'rubygems'
-require 'bundler'
-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
-require 'rake'
+require_relative 'lib/fun_with_gems'
+self.extend( FunWith::Gems::Rakefile )
+
+rakefile_setup( FunWith::Gems )
+
 
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
+
+gem_specification do |gem|
   # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
-  gem.name = "fun_with_gems"
-  gem.homepage = "http://github.com/darthschmoo/fun_with_gems"
-  gem.license = "MIT"
-  gem.summary = "Dependency for most of my FunWith:: gems.  Not much use standalone."
+  gem.name        = "fun_with_gems"
+  gem.homepage    = "http://github.com/darthschmoo/fun_with_gems"
+  gem.license     = "MIT"
+  gem.summary     = "Dependency for most of my FunWith:: gems.  Not much use standalone."
   gem.description = "Dependency for FunWith gems, simplifies the setup of new gems, installing version data, root filepath, and default requirements."
-  gem.email = "keeputahweird@gmail.com"
-  gem.authors = ["Bryce Anderson"]
+  gem.email       = "keeputahweird@gmail.com"
+  gem.authors     = ["Bryce Anderson"]
   # dependencies defined in Gemfile
   
-  gem.files = Dir.glob( File.join( ".", "lib", "**", "*.rb" ) ) + 
-              Dir.glob( File.join( ".", "test", "**", "*" ) ) +
-              %w( Gemfile Rakefile LICENSE.txt README.rdoc VERSION CHANGELOG.markdown )  
-end
-Jeweler::RubygemsDotOrgTasks.new
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
+  add_specification_files( gem, :default )
 end
 
-desc "Code coverage detail"
-task :simplecov do
-  ENV['COVERAGE'] = "true"
-  Rake::Task['test'].execute
-end
-
-task :default => :test
-
-require 'rdoc/task'
-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
+setup_gem_boilerplate

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.8

data/lib/fun_with/gems/api_extender.rb

@@ -0,0 +1,46 @@
+module FunWith
+  module Gems
+    class ApiExtender
+      def self.extend_with_api( *args, &block )
+        self.new(*args,&block).extend_with_api
+      end
+      
+      def initialize(const)
+        @const = const
+      end
+      
+      def extend_with_api
+        api = get_gem_api_module
+        
+        if api.is_a?(Module)
+          @const.extend( api )
+        end
+      end
+      
+      def get_gem_api_module
+        existing_gem_api_constant || load_api_constant
+      end
+      
+      def load_api_constant
+        if @const.respond_to?(:root)
+          rootpath = @const.root / :lib
+          gem_api_path = @const.to_s.gsub("::","/").gsub(/(.)([A-Z])/,'\1_\2').downcase
+          
+          path = rootpath / gem_api_path
+          
+          require path if path.ext(:rb).file?
+          existing_gem_api_constant            # maybe it exists now?
+        end
+      end
+      
+      def existing_gem_api_constant
+        return @const::GemAPI if defined?(@const::GemAPI)
+        return @const::API    if defined?(@const::API)
+        return @const::GemApi if defined?(@const::GemApi)
+        
+        return nil
+      end
+    end
+  end
+end
+        

data/lib/fun_with/gems/configuration_installer.rb

@@ -0,0 +1,86 @@
+module FunWith
+  module Gems
+    class ConfigurationInstaller
+      def self.install_configuration( *args, &block )
+        self.new.install_configuration( *args, &block )
+      end
+      
+      def install_configuration( gc, opts = {} )
+        cfg = opts.fetch(:configuration){ false }
+        
+        if configuration_needed?( gc, cfg )
+          return false unless load_fun_with_configurations
+          
+          cfg = get_configuration( gc, cfg )
+          
+          if cfg.is_a?( FunWith::Configurations::Config )
+            gc.install_fwc_config( cfg )
+          end
+        end
+      end
+      
+      protected
+      # If no configuration (or file) was passed in as an argument and a magic file doesn't exist 
+      # for the gem configuration, don't do anything
+      def configuration_needed?( gc, cfg = false )
+        return false if cfg == :skip
+        return true if cfg                                 # user has provided a configuration
+        # a configuration has already been installed, or .config() is already defined
+        return false if gc.respond_to?( :config )          
+        
+        # returns false if there's no magic file below the gem's root
+        gem_default_configuration_file( gc ) ? true : false
+      end
+      
+      # 
+      def load_fun_with_configurations
+        require 'fun_with_configurations' unless defined?( FunWith::Configurations )
+        true
+      rescue LoadError
+        false
+      end
+      
+      # returns a FunWith::Configurations::Config option which can be installed on the gem
+      #
+      # if 
+      def get_configuration( gc, cfg )
+        case cfg
+        when :skip
+          return false      # don't try to install a configuration, not even the default one
+        when FunWith::Configurations::Config
+          return cfg
+        when Hash
+          return FunWith::Configurations::Config.from_hash( cfg )
+        when FunWith::Files::FilePath
+          return get_configuration_from_file( cfg )
+        when String
+          # assume we've been given a filepath
+          return get_configuration_from_file( cfg.fwf_filepath )
+        when false
+          # 
+          return get_configuration_from_file( gem_default_configuration_file( gc ) ) # returns 
+        end
+      end
+      
+      def get_configuration_from_file( f )
+        return false if f == false
+        (f.file? && f.readable?) ? FunWith::Configurations::Config.from_file( f ) : false
+      end
+      
+      # Default configuration file is either <GEM_ROOT>/config/gem_config.(yml or rb).
+      # If both exist, the .rb file is returned
+      def gem_default_configuration_file( gc )
+        return false unless gc.respond_to?(:root)
+        config_dir = gc.root / :config
+        
+        for filename in ["gem_config.rb", "gem_config.yml", "gem_config.yaml"]
+          f = config_dir / filename
+          
+          return f if (f.file? && f.readable?)
+        end
+        
+        return false
+      end
+    end
+  end
+end

data/lib/fun_with/gems/constant_builder.rb

@@ -0,0 +1,36 @@
+module FunWith
+  module Gems
+    class ConstantBuilder
+      def self.build_constant( *args, &block )
+        self.new.build_constant( *args, &block )
+      end
+      
+      # Expecting that constants will only be passed as strings when the constants hasn't been previously defined.
+      #
+      # returns the constant
+      def build_constant( c )
+        if c.is_a?( String )
+          #create the module
+          const = Object
+          
+          # go down the ::Module stack, creating modules along the way
+          full_const_name = ""
+          c.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
+        
+          eval( c )
+        else
+          c
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/gems/core_extender.rb

@@ -0,0 +1,65 @@
+module FunWith
+  module Gems
+    class CoreExtender
+      def self.extend_core( *args, &block )
+        self.new.extend_core( *args, &block )
+      end
+      
+      def extend_core( gem_const )
+        return false unless defined?( gem_const::CoreExtensions )
+        
+        ce = gem_const::CoreExtensions
+        
+        for mod in ce.constants
+          if Object.const_defined?( mod )
+            original = Object.const_get( mod )
+            includable = ce.const_get( mod )
+            include_in_core( original, includable )
+          end
+        end
+      end
+      
+      protected
+      def include_in_core( original, includable )
+        unless original.included_modules.include?( includable )    # it's already been included, so don't bother.
+          override_default_included_method( includable ) # basically gives it the inclusionizer treatment
+          original.send( :include, includable )
+          reinclude( original ) if original.is_a?( Module )
+        end
+      end
+      
+      def override_default_included_method( includable )
+        # leave it alone if an #included() method is already defined, 
+        # or if the module doesn't define the submodules that
+        # the new #included() method expects it to.
+        unless includable.respond_to?( :included ) || !( defined?(includable::ClassMethods) || defined?(includable::InstanceMethods) || defined?(includable::Constants) )
+          Inclusionizer.inclusionize( includable ) 
+        end
+      end
+      
+      # There's something odd about Ruby. When you include a module into a module that is itself included in a class/module, the class/module
+      # needs the included module to be re-included, otherwise stuff doesn't show up.
+      def reinclude( const )
+        silence_deprecation_warnings do
+          @core_classes_and_modules = Object.constants.map{|sym| Object.const_get(sym) }.select{|cnst| cnst.is_a?(Class) || cnst.is_a?(Module)}
+        
+          for klass in @core_classes_and_modules
+            if klass.included_modules.include?( const )
+              klass.send( :include, const )
+            end
+          end
+        end
+      end
+      
+      
+      # reinclude() pulls up a bunch of classes that have been marked as deprecated, and spits out warnings.
+      def silence_deprecation_warnings(&block)
+        old_stderr = $stderr
+        $stderr = StringIO.new
+        yield
+      ensure 
+        $stderr = old_stderr
+      end
+    end
+  end
+end

data/lib/fun_with/gems/core_extensions/module.rb

@@ -1,5 +1,11 @@
-class Module
-  def is_fun_gem?
-    false
+module FunWith
+  module Gems
+    module CoreExtensions
+      module Module
+        def is_fun_gem?
+          false
+        end
+      end
+    end
   end
 end

data/lib/fun_with/gems/fun_gem_api.rb

@@ -1,20 +1,28 @@
 module FunWith
   module Gems
+    # The API that gets added to a "gem module" by FunWithGems.make_gem_fun(*)
     module FunGemAPI
       def is_fun_gem?
         true
       end
       
       def validate_gem
-        FunWith::Gems::Validator.new( self ).validate
+        errors = FunWith::Gems::Testing::Validator.validate self
+        errors
       end
       
       def valid_gem?
-        self.validate_gem.fwf_blank?
+        errors = self.validate_gem
+        errors.fwf_blank?
+      end
+      
+      def passes_tests?
+        FunWith::Gems::Testing::TestSuiteRunner.new( self ).passes_tests?
       end
       
       def gem_test_mode?
-        @fwg_gem_test_mode || false
+        @fwg_gem_test_mode = false unless defined?( @fwg_gem_test_mode )
+        @fwg_gem_test_mode
       end
       
       # I can't think of a compelling reason to go beyond true/false here
@@ -33,6 +41,57 @@ module FunWith
       def say_if_verbose( msg, stream = $stdout )
         stream.puts( msg ) if gem_verbose?
       end
+      
+      def setup_for_testing
+        FunWith::Gems::Testing::TestSetup.setup( self )
+      end
+      
+      def load_tasks
+        load_internal_tasks
+        load_external_tasks
+      end
+      
+      # Tasks in gem/tasks should be those which are specific to the gem itself.
+      # Tasks located here will not be made available to gems which depend on it.
+      # Made accessible during the Rakefile.setup
+      def load_internal_tasks
+        _load_tasks_from_directory self.root( "tasks" )
+      end
+      
+      # Tasks in gem/lib/tasks will be usable by gems which have this gem as a dependency.
+      def load_external_tasks
+        _load_tasks_from_directory self.root( "lib", "tasks" )
+      end
+      
+      protected
+      def _load_tasks_from_directory dir
+        _rake_gem_loaded? do
+          files = dir.glob.select{ |f| 
+            f.file? && ( f.ext == "rb" || f.ext == "rake" ) 
+          }
+          
+          return false if files.length == 0
+        
+          unless Rake.respond_to?( :load_rakefile )
+            puts "Rake.load_rakefile missing: #{files.length} files will not be loaded."
+            return false
+          end
+          
+          for file in files
+            Rake.load_rakefile( file )
+          end
+        end
+      end
+      
+      def _rake_gem_loaded?( &block )
+        loaded = defined?( Gem ) && Gem.respond_to?( :loaded_specs ) && defined?( Rake ) && Gem.loaded_specs.keys.include?( "rake" )
+        
+        if block_given?
+          yield if loaded
+        else
+          loaded
+        end
+      end
     end
   end
 end