ruby-features 1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Sergey Tokarenko
+
+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,4 @@
+Ruby Features
+=============
+
+Ruby Features makes extending of Ruby classes and modules to be easy, safe and controlled.

data/lib/generators/ruby_features/install_generator.rb

@@ -0,0 +1,13 @@
+module RubyFeatures
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc 'Copy RubyFeatures initializer'
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_initializer
+        template 'ruby-features.rb', 'config/initializers/ruby-features.rb'
+      end
+
+    end
+  end
+end

data/lib/generators/ruby_features/templates/ruby-features.rb

@@ -0,0 +1 @@
+RubyFeatures.find_in_path(Rails.root.join('app/models/concerns')).apply_all

data/lib/ruby-features.rb

@@ -0,0 +1,45 @@
+require 'ruby-features/version'
+
+module RubyFeatures
+  autoload :Container,  'ruby-features/container'
+  autoload :Single,     'ruby-features/single'
+  autoload :Mixins,     'ruby-features/mixins'
+  autoload :Concern,    'ruby-features/concern'
+  autoload :Utils,      'ruby-features/utils'
+  autoload :Lazy,       'ruby-features/lazy'
+
+  module Generators
+    autoload :InstallGenerator, 'generators/ruby-features/install_generator'
+  end
+
+  @@features = {}
+
+  class << self
+    def find_in_path(*folders)
+      old_feature_names = @@features.keys
+
+      Dir[*folders.map{|folder| File.join(folder, '**', '*_feature.rb') }].each do |file|
+        require file
+      end
+
+      Container.new(@@features.keys - old_feature_names)
+    end
+
+    def define(feature_name, &feature_body)
+      feature = Single.new(feature_name, feature_body)
+      feature_name = feature.name
+      raise NameError.new("Such feature is already registered: #{feature_name}") if @@features.has_key?(feature_name)
+
+      @@features[feature_name] = feature
+    end
+
+    def apply(*feature_names)
+      feature_names.each do |feature_name|
+        raise NameError.new("Such feature is not registered: #{feature_name}") unless @@features.has_key?(feature_name)
+
+        @@features[feature_name].apply
+      end
+    end
+
+  end
+end

data/lib/ruby-features/concern.rb

@@ -0,0 +1,50 @@
+module RubyFeatures
+  module Concern
+
+    def _apply(target, feature_name)
+      target_class = RubyFeatures::Utils.ruby_const_get(self, "::#{target}")
+
+      _apply_methods(target_class, feature_name, :class)
+      _apply_methods(target_class, feature_name, :instance)
+      _apply_applied_blocks(target_class)
+    end
+
+    private
+
+    def self.extended(base)
+      base.instance_variable_set(:@_applied_blocks, [])
+    end
+
+    def applied(&block)
+      instance_variable_get(:@_applied_blocks) << block
+    end
+
+    def class_methods(&block)
+      RubyFeatures::Utils.prepare_module(self, 'ClassMethods').class_eval(&block)
+    end
+
+    def instance_methods(&block)
+      RubyFeatures::Utils.prepare_module(self, 'InstanceMethods').class_eval(&block)
+    end
+
+    def _apply_methods(target_class, feature_name, methods_type)
+      methods_module_name = "#{methods_type.capitalize}Methods"
+
+      if RubyFeatures::Utils.module_defined?(self, methods_module_name)
+        methods_module = const_get(methods_module_name)
+        common_methods = target_class.public_send(:"#{'instance_' if methods_type == :instance}methods") & methods_module.instance_methods
+        raise NameError.new("Feature #{feature_name} tried to define already existing #{methods_type} methods: #{common_methods.inspect}") unless common_methods.empty?
+
+        target_class.send((methods_type == :instance ? :include : :extend), methods_module)
+      end
+
+    end
+
+    def _apply_applied_blocks(target_class)
+      instance_variable_get(:@_applied_blocks).each do |applied_block|
+        target_class.class_eval(&applied_block)
+      end
+    end
+
+  end
+end

data/lib/ruby-features/container.rb

@@ -0,0 +1,13 @@
+module RubyFeatures
+  class Container
+
+    def initialize(feature_names)
+      @feature_names = feature_names
+    end
+
+    def apply_all
+      RubyFeatures.apply(*@feature_names)
+    end
+
+  end
+end

data/lib/ruby-features/lazy.rb

