wrap_in_module 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3-p194@wrap_in_module"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.14.7 (master)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wrap_in_module.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,2 @@
+Usable under the Ruby license. Copyright (C)2004 Joel VanderWerf. Questions to
+mailto:vjoel@users.sourceforge.net.

data/README.md

@@ -0,0 +1,138 @@
+# WrapInModule
+
+This is a Ruby gem I created to house the functionality to be able to wrap
+various things inside modules. The primary focus of it was to be able to load a
+ruby file in using a module as namespace for all the top level Constants,
+Methods, Classes, Modules, etc. This does the same for any sub ruby scripts
+that are required as well.
+
+I found this functionality in a ruby script, supprisingly called script.rb
+written by Joel VanderWerf released under the Ruby license in 2004. I have
+simply wrapped his script inside a gem so that this functionality can be easily
+accessed. The following is the description provided with Joel's script with my
+gem namespacing.
+
+`WrapInModule::Script` is a subclass of Module. A module which is an instance
+of the `WrapInModule::Script` class encapsulates in its scope the top-level
+methods, top-level constants, and instance variables defined in a ruby script
+file (and its dependent files) loaded by a ruby program. This allows use of
+script files to define objects that can be loaded into a program in much the
+same way that objects can be loaded from YAML or Marshal files.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'wrap_in_module'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wrap_in_module
+
+## Synopsis
+
+**program.rb:**
+
+    require 'wrap_in_module'
+    my_script = WrapInModule::Script.load("my-script.rb")
+    p my_script::VALUE
+    my_script.run
+
+**my-script.rb:**
+
+    VALUE = [1,2,3]
+    def run
+      puts "#{self} running."
+    end
+
+**output:**
+
+    $ ruby program.rb
+    [1, 2, 3]
+    #<Script:/tmp/my-script.rb> running.
+
+## Usage
+
+`WrapInModule::Script` modules are instantiated with
+<tt>WrapInModule::Script.new(main_file)</tt> or the alias
+<tt>WrapInModule::Script.load(main_file)</tt>. All the top-level constants and
+top-level methods that are defined in the +main_file+ and its dependent local
+files (see below) are scoped in the same Script module, and are thereby
+available to the calling program.
+
+The +main_file+ can load or require other files with +load+ and +require+, as
+usual. These methods, in the `WrapInModule::Script` context, add some behavior
+to the +Kernel+ +load+ and +require+ methods:
+<tt>WrapInModule::Script#load</tt> and <tt>WrapInModule::Script#require</tt>
+first search for files relative to the +main_file+'s dir. Files loaded in this
+way ("dependent local files") are treated like the script file itself:
+top-level definitions are added to the script module that is returned by +load+
+or +require+.
+
+Both <tt>WrapInModule::Script#load</tt> and
+<tt>WrapInModule::Script#require</tt> fall back to the Kernel versions if the
+file is not found locally. Hence, other ruby libraries can be loaded and
+required as usual, assuming their names do not conflict with local file names.
+Definitions from those files go into the usual scope (typically global). The
+normal ruby +load+ and +require+ behavior can be forced by calling
+<tt>Kernel.load</tt> and <tt>Kernel.require</tt>.
+
+A `WrapInModule::Script` immitates the way the top-level ruby context works, so
+a ruby file that was originally intended to be run from the top level, defining
+top-level constants and top-level methods, can also be run as a
+`WrapInModule::Script`, and its top-level constants and top-level methods are
+wrapped in the script's scope.  The difference between this behavior and simply
+wrapping the loaded definitions in an _anonymous_ module using
+<tt>Kernel.load(main_file, true)</tt> is that the top-level methods and
+top-level constants defined in the script are accessible using the
+`WrapInModule::Script` instance.
+
+The top-level definitions of a `WrapInModule::Script` can be accessed after it
+has been loaded, as follows:
+
+<tt>script.meth</tt>
+
+- Call a method defined using <tt>def meth</tt> or <tt>def self.meth</tt> in
+  the script file.
+
+<tt>script::K</tt>
+
+- Access a class, module, or constant defined using <tt>K = val</tt> in the
+  script file.
+
+An "input" can be passed to the script before loading. Simply call
+`WrapInModule::Script.new` (or `WrapInModule::Script.load`) with a block. The
+block is passed a single argument, the `WrapInModule::Script` module, and
+executed before the files are loaded into the Script's scope. Setting a
+constant in this block makes the constant available to the script during
+loading. For example:
+
+    script = Script.load("my-script.rb") { |script| script::INPUT = 3 }
+
+Note that all methods defined in the script file are both instance methods of
+the module and methods of the module instance (the effect of
+<tt>Module#module_function</tt>). So <tt>include</tt>-ing a Script module in a
+class will give instances of the class all the methods and constants defined in
+the script, and they will reference the instance's instance variables,
+rather than the Script module's instance variables.
+
+The Script class was inspired by Nobu Nokada's suggestion in
+http://ruby-talk.org/62727, in a thread (started in http://ruby-talk.org/62660)
+about how to use ruby script files as specifications of objects.
+
+## Legal and Contact Information
+
+Usable under the Ruby license. Copyright (C)2004 Joel VanderWerf. Questions to
+mailto:vjoel@users.sourceforge.net.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/wrap_in_module/version.rb

@@ -0,0 +1,3 @@
+module WrapInModule
+  VERSION = "0.0.1"
+end

data/lib/wrap_in_module.rb

@@ -0,0 +1,137 @@
+require "wrap_in_module/version"
+
+module WrapInModule
+  # NOTE: The following is coppied out of script.rb v0.3
+  # For more information please refer to http://redshift.sourceforge.net where
+  # I acquired the script-0.3.tar
+
+  # A module which is an instance of the Script class encapsulates in its scope
+  # the top-level methods, top-level constants, and instance variables defined in
+  # a ruby script file (and its subfiles) loaded by a ruby program. This allows
+  # use of script files to define objects that can be loaded into a program in
+  # much the same way that objects can be loaded from YAML or Marshal files.
+  #
+  # See intro.txt[link:files/intro_txt.html] for an overview.
+
+  class Script < Module
+    # The file with which the Script was instantiated.
+    attr_reader :__main_file
+
+    # The directory in which main_file is located, and relative to which
+    # #load searches for files before falling back to Kernel#load.
+    attr_reader :__dir
+    
+    # A hash that maps <tt>filename=>true</tt> for each file that has been
+    # required locally by the script. This has the same semantics as <tt>$"</tt>,
+    # alias <tt>$LOADED_FEATURES</tt>, except that it is local to this script.
+    attr_reader :__loaded_features
+
+    class << self
+      alias load new
+    end
+    
+    # Creates new Script, and loads _main_file_ in the scope of the Script. If a
+    # block is given, the script is passed to it before loading from the file, and
+    # constants can be defined as inputs to the script.
+    
+    def initialize(main_file)   # :yields: self
+      extend ScriptModuleMethods
+      @__main_file = File.expand_path(main_file)
+      @__dir = File.dirname(@__main_file)
+      @__loaded_features = {}
+      
+      yield self if block_given?
+      load_in_module(main_file)
+    end
+    
+    # Loads _file_ into this Script. Searches relative to the local dir, that is,
+    # the dir of the file given in the original call to
+    # <tt>Script.load(file)</tt>, loads the file, if found, into this Script's
+    # scope, and returns true. If the file is not found, falls back to
+    # <tt>Kernel.load</tt>, which searches on <tt>$LOAD_PATH</tt>, loads the file,
+    # if found, into global scope, and returns true. Otherwise, raises
+    # <tt>LoadError</tt>.
+    #
+    # The _wrap_ argument is passed to <tt>Kernel.load</tt> in the fallback case,
+    # when the file is not found locally.
+    #
+    # Typically called from within the main file to load additional sub files, or
+    # from those sub files.
+    
+    def load(file, wrap = false)
+      load_in_module(File.join(@__dir, file))
+      true
+    rescue MissingFile
+      super
+    end
+
+    # Analogous to <tt>Kernel#require</tt>. First tries the local dir, then falls
+    # back to <tt>Kernel#require</tt>. Will load a given _feature_ only once.
+    #
+    # Note that extensions (*.so, *.dll) can be required in the global scope, as
+    # usual, but not in the local scope. (This is not much of a limitation in
+    # practice--you wouldn't want to load an extension more than once.) This
+    # implementation falls back to <tt>Kernel#require</tt> when the argument is an
+    # extension or is not found locally.
+    
+    def require(feature)
+      unless @__loaded_features[feature]
+        @__loaded_features[feature] = true
+        file = File.join(@__dir, feature)
+        file += ".rb" unless /\.rb$/ =~ file
+        load_in_module(file)
+      end
+    rescue MissingFile
+      @__loaded_features[feature] = false
+      super
+    end
+    
+    # Raised by #load_in_module, caught by #load and #require.
+    class MissingFile < LoadError; end
+    
+    # Loads _file_ in this module's context. Note that <tt>\_\_FILE\_\_</tt> and
+    # <tt>\_\_LINE\_\_</tt> work correctly in _file_.
+    # Called by #load and #require; not normally called directly.
+    
+    def load_in_module(__file__)
+      module_eval("@__script_scope ||= binding\n" + IO.read(__file__),
+        File.expand_path(__file__), 0)
+        # start numbering at 0 because of the extra line.
+        # The extra line does nothing in sub-script files.
+    rescue Errno::ENOENT
+      if /#{__file__}$/ =~ $!.message # No extra locals in this scope.
+        raise MissingFile, $!.message
+      else
+        raise
+      end
+    end
+    
+    def to_s # :nodoc:
+      "#<#{self.class}:#{File.join(__dir, File.basename(__main_file))}>"
+    end
+
+    module ScriptModuleMethods
+      # This is so that <tt>def meth...</tt> behaves like in Ruby's top-level
+      # context. The implementation simply calls
+      # <tt>Module#module_function(name)</tt>.
+      def method_added(name) # :nodoc:
+        module_function(name)
+      end
+      
+      attr_reader :__script_scope
+
+      # Gets list of local vars in the script. Does not see local vars in files
+      # loaded or required by that script.
+      def __local_variables
+        eval("local_variables", __script_scope)
+      end
+      
+      # Gets value of local var in the script. Does not see local vars in files
+      # loaded or required by that script.
+      def __local_variable_get(name)
+        eval(name.to_s, __script_scope)
+      end
+    end
+  end
+end
+

data/wrap_in_module.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/wrap_in_module/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Andrew De Ponte"]
+  gem.email         = ["cyphactor@gmail.com"]
+  gem.description   = %q{Ruby gem that allows you to load a ruby file into a module. Think scoping bunch of code inside a module.}
+  gem.summary       = %q{Ruby gem that allows you to load a ruby file into a module. Think scoping bunch of code inside a module.}
+  gem.homepage      = "http://github.com/realpractice/wrap_in_module"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "wrap_in_module"
+  gem.require_paths = ["lib"]
+  gem.version       = WrapInModule::VERSION
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: wrap_in_module
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Andrew De Ponte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-22 00:00:00.000000000 Z
+dependencies: []
+description: Ruby gem that allows you to load a ruby file into a module. Think scoping
+  bunch of code inside a module.
+email:
+- cyphactor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/wrap_in_module.rb
+- lib/wrap_in_module/version.rb
+- wrap_in_module.gemspec
+homepage: http://github.com/realpractice/wrap_in_module
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby gem that allows you to load a ruby file into a module. Think scoping
+  bunch of code inside a module.
+test_files: []