boil 0.0.5

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Martin Bilski
+
+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

@@ -0,0 +1,117 @@
+Automatic building of composed objects using Ruby reflection and meta-programming.
+
+---
+
+TODO
+----
+
+- Global namespace.
+- Same module.
+- Different modules.
+
+---
+
+Quick start
+-----------
+
+	> gem install boil
+	
+	An example: 
+	
+	ReviewSubmissionPresenter
+      ReviewSubmissionView
+      ReviewSubmissionModel
+        ReviewStore
+        ReviewValidationPolicy
+        ReviewResubmissionPolicy
+        
+  (TODO: insert image of dependency diagram)
+
+  With classes in the global namespace or in the same module, it uses reasonable defaults:
+
+      class ReviewSubmissionPresenter
+        def initialize(review_submission_view, review_submission_model)
+        # ...
+        end
+      end
+
+      class ReviewSubmissionModel
+        def initialize(review_workflow_policy)
+        # ...
+        end
+      end
+
+      def ReviewSubmissionView
+        # ...
+      end
+
+      class ReviewWorkflowPolicy
+        def initialize(review_store, review_validation_policy, review_resubmission_policy)
+        # ...
+        end
+      end
+
+  
+  **TBD** With different module, you need to explicitly compose:
+  
+      module Presenters
+        class ReviewSubmissionPresenter
+          include Boil::Composer
+          compose view: Views::ReviewSubmissionView
+          compose model: Models::ReviewSubmissionModel
+
+          def initialize(view, model)
+          # ...
+          end
+        end
+
+      module Models
+      
+        class ReviewSubmissionModel
+          include Boil::Composer
+          compose review_workflow_policy: Policies::ReviewWorkflowPolicy
+        
+          def initialize(review_workflow_policy)
+          # ...
+          end
+        end
+      end
+      
+      module Views
+        def ReviewSubmissionView
+          # ...
+        end
+      end
+      
+      
+      module Policies
+        class ReviewWorkflowPolicy
+          include Boil::Composer
+          
+          compose 
+            review_store: Stores::ReviewStore,
+            review_validation_policy: Policies::ReviewValidationPolicy,
+            review_resubmission_policy: Policies::ReviewResubmissionPolicy
+
+        
+          def initialize(review_store, review_validation_policy, review_resubmission_policy)
+          # ...
+          end
+        end
+      
+        class ReviewValidationPolicy
+        end
+      
+        class ReviewResubmissionPolicy
+          include Boil::Composer
+          compose review_store: DataStores::ReviewStore
+          
+          def initialize(review_store)
+          end
+        end
+      end
+      
+      module DataStores
+        class ReviewStore
+        end
+      end

data/lib/boil/composer/builder.rb

@@ -0,0 +1,20 @@
+require 'active_support/inflector' # String.camelize, String.constantize, String.underscore
+require_relative './reflection_helpers'
+require_relative './dependency_walker'
+require_relative './target_class_decorator'
+
+module Boil
+  module Composer
+    module Builder
+      def create_factory_method_for(*classes)
+        classes.each do |cls|
+          DependencyWalker.new(TargetClassDecorator.new(self)).create_factory_method_for_class(cls)
+        end
+      end
+    
+      def factory_methods
+        TargetClassDecorator.new(self).factory_methods
+      end
+    end
+  end
+end

data/lib/boil/composer/dependency_walker.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/module/introspection'
+
+module Boil
+  module Composer
+    class DependencyWalker
+      include ReflectionHelpers
+    
+      def initialize(target_class)
+        @target_class = target_class
+      end
+    
+      def create_factory_method_for_class(cls)
+        begin
+          create_factory_methods_for_dependencies(constantize_class(cls))
+          @target_class.define_factory_method(cls)
+        rescue SystemStackError
+          raise "Stack too deep when trying to define factory method for #{cls} -- circular reference in initialize parameters?"
+        end
+      end
+
+      def create_factory_methods_for_dependencies(cls)
+        constructor_parameters(cls).each do |param|
+          begin
+            if class_name?(class_from_constructor_param(cls, param))
+              create_factory_method_for_class(class_from_constructor_param(cls, param))
+            else 
+              # If it's already defined, we don't care that there is no corresponding class.
+              raise ClassConstNotFound unless @target_class.method_defined?(param)
+            end
+          rescue ClassConstNotFound
+            class_name = class_from_constructor_param(cls, param)
+            raise "#{cls} has constructor argument '#{param}' without a corresponding class (#{class_name})"
+          end
+        end
+      end
+
+      def class_from_constructor_param(parent_class, constructor_param)
+        parent_module_name = parent_class.parent.to_s
+        class_name = "#{parent_module_name}::#{constructor_param.to_s.camelize}"
+      end
+    end
+  end
+end

