recess 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Brian Leonard
+
+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.mdown

@@ -0,0 +1,83 @@
+## Recess
+
+You know... to break up your classes.
+
+### Inside
+
+You can make classes that completely encapsulate behavior and have a defined interface with a parent object.
+
+For example, let's define the behavior.
+
+    class TestInside1 < Recess::Inside::Base
+      parent_instance :foo
+  
+      def my_method
+        "yes: #{foo}"
+      end
+  
+      def other_method
+        "no"
+      end
+    end
+    
+This has methods that interact with the parent's foo method. This is then included within the parent.
+The parent also declares what method it wants from the inside class.
+
+    class TestContainer1
+      inside TestInside1, :my_method
+  
+      def initialize(val)
+        @val = val
+      end
+  
+      def foo
+        @val
+      end
+      
+    end
+
+Technically, calling the inside method, defines a method on the parent that delegates to the inner class. Note that in the above other_method is not actually available on the parent, but my_method is.
+The parent_instance method does something similar to get/set data on the parent.
+
+Why would you want to do such a thing?
+
+* TestInside1 is completely testable as a standalone class
+* The inner class can be shared among models but the surface area of the inside class is minimized to only what is needed
+* Understanding dependencies through these strict mechanisms helps understand the impact of changes to shared code
+
+### Outside
+
+The other functionality is for class methods and stretches the metaphor a bit.
+
+    module TestOutside1
+      recess_group :something do
+        def self.test_class_method
+          "class_level"
+        end
+    
+        def test_instance_method
+          "instance_level"
+        end
+      end
+  
+      recess_group :else do
+        def self.other_test_class_method
+          "class_level2"
+        end
+    
+        def other_test_instance_method
+          "instance_level2"
+        end
+      end
+    end
+
+    class TestOutsideExample1
+      outside TestOutside1, :something
+    end
+
+It's like doing an include but with a certain name. In the above, only the :something group is included into TestOutsideExample1.
+Again, this is mainly about understanding dependencies.
+
+Copyright (c) 2011 Brian Leonard, released under the MIT license
+
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/recess/inside.rb

@@ -0,0 +1,133 @@
+module Recess::Inside
+  module ClassMethods
+    def recess_inside_instance_methods(from_base=nil)
+      return [] unless @recess_inside_instance_methods
+      return @recess_inside_instance_methods.keys unless from_base
+      (@recess_inside_base_classes[from_base] || []).uniq
+    end
+    
+    def recess_inside_objects_options
+      @recess_inside_objects_options ||= {}
+    end
+    
+    def inside(what, *args)
+      options = args.last.is_a?(::Hash) ? args.pop : {}
+      object_clazz = what
+      recess_inside_objects_options[object_clazz.to_s] = options
+      
+      @recess_inside_instance_methods ||= {}
+      @recess_inside_base_classes ||= {}
+      
+      unless @recess_inside_base_classes[object_clazz]
+        if object_clazz.respond_to?(:insided)
+          if object_clazz.method(:insided).arity == 1
+            object_clazz.insided(self)
+          else
+            object_clazz.insided(self, args)
+          end
+        end
+      end
+      
+      object_clazz.all_parent_instance_methods.each do |used|
+        @recess_inside_base_classes[object_clazz] ||= []
+        @recess_inside_base_classes[object_clazz] << used
+        
+        @recess_inside_instance_methods[used] ||= []
+        @recess_inside_instance_methods[used] << object_clazz
+      end
+      
+      unless method_defined? :recess_inside_instance_objects
+        define_method(:recess_inside_instance_objects) do |clazz|
+          data_method = self.class.recess_inside_objects_options[clazz.to_s][:data]
+          @recess_inside_instance_objects ||= {}
+          @recess_inside_instance_objects[clazz.to_s] ||= clazz.new(self, data_method)
+        end
+      end
+
+      args.each do |delegated|
+        the_alias = object_clazz.parent_aliased_instance_methods[delegated.to_s]
+        if the_alias and not method_defined?(the_alias)
+          if method_defined?(delegated)
+            class_eval("alias #{the_alias} #{delegated}")
+          elsif respond_to?(:column_names) # TODO: causing crash on load --- and column_names.include?(delegated.to_s)
+            define_method the_alias do
+              read_attribute(delegated)
+            end
+          end
+        end
+        
+        define_method delegated do |*args|
+          recess_inside_instance_objects(object_clazz).send(delegated, *args)
+        end
+      end
+    end
+  end
+  
+  class Base
+    def self.all_parent_instance_methods
+      (parent_instance_methods + parent_aliased_instance_methods.keys).collect(&:to_s).uniq
+    end
+    
+    def self.parent_instance_methods
+      @parent_instance_methods ||= []
+    end
+    
+    def self.parent_aliased_instance_methods
+      @parent_aliased_instance_methods ||= {}
+    end
+    
+    def self.parent_instance meth
+      parent_instance_methods << meth.to_s
+      define_method meth do |*args|
+        parent_data.send(meth, *args)
+      end
+    end
+    
+    def self.alias_parent_instance super_meth, meth
+      parent_instance_methods << meth.to_s
+      the_alias = "#{meth}_before_recess"
+      parent_aliased_instance_methods[meth.to_s] = the_alias
+      define_method super_meth do |*args|
+        if parent_data.respond_to?(the_alias)
+          parent_data.send(the_alias, *args)
+        else
+          parent_data.send(meth, *args)
+        end
+      end
+    end
+    
+    def initialize(instance, data_method = nil)
+      @instance = instance
+
+      if data_method
+        if data_method.is_a? Array
+          @data_args = data_method
+        else
+          @data_args = [data_method]
+        end
+      else
+        @data_args = nil
+      end
+    end
+
+    protected
+    
+    def parent_root
+      @instance
+    end
+    
+    def data_args
+      @data_args
+    end
+    
+    def parent_data
+      if data_args
+        parent_root.send(*data_args)
+      else
+        parent_root
+      end
+    end
+  end
+end
+
+Object.send :include, Recess::Inside::ClassMethods

