choose_class 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joel Plane
+
+MIT License
+
+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,91 @@
+# choose_class
+
+Facilitates choosing a class based on the value that would be passed to that class.
+Useful for implementing the factory method pattern.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'choose_class'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install choose_class
+
+## Example Usage
+
+Include ChooseClass::Base into your base class. It will gain a choose_class
+method. Call choose_class and pass it a value by which to decide which class
+to return.
+
+Say we're implementing an object serializer of some sort. We may have a base
+class that implments some common functionalty, and then several subclasses
+that specialise the serialization for specific types.
+
+We want to determine which class to use based on the object we are to
+serialize.
+
+```ruby
+module Serializers
+  class Base
+    include ChooseClass::Base
+  end
+
+  # Specialisation class for Fixnum values
+  class Fixnum < Base
+  end
+end
+```
+
+elsewhere:
+
+```ruby
+  Serializers.choose_class(1) # => Serializers::Fixnum
+```
+
+The class chosen was Serializers::Fixnum because it is a class in the same
+namespace as the base class, and it has the same name as the class of the value
+passed in. (These conventions are configurable in a limited way. See spec/example)
+
+```ruby
+Serializers.choose_class("some string") # => Serializers::Base
+```
+
+The class chosen was Serializers::Base because there was no Serializers::String
+class to choose instead.
+
+To complete the serializer example, a final implementation might look something
+like this:
+
+```ruby
+module Serializers
+  class Base
+    include ChooseClass::Base
+
+    def self.serialize value
+      choose_class(value).new(value).serialize
+    end
+
+    def serialize
+      # general object serialization implementation
+    end
+  end
+
+  # Specialisation class for Fixnum values
+  class Fixnum < Base
+    def serialize
+      # fixnum-specific serialization implementation
+    end
+  end
+end
+
+Serializers.serialize(1) # => output of Serializers::Fixnum.serialize
+Serializers.serialize("some string") # => output of Serializers::Base.serialize
+```
+
+See also spec/example.

data/Rakefile

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

data/choose_class.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'choose_class/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "choose_class"
+  spec.version       = ChooseClass::VERSION
+  spec.authors       = ["Joel Plane"]
+  spec.email         = ["joel.plane@gmail.com"]
+  spec.description   = %q{Choose a class based on the value that would be passed to that class. Useful for implementing factory method pattern.}
+  spec.summary       = %q{Choose subclass based on another objects class}
+  spec.homepage      = "https://github.com/joelplane/choose_class"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/choose_class.rb

@@ -0,0 +1,9 @@
+require "choose_class/version"
+require "choose_class/util"
+require "choose_class/class_naming_conventions"
+require "choose_class/class_lookup"
+require "choose_class/config"
+require "choose_class/base"
+
+module ChooseClass
+end

data/lib/choose_class/base.rb

@@ -0,0 +1,29 @@
+module ChooseClass
+  module Base
+
+    module ClassMethods
+      def choose_class_config
+        @config ||= Config.new(self)
+      end
+
+      def choose_class value
+        class_name = class_name_for_value value
+        convention = choose_class_config.naming_convention
+        ClassLookup.new(convention).find_class_by_name class_name
+      end
+
+      private
+
+      # @return [String] class name
+      def class_name_for_value value
+        ChooseClass::Util.class_name_without_namespace value.class
+      end
+
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+  end
+end

data/lib/choose_class/class_lookup.rb

@@ -0,0 +1,32 @@
+module ChooseClass
+  class ClassLookup
+
+    # @param rules [ChooseClass::ClassNamingConventions]
+    def initialize rules
+      @rules = rules
+    end
+
+    # @param value_class_name [String]
+    def find_class_by_name value_class_name
+      class_name = factory_class_name value_class_name
+      begin
+        ChooseClass::Util.local_const_get(@rules.factory_namespace, class_name) ||
+          @rules.base_class
+      rescue NameError => e
+        if e.message =~ /#{@rules.factory_namespace.name}::#{class_name}$/
+          @rules.base_class
+        else
+          raise e # not the error we were expecting, so re-raise
+        end
+      end
+    end
+
+    private
+
+    # @param value_class_name [String]
+    def factory_class_name value_class_name
+      @rules.factory_class_name_from_value_class_name value_class_name
+    end
+
+  end
+end

data/lib/choose_class/class_naming_conventions.rb

