super_module 1.1.1 → 1.2.0

data/spec/support/v1/fake_active_model.rb

@@ -0,0 +1,16 @@
+# Uses CRLF for line breaks to provide a test case for having SuperModule work with it
+# This is done to test support for Windows Ruby files, which usually use CRLF for line breaks
+module Support::V1::FakeActiveModel
+
+  include SuperModule
+
+  def self.validates(attribute, options)
+    validations << [attribute, options]
+  end
+
+  def self.validations
+    @validations ||= []
+  end
+
+end
+

data/spec/support/v1/foo.rb

@@ -0,0 +1,87 @@
+module Support::V1::Foo
+  include SuperModule
+  include Support::V1::FakeActiveModel
+  validates 'foo', {:presence => true}
+
+  class << self
+    def foo_class_self
+      'self.foo_class_self'
+    end
+
+    def foo_class_self_define_method; 'self.foo_class_self_define_method'; end
+
+    def foo_private_declaration_follow_up
+      'self.foo_private_declaration_follow_up'
+    end
+    private :foo_private_declaration_follow_up
+
+    def foo_protected_declaration_follow_up
+      'self.foo_protected_declaration_follow_up'
+    end
+    protected :foo_protected_declaration_follow_up
+
+    private 
+    def foo_private
+      'self.foo_private'
+    end
+  
+    protected
+    def foo_protected
+      'self.foo_protected'
+    end
+
+  end
+
+  def self.meh
+    self
+  end
+
+  def self.foo
+    'self.foo'
+  end
+
+  def self.foo_one_line; 'self.foo_one_line'; end
+
+  def self.foo_single_param(param1)
+    "self.foo(#{param1})"
+  end
+
+  def self.foo_multi_params(param1, param2, param3)
+    "self.foo(#{param1},#{param2},#{param3})"
+  end
+
+  def self.foo_block(&formatter)
+    formatter.call('self.foo')
+  end
+
+  def self.foo_single_param_block(param1, &formatter)
+    formatter.call('self.foo', param1)
+  end
+
+  def self.foo_multi_params_block(param1, param2, param3, &formatter)
+    formatter.call('self.foo', param1, param2, param3)
+  end
+
+  public
+
+  def self.empty
+  end
+
+  def self.empty_one_empty_line
+
+  end
+
+  def self.empty_with_comment
+    # no op
+  end
+
+  def self.empty_one_line_definition; end
+
+  def self.empty_one_line_definition_with_spaces;          end
+
+  def foo
+    'foo'
+  end
+
+end
+

data/spec/support/v2.rb

@@ -0,0 +1,6 @@
+module Support::V2
+end
+require File.join(File.dirname(__FILE__), 'v2', 'fake_active_model')
+require File.join(File.dirname(__FILE__), 'v2', 'foo')
+require File.join(File.dirname(__FILE__), 'v2', 'bar')
+require File.join(File.dirname(__FILE__), 'v2', 'baz')

data/spec/support/v2/bar.rb

@@ -0,0 +1,52 @@
+require 'forwardable'
+
+module Support::V2
+  super_module :Bar do
+    include Foo
+    include Comparable
+    validates 'bar', {:presence => true}
+    attr_reader :created_at
+
+    # Defines singleton methods via class << self to provide as a test case for SuperModule
+    class << self
+      include Forwardable
+
+      def barrable
+        @barrable
+      end
+
+      def barrable=(value)
+        @barrable = value
+      end
+
+      def make_barrable
+        self.barrable = true
+      end
+    end
+
+    make_barrable
+    def_delegators :@bar, :length
+
+    def initialize
+      @bar = bar
+      @created_at = Time.now.to_f
+    end
+
+    def bar
+      'bar'
+    end
+
+    # Defines singleton method via a form of eval (class_eval) to provide as a test case for SuperModule
+    class_eval do
+      def self.bar
+        'self.bar'
+      end
+    end
+    
+    def <=>(other)
+      created_at <=> other.created_at
+    end
+
+  end
+
+end