data/lib/recess/outside.rb

@@ -0,0 +1,25 @@
+module Recess::Outside
+  module ClassMethods
+    def recess_group(name, &block)
+      @recess_groups ||= {}
+      @recess_groups[name.to_s] = block
+    end
+    
+    def outside(what, *args)
+      options = args.last.is_a?(::Hash) ? args.pop : {}
+      object_clazz = what
+      
+      groups = object_clazz.instance_variable_get("@recess_groups")
+      raise "Missing recess_groups directive in #{object_clazz}" unless groups
+      
+      args.each do |trait_name|
+        macro = groups[trait_name.to_s]
+        raise "Missing recess group name: #{trait_name}" unless macro
+        
+        class_exec(&macro)
+      end
+    end
+  end
+end
+
+Object.send :include, Recess::Outside::ClassMethods

data/lib/recess/version.rb

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

data/lib/recess.rb

@@ -0,0 +1,11 @@
+require "recess/version"
+
+module Recess
+  module Inside
+    
+  end
+end
+
+require "recess/outside"
+require "recess/inside"
+

data/recess.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "recess/version"
+
+Gem::Specification.new do |s|
+  s.name        = "recess"
+  s.version     = Recess::VERSION
+  s.authors     = ["Brian Leonard"]
+  s.email       = ["brian@bleonard.com"]
+  s.homepage    = ""
+  s.summary     = %q{You know, to break up your classes.}
+  s.description = %q{You know, to break up your classes.}
+
+  s.rubyforge_project = "recess"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec', '1.3.0'
+  s.add_development_dependency 'mocha', '0.9.8'
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/spec/inside_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+class TestInside1 < Recess::Inside::Base
+  parent_instance :foo
+  parent_instance :foo=
+  
+  def my_method
+    "yes: #{foo}"
+  end
+  
+  def other_method
+    "no"
+  end
+end
+
+class TestInside2 < Recess::Inside::Base
+  alias_parent_instance :super_foo, :foo
+  
+  def foo
+    "super: #{super_foo}"
+  end
+end
+
+class TestContainer1
+  inside TestInside1, :my_method
+  
+  def initialize(val)
+    @val = val
+  end
+  
+  def foo
+    @val
+  end
+end
+
+class TestContainer2
+  inside TestInside1, :my_method, :data => :whatever
+  
+  def initialize(val)
+    @val = val
+  end
+  
+  def foo
+    @val
+  end
+  
+  def whatever
+    @whatever ||= TestExample1Data.new
+  end
+end
+
+class TestContainer3
+  # can't put it before as it prevents aliasing
+  
+  def foo
+    "container"
+  end
+  
+  # override, but call back to the above
+  inside TestInside2, :foo
+end
+
+
+class TestInside4 < Recess::Inside::Base
+  
+  def self.insided(model)
+    model.callback_here("yeah")
+  end
+  
+  def foo
+    "here"
+  end
+end
+
+class TestContainer4
+  def self.callback_here(val)
+    @called_value = val
+  end
+  
+  def self.called_value
+    @called_value
+  end
+  
+  inside TestInside4, :foo
+end
+
+class TestExample1Data
+  def initialize(val="data")
+    @val = val
+  end
+  def foo
+    @val
+  end
+end
+
+class TestExample1
+  def foo=val
+    @foo = val
+  end
+  def foo
+    @foo ||= "one"
+  end
+  
+  def bar
+    "two"
+  end
+  
+  def data
+    @data ||= TestExample1Data.new
+  end
+  
+  def initd(val)
+    @initd ||= TestExample1Data.new(val)
+  end
+end
+
+describe "Containers" do
+  it "should know what properties are requested of it" do
+    TestContainer1.recess_inside_instance_methods.should =~ ["foo", "foo="]
+    TestContainer1.recess_inside_instance_methods(TestInside1).should =~ ["foo", "foo="]
+    TestContainer3.recess_inside_instance_methods(TestInside2).should =~ ["foo"]
+  end
+  
+  it "should allow call through to super" do
+    container = TestContainer3.new
+    container.foo.should == "super: container"
+  end
+  
+  it "should pass through to the inside" do
+    container = TestContainer1.new("what")
+    container.foo.should == "what"
+    container.my_method.should == "yes: what"
+    
+    lambda { container.other_method }.should raise_error
+  end
+  
+  it "should be able to take in data attribute" do
+    container = TestContainer2.new("what")
+    container.foo.should == "what"
+    container.whatever.foo.should == "data"
+    container.my_method.should == "yes: data"
+    
+    lambda { container.other_method }.should raise_error
+  end
+  
+  it "should call back the container when included" do
+    TestContainer4.called_value.should == "yeah"
+  end
+end
+
+describe "Base" do
+  it "should pass through declared attribtues to the init'd class" do
+    example = TestExample1.new
+    test = TestInside1.new(example)
+    test.foo.should == "one"
+    test.foo = "set"
+    test.foo.should == "set"
+    
+    lambda { test.bar }.should raise_error
+  end
+  
+  it "should use the data if noted" do
+    example = TestExample1.new
+    test = TestInside1.new(example, :data)
+    test.foo.should == "data"
+    
+    example = TestExample1.new
+    test = TestInside1.new(example, [:data])
+    test.foo.should == "data"
+  end
+  
+  it "should use the data and args" do
+    example = TestExample1.new
+    test = TestInside1.new(example, [:initd, "sent"])
+    test.foo.should == "sent"
+  end
+  
+  it "should call through to the parent" do
+    example = TestExample1.new
+    test = TestInside2.new(example)
+    test.foo.should == "super: one"
+  end
+end