@@ -0,0 +1,47 @@
+module ChooseClass
+  class ClassNamingConventions
+
+    attr_reader :base_class
+
+    # @param [Class] base_class
+    # @param [Array] rules
+    def initialize base_class, rules
+      @base_class = base_class
+      @rules = rules
+      set_default_rules
+    end
+
+    def factory_namespace
+      rule = @rules.detect do |rule|
+        rule.respond_to? :factory_namespace
+      end
+      rule.factory_namespace
+    end
+
+    def factory_class_name_from_value_class_name class_name
+      @rules.each do |rule|
+        if rule.respond_to? :factory_class_name_from_value_class_name
+          class_name = rule.factory_class_name_from_value_class_name class_name
+        end
+      end
+      class_name
+    end
+
+    private
+
+    def set_default_rules
+      if @rules.none?{|r|r.respond_to? :factory_namespace}
+        @rules << ChooseClass::ClassNamingConventions::Namespace.new(@base_class, nil)
+      end
+      if @rules.none?{|r|r.respond_to? :factory_class_name_from_value_class_name}
+        @rules << ChooseClass::ClassNamingConventions::Suffix.new(@base_class, "")
+      end
+    end
+
+  end
+end
+
+rules_dir = File.expand_path('./class_naming_conventions', File.dirname(__FILE__))
+Dir[File.join(rules_dir,"*.rb")].each do |file|
+  require file
+end

data/lib/choose_class/class_naming_conventions/namespace.rb

@@ -0,0 +1,21 @@
+module ChooseClass
+  class ClassNamingConventions
+    class Namespace
+
+      def initialize base_class, ns
+        @base_class = base_class
+        @namespace = ns
+      end
+
+      # same namespace as base class
+      def factory_namespace
+        if @namespace
+          @namespace
+        else
+          ChooseClass::Util.module_parent @base_class
+        end
+      end
+
+    end
+  end
+end

data/lib/choose_class/class_naming_conventions/suffix.rb

@@ -0,0 +1,37 @@
+module ChooseClass
+  class ClassNamingConventions
+    class Suffix
+
+      def initialize base_class, suffix
+        @base_class = base_class
+        @suffix = suffix
+      end
+
+      def factory_class_name_from_value_class_name class_name
+        if @suffix
+          "#{class_name}#{@suffix}"
+        else
+          # TODO this path is dead code,
+          #  but we probably want to resurrect it at some point.
+          "#{class_name}#{factory_class_name_suffix}"
+        end
+      end
+
+      private
+
+      # Eg.
+      #     if base class name is "SerializerBase", returns "Serializer"
+      #     if base class name is "Penguins", returns nil
+      # @return [String, nil]
+      def factory_class_name_suffix
+        match = class_name_without_namespace(@base_class).match(/(.*)Base$/)
+        match && match[1]
+      end
+
+      def class_name_without_namespace klass
+        ChooseClass::Util.class_name_without_namespace klass
+      end
+
+    end
+  end
+end

data/lib/choose_class/config.rb

@@ -0,0 +1,25 @@
+module ChooseClass
+  class Config
+
+    def initialize base_class
+      @rules = []
+      @base_class = base_class
+    end
+
+    def namespace ns
+      @rules << ChooseClass::ClassNamingConventions::Namespace.new(@base_class, ns)
+      self
+    end
+
+    def with_suffix suffix
+      @rules << ChooseClass::ClassNamingConventions::Suffix.new(@base_class, suffix)
+      self
+    end
+
+    # @return [ChooseClass::ClassNamingConventions]
+    def naming_convention
+      ChooseClass::ClassNamingConventions.new @base_class, @rules
+    end
+
+  end
+end

data/lib/choose_class/util.rb