data/spec/support/v2/baz.rb

@@ -0,0 +1,27 @@
+super_module 'Support::V2::Baz' do
+  include Support::V2::Bar
+  make_barrable
+  validates 'baz', {:presence => true}
+  attr_reader :baz_factor
+  
+  class << self
+    def baz
+      'self.baz'
+    end
+  end
+  
+  def initialize(baz_factor)
+    super()
+    @baz_factor = baz_factor
+  end
+
+  def baz
+    'baz'
+  end
+
+  def <=>(other)
+    baz_factor <=> other.baz_factor
+  end
+
+end
+

data/spec/support/v2/fake_active_model.rb

@@ -0,0 +1,14 @@
+# Uses CRLF for line breaks to provide a test case for having SuperModule work with it
+# This is done to test support for Windows Ruby files, which usually use CRLF for line breaks
+super_module 'Support::V2::FakeActiveModel' do
+
+  def self.validates(attribute, options)
+    validations << [attribute, options]
+  end
+
+  def self.validations
+    @validations ||= []
+  end
+
+end
+

data/spec/support/v2/foo.rb

@@ -0,0 +1,87 @@
+module Support
+  super_module 'V2::Foo' do
+    include V2::FakeActiveModel
+    validates 'foo', {:presence => true}
+
+    class << self
+      def foo_class_self
+        'self.foo_class_self'
+      end
+
+      def foo_class_self_define_method; 'self.foo_class_self_define_method'; end
+
+      def foo_private_declaration_follow_up
+        'self.foo_private_declaration_follow_up'
+      end
+      private :foo_private_declaration_follow_up
+
+      def foo_protected_declaration_follow_up
+        'self.foo_protected_declaration_follow_up'
+      end
+      protected :foo_protected_declaration_follow_up
+
+      private 
+      def foo_private
+        'self.foo_private'
+      end
+    
+      protected
+      def foo_protected
+        'self.foo_protected'
+      end
+
+    end
+
+    def self.meh
+      self
+    end
+
+    def self.foo
+      'self.foo'
+    end
+
+    def self.foo_one_line; 'self.foo_one_line'; end
+
+    def self.foo_single_param(param1)
+      "self.foo(#{param1})"
+    end
+
+    def self.foo_multi_params(param1, param2, param3)
+      "self.foo(#{param1},#{param2},#{param3})"
+    end
+
+    def self.foo_block(&formatter)
+      formatter.call('self.foo')
+    end
+
+    def self.foo_single_param_block(param1, &formatter)
+      formatter.call('self.foo', param1)
+    end
+
+    def self.foo_multi_params_block(param1, param2, param3, &formatter)
+      formatter.call('self.foo', param1, param2, param3)
+    end
+
+    public
+
+    def self.empty
+    end
+
+    def self.empty_one_empty_line
+
+    end
+
+    def self.empty_with_comment
+      # no op
+    end
+
+    def self.empty_one_line_definition; end
+
+    def self.empty_one_line_definition_with_spaces;          end
+
+    def foo
+      'foo'
+    end
+
+  end
+end

data/spec/support/v2_alt.rb

@@ -0,0 +1,6 @@
+module Support::V2Alt
+end
+require File.join(File.dirname(__FILE__), 'v2_alt', 'fake_active_model')
+require File.join(File.dirname(__FILE__), 'v2_alt', 'foo')
+require File.join(File.dirname(__FILE__), 'v2_alt', 'bar')
+require File.join(File.dirname(__FILE__), 'v2_alt', 'baz')

data/spec/support/v2_alt/bar.rb