@@ -0,0 +1,38 @@
+module RubyFeatures
+  module Lazy
+
+    ACTIVE_SUPPORT_LAZY_TARGETS = %w(
+      action_view action_controller action_mailer
+      active_record active_job
+      i18n
+    ).map(&:to_sym).freeze
+
+    @active_support_available = begin
+      require 'active_support'
+      true
+    rescue LoadError
+      false
+    end
+
+    class << self
+      def active_support_available?
+        @active_support_available
+      end
+
+      def apply(target, &block)
+        if active_support_available?
+          target_namespace = RubyFeatures::Utils.underscore(target.split('::').first).to_sym
+
+          if ACTIVE_SUPPORT_LAZY_TARGETS.include?(target_namespace)
+            ActiveSupport.on_load target_namespace, yield: true, &block
+
+            return
+          end
+        end
+
+        yield
+      end
+    end
+
+  end
+end

data/lib/ruby-features/mixins.rb

@@ -0,0 +1,27 @@
+module RubyFeatures
+  module Mixins
+    class << self
+
+      def build_and_apply!(feature)
+        feature_module = RubyFeatures::Utils.prepare_module!(
+          self,
+          RubyFeatures::Utils.modulize(feature.name)
+        )
+
+        feature.apply_to_blocks.each do |target, blocks|
+          RubyFeatures::Lazy.apply(target) do
+            _lazy_build_and_apply!(feature, feature_module, target, blocks)
+          end
+        end
+      end
+
+      def _lazy_build_and_apply!(feature, feature_module, target, blocks)
+        lazy_module = RubyFeatures::Utils.prepare_module!(feature_module, target)
+        lazy_module.extend RubyFeatures::Concern
+        blocks.each { |block| lazy_module.class_eval(&block) }
+        lazy_module._apply(target, feature.name)
+      end
+
+    end
+  end
+end

data/lib/ruby-features/single.rb

@@ -0,0 +1,36 @@
+module RubyFeatures
+  class Single
+
+    attr_reader :name, :applied, :apply_to_blocks
+    alias applied? applied
+
+    def initialize(name, feature_body)
+      @name = name = name.to_s
+      raise NameError.new("Wrong feature name: #{name}") unless name.match(/^[\/_a-z\d]+$/)
+
+      @apply_to_blocks = {}
+      @applied = false
+
+      instance_eval(&feature_body) if feature_body
+    end
+
+    def apply
+      unless applied?
+        Mixins.build_and_apply!(self)
+
+        @apply_to_blocks = nil
+        @applied = true
+      end
+    end
+
+    private
+
+    def apply_to(target, &block)
+      target = target.to_s
+
+      @apply_to_blocks[target] ||= []
+      @apply_to_blocks[target] << block
+    end
+
+  end
+end

data/lib/ruby-features/utils.rb

@@ -0,0 +1,51 @@
+module RubyFeatures
+  module Utils
+
+    autoload :ConstAccessor19, 'ruby-features/utils/const_accessor_19'
+    autoload :ConstAccessor20, 'ruby-features/utils/const_accessor_20'
+
+    begin
+      const_defined?('Some::Const')
+      extend ConstAccessor20
+    rescue NameError
+      extend ConstAccessor19
+    end
+
+    class << self
+
+      def module_defined?(target, module_name)
+        ruby_const_defined?(target, module_name) && ruby_const_get(target, module_name).name.start_with?(target.name)
+      end
+
+      def prepare_module!(target, module_name)
+        module_defined?(target, module_name) ?
+          raise(NameError.new("Module already initiated: #{target.name}::#{module_name}")) :
+          prepare_module(target, module_name)
+      end
+
+      def prepare_module(target, modules)
+        modules = modules.split('::') unless modules.kind_of?(Array)
+
+        first_submodule = modules.shift
+        new_target = module_defined?(target, first_submodule) ?
+          target.const_get(first_submodule) :
+          target.const_set(first_submodule, Module.new)
+
+        modules.empty? ?
+          new_target :
+          prepare_module(new_target, modules)
+      end
+
+      def modulize(string)
+        string.gsub(/([a-z\d]+)/i) { $1.capitalize }.gsub(/[-_]/, '').gsub('/', '::')
+      end
+
+      def underscore(string)
+        string.gsub(/([A-Z][a-z\d]*)/){ "_#{$1.downcase}" }.
+        gsub(/^_/, '').
+        gsub('::', '/')
+      end
+
+    end
+  end
+end