@@ -0,0 +1,69 @@
+module ChooseClass
+  module Util
+    class << self
+
+      # Copied from ActiveSupport Module#parent
+      def module_parent mod
+        module_parent_name(mod) ? constantize(module_parent_name(mod)) : Object
+      end
+
+      # Copied from ActiveSupport in Rails 3.
+      def constantize camel_cased_word
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      end
+
+      # Copied/adapted from ActiveSupport Module#parents
+      def module_parents mod
+        parents = []
+        if (parent_name = module_parent_name mod)
+          parts = parent_name.split('::')
+          until parts.empty?
+            parents << constantize(parts * '::')
+            parts.pop
+          end
+        end
+        parents << Object unless parents.include? Object
+        parents
+      end
+
+      # @param klass [Class]
+      # @return [String]
+      def class_name_without_namespace klass
+        klass.name.split('::').last
+      end
+
+      # If the constant is not found, const_get will search on Object
+      # which might find a class or module we don't want - we only want modules
+      # inside the namespace given.
+      # This method wraps const_get, throwing away the result if it is not
+      # within the namespace.
+      # @param namespace [Class, Module]
+      # @param symbol [Symbol]
+      # @return [Class, Module, nil]
+      def local_const_get namespace, symbol
+        return nil unless namespace.const_defined?(symbol)
+        found_class = namespace.const_get(symbol)
+        if module_parents(found_class).include?(namespace)
+          found_class
+        else
+          nil
+        end
+      end
+
+      private
+
+      # Copied from ActiveSupport Module#parent_name
+      def module_parent_name mod
+        mod.name =~ /::[^:]+\Z/ ? $`.freeze : nil
+      end
+
+    end
+  end
+end

data/lib/choose_class/version.rb

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

data/spec/example/example1.rb

@@ -0,0 +1,15 @@
+module ChooseClass
+  module Example1
+
+    class SerializerBase
+      include ChooseClass::Base
+      choose_class_config.namespace(Example1).with_suffix("Serializer")
+    end
+
+    # Specialisation class for Fixnum values
+    class FixnumSerializer
+
+    end
+
+  end
+end

data/spec/example/example2.rb

@@ -0,0 +1,16 @@
+module ChooseClass
+  module Example2
+
+    class SerializerBase
+      include ChooseClass::Base
+      choose_class_config.namespace(Example2).with_suffix("")
+    end
+
+    # Specialisation class for Fixnum values
+    # Does not have to be a subclass of SerializerBase, but is in this case.
+    class Fixnum < SerializerBase
+
+    end
+
+  end
+end

data/spec/example/example3.rb

@@ -0,0 +1,16 @@
+module ChooseClass
+  module Example3
+
+    module Serializers
+      class Base
+        include ChooseClass::Base
+        # not calling choose_class_config in this example
+      end
+
+      # Specialisation class for Fixnum values
+      class Fixnum
+      end
+    end
+
+  end
+end

data/spec/example/example_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require File.expand_path('../../lib/choose_class', File.dirname(__FILE__))
+require File.expand_path('./example1', File.dirname(__FILE__))
+require File.expand_path('./example2', File.dirname(__FILE__))
+require File.expand_path('./example3', File.dirname(__FILE__))
+
+module ChooseClass
+  describe "serializers example 1" do
+    describe ".choose_class" do
+
+      it "returns a specialised instance" do
+        Example1::SerializerBase.choose_class(1).new.should be_a Example1::FixnumSerializer
+      end
+
+      it "returns the generic instance when no specific class available" do
+        Example1::SerializerBase.choose_class("string").new.should be_a Example1::SerializerBase
+      end
+
+    end
+  end
+
+  describe "serializers example 2" do
+    describe ".choose_class" do
+
+      it "returns a specialised instance" do
+        Example2::SerializerBase.choose_class(1).new.should be_a Example2::Fixnum
+      end
+
+      it "returns the generic instance when no specific class available" do
+        Example2::SerializerBase.choose_class("string").new.should be_a Example2::SerializerBase
+      end
+
+    end
+  end
+
+  describe "serializers example 3" do
+    describe ".choose_class" do
+
+      it "returns a specialised instance" do
+        Example3::Serializers::Base.choose_class(1).new.should be_a Example3::Serializers::Fixnum
+      end
+
+      it "returns the generic instance when no specific class available" do
+        Example3::Serializers::Base.choose_class("string").new.should be_a Example3::Serializers::Base
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification 
+name: choose_class
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Joel Plane
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-07-31 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Choose a class based on the value that would be passed to that class. Useful for implementing factory method pattern.
+email: 
+- joel.plane@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- choose_class.gemspec
+- lib/choose_class.rb
+- lib/choose_class/base.rb
+- lib/choose_class/class_lookup.rb
+- lib/choose_class/class_naming_conventions.rb
+- lib/choose_class/class_naming_conventions/namespace.rb
+- lib/choose_class/class_naming_conventions/suffix.rb
+- lib/choose_class/config.rb
+- lib/choose_class/util.rb
+- lib/choose_class/version.rb
+- spec/example/example1.rb
+- spec/example/example2.rb
+- spec/example/example3.rb
+- spec/example/example_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/joelplane/choose_class
+licenses: 
+- MIT
+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: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Choose subclass based on another objects class
+test_files: 
+- spec/example/example1.rb
+- spec/example/example2.rb
+- spec/example/example3.rb
+- spec/example/example_spec.rb
+- spec/spec_helper.rb