data/spec/outside_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module TestOutside1
+  recess_group :something do
+    def self.test_class_method
+      "class_level"
+    end
+    
+    def test_instance_method
+      "instance_level"
+    end
+  end
+  
+  recess_group :else do
+    def self.other_test_class_method
+      "class_level2"
+    end
+    
+    def other_test_instance_method
+      "instance_level2"
+    end
+  end
+end
+
+class TestOutsideExample1
+  outside TestOutside1, :something
+end
+
+describe "Outside methods" do
+  it "should inject those methods" do
+    TestOutsideExample1.test_class_method.should == "class_level"
+    TestOutsideExample1.new.test_instance_method.should == "instance_level"
+    
+    lambda { TestOutsideExample1.other_test_class_method }.should raise_error
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require 'spec/autorun'
+
+require 'recess'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/test_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "Setup Rspec" do
+  it "should work" do
+    (1+1).should == 2
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: recess
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brian Leonard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id002
+description: You know, to break up your classes.
+email: 
+- brian@bleonard.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.mdown
+- Rakefile
+- lib/recess.rb
+- lib/recess/inside.rb
+- lib/recess/outside.rb
+- lib/recess/version.rb
+- recess.gemspec
+- spec/inside_spec.rb
+- spec/outside_spec.rb
+- spec/spec_helper.rb
+- spec/test_spec.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: recess
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: You know, to break up your classes.
+test_files: 
+- spec/inside_spec.rb
+- spec/outside_spec.rb
+- spec/spec_helper.rb
+- spec/test_spec.rb