wrap_in_module 0.0.3 → 0.1.0

data/LICENSE

@@ -1,2 +1,25 @@
-Usable under the Ruby license. Copyright (C)2004 Joel VanderWerf. Questions to
+This project is licensed under the MIT license which can be seen below.
+
+This project was based script.rb which is usable under the Ruby license.
+Copyright (C)2004 Joel VanderWerf. Questions to
 mailto:vjoel@users.sourceforge.net.
+
+Copyright (c) 2012 ReachLocal, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -2,23 +2,10 @@
 
 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,
+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:
@@ -33,14 +20,15 @@ Or install it yourself as:
 
     $ gem install wrap_in_module
 
-## Synopsis
+## Usage:
 
 **program.rb:**
 
     require 'wrap_in_module'
-    my_script = WrapInModule::Script.load("my-script.rb")
-    p my_script::VALUE
-    my_script.run
+    module MyModule
+    WrapInModule::wrap_file(MyModule, "my-script.rb")
+    p MyModule::VALUE
+    MyModule.run
 
 **my-script.rb:**
 
@@ -53,77 +41,72 @@ Or install it yourself as:
 
     $ ruby program.rb
     [1, 2, 3]
-    #<Script:/tmp/my-script.rb> running.
 
-## Usage
+## Detailed 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
+`WrapInModule::wrap_file(_module, file_path)` wraps the file specified by
+*file_path* under the specified *_module*.  All the top-level constants and
+top-level methods that are defined in the file at *file_path* and its dependent
+local files (see below) are scoped in the same 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
+The file located at *file_path* can load or require other files with *load* and
+*require*, as usual. These methods, in the *_module* context, add some behavior
+to the *Kernel* *load* and *require* methods: Within the *_module* context they
+first search for files relative to the *file_path*'s dir. Files loaded in this
+way ("dependent local files") are treated like the file located at *file_path*:
+top-level definitions are added to the module.
+
+Both *load* and *require* 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 `Kernel.load` and
+`Kernel.require`.
+
+A `WrapInModule` wrapped file 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 module, and its top-level constants and top-level methods are wrapped in
+the modules scope. The difference between this behavior and simply wrapping the
+loaded definitions in an _anonymous_ module using `Kernel.load(main_file,
+true)` is that the top-level methods and top-level constants defined in the
+module are accessible using the *_module*.
+
+The top-level definitions of a `WrapInModule` module can be accessed after it
 has been loaded, as follows:
 
-<tt>script.meth</tt>
+`module.meth`
+
+- Call a method defined using `def meth` or `def self.meth` in the specified
+  file.
 
-- Call a method defined using <tt>def meth</tt> or <tt>def self.meth</tt> in
-  the script file.
+`module::K`
 
-<tt>script::K</tt>
+- Access a class, module, or constant defined using `K = val` in the specified
+  file.
 
-- Access a class, module, or constant defined using <tt>K = val</tt> in the
-  script file.
+## History
 
-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:
+This is largely based on an older script called **script.rb**  written by Joel
+VanderWerf and released under the Ruby license in 2004. I found issues with the
+way **script.rb** was doing things, specifically with respect to creating a
+module like object rather than an actual module. This caused problems with
+libraries such as ActiveModel and validations, etc. Therefore, I rewrote it to
+work with normal modules.
 
-    script = Script.load("my-script.rb") { |script| script::INPUT = 3 }
+Lots of props have to go out to Joel VanderWerf for writing **script.rb** in
+the first place. It would have taken me a lot longer to accomplish this if I
+didn't have Joel's **script.rb** ruby file to go off of.
 
-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.
+Thanks Joel
 
-The Script class was inspired by Nobu Nokada's suggestion in
+It also looks that Joel was originally 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

data/lib/wrap_in_module.rb

@@ -1,7 +1,9 @@
 require "wrap_in_module/version"
 
 module WrapInModule
