class_inheritable 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+.ignore
+.rvmrc

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    class_inheritable (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.0)
+    rspec-expectations (2.11.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  class_inheritable!
+  rspec (~> 2.11.0)

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Jonathan Thomas
+
+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.txt

@@ -0,0 +1,22 @@
+Attempt to duplicate the functionality of Rails' old class_inheritable_ary
+without monkey-patching base-classes or polluting target classes with
+unexpected methods/attributes
+
+Basic use-case:
+  irb -r "./lib/class_inheritable/array.rb"   
+    class MyClass
+       ClassInheritable::Array.attach :to => self, :as => :foo
+       append_foo :bar
+    end
+    class MySubClass < MyClass
+      append_foo :baz
+    end
+
+    [:bar] == MyClass.foo
+    [:bar] == MyClass.new.foo
+
+    [:bar, :baz] == MySubClass.foo
+    [:bar, :baz] == MySubClass.new.foo
+
+(See specs for more detailed use-cases.)
+rspec ./spec/lib/class_inheritable/array_spec.rb

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+gemspec = eval(File.read("class_inheritable.gemspec"))
+
+task :build => "#{gemspec.full_name}.gem"
+
+file "#{gemspec.full_name}.gem" => gemspec.files + ["class_inheritable.gemspec"] do
+  system "gem build class_inheritable.gemspec"
+  system "gem install class_inheritable-#{ClassInheritable::VERSION}.gem"
+end

data/class_inheritable.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "class_inheritable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "class_inheritable"
+  s.version     = ClassInheritable::VERSION
+  s.authors     = ["JayTeeSr"]
+  s.email       = ["jaytee_sr_at_his-service_dot_net"]
+  s.homepage    = "https://github.com/JayTeeSF/class_inheritable"
+  s.summary     = %q{Automate management of i18n locale files}
+  s.description = %q{Export strings that need to be translated and integrate the completed translations}
+  s.rubyforge_project = "class_inheritable"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.bindir        = 'bin'
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", "~> 2.11.0"
+end

data/lib/class_inheritable/array.rb

@@ -0,0 +1,127 @@
+module ClassInheritable
+  class Array
+
+    DEFAULT_ARRAY_NAME = 'class_inheritable_array'
+
+    attr_reader :caller_class
+    def initialize( _caller_class )
+      raise ArgumentError, "invalid calling class" if _caller_class <= ClassInheritable::Array
+      @caller_class = _caller_class
+    end
+
+    def attach( options = {} )
+      define_writer_for( caller_class, options )
+      define_appender_for( caller_class, options )
+      define_reader_for( caller_class, options )
+      define_instance_reader_for( caller_class, options )
+      _init( options )
+    end
+
+    class << self
+      # Factory method:
+      def attach( options = {}, &block )
+        caller_class = options[ :to ]
+        caller_class ||= calling_object( &block ) if block_given?
+        raise ArgumentError, ":to or block required" unless caller_class
+        new( caller_class ).attach( options )
+      end
+
+      # Class methods
+      def array_of_parent( child, options = {} )
+        array = array_name( options )
+        parent = child.send( :superclass )
+        return [] unless parent.respond_to?( array )
+
+        parent.send( array ) || []
+      end
+
+      def writer_name( options = {} )
+        options[ :writer_name ] || "#{array_name( options )}="
+      end
+
+      def appender_name( options = {} )
+        options[ :appender_name ] || "append_#{array_name( options )}"
+      end
+
+      def instance_reader_name( options = {} )
+        options[ :instance_reader_name ] || reader_name( options )
+      end
+
+      def reader_name( options = {} )
+        options[ :reader_name ] || array_name( options )
+      end
+
+      def array_name( options = {} )
+        options[ :as ] || DEFAULT_ARRAY_NAME
+      end
+
+      def eigenclass_for( base )
+        class << base; self; end
+      end
+
+      def calling_object( &block )
+        eval 'self', block.send(:binding)
+      end
+    end
+
+
+    private
+
+    def _init( options = {} )
+      reader = ClassInheritable::Array.reader_name( options )
+      caller_class.send( reader )
+      self
+    end
+
+    def define_writer_for( base, options = {} )
+      eigenclass = ClassInheritable::Array.eigenclass_for( base )
+      writer = ClassInheritable::Array.writer_name( options )
+      array = ClassInheritable::Array.array_name( options )
+      eigenclass.class_eval do
+        define_method( "#{writer}" ) do |entries|
+          entries = [ entries ] unless entries.is_a?( ::Array )
+          instance_variable_set( "@#{array}", entries )
+        end
+      end
+    end
+
+    def define_appender_for( base, options = {} )
+      eigenclass = ClassInheritable::Array.eigenclass_for( base )
+      appender = ClassInheritable::Array.appender_name( options )
+      reader = ClassInheritable::Array.reader_name( options )
+      writer = ClassInheritable::Array.writer_name( options )
+      eigenclass.class_eval do
+        define_method( "#{appender}" ) do |entries|
+          entries = [ entries ] unless entries.is_a?( ::Array )
+          self.send( writer, self.send( reader ) | entries )
+        end
+      end
+    end
+
+    def define_instance_reader_for( base, options = {} )
+      reader = ClassInheritable::Array.instance_reader_name( options )
+      base.class_eval do
+        define_method( "#{reader}" ) do
+          self.class.send( "#{reader}" )
+        end
+      end
+    end
+
+    def define_reader_for( base, options = {} )
+      eigenclass = ClassInheritable::Array.eigenclass_for( base )
+      array = ClassInheritable::Array.array_name( options )
+      reader = ClassInheritable::Array.reader_name( options )
+      eigenclass.class_eval do
+        define_method( "#{reader}" ) do
+          unless instance_variable_get( "@#{array}" )
+            instance_variable_set(
+              "@#{array}", [] |
+              ClassInheritable::Array.array_of_parent( self, options )
+            )
+          end
+          instance_variable_get( "@#{array}" )
+        end
+      end
+    end
+  end
+end

data/lib/class_inheritable/version.rb

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

data/lib/class_inheritable.rb

@@ -0,0 +1,4 @@
+require 'class_inheritable/version'
+require 'class_inheritable/array'
+module ClassInheritable
+end

data/spec/lib/class_inheritable/array_spec.rb

@@ -0,0 +1,214 @@
+require  "spec_helper"
+describe ClassInheritable::Array do
+  let(:some_class) { Class.new(Object) }
+  let(:some_class_expected_methods) {
+    base_name = ClassInheritable::Array::DEFAULT_ARRAY_NAME
+    [ "#{base_name}=", "append_#{base_name}", base_name ].map(&:to_sym)
+  }
+
+  context "initialization" do
+    context "without valid params" do
+      it "should raise an error" do
+        expect { ClassInheritable::Array.new }.to raise_error(ArgumentError)
+      end
+
+      context "with invalid params" do
+        it "should raise an error" do
+          expect { ClassInheritable::Array.new( ClassInheritable::Array ) }.to raise_error(ArgumentError)
+          expect { ClassInheritable::Array.new( Class.new( ClassInheritable::Array ) ) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    context "with valid params" do
+      it "should not raise an error" do
+        expect { ClassInheritable::Array.new( some_class ) }.not_to raise_error
+      end
+    end
+  end
+
+  context "attachment" do
+    context "without valid params" do
+      it "should raise an error" do
+        expect { ClassInheritable::Array.attach }.to raise_error(ArgumentError)
+      end
+
+      context "with invalid params" do
+        it "should raise an error" do
+          expect { ClassInheritable::Array.class_eval { ClassInheritable::Array.attach {} } }.to raise_error
+        end
+      end
+    end
+
+    context "with valid params" do
+      it "should not raise an error" do
+        expect { some_class.class_eval { ClassInheritable::Array.attach {} } }.not_to raise_error
+        expect { ClassInheritable::Array.attach :to => some_class }.not_to raise_error
+      end
+
+      it "should attach expected methods and variables to some class" do
+        ( some_class.methods - Object.methods ).should eq( [] )
+        ClassInheritable::Array.attach :to => some_class
+        ( some_class.methods - Object.methods ).should eq( some_class_expected_methods )
+      end
+
+      context "with params that override attribute and method name(s) on a base class" do
+        let(:as) { :required_items }
+        let(:writer) { :only_require_item }
+        let(:appender) { :require_item }
+        let(:method_names) { [ writer, appender, as ] }
+        let(:base_class) {
+          _as = as; _appender = appender; _writer = writer
+          Class.new(Object).tap do |_base_class|
+            _base_class.class_eval do
+              ClassInheritable::Array.attach(
+                :as => _as,
+                :appender_name => _appender,
+                :writer_name => _writer
+              ) {}
+              def expected_items
+                []
+              end
+            end
+          end
+        }
+
+        it "should add expected attribute and methods to that base class" do
+          ( base_class.methods - Object.methods ).should eq( method_names )
+          base_class.instance_variables.should == [ "@#{as}".to_sym ]
+        end
+
+        let(:base_class_instance) { base_class.new }
+        it "should return expected items from base_class instances" do
+          base_class_instance.required_items.should == base_class_instance.expected_items
+        end
+
+
+        context "with multiple arrays on a class" do
+          let(:subclass_of_base_class) {
+            Class.new(base_class).tap do |_subclass_of_base_class|
+              _subclass_of_base_class.class_eval do
+                ClassInheritable::Array.attach {}
+                append_class_inheritable_array [ :cia_1, :cia_2 ]
+                require_item :subclass_of_base_class
+              end
+            end
+          }
+          it "should maintain both arrays" do
+            subclass_of_base_class.required_items.should == [:subclass_of_base_class]
+            subclass_of_base_class.class_inheritable_array.should == [:cia_1, :cia_2]
+          end
+          it "should add new methods to the child but not its parent class" do
+            some_class_expected_methods.each do |subclass_method|
+              subclass_of_base_class.should respond_to( subclass_method )
+              base_class.should_not respond_to( subclass_method )
+            end
+          end
+        end
+
+        context "given subclasses (of the base class) with appended items" do
+          let(:subclass_a) {
+            Class.new(base_class).tap do |_subclass_a|
+              _subclass_a.class_eval do
+                require_item :subclass_a
+                def expected_items
+                  [:subclass_a]
+                end
+              end
+            end
+          }
+          let(:subclass_a_instance) { subclass_a.new }
+
+          let(:subclass_b) {
+            Class.new(base_class).tap do |_subclass_b|
+              _subclass_b.class_eval do
+                require_item :subclass_b
+                def expected_items
+                  [:subclass_b]
+                end
+              end
+            end
+          }
+          let(:subclass_b_instance) { subclass_b.new }
+
+          it "should return all items in this (sub)class's hierarcy for this array" do
+            subclass_a.required_items.should == subclass_a_instance.expected_items
+            subclass_b.required_items.should == subclass_b_instance.expected_items
+          end
+
+          it "should return all items in an instance of this (sub)class's hierarcy for this array" do
+            subclass_a_instance.required_items.should == subclass_a_instance.expected_items
+            subclass_b_instance.required_items.should == subclass_b_instance.expected_items
+          end
+
+          context "given sub-subclasses" do
+            context "with overriden items" do
+              let(:sub_base_a) {
+                Class.new(subclass_a).tap do |_sub_base_a|
+                  _sub_base_a.class_eval do
+                    only_require_item :sub_base_a
+                    def expected_items
+                      [:sub_base_a]
+                    end
+                  end
+                end
+              }
+              let(:sub_base_a_instance) { sub_base_a.new }
+
+              it "should ignore this (sub)class's parent's items" do
+                sub_base_a.required_items.should == sub_base_a_instance.expected_items
+              end
+
+              it "should ignore an instance of this (sub)class's parent's items" do
+                sub_base_a_instance.required_items.should == sub_base_a_instance.expected_items
+              end
+
+              context "with a subsequent level of appended items" do
+                let(:subclass_sub_base_a) {
+                  Class.new(sub_base_a).tap do |_subclass_sub_base_a|
+                    _subclass_sub_base_a.class_eval do
+                      require_item :subclass_sub_base_a
+                      def expected_items
+                        [:sub_base_a, :subclass_sub_base_a]
+                      end
+                    end
+                  end
+                }
+                let(:subclass_sub_base_a_instance) { subclass_sub_base_a.new }
+
+                it "should ignore this (sub-sub)class's grand-parent's items" do
+                  subclass_sub_base_a.required_items.should == subclass_sub_base_a_instance.expected_items
+                end
+                it "should ignore an instance of this (sub-sub)class's grand-parent's items" do
+                  subclass_sub_base_a_instance.required_items.should == subclass_sub_base_a_instance.expected_items
+                end
+              end # overriden-then-extended
+            end # overriden
+
+            context "with more items appended" do
+              let(:sub_subclass_b) {
+                Class.new(subclass_b).tap do |_sub_subclass_b|
+                  _sub_subclass_b.class_eval do
+                    require_item :sub_subclass_b
+                    def expected_items
+                      [:subclass_b, :sub_subclass_b]
+                    end
+                  end
+                end
+              }
+              let(:sub_subclass_b_instance) { sub_subclass_b.new }
+
+              it "should include all items in this (sub-sub)class's hierarchy" do
+                sub_subclass_b.required_items.should == sub_subclass_b_instance.expected_items
+              end
+
+              it "should include all items in an instance of this (sub-sub)class's hierarchy" do
+                sub_subclass_b_instance.required_items.should == sub_subclass_b_instance.expected_items
+              end
+            end # more appended
+          end # sub-subclasses
+        end # subclasses
+      end # overriden attr/methods
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require "bundler"
+Bundler.setup
+
+require "rspec"
+require "class_inheritable"

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: class_inheritable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- JayTeeSr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-19 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70181116808720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: *70181116808720
+description: Export strings that need to be translated and integrate the completed
+  translations
+email:
+- jaytee_sr_at_his-service_dot_net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.txt
+- Rakefile
+- class_inheritable.gemspec
+- lib/class_inheritable.rb
+- lib/class_inheritable/array.rb
+- lib/class_inheritable/version.rb
+- spec/lib/class_inheritable/array_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/JayTeeSF/class_inheritable
+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: class_inheritable
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Automate management of i18n locale files
+test_files:
+- spec/lib/class_inheritable/array_spec.rb
+- spec/spec_helper.rb