@@ -0,0 +1,52 @@
+require 'forwardable'
+
+module Support::V2Alt
+  Bar = super_module do
+    include Foo
+    include Comparable
+    validates 'bar', {:presence => true}
+    attr_reader :created_at
+
+    # Defines singleton methods via class << self to provide as a test case for SuperModule
+    class << self
+      include Forwardable
+
+      def barrable
+        @barrable
+      end
+
+      def barrable=(value)
+        @barrable = value
+      end
+
+      def make_barrable
+        self.barrable = true
+      end
+    end
+
+    make_barrable
+    def_delegators :@bar, :length
+
+    def initialize
+      @bar = bar
+      @created_at = Time.now.to_f
+    end
+
+    def bar
+      'bar'
+    end
+
+    # Defines singleton method via a form of eval (class_eval) to provide as a test case for SuperModule
+    class_eval do
+      def self.bar
+        'self.bar'
+      end
+    end
+    
+    def <=>(other)
+      created_at <=> other.created_at
+    end
+
+  end
+
+end

data/spec/support/v2_alt/baz.rb

@@ -0,0 +1,27 @@
+Support::V2Alt::Baz = super_module do
+  include Support::V2::Bar
+  make_barrable
+  validates 'baz', {:presence => true}
+  attr_reader :baz_factor
+  
+  class << self
+    def baz
+      'self.baz'
+    end
+  end
+  
+  def initialize(baz_factor)
+    super()
+    @baz_factor = baz_factor
+  end
+
+  def baz
+    'baz'
+  end
+
+  def <=>(other)
+    baz_factor <=> other.baz_factor
+  end
+
+end
+

data/spec/support/v2_alt/fake_active_model.rb

@@ -0,0 +1,14 @@
+# Uses CRLF for line breaks to provide a test case for having SuperModule work with it
+# This is done to test support for Windows Ruby files, which usually use CRLF for line breaks
+Support::V2Alt::FakeActiveModel = super_module do
+
+  def self.validates(attribute, options)
+    validations << [attribute, options]
+  end
+
+  def self.validations
+    @validations ||= []
+  end
+
+end
+

data/spec/support/v2_alt/foo.rb

@@ -0,0 +1,87 @@
+module Support
+  V2Alt::Foo = super_module do
+    include V2::FakeActiveModel
+    validates 'foo', {:presence => true}
+
+    class << self
+      def foo_class_self
+        'self.foo_class_self'
+      end
+
+      def foo_class_self_define_method; 'self.foo_class_self_define_method'; end
+
+      def foo_private_declaration_follow_up
+        'self.foo_private_declaration_follow_up'
+      end
+      private :foo_private_declaration_follow_up
+
+      def foo_protected_declaration_follow_up
+        'self.foo_protected_declaration_follow_up'
+      end
+      protected :foo_protected_declaration_follow_up
+
+      private 
+      def foo_private
+        'self.foo_private'
+      end
+    
+      protected
+      def foo_protected
+        'self.foo_protected'
+      end
+
+    end
+
+    def self.meh
+      self
+    end
+
+    def self.foo
+      'self.foo'
+    end
+
+    def self.foo_one_line; 'self.foo_one_line'; end
+
+    def self.foo_single_param(param1)
+      "self.foo(#{param1})"
+    end
+
+    def self.foo_multi_params(param1, param2, param3)
+      "self.foo(#{param1},#{param2},#{param3})"
+    end
+
+    def self.foo_block(&formatter)
+      formatter.call('self.foo')
+    end
+
+    def self.foo_single_param_block(param1, &formatter)
+      formatter.call('self.foo', param1)
+    end
+
+    def self.foo_multi_params_block(param1, param2, param3, &formatter)
+      formatter.call('self.foo', param1, param2, param3)
+    end
+
+    public
+
+    def self.empty
+    end
+
+    def self.empty_one_empty_line
+
+    end
+
+    def self.empty_with_comment
+      # no op
+    end
+
+    def self.empty_one_line_definition; end
+
+    def self.empty_one_line_definition_with_spaces;          end
+
+    def foo
+      'foo'
+    end
+
+  end
+end