data/lib/ruby-features/utils/const_accessor_19.rb

@@ -0,0 +1,32 @@
+module RubyFeatures
+  module Utils
+    module ConstAccessor19
+      def ruby_const_defined?(target, const_parts)
+        const_parts = const_parts.split('::') unless const_parts.kind_of?(Array)
+
+        first_const_part = const_parts.shift
+        first_const_defined = target.const_defined?(first_const_part)
+
+        !first_const_defined || const_parts.empty? ?
+          first_const_defined :
+          ruby_const_defined?(target.const_get(first_const_part), const_parts)
+      end
+
+      def ruby_const_get(target, const_parts)
+        const_parts = const_parts.split('::') unless const_parts.kind_of?(Array)
+
+        first_const_part = const_parts.shift
+        if first_const_part == ''
+          target = ::Object
+          first_const_part = const_parts.shift
+        end
+
+        first_const = target.const_get(first_const_part)
+
+        const_parts.empty? ?
+          first_const :
+          ruby_const_get(first_const, const_parts)
+      end
+    end
+  end
+end

data/lib/ruby-features/utils/const_accessor_20.rb

@@ -0,0 +1,13 @@
+module RubyFeatures
+  module Utils
+    module ConstAccessor20
+      def ruby_const_defined?(target, const_name)
+        target.const_defined?(const_name)
+      end
+
+      def ruby_const_get(target, const_name)
+        target.const_get(const_name)
+      end
+    end
+  end
+end

data/lib/ruby-features/version.rb

@@ -0,0 +1,3 @@
+module RubyFeatures
+  VERSION = '1.0.0'.freeze
+end

data/spec/define_spec.rb

@@ -0,0 +1,69 @@
+describe RubyFeatures::Single do
+
+  prepare_test_class 'DefineTestModule::DefineTestClass'
+
+  it 'should apply class methods' do
+    expect{
+      define_test_feature('class_methods') do
+        class_methods do
+          def test_class_method; end
+        end
+      end.apply
+    }.to change{test_class.respond_to?(:test_class_method)}.from(false).to(true)
+  end
+
+  it 'should apply instance methods' do
+    expect{
+      define_test_feature('instance_methods') do
+        instance_methods do
+          def test_instance_method; end
+        end
+      end.apply
+    }.to change{test_class.new.respond_to?(:test_instance_method)}.from(false).to(true)
+  end
+
+  it 'should process applied block' do
+    expect{
+      define_test_feature('applied_block') do
+        applied do
+          attr_accessor :applied_block_accessor
+        end
+      end.apply
+    }.to change{test_class.new.respond_to?(:applied_block_accessor)}.from(false).to(true)
+  end
+
+  it 'should check that feature name is correct' do
+    expect{
+      define_test_feature('wrong feature name')
+    }.to raise_error(/Wrong feature name/)
+  end
+
+  it 'should raise error if target already has feature class method' do
+    test_class.class_eval do
+      def self.existing_class_method; end
+    end
+
+    expect{
+      define_test_feature('existing_class_method') do
+        class_methods do
+          def existing_class_method; end
+        end
+      end.apply
+    }.to raise_error(/tried to define already existing class methods: \[:existing_class_method\]/)
+  end
+
+  it 'should raise error if target already has feature instance method' do
+    test_class.class_eval do
+      def existing_instance_method; end
+    end
+
+    expect{
+      define_test_feature('existing_instance_method') do
+        instance_methods do
+          def existing_instance_method; end
+        end
+      end.apply
+    }.to raise_error(/tried to define already existing instance methods: \[:existing_instance_method\]/)
+  end
+
+end

data/spec/find_and_apply_spec.rb

