ruby-features 1.0.0 → 1.1.0

data/README.md

@@ -1,4 +1,246 @@
 Ruby Features
 =============
+[![Version](https://badge.fury.io/rb/ruby-features.svg)](http://badge.fury.io/rb/ruby-features)
+[![Build](https://travis-ci.org/stokarenko/ruby-features.svg?branch=master)](https://travis-ci.org/stokarenko/ruby-features)
+[![Climate](https://codeclimate.com/github/stokarenko/ruby-features/badges/gpa.svg)](https://codeclimate.com/github/stokarenko/ruby-features)
+[![Coverage](https://codeclimate.com/github/stokarenko/ruby-features/badges/coverage.svg)](https://codeclimate.com/github/stokarenko/ruby-features/coverage)
 
-Ruby Features makes extending of Ruby classes and modules to be easy, safe and controlled.
+Ruby Features makes the extending of Ruby classes and modules to be easy, safe and controlled.
+
+## Why?
+Lets ask, is good to write the code like this:
+```ruby
+String.send :include, MyStringExtension
+```
+
+Or even like this:
+```ruby
+Object.class_eval do
+  def my_object_method
+    # some super code
+  end
+end
+```
+
+The question is about motivation to write such things. Lets skip well-known reason like
+> Because I can! That is Ruby baby, lets make some anarchy!
+
+but say:
+> I want to implement the functionality, which I expected to find right in the box.
+
+In fact, the cool things can be injected right in core programming entities in this way.
+They are able to improve the development speed, to make the sources to be more readable and light.
+
+From the other side, the project's behavior loses the predictability once it requires the third-party
+library, infected by massive patches to core entities.
+
+Ruby Features goal is to take that under control.
+
+The main features are:
+* No any dependencies;
+* Built-in lazy load;
+* Supports ActiveSupport lazy load as well;
+* Stimulates the clear extending, but prevents monkey patching;
+* Gives the control what core extensions to apply;
+* Any moment gives the knowledge who and how exactly affected to programming entities.
+
+## requirements
+* Ruby >= 1.9.3
+
+## Getting started
+
+Add to your Gemfile:
+
+```ruby
+gem 'ruby-features'
+```
+
+Run the bundle command to install it.
+
+For Rails projects, gun generator:
+```console
+rails generate ruby_features:install
+```
+
+Generator will add `ruby-features.rb` initializer, which loads the ruby features
+from `{Rails.root}/lib/features` folder. Also such initializer is a good place
+to apply third-party features.
+
+## Usage
+### Feature definition
+Feature file name should ends with `_feature.rb`.
+
+Lets define the feature in `lib/features/something_useful_feature.rb`:
+```ruby
+RubyFeatures.define 'some_namespace/something_useful' do
+  apply_to 'ActiveRecord::Base' do
+
+    applied do
+      # will be evaluated on target class
+      attr_accessor :useful_variable
+    end
+
+    instance_methods do
+      # instance methods
+      def useful_instance_method
+      end
+    end
+
+    class_methods do
+      # class methods
+      def useful_class_method
+      end
+    end
+
+    apply_to 'ActiveRecord::Relation' do
+      # feature can contain several apply_to definition
+    end
+
+  end
+end
+```
+
+### Dependencies
+The dependencies from other Ruby Features can be defined like:
+```ruby
+RubyFeatures.define 'main_feature' do
+  dependency 'dependent_feature1'
+  dependencies 'dependent_feature2', 'dependent_feature3'
+end
+```
+
+### Conditions
+Sometimes is required to apply different things, dependent on some criteria:
+```ruby
+RubyFeatures.define 'some_namespace/something_useful' do
+  apply_to 'ActiveRecord::Base' do
+
+    class_methods do
+      if ActiveRecord::VERSION::MAJOR > 3
+        def useful_method
+          # Implementation for newest ActiveRecord
+        end
+      else
+        def useful_method
+          # Implementation for ActiveRecord 3
+        end
+      end
+    end
+  end
+end
+```
+
+It's bad to do like that, because the mixin applied by Ruby Features became to be not static.
+That cause not predictable behavior.
+
+Ruby Features provides the `conditions` mechanism to avoid such problem:
+```ruby
+RubyFeatures.define 'some_namespace/something_useful' do
+  condition(:newest_activerecord){ ActiveRecord::VERSION::MAJOR > 3 }
+
+  apply_to 'ActiveRecord::Base' do
+
+    class_methods if: :newest_activerecord do
+      def useful_method
+        # Implementation for newest ActiveRecord
+      end
+    end
+
+    class_methods unless: :newest_activerecord do
+      def useful_method
+        # Implementation for ActiveRecord 3
+      end
+    end
+
+  end
+end
+```
+
+All feature definition helpers supports the conditions:
+```ruby
+apply_to 'ActiveRecord::Base', if: :first_criteria do; end
+
+applied if: :second_criteria do; end
+
+class_methods if: :third_criteria do; end
+
+instance_methods if: :fourth_criteria do; end
+```
+
+It's possible to define not boolean condition:
+```ruby
+RubyFeatures.define 'some_namespace/something_useful' do
+  condition(:activerecord_version){ ActiveRecord::VERSION::MAJOR }
+
+  apply_to 'ActiveRecord::Base' do
+
+    class_methods unless: {activerecord_version: 3} do
+      def useful_method
+        # Implementation for newest ActiveRecord
+      end
+    end
+
+    class_methods if: {activerecord_version: 3} do
+      def useful_method
+        # Implementation for ActiveRecord 3
+      end
+    end
+
+  end
+end
+```
+
+It's possible to combine the conditions:
+```ruby
+class_methods {
+  if: [
+    :boolean_condition,
+    :other_boolean_condition,
+    {
+      string_condition: 'some_string',
+      symbol_condition: :some_symbol
+    }
+  ],
+  unless: :unless_boolean_condition
+} do; end
+```
+
+### Feature loading
+Feature can be loaded by normal `require` call:
+```ruby
+require `lib/features/something_useful_feature`
+```
+
+All features within path can be loaded as follows:
+```ruby
+# require all "*_feature.rb" files within path, recursively:
+RubyFeatures.find_in_path(File.expand_path('../lib/features', __FILE__))
+```
+
+### Feature applying
+Feature can be applied immediately after it's definition:
+```ruby
+RubyFeatures.define 'some_namespace/something_useful' do
+  # definition
+end.apply
+```
+
+Features can be applied right after loading from path:
+```ruby
+RubyFeatures.find_in_path(File.expand_path('../lib/features', __FILE__)).apply_all
+```
+
+Feature can be applied by name, if such feature is already loaded:
+```ruby
+require `lib/features/something_useful_feature`
+
+RubyFeatures.apply 'some_namespace/something_useful'
+```
+
+## Changes
+### v1.1.0
+* Added conditions.
+* Added dependencies.
+
+## License
+MIT License. Copyright (c) 2015 Sergey Tokarenko

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

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

data/lib/ruby-features.rb

@@ -1,45 +1,62 @@
 require 'ruby-features/version'
 
 module RubyFeatures
+  autoload :Conditions, 'ruby-features/conditions'
   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 Concern
+    autoload :ApplyTo,    'ruby-features/concern/apply_to'
+    autoload :Feature,    'ruby-features/concern/feature'
+  end
+
   module Generators
     autoload :InstallGenerator, 'generators/ruby-features/install_generator'
   end
 
-  @@features = {}
+  class ApplyError < StandardError; end
+
+  @features = {}
+
+  @active_support_available = begin
+    require 'active_support'
+    true
+  rescue LoadError
+    false
+  end
 
   class << self
     def find_in_path(*folders)
-      old_feature_names = @@features.keys
+      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)
+      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)
+      feature_name = feature_name.to_s
+      raise NameError.new("Wrong feature name: #{name}") unless feature_name.match(/^[\/_a-z\d]+$/)
+      raise NameError.new("Such feature is already registered: #{feature_name}") if @features.has_key?(feature_name)
 
-      @@features[feature_name] = feature
+      @features[feature_name] = Mixins.new(feature_name, feature_body)
     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)
+        raise NameError.new("Such feature is not registered: #{feature_name}") unless @features.has_key?(feature_name)
 
-        @@features[feature_name].apply
+        @features[feature_name].apply
       end
     end
 
+    def active_support_available?
+      @active_support_available
+    end
+
   end
 end

data/lib/ruby-features/concern/apply_to.rb

@@ -0,0 +1,86 @@
+module RubyFeatures
+  module Concern
+    module ApplyTo
+
+      def _apply(target, apply_to_definitions, conditions)
+        _with_instance_variable(:@_conditions, conditions) do
+          _build_mixins(apply_to_definitions)
+        end
+
+        target_class = RubyFeatures::Utils.ruby_const_get(self, "::#{target}")
+
+        _apply_methods(target_class)
+        _apply_applied_blocks(target_class)
+      end
+
+      private
+
+      def self.extended(base)
+        base.instance_variable_set(:@_applied_blocks, [])
+      end
+
+      def applied(asserts = {}, &block)
+        if @_conditions.match?(asserts, false)
+          @_applied_blocks << block
+        end
+      end
+
+      def class_methods(asserts = {}, &block)
+        _methods('Extend', asserts, block)
+      end
+
+      def instance_methods(asserts = {}, &block)
+        _methods('Include', asserts, block)
+      end
+
+      def _apply_methods(target_class)
+        constants.each do |constant|
+          mixin_method, existing_methods_method = case(constant)
+          when /^Extend/ then [:extend, :methods]
+          when /^Include/ then [:include, :instance_methods]
+          else raise ArgumentError.new("Wrong mixin constant: #{constant}")
+          end
+
+          mixin = const_get(constant)
+
+          common_methods = target_class.public_send(existing_methods_method) & mixin.instance_methods
+          raise NameError.new("Tried to #{mixin_method} already existing methods: #{common_methods.inspect}") unless common_methods.empty?
+
+          target_class.send(mixin_method, mixin)
+        end
+      end
+
+      def _apply_applied_blocks(target_class)
+        @_applied_blocks.each do |applied_block|
+          target_class.class_eval(&applied_block)
+        end
+      end
+
+      def _methods(mixin_prefix, asserts, block)
+        asserts = @_conditions.normalize_asserts(asserts)
+
+        if @_conditions.match?(asserts)
+          RubyFeatures::Utils.prepare_module(self, "#{mixin_prefix}#{@_conditions.build_constant_postfix(@_global_asserts, asserts)}").class_eval(&block)
+        end
+      end
+
+      def _with_instance_variable(variable_name, value)
+        instance_variable_set(variable_name, value)
+        yield
+        remove_instance_variable(variable_name)
+      end
+
+      def _build_mixins(apply_to_definitions)
+        apply_to_definitions.each do |apply_to_definition|
+          global_asserts = @_conditions.normalize_asserts(apply_to_definition[:asserts])
+          if @_conditions.match?(global_asserts)
+            _with_instance_variable(:@_global_asserts, global_asserts) do
+              class_eval(&apply_to_definition[:block])
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ruby-features/concern/feature.rb

@@ -0,0 +1,65 @@
+module RubyFeatures
+  module Concern
+    module Feature
+
+      def apply
+        unless applied?
+          RubyFeatures.apply(*@_dependencies)
+
+          @_apply_to_definitions.keys.each do |target|
+            RubyFeatures::Lazy.apply(target) do
+              _lazy_apply(target)
+            end
+          end
+
+          @_applied = true
+        end
+      end
+
+      def applied?
+        @_applied
+      end
+
+      def _set_name(name)
+        @_name = name
+      end
+
+      def name
+        @_name
+      end
+
+      private
+
+      def self.extended(base)
+        base.instance_variable_set(:@_dependencies, [])
+        base.instance_variable_set(:@_conditions, RubyFeatures::Conditions.new)
+        base.instance_variable_set(:@_apply_to_definitions, {})
+        base.instance_variable_set(:@_applied, false)
+      end
+
+      def dependencies(*feature_names)
+        @_dependencies.push(*feature_names).uniq!
+      end
+      alias dependency dependencies
+
+      def condition(condition_name, &block)
+        @_conditions.push(condition_name, block)
+      end
+
+      def apply_to(target, asserts = {}, &block)
+        target = target.to_s
+
+        (@_apply_to_definitions[target] ||= []) << { asserts: asserts, block: block }
+      end
+
+      def _lazy_apply(target)
+        apply_to_module = RubyFeatures::Utils.prepare_module!(self, target)
+        apply_to_module.extend RubyFeatures::Concern::ApplyTo
+        apply_to_module._apply(target, @_apply_to_definitions.delete(target), @_conditions)
+      rescue NameError => e
+        raise ApplyError.new("[#{name}] #{e.message}")
+      end
+
+    end
+  end
+end

data/lib/ruby-features/conditions.rb

@@ -0,0 +1,72 @@
+module RubyFeatures
+  class Conditions
+    def initialize
+      @conditions = {}
+    end
+
+    def push(condition_name, block)
+      condition_name = condition_name.to_sym
+      raise NameError.new("Such condition is already defined: #{condition_name}") if @conditions.has_key?(condition_name)
+
+      @conditions[condition_name] = block
+    end
+
+    def normalize_asserts(asserts)
+      asserts.inject({if: {}, unless: {}}) do |mem, (assert_type, asserts_per_type)|
+        asserts_per_type = [asserts_per_type] unless asserts_per_type.kind_of?(Array)
+        asserts_per_type.each do |assert_per_type|
+          assert_per_type = {assert_per_type => true} unless assert_per_type.kind_of?(Hash)
+          mem[assert_type].merge!(assert_per_type)
+        end
+
+        mem
+      end
+    end
+
+    def match?(asserts, normalized = true)
+      asserts = normalize_asserts(asserts) unless normalized
+
+      asserts[:if].each do |condition_name, condition_value|
+        return false unless value(condition_name) == condition_value
+      end
+
+      asserts[:unless].each do |condition_name, condition_value|
+        return false if value(condition_name) == condition_value
+      end
+
+      true
+    end
+
+    def build_constant_postfix(*asserts)
+      asserts = merge_asserts(asserts)
+
+      RubyFeatures::Utils.camelize(
+        asserts.sort.map { |assert_type, asserts_per_type|
+          if asserts_per_type.empty?
+            nil
+          else
+            "#{assert_type}_" + asserts_per_type.sort.map { |condition_name, condition_value|
+              "#{condition_name}_is_#{condition_value}"
+            }.join('_and_')
+          end
+        }.compact.join('_and_')
+      )
+    end
+
+    private
+
+    def value(condition_name)
+      @conditions[condition_name] = @conditions[condition_name].call if @conditions[condition_name].respond_to?(:call)
+      @conditions[condition_name]
+    end
+
+    def merge_asserts(asserts)
+      asserts.inject({if: {}, unless: {}}) do |mem, assert|
+        mem[:if].merge!(assert[:if])
+        mem[:unless].merge!(assert[:unless])
+        mem
+      end
+    end
+
+  end
+end

data/lib/ruby-features/lazy.rb

@@ -7,26 +7,13 @@ module RubyFeatures
       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?
+        if RubyFeatures.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
+            return ActiveSupport.on_load target_namespace, yield: true, &block
           end
         end
 

data/lib/ruby-features/mixins.rb

@@ -2,26 +2,17 @@ module RubyFeatures
   module Mixins
     class << self
 
-      def build_and_apply!(feature)
-        feature_module = RubyFeatures::Utils.prepare_module!(
+      def new(feature_name, feature_body)
+        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
+          RubyFeatures::Utils.camelize(feature_name)
+        ).tap do |feature_module|
+          feature_module.extend RubyFeatures::Concern::Feature
+          feature_module._set_name(feature_name)
+          feature_module.class_eval(&feature_body) if feature_body
         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/utils.rb

@@ -1,8 +1,11 @@
 module RubyFeatures
   module Utils
 
-    autoload :ConstAccessor19, 'ruby-features/utils/const_accessor_19'
-    autoload :ConstAccessor20, 'ruby-features/utils/const_accessor_20'
+    autoload :ConstAccessor19,        'ruby-features/utils/const_accessor_19'
+    autoload :ConstAccessor20,        'ruby-features/utils/const_accessor_20'
+
+    autoload :Inflector,              'ruby-features/utils/inflector'
+    autoload :InflectorActiveSupport, 'ruby-features/utils/inflector_active_support'
 
     begin
       const_defined?('Some::Const')
@@ -11,6 +14,10 @@ module RubyFeatures
       extend ConstAccessor19
     end
 
+    extend RubyFeatures.active_support_available? ?
+      InflectorActiveSupport :
+      Inflector
+
     class << self
 
       def module_defined?(target, module_name)
@@ -23,27 +30,24 @@ module RubyFeatures
           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)
+      def prepare_module(target, module_name)
+        inject_const_parts_with_target(target, module_name) do |parent, submodule|
+          module_defined?(parent, submodule) ?
+            parent.const_get(submodule) :
+            parent.const_set(submodule, Module.new)
+        end
       end
 
-      def modulize(string)
-        string.gsub(/([a-z\d]+)/i) { $1.capitalize }.gsub(/[-_]/, '').gsub('/', '::')
-      end
+      private
+
+      def inject_const_parts_with_target(target, const_name, &block)
+        const_parts = const_name.split('::')
+        if const_parts.first == ''
+          target = ::Object
+          const_parts.shift
+        end
 
-      def underscore(string)
-        string.gsub(/([A-Z][a-z\d]*)/){ "_#{$1.downcase}" }.
-        gsub(/^_/, '').
-        gsub('::', '/')
+        const_parts.inject(target, &block)
       end
 
     end

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

@@ -1,32 +1,20 @@
 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)
+      def ruby_const_defined?(target, const_name)
+        !!inject_const_parts_with_target(target, const_name){ |parent, submodule|
+          parent && parent.const_defined?(submodule) ?
+            parent.const_get(submodule) :
+            false
+        }
       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
+      def ruby_const_get(target, const_name)
+        inject_const_parts_with_target(target, const_name) do |parent, submodule|
+          parent.const_get(submodule)
         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/inflector.rb

@@ -0,0 +1,17 @@
+module RubyFeatures
+  module Utils
+    module Inflector
+
+      def camelize(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/inflector_active_support.rb

@@ -0,0 +1,15 @@
+module RubyFeatures
+  module Utils
+    module InflectorActiveSupport
+
+      def camelize(string)
+        ActiveSupport::Inflector.camelize(string)
+      end
+
+      def underscore(string)
+        ActiveSupport::Inflector.underscore(string)
+      end
+
+    end
+  end
+end

data/lib/ruby-features/version.rb

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

data/spec/conditions_spec.rb

@@ -0,0 +1,85 @@
+describe RubyFeatures do
+
+  class ConditionsTestClass; end
+
+  RubyFeatures.define 'conditions_test_feature' do
+    condition(:boolean) { true }
+    condition(:string) { 'string' }
+
+    apply_to 'ConditionsTestClass', if: :boolean do
+      class_methods if: {string: 'string'} do
+        def boolean_true; end
+      end
+    end
+
+    apply_to 'ConditionsTestClass', unless: :boolean do
+      class_methods do
+        def boolean_false; end
+      end
+    end
+
+    apply_to 'ConditionsTestClass' do
+      class_methods if: :boolean do
+        def class_boolean_true; end
+      end
+
+      class_methods unless: :boolean do
+        def class_boolean_false; end
+      end
+
+      instance_methods if: :boolean do
+        def instance_boolean_true; end
+      end
+
+      instance_methods unless: :boolean do
+        def instance_boolean_false; end
+      end
+
+      applied if: :boolean do
+        attr_accessor :boolean_true_accessor
+      end
+
+      applied unless: :boolean do
+        attr_accessor :boolean_false_accessor
+      end
+
+    end
+
+  end.apply
+
+  subject { ConditionsTestClass }
+
+  it 'should respect conditions when appling to target' do
+    expect(subject).to respond_to(:boolean_true)
+    expect(subject).to_not respond_to(:boolean_false)
+
+    expect(subject.singleton_class.included_modules).to include(
+      RubyFeatures::Mixins::ConditionsTestFeature::ConditionsTestClass::ExtendIfBooleanIsTrueAndStringIsString
+    )
+  end
+
+  it 'should respect conditions for class methods' do
+    expect(subject).to respond_to(:class_boolean_true)
+    expect(subject).to_not respond_to(:class_boolean_false)
+  end
+
+  it 'should respect conditions for instance methods' do
+    expect(subject.new).to respond_to(:instance_boolean_true)
+    expect(subject.new).to_not respond_to(:instance_boolean_false)
+  end
+
+  it 'should respect conditions for applied blocks' do
+    expect(subject.new).to respond_to(:boolean_true_accessor)
+    expect(subject.new).to_not respond_to(:boolean_false_accessor)
+  end
+
+  it 'should raise error if such condition is aready defined' do
+    expect{
+      RubyFeatures.define 'conditions_test_class/duplicate_conditions' do
+        condition(:duplicate_condition){ :duplicate_condition }
+        condition('duplicate_condition'){ 'duplicate_condition' }
+      end
+    }.to raise_error(/Such condition is already defined/)
+  end
+
+end

data/spec/define_spec.rb

@@ -1,25 +1,34 @@
-describe RubyFeatures::Single do
+describe RubyFeatures::Concern::Feature do
 
   prepare_test_class 'DefineTestModule::DefineTestClass'
 
   it 'should apply class methods' do
     expect{
-      define_test_feature('class_methods') do
+      define_test_feature('class_methods_feature') 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)
+
+
+    expect(test_class.singleton_class.included_modules).to include(
+      RubyFeatures::Mixins::DefineTestModule::DefineTestClass::ClassMethodsFeature::DefineTestModule::DefineTestClass::Extend
+    )
   end
 
   it 'should apply instance methods' do
     expect{
-      define_test_feature('instance_methods') do
+      define_test_feature('instance_methods_feature') 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)
+
+    expect(test_class.included_modules).to include(
+      RubyFeatures::Mixins::DefineTestModule::DefineTestClass::InstanceMethodsFeature::DefineTestModule::DefineTestClass::Include
+    )
   end
 
   it 'should process applied block' do
@@ -49,7 +58,7 @@ describe RubyFeatures::Single do
           def existing_class_method; end
         end
       end.apply
-    }.to raise_error(/tried to define already existing class methods: \[:existing_class_method\]/)
+    }.to raise_error(/Tried to extend already existing methods: \[:existing_class_method\]/)
   end
 
   it 'should raise error if target already has feature instance method' do
@@ -63,7 +72,7 @@ describe RubyFeatures::Single do
           def existing_instance_method; end
         end
       end.apply
-    }.to raise_error(/tried to define already existing instance methods: \[:existing_instance_method\]/)
+    }.to raise_error(/Tried to include already existing methods: \[:existing_instance_method\]/)
   end
 
 end

