scoped_struct 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Mike Ferrier
+
+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

@@ -0,0 +1,100 @@
+== Scoped Struct
+
+Ever write a ruby class and wish you could organize your methods into sub-objects? Take, for example, a class that represents an NFL player:
+
+  class Player
+    def fumbles_dropped; end
+    def fumbles_lost; end
+    def fumbles_recovered; end
+    def passes_attempted; end
+    def passes_completed; end
+    def passes_incomplete; end
+    def pass_completion_percentage; end
+  end
+
+But we're ~Ruby Programmers~ and we write DRY code, right? Wouldn't it be nicer if you could take all that repetition and eliminate it?
+
+  class Player
+    scope :fumbles do
+      def dropped; end
+      def lost; end
+      def recovered; end
+    end
+    
+    scope :passes do
+      def attempted; end
+      def completed; end
+      def incomplete; end
+      def completion_percentage; end
+    end
+  end
+
+And then instead of those long ugly method names, you could just be all like,
+
+  my_player.passes.attempted
+  my_player.passes.completed
+  my_player.fumbles.recovered
+  
+Eez better, yes?
+
+The methods you define in the scoping block, when called, run in the same context as if you defined them on the class itself. So you ccan have them referencing instance variables or other methods of the class as if they were local. Likewise, you can also reference other scoped methods from scoped methods, even from other scopes; just make sure to reference them by their full scoped path:
+
+  class Player
+    def name
+      "John Rambo"
+    end
+    
+    scope :formatting do
+      def loud_name
+        name.upcase + '!!!'
+      end
+    end
+    
+    scope :actions do
+      def scream_my_name
+        puts "MY NAME IS #{formatting.loud_name}"
+      end
+      
+      def scream_twice
+        2.times{ actions.scream_my_name }
+      end
+    end
+  end
+  
+  Player.new.actions.scream_twice # prints "MY NAME IS JOHN RAMBO!!!" twice
+
+And that's not all! The object returned by the scoping method, you can pass it around and it will still act the way you'd expect:
+
+  fumble_records = my_players.collect{|player| player.fumbles}
+  fumble_records.first.dropped
+
+And if you want even more organizational fun, you can stick your methods in modules and then include them in their own scoping blocks:
+
+  module Passes
+    def attempted; end
+  end
+  
+  module Fumbles
+    def dropped; end
+  end
+  
+  class Player
+    scope :passes do
+      include Passes
+    end
+    
+    scope :fumbles do
+      include Fumbles
+    end
+  end
+
+
+== Troubleshooting
+
+One thing that will cause weirdness is if you name a scoped method the same thing as one of your base instance methods. Rename it to something else and all will be well.
+
+== Credits
+
+By Mike Ferrier (http://www.mikeferrier.ca)
+
+Contributions by Hampton Catlin (http://www.hamptoncatlin.com)

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+Gem::manage_gems
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  s.name = "scoped_struct"
+  s.summary = "A library that allows Ruby programmers to better organize their instance methods."
+  s.version = File.read('VERSION').strip
+  s.author = "Mike Ferrier"
+  s.email = "mferrier@gmail.com"
+  s.homepage = "http://scopedstruct.rubyforge.org"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "http://scopedstruct.rubyforge.org"
+  
+  readmes = FileList.new('*') do |list|
+    list.exclude(/[a-z]/)
+    list.exclude('TODO')
+  end.to_a
+  s.files = FileList['lib/**/*', 'test/**/*', 'Rakefile'].to_a + readmes
+  
+  s.require_path = "lib"
+  s.rubyforge_project = "scopedstruct"
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "MIT-LICENSE"]
+  s.rdoc_options += [
+    '--title', 'Scoped Struct',
+    '--main', 'README',
+    '--line-numbers',
+    '--inline-source'
+  ]
+  
+  s.test_files = FileList['test/**/*_test.rb'].to_a
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+task :release => [:package] do
+  name, version = ENV['NAME'], ENV['VERSION']
+  raise "Must supply NAME and VERSION for release task." unless name && version
+  sh %{rubyforge login}
+  sh %{rubyforge add_release scopedstruct scopedstruct "#{name} (v#{version})" pkg/scoped_struct-#{version}.gem}
+  sh %{rubyforge add_file    scopedstruct scopedstruct "#{name} (v#{version})" pkg/scoped_struct-#{version}.zip}
+end

data/VERSION

@@ -0,0 +1 @@
+0.1

data/lib/scoped_struct.rb

@@ -0,0 +1,56 @@
+module ScopedStruct
+    
+  module ClassMethods
+    def scope(scope_name, &block)
+      MethodCarrier.set_scoped_methods(scope_name, block)
+      self.extend MethodCarrier
+      self.send(:define_method, scope_name) do
+        ProxyObject.new(self, scope_name)
+      end
+    end
+  end
+  
+  class ProxyObject
+    def initialize(parent, scope_name)
+      @parent, @scope_name = parent, scope_name
+    end
+    
+    def method_missing(name, *args, &block)
+      @parent.send(@scope_name.to_s + "_" + name.to_s, *args, &block)
+    end
+  end
+  
+  module MethodCarrier
+    def self.extend_object(base)
+      @@method_names.each do |method_name|
+        base.class_eval %Q(
+          alias #{@@scope_name + '_' + method_name} #{method_name}
+          undef #{method_name}
+        )
+      end
+    end
+    
+    def self.set_scoped_methods(scope_name, method_declarations)
+      raise SyntaxError.new("No block passed to scope command.") if method_declarations.nil?
+      @@scope_name = scope_name.to_s
+      @@method_names = extract_method_names(method_declarations).collect{|m| m.to_s}
+      raise SyntaxError.new("No methods defined in scope block.") unless @@method_names.any?
+      method_declarations.call
+    end
+    
+    def self.extract_method_names(method_declarations)
+      cls = BlankSlate.new
+      original_methods = cls.methods
+      cls.extend(Module.new(&method_declarations))
+      cls.methods - original_methods
+    end
+    
+    # Jim Weirich's BlankSlate class from http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+    # We use a slightly modified version of it to figure out what methods were defined in the scope block
+    class BlankSlate
+      instance_methods.each { |m| undef_method m unless m =~ /^(__|methods|extend)/ }
+    end
+  end
+end
+
+Object.extend(ScopedStruct::ClassMethods)

data/test/scoped_struct_test.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + "/../lib/scoped_struct")
+
+module Passing
+  def attempts
+    50
+  end
+  
+  def completions
+    25
+  end
+  
+  def percent_completed
+    passing.completions.to_f / passing.attempts.to_f
+  end
+end
+
+module Defense
+  def tackles
+    23
+  end
+  
+  def passes_blocked
+    8
+  end  
+end
+
+class Player
+  
+  def name
+    "jimmy"
+  end
+    
+  scope :passing do
+    include Passing
+  end
+  
+  scope :defense do
+    include Defense
+  end
+  
+  scope :foo do
+    def scream_name
+      name.upcase
+    end
+  end
+end
+
+class ScopedStructTest < Test::Unit::TestCase
+  def test_it
+    assert_equal 50, Player.new.passing.attempts
+    assert_equal 23, Player.new.defense.tackles
+    assert_equal 0.5, Player.new.passing.percent_completed
+    assert_equal 'JIMMY', Player.new.foo.scream_name
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: scoped_struct
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Mike Ferrier
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-27 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mferrier@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+files: 
+- lib/scoped_struct.rb
+- test/scoped_struct_test.rb
+- Rakefile
+- VERSION
+- MIT-LICENSE
+- README
+has_rdoc: true
+homepage: http://scopedstruct.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --title
+- Scoped Struct
+- --main
+- README
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: scopedstruct
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: http://scopedstruct.rubyforge.org
+test_files: 
+- test/scoped_struct_test.rb