@@ -0,0 +1,44 @@
+describe RubyFeatures do
+
+  prepare_test_class('FindAndApplyTestClass')
+
+  it 'should find features in path and apply all on demand' do
+    features_container = subject.find_in_path(File.expand_path('../ruby_features', __FILE__))
+
+    expect(test_class).to_not respond_to(:root_method)
+    expect(test_class).to_not respond_to(:nested_method)
+
+    features_container.apply_all
+
+    expect(test_class).to respond_to(:root_method)
+    expect(test_class).to respond_to(:nested_method)
+  end
+
+  it 'should apply features by name' do
+
+    define_test_feature('manual') do
+      class_methods do
+        def manual_method; end
+      end
+    end
+
+    expect(test_class).to_not respond_to(:manual_method)
+    RubyFeatures.apply('find_and_apply_test_class/manual')
+    expect(test_class).to respond_to(:manual_method)
+  end
+
+  it 'should raise error if trying to apply not existing feature' do
+    expect{
+      RubyFeatures.apply('find_and_apply_test_class/not_existing_feature')
+    }.to raise_error(/Such feature is not registered/)
+  end
+
+  it 'should raise error if trying to define already registered feature' do
+    RubyFeatures.define('find_and_apply_test_class/duplicate_feature')
+
+    expect{
+      RubyFeatures.define('find_and_apply_test_class/duplicate_feature')
+    }.to raise_error(/Such feature is already registered/)
+  end
+
+end

data/spec/lazy_apply_spec.rb

@@ -0,0 +1,19 @@
+if RubyFeatures::Lazy.active_support_available?
+  describe RubyFeatures::Lazy do
+
+    it 'should use ActiveSupport lazy load' do
+      RubyFeatures.define 'lazy_load/active_support' do
+        apply_to 'ActiveRecord::Base' do
+          class_methods do
+            def lazy_active_support; end
+          end
+        end
+      end.apply
+      expect(defined?(ActiveRecord)).to_not be true
+
+      require 'active_record'
+      expect(ActiveRecord::Base).to respond_to(:lazy_active_support)
+    end
+
+  end
+end

data/spec/ruby_features/nested/nested_feature.rb

@@ -0,0 +1,9 @@
+RubyFeatures.define 'find_and_apply_test_class/nested' do
+  apply_to 'FindAndApplyTestClass' do
+
+    class_methods do
+      def nested_method; end
+    end
+
+  end
+end

data/spec/ruby_features/root_feature.rb

@@ -0,0 +1,9 @@
+RubyFeatures.define 'find_and_apply_test_class/root' do
+  apply_to 'FindAndApplyTestClass' do
+
+    class_methods do
+      def root_method; end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
+require 'bundler/setup'
+Bundler.require(:default)
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/spec/support/helpers.rb

@@ -0,0 +1,25 @@
+RSpec.configure do
+
+  def prepare_test_class(class_parts)
+    class_parts = class_parts.split('::') unless class_parts.kind_of?(Array)
+
+    test_class = Object
+
+    until class_parts.empty?
+      test_class = class_parts.size > 1 ?
+        test_class.const_set(class_parts.shift, Module.new) :
+        test_class.const_set(class_parts.shift, Class.new)
+    end
+
+    let(:test_class){ test_class }
+  end
+
+  def define_test_feature(feature_name_postfix, &block)
+    test_class_name = test_class.name
+    feature_name = "#{RubyFeatures::Utils.underscore(test_class_name)}/#{feature_name_postfix}"
+
+    RubyFeatures.define feature_name do
+      apply_to test_class_name, &block
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: ruby-features
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sergey Tokarenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Makes extending of Ruby classes and modules to be easy, safe and controlled.
+email: private.tokarenko.sergey@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/ruby_features/install_generator.rb
+- lib/generators/ruby_features/templates/ruby-features.rb
+- lib/ruby-features/concern.rb
+- lib/ruby-features/container.rb
+- lib/ruby-features/lazy.rb
+- lib/ruby-features/mixins.rb
+- lib/ruby-features/single.rb
+- lib/ruby-features/utils/const_accessor_19.rb
+- lib/ruby-features/utils/const_accessor_20.rb
+- lib/ruby-features/utils.rb
+- lib/ruby-features/version.rb
+- lib/ruby-features.rb
+- LICENSE
+- README.md
+- spec/define_spec.rb
+- spec/find_and_apply_spec.rb
+- spec/lazy_apply_spec.rb
+- spec/ruby_features/nested/nested_feature.rb
+- spec/ruby_features/root_feature.rb
+- spec/spec_helper.rb
+- spec/support/helpers.rb
+homepage: https://github.com/stokarenko/ruby-features
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: Makes extending of Ruby classes and modules to be easy, safe and controlled.
+test_files:
+- spec/define_spec.rb
+- spec/find_and_apply_spec.rb
+- spec/lazy_apply_spec.rb
+- spec/ruby_features/nested/nested_feature.rb
+- spec/ruby_features/root_feature.rb
+- spec/spec_helper.rb
+- spec/support/helpers.rb