data/spec/lazy_apply_spec.rb

@@ -1,4 +1,4 @@
-if RubyFeatures::Lazy.active_support_available?
+if RubyFeatures.active_support_available?
   describe RubyFeatures::Lazy do
 
     it 'should use ActiveSupport lazy load' do

data/spec/require_features_spec.rb

@@ -0,0 +1,38 @@
+describe RubyFeatures::Concern::Feature do
+
+  prepare_test_class 'RequreFeaturesTestClass'
+
+  before do
+    define_test_feature('required_feature1') do
+      class_methods do
+        def required_method1; end
+      end
+    end
+
+    define_test_feature('required_feature2') do
+      class_methods do
+        def required_method2; end
+      end
+    end
+
+    define_test_feature('required_feature3') do
+      class_methods do
+        def required_method3; end
+      end
+    end
+  end
+
+  let(:main_feature) do
+    RubyFeatures.define 'requre_features_test_class/main_feature' do
+      dependency 'requre_features_test_class/required_feature1'
+      dependencies 'requre_features_test_class/required_feature2', 'requre_features_test_class/required_feature3'
+    end
+  end
+
+  it 'should apply required features' do
+    expect{main_feature.apply}.to change{
+      (1..3).map{|i| test_class.respond_to?("required_method#{i}")}
+    }.from(Array.new(3, false)).to(Array.new(3, true))
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-features
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-17 00:00:00.000000000 Z
+date: 2015-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -35,21 +35,26 @@ 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/concern/apply_to.rb
+- lib/ruby-features/concern/feature.rb
+- lib/ruby-features/conditions.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/inflector.rb
+- lib/ruby-features/utils/inflector_active_support.rb
 - lib/ruby-features/utils.rb
 - lib/ruby-features/version.rb
 - lib/ruby-features.rb
 - LICENSE
 - README.md
+- spec/conditions_spec.rb
 - spec/define_spec.rb
 - spec/find_and_apply_spec.rb
 - spec/lazy_apply_spec.rb
+- spec/require_features_spec.rb
 - spec/ruby_features/nested/nested_feature.rb
 - spec/ruby_features/root_feature.rb
 - spec/spec_helper.rb
@@ -80,9 +85,11 @@ signing_key:
 specification_version: 3
 summary: Makes extending of Ruby classes and modules to be easy, safe and controlled.
 test_files:
+- spec/conditions_spec.rb
 - spec/define_spec.rb
 - spec/find_and_apply_spec.rb
 - spec/lazy_apply_spec.rb
+- spec/require_features_spec.rb
 - spec/ruby_features/nested/nested_feature.rb
 - spec/ruby_features/root_feature.rb
 - spec/spec_helper.rb

data/lib/ruby-features/concern.rb

@@ -1,50 +0,0 @@
-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/single.rb

@@ -1,36 +0,0 @@
-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