-  # NOTE: The following is coppied out of script.rb v0.3
+  # NOTE: The following is rewrite of script.rb v0.3. I had some issues with
+  # script.rb v0.3 so I rewrote large portions of it to work with existing
+  # modules rather than define pho modules.
   # For more information please refer to http://redshift.sourceforge.net where
   # I acquired the script-0.3.tar
 
@@ -12,128 +14,115 @@ module WrapInModule
   # 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 MissingFile < LoadError; end
 
-  class Script
-    # 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(_module, main_file)   # :yields: self
-      @__module = _module
-      @__module.extend LoadInModuleMethods
-      @__module.extend ScriptModuleMethods
-      
-      yield self if block_given?
+  def self.wrap_file(_module, _file_path)
+    _module.extend ::WrapInModule::LoadInModuleMethods
+    _module.module_eval do
+      # The file with which the Script was instantiated.
+      attr_reader :__main_file
 
-      @__module.module_eval do
-        # 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
 
-        # 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
+      @__main_file = File.expand_path(_file_path)
+      @__dir = File.dirname(@__main_file)
+      @__loaded_features = {}
+      load_in_module(@__main_file)
+    end
+  end
 
-        @__main_file = File.expand_path(main_file)
-        @__dir = File.dirname(@__main_file)
-        @__loaded_features = {}
-        load_in_module(main_file)
+  module LoadInModuleMethods
+    # 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
+        raise ::WrapInModule::MissingFile, $!.message
+      else
+        raise
       end
     end
 
-    module LoadInModuleMethods
-      # 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
+    # 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
     
-    # 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
+    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
+    # 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
 
-      # Raised by #load_in_module, caught by #load and #require.
-      class MissingFile < LoadError; 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)
+    # 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)
+      begin
         load_in_module(File.join(@__dir, file))
         true
-      rescue MissingFile
+      rescue ::WrapInModule::MissingFile
         super
       end
+    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)
+    # 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)
+      begin
         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
+      rescue ::WrapInModule::MissingFile
         @__loaded_features[feature] = false
         super
       end
     end
   end
 end
-

data/lib/wrap_in_module/version.rb

@@ -1,3 +1,3 @@
 module WrapInModule
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/spec/lib/wrap_in_module_spec.rb

@@ -3,26 +3,26 @@ require 'spec_helper'
 describe "WrapInModule" do
   it "loads a file with a single top level class" do
     module FooMod; end
-    WrapInModule::Script.new(FooMod, File.dirname(__FILE__) + '/../example_data/single_top_level_class.rb')
+    WrapInModule.wrap_file(FooMod, File.dirname(__FILE__) + '/../example_data/single_top_level_class.rb')
     FooMod::Hoopty.new
   end
 
   it "loads a file without overwriting existing module definition" do
     module FooMod; BOB="hello there I am bob"; end
-    WrapInModule::Script.new(FooMod, File.dirname(__FILE__) + '/../example_data/single_top_level_class.rb')
+    WrapInModule.wrap_file(FooMod, File.dirname(__FILE__) + '/../example_data/single_top_level_class.rb')
     FooMod::BOB
   end
 
   it "loads a file with a top level class that requires another file with a top level class" do
     module FooMod; end
-    WrapInModule::Script.new(FooMod, File.dirname(__FILE__) + '/../example_data/top_level_class_requires_another_file.rb')
+    WrapInModule.wrap_file(FooMod, File.dirname(__FILE__) + '/../example_data/top_level_class_requires_another_file.rb')
     FooMod::Doopty.new
     FooMod::Hoopty.new
   end
 
   it "verify that classes required inside of the top level loaded file are accesible in the non namespaces scope" do
     module FooMod; end
-    WrapInModule::Script.new(FooMod, File.dirname(__FILE__) + '/../example_data/top_level_class_requires_another_file.rb')
+    WrapInModule.wrap_file(FooMod, File.dirname(__FILE__) + '/../example_data/top_level_class_requires_another_file.rb')
     a = FooMod::Doopty.new
     a.test_hoopty
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wrap_in_module
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors: