RubyGems - minilab - Versions diffs - 1.1.0-x86-mswin32-60 - Mend

minilab 1.1.0-x86-mswin32-60

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (492) hide show

data/vendor/diy-1.1.1/homepage/index.html ADDED Viewed

@@ -0,0 +1,45 @@
+<html>
+  <head>
+    <title>DIY - atomicobject.rb</title>
+    <style>
+      .code_sample_title {
+        border-top: 1px solid grey;
+        width: 625px;
+        font: bold 12pt Trebuchet MS;
+        text-align:left;
+        margin: 5px;
+        padding-top: 5px;
+      }
+    </style>
+  </head>
+  <body>
+    <div align="center">
+      <map name="GraffleExport">
+	<area shape=rect coords="486,91,635,108" href="http://atomicobjectrb.rubyforge.org/">
+	<area shape=rect coords="485,120,635,187" href="rdoc/index.html">
+	<area shape=rect coords="310,120,463,187" href="http://rubyforge.org/frs/?group_id=4897&release_id=16546">
+	<area shape=rect coords="14,91,206,108" href="http://atomicobject.com">
+	<area shape=rect coords="572,16,627,71" href="http://atomicobjectrb.rubyforge.org/">
+	<area shape=rect coords="21,13,83,75" href="http://atomicobject.com">
+</map>
+<img border=0 src="page_header.png" usemap="#GraffleExport">
+      <div class="code_sample_title">
+        objects.yml:
+      </div>
+      <a href="rdoc/index.html"><img border="0" src="objects_yml.png"></a>
+      <div class="code_sample_title">
+        diy_example.rb:
+      </div>
+      <a href="rdoc/index.html"><img border="0" src="diy_example.png"></a>
+    </div>
+  </body>
+</html>

data/vendor/diy-1.1.1/homepage/objects_yml.png ADDED Viewed

Binary file

data/vendor/diy-1.1.1/homepage/page_header.graffle ADDED Viewed

Binary file

data/vendor/diy-1.1.1/homepage/page_header.html ADDED Viewed

@@ -0,0 +1,9 @@
+<map name="GraffleExport">
+	<area shape=rect coords="486,91,635,108" href="http://atomicobjectrb.rubyforge.org/">
+	<area shape=rect coords="485,120,635,187" href="rdoc/index.html">
+	<area shape=rect coords="310,120,463,187" href="http://rubyforge.org/frs/?group_id=4897&release_id=16546">
+	<area shape=rect coords="14,91,206,108" href="http://atomicobject.com">
+	<area shape=rect coords="572,16,627,71" href="http://atomicobjectrb.rubyforge.org/">
+	<area shape=rect coords="21,13,83,75" href="http://atomicobject.com">
+</map>
+<img border=0 src="page_header.png" usemap="#GraffleExport">

data/vendor/diy-1.1.1/homepage/page_header.png ADDED Viewed

Binary file

data/vendor/diy-1.1.1/lib/diy.rb ADDED Viewed

@@ -0,0 +1,365 @@
+require 'yaml'
+require 'set'
+module DIY #:nodoc:#
+  VERSION = '1.1.1'
+	class Context
+    class << self
+      # Enable / disable automatic requiring of libraries. Default: true
+      attr_accessor :auto_require
+    end
+    @auto_require = true
+    # Accepts a Hash defining the object context (usually loaded from objects.yml), and an additional
+    # Hash containing objects to inject into the context.
+		def initialize(context_hash, extra_inputs={})
+			raise "Nil context hash" unless context_hash
+			raise "Need a hash" unless context_hash.kind_of?(Hash)
+			[ "[]", "keys" ].each do |mname|
+				unless extra_inputs.respond_to?(mname)
+					raise "Extra inputs must respond to hash-like [] operator and methods #keys and #each"
+				end
+			end
+			# store extra inputs
+			if extra_inputs.kind_of?(Hash)
+				@extra_inputs= {}
+				extra_inputs.each { |k,v| @extra_inputs[k.to_s] = v } # smooth out the names
+			else
+				@extra_inputs = extra_inputs
+			end
+      collect_object_and_subcontext_defs context_hash
+			# init the cache
+			@cache = {}
+			@cache['this_context'] = self
+		end
+    # Convenience: create a new DIY::Context by loading from a String (or open file handle.)
+		def self.from_yaml(io_or_string, extra_inputs={})
+			raise "nil input to YAML" unless io_or_string
+			Context.new(YAML.load(io_or_string), extra_inputs)
+		end
+    # Convenience: create a new DIY::Context by loading from the named file.
+		def self.from_file(fname, extra_inputs={})
+			raise "nil file name" unless fname
+			self.from_yaml(File.read(fname), extra_inputs)
+		end
+    # Return a reference to the object named.  If necessary, the object will
+    # be instantiated on first use.  If the object is non-singleton, a new
+    # object will be produced each time.
+		def get_object(obj_name)
+			key = obj_name.to_s
+			obj = @cache[key]
+			unless obj
+				if extra_inputs_has(key)
+					obj = @extra_inputs[key]
+        else
+          case @defs[key]
+          when MethodDef
+            obj = construct_method(key)
+            @cache[key] = obj
+          else
+            obj = construct_object(key)
+            @cache[key] = obj if @defs[key].singleton?
+          end
+				end
+			end
+			obj
+		end
+		alias :[] :get_object
+    # Inject a named object into the Context.  This must be done before the Context has instantiated the
+    # object in question.
+		def set_object(obj_name,obj)
+			key = obj_name.to_s
+			raise "object '#{key}' already exists in context" if @cache.keys.include?(key)
+			@cache[key] = obj
+		end
+		alias :[]= :set_object
+    # Provide a listing of object names
+		def keys
+			(@defs.keys.to_set + @extra_inputs.keys.to_set).to_a
+		end
+		# Instantiate and yield the named subcontext
+		def within(sub_context_name)
+			# Find the subcontext definitaion:
+			context_def = @sub_context_defs[sub_context_name.to_s]
+			raise "No sub-context named #{sub_context_name}" unless context_def
+			# Instantiate a new context using self as parent:
+			context = Context.new( context_def, self )
+			yield context
+		end
+    # Returns true if the context contains an object with the given name
+		def contains_object(obj_name)
+			key = obj_name.to_s
+			@defs.keys.member?(key) or extra_inputs_has(key)
+		end
+    # Every top level object in the Context is instantiated.  This is especially useful for
+    # systems that have "floating observers"... objects that are never directly accessed, who
+    # would thus never be instantiated by coincedence.  This does not build any subcontexts
+    # that may exist.
+		def build_everything
+			@defs.keys.each { |k| self[k] }
+		end
+		alias :build_all :build_everything
+		alias :preinstantiate_singletons :build_everything
+		private
+    def collect_object_and_subcontext_defs(context_hash)
+			@defs = {}
+			@sub_context_defs = {}
+      get_defs_from context_hash
+    end
+    def get_defs_from(hash, namespace=nil)
+      hash.each do |name,info|
+        name = name.to_s
+        case name
+        when /^\+/
+          # subcontext
+          @sub_context_defs[name.gsub(/^\+/,'')] = info
+        when /^using_namespace/
+          # namespace: use a module(s) prefix for the classname of contained object defs
+          # NOTE: namespacing is NOT scope... it's just a convenient way to setup class names for a group of objects.
+          get_defs_from info, parse_namespace(name)
+        when /^method\s/
+          key_name = name.gsub(/^method\s/, "")
+          @defs[key_name] = MethodDef.new(:name => key_name,
+                                      :object => info['object'],
+                                      :method => info['method'])
+        else
+          # Normal object def
+          info ||= {}
+          if extra_inputs_has(name)
+            raise ConstructionError.new(name, "Object definition conflicts with parent context")
+          end
+          unless info.has_key?('auto_require')
+            info['auto_require'] = self.class.auto_require
+          end
+          if namespace
+            if info['class']
+              info['class'] = namespace.build_classname(info['class'])
+            else
+              info['class'] = namespace.build_classname(name)
+            end
+          end
+          @defs[name] = ObjectDef.new(:name => name, :info => info)
+        end
+      end
+    end
+    def construct_method(key)
+      method_definition = @defs[key]
+      object = get_object(method_definition.object)
+      return object.method(method_definition.method)
+    rescue Exception => oops
+      build_and_raise_construction_error(key, oops)
+    end
+		def construct_object(key)
+			# Find the object definition
+			obj_def = @defs[key]
+			raise "No object definition for '#{key}'" unless obj_def
+			# If object def mentions a library, load it
+      require obj_def.library	if obj_def.library
+			# Resolve all components for the object
+			arg_hash = {}
+			obj_def.components.each do |name,value|
+				case value
+				when Lookup
+					arg_hash[name.to_sym] = get_object(value.name)
+				when StringValue
+					arg_hash[name.to_sym] = value.literal_value
+				else
+					raise "Cannot cope with component definition '#{value.inspect}'"
+				end
+			end
+			# Get a reference to the class for the object
+			big_c = get_class_for_name_with_module_delimeters(obj_def.class_name)
+			# Make and return the instance
+      if obj_def.use_class_directly?
+        return big_c
+      elsif arg_hash.keys.size > 0
+  			return big_c.new(arg_hash)
+			else
+				return big_c.new
+			end
+		rescue Exception => oops
+		  build_and_raise_construction_error(key, oops)
+		end
+		def build_and_raise_construction_error(key, oops)
+		  cerr = ConstructionError.new(key,oops)
+			cerr.set_backtrace(oops.backtrace)
+			raise cerr
+		end
+		def get_class_for_name_with_module_delimeters(class_name)
+			class_name.split(/::/).inject(Object) do |mod,const_name| mod.const_get(const_name) end
+		end
+		def extra_inputs_has(key)
+			if key.nil? or key.strip == ''
+				raise ArgumentError.new("Cannot lookup objects with nil keys")
+			end
+			@extra_inputs.keys.member?(key) or @extra_inputs.keys.member?(key.to_sym)
+		end
+    def parse_namespace(str)
+      Namespace.new(str)
+    end
+	end
+  class Namespace #:nodoc:#
+    def initialize(str)
+      # 'using_namespace Animal Reptile'
+      parts = str.split(/\s+/)
+      raise "Namespace definitions must begin with 'using_namespace'" unless parts[0] == 'using_namespace'
+      parts.shift
+      if parts.length > 0 and parts[0] =~ /::/
+        parts = parts[0].split(/::/)
+      end
+      raise NamespaceError, "Namespace needs to indicate a module" if parts.empty?
+      @module_nest = parts
+    end
+    def build_classname(name)
+      [ @module_nest, Infl.camelize(name) ].flatten.join("::")
+    end
+  end
+	class Lookup #:nodoc:
+		attr_reader :name
+		def initialize(obj_name)
+			@name = obj_name
+		end
+	end
+  class MethodDef #:nodoc:
+    attr_accessor :name, :object, :method
+    def initialize(opts)
+      @name, @object, @method = opts[:name], opts[:object], opts[:method]
+    end
+  end
+	class ObjectDef #:nodoc:
+		attr_accessor :name, :class_name, :library, :components
+		def initialize(opts)
+      name = opts[:name]
+      raise "Can't make an ObjectDef without a name" if name.nil?
+      info = opts[:info] || {}
+      info = info.clone
+			@components = {}
+			# Object name
+			@name = name
+			# Class name
+			@class_name = info.delete 'class'
+			@class_name ||= info.delete 'type'
+			@class_name ||= Infl.camelize(@name)
+      # Auto Require
+      @auto_require = info.delete 'auto_require'
+			# Library
+			@library = info.delete 'library'
+			@library ||= info.delete 'lib'
+			@library ||= Infl.underscore(@class_name) if @auto_require
+			# Use Class Directly
+			@use_class_directly = info.delete 'use_class_directly'
+			# Auto-compose
+			compose = info.delete 'compose'
+			if compose
+				case compose
+				when Array
+					auto_names = compose.map { |x| x.to_s }
+				when String
+					auto_names = compose.split(',').map { |x| x.to_s.strip }
+				when Symbol
+					auto_names = [ compose.to_s ]
+				else
+					raise "Cannot auto compose object #{@name}, bad 'compose' format: #{compose.inspect}"
+				end
+			end
+			auto_names ||= []
+			auto_names.each do |cname|
+				@components[cname] = Lookup.new(cname)
+			end
+      # Singleton status
+      if info['singleton'].nil?
+        @singleton = true
+      else
+        @singleton = info['singleton']
+      end
+      info.delete 'singleton'
+			# Remaining keys
+			info.each do |key,val|
+				@components[key.to_s] = Lookup.new(val.to_s)
+			end
+		end
+    def singleton?
+      @singleton
+    end
+    def use_class_directly?
+      @use_class_directly == true
+    end
+	end
+	class ConstructionError < RuntimeError #:nodoc:#
+		def initialize(object_name, cause=nil)
+			object_name = object_name
+			cause = cause
+			m = "Failed to construct '#{object_name}'"
+			if cause
+				m << "\n  ...caused by:\n  >>> #{cause}"
+			end
+			super m
+		end
+	end
+  class NamespaceError < RuntimeError #:nodoc:#
+  end
+  module Infl #:nodoc:#
+    # Ganked this from Inflector:
+    def self.camelize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+    # Ganked this from Inflector:
+    def self.underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+    end
+  end
+end

data/vendor/diy-1.1.1/sample_code/car.rb ADDED Viewed

@@ -0,0 +1,7 @@
+class Car
+  attr_reader :engine, :chassis
+  def initialize(arg_hash)
+    @engine = arg_hash[:engine]
+    @chassis = arg_hash[:chassis]
+  end
+end

data/vendor/diy-1.1.1/sample_code/chassis.rb ADDED Viewed

@@ -0,0 +1,5 @@
+class Chassis
+  def to_s
+    "Chassis"
+  end
+end

data/vendor/diy-1.1.1/sample_code/diy_example.rb ADDED Viewed

@@ -0,0 +1,26 @@
+require "rubygems"
+require "diy"
+class Car
+  attr_reader :engine, :chassis
+  def initialize(arg_hash)
+    @engine = arg_hash[:engine]
+    @chassis = arg_hash[:chassis]
+  end
+end
+class Chassis
+  def to_s
+    "Chassis"
+  end
+end
+class Engine
+  def to_s
+    "Engine"
+  end
+end
+context = DIY::Context.from_file("objects.yml")
+car = context['car']
+puts "Car is made of: #{car.engine} and #{car.chassis}"