data/lib/boil/composer/reflection_helpers.rb

@@ -0,0 +1,29 @@
+module Boil
+  module Composer
+    module ReflectionHelpers
+      ClassConstNotFound = Class.new(RuntimeError)
+    
+      def constructor_parameters(cls)
+        parameters = cls.instance_method(:initialize).parameters
+        return [] if parameters == [[:rest]]
+        parameters.map {|req, name| name || req }
+      end
+
+      def class_name?(name)
+        begin
+          name.constantize.is_a?(Class)
+        rescue NameError
+          false
+        end
+      end
+    
+      def constantize_class(class_or_name)
+        begin
+          class_or_name.is_a?(String) ? class_or_name.constantize : class_or_name
+        rescue NameError
+          raise ClassConstNotFound
+        end
+      end
+    end
+  end
+end

data/lib/boil/composer/target_class_decorator.rb

@@ -0,0 +1,68 @@
+module Boil
+  module Composer
+    class TargetClassDecorator
+      include ReflectionHelpers
+    
+      def initialize(target_class)
+        @target_class = target_class
+      end
+    
+      def define_factory_method(class_or_name)
+        factory_method_name = factory_method_name(class_or_name)
+        prevent_old_method_override(factory_method_name)
+        unless @target_class.method_defined?(factory_method_name)
+          cls = constantize_class(class_or_name)
+          constructor_params = constructor_parameters(cls)
+          @target_class.send(:define_method, factory_method_name) do
+            instance_variable_name = "@#{factory_method_name.to_s}".to_sym
+            instance_variable = instance_variable_get(instance_variable_name)
+            if instance_variable
+              instance_variable
+            else
+              instance_variable_set(instance_variable_name, cls.new(*constructor_params.map {|p| send(p)}))
+            end
+          end 
+          register_factory_method(factory_method_name)
+        end
+      end
+    
+      def method_defined?(meth)
+        @target_class.method_defined?(meth)
+      end
+
+      def factory_method?(meth)
+        factory_methods.include?(meth)
+      end
+    
+      def factory_methods
+        if @target_class.class_variable_defined?(FACTORY_METHODS_VAR_NAME) 
+          @target_class.class_variable_get(FACTORY_METHODS_VAR_NAME)
+        else
+          []
+        end
+      end
+    
+      private
+    
+      def prevent_old_method_override(meth)
+        raise "Factory method #{meth} conflicts with an existing method." if method_defined?(meth) && !factory_method?(meth)
+      end
+        
+      FACTORY_METHODS_VAR_NAME = "@@__factory_methods"
+    
+      def register_factory_method(meth)
+        @target_class.class_variable_set(FACTORY_METHODS_VAR_NAME, []) unless @target_class.class_variable_defined?(FACTORY_METHODS_VAR_NAME)
+        factory_methods = @target_class.class_variable_get(FACTORY_METHODS_VAR_NAME)
+        factory_methods << meth
+      end
+      
+      def factory_method_name(class_or_name)
+        # Looks odd but it's there to use only the class name if it's in a module.
+        # "Boil::Composer::Independent".underscore => "boil/composer/independent" 
+        # File.basename takes the last component.
+        # This will create clashes for classes with identical names (in different modules).
+        File.basename("#{class_or_name.to_s.underscore}").to_sym
+      end
+    end
+  end
+end

data/spec/boil/composer/builder_spec.rb

@@ -0,0 +1,143 @@
+require_relative '../../../lib/boil/composer/builder'
+
+
+describe Boil::Composer::Builder do
+
+  
+  describe "given classes in the same namespace" do
+
+    module CommonModule
+      class Independent
+        def initialize
+        end
+      end
+
+      class Dependent
+        def initialize(independent)
+          @independent = independent
+        end
+
+        attr_reader :independent
+      end
+
+      class VeryDependent
+        def initialize(independent, dependent)
+          @independent = independent
+          @dependent = dependent
+        end
+
+        attr_reader :independent
+        attr_reader :dependent
+      end
+
+      class DependentOnPredefined
+        def initialize(predefined)
+          @predefined = predefined
+        end
+
+        attr_reader :predefined
+      end
+
+      class DependentOnNonExisting
+        def initialize(non_existing)
+        end
+      end
+
+      class Circular1
+        def initialize(circular2)
+        end
+      end
+
+      class Circular2
+        def initialize(circular1)
+        end
+      end
+
+      class DependentOnConflicting
+        def initialize(conflicting)
+        end
+      end
+
+      class Conflicting
+      end
+    end
+
+    
+    let(:target_class) do
+      Class.new do
+        extend Boil::Composer::Builder
+  
+        def predefined
+          "predefined"
+        end
+  
+        def conflicting
+        end
+      end
+    end
+    
+    before do
+      ::Module.module_eval do
+        include CommonModule
+      end
+    end
+    
+    it "should create factory method for class with parameter-less constructor" do
+      target_class.create_factory_method_for(CommonModule::Independent)
+      target_class.new.should respond_to(:independent)
+    end
+
+    it "should create only one instance with multiple calls to factory method" do
+      target_class.create_factory_method_for(CommonModule::Independent)
+      target = target_class.new
+      target.independent.should_not be_nil
+      target.independent.should == target.independent
+    end
+
+    it "should create factory method depending on another class" do
+      target_class.create_factory_method_for(CommonModule::Dependent)
+      target = target_class.new
+      target.should respond_to(:independent)
+      target.should respond_to(:dependent)
+      target.independent.should == target.dependent.independent
+    end
+
+    it "should support multiple root classes" do
+      target_class.create_factory_method_for(CommonModule::Dependent, CommonModule::VeryDependent)
+      target = target_class.new
+      target.should respond_to(:independent)
+      target.should respond_to(:dependent)
+      target.should respond_to(:very_dependent)
+      target.very_dependent.dependent == target.dependent
+      target.very_dependent.dependent.independent == target.dependent.independent
+    end
+
+    it "should support pre-defined factory method" do
+      target_class.create_factory_method_for(CommonModule::DependentOnPredefined)
+      target = target_class.new
+      target.should respond_to(:dependent_on_predefined)
+      target.dependent_on_predefined.predefined.should == target.predefined
+    end
+
+    it "should raise error if no factory method and no matching class" do
+      lambda { target_class.create_factory_method_for(CommonModule::DependentOnNonExisting) }.should raise_error
+    end
+
+    it "should raise error for circular dependencies" do
+      lambda { target_class.create_factory_method_for(CommonModule::Circular1) }.should raise_error
+      lambda { target_class.create_factory_method_for(CommonModule::Circular1) }.should_not raise_error(SystemStackError)
+    end
+
+    it "should raise error if methods conflict" do
+      lambda { target_class.create_factory_method_for(CommonModule::DependentOnConflicting) }.should raise_error
+    end
+
+    it "should list factory methods" do
+      target_class.create_factory_method_for(CommonModule::Dependent, CommonModule::VeryDependent)
+      target_class.factory_methods.should have(3).items
+    end
+  end
+  
+  describe "given classes in different namespaces" do
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: boil
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
+platform: ruby
+authors:
+- Martin Bilski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Escape from boilerplate code hell. This version supports automatic building
+  of composed objects.
+email: gyamtso@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- MIT-LICENSE
+- lib/boil/composer/builder.rb
+- lib/boil/composer/dependency_walker.rb
+- lib/boil/composer/reflection_helpers.rb
+- lib/boil/composer/target_class_decorator.rb
+- spec/boil/composer/builder_spec.rb
+homepage: https://github.com/bilus/compser
+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: Escape from boilerplate code hell.
+test_files: []