dry-core 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f18461caed54954ed1ded7991e22481fb2460f54
-  data.tar.gz: 6f14a3398ad397e64db754967b4315a440b225f1
+  metadata.gz: 67a852de7314c5546f3d556d5f814270b1f4bd41
+  data.tar.gz: 8f34325aacc8019f2203c9486abdddacccaa4be1
 SHA512:
-  metadata.gz: b68b62a1b7bceb698b669c9462c4bfded77dd1536dbcaaa201c76c34414df3d28e85042e106d2809ad118caabbd8ce84a4e5d09da835cf03dfa7f1f53ea7cda7
-  data.tar.gz: 0960b20d7483027f61502c64c0c06d69f37bca79c90f6bc4aedc190328bf9d354ca323c17e34a28a281f9cf27b59b6acd6c51fb0d7f36089fb1665d9103257e2
+  metadata.gz: 4c8b853aecef987b247b614ddc828c94bf403660fd38b751f5f12042b5984049a7971df2c82e4de7c176d2655c91964366ca2fbb8285875478d48c586f051831
+  data.tar.gz: 6afcac12f9ad38b5fea9d069b48b6a6488c757cbb0c791833eb24298d35e0d3346544c1a84fba14149ea83aeae88cfc6af94719b6268cf95f9ecbdbbe81b444f

data/.travis.yml

@@ -1,17 +1,18 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.1.9
+  - 2.1.10
   - 2.2.5
   - 2.3.1
-  - rbx-2
   - jruby-9.1.4.0
   - ruby-head
+  - rbx
 
 before_install: gem update bundler
 matrix:
   allow_failures:
     - rvm: ruby-head
+    - rvm: rbx
 notifications:
   email:
     recipients:
@@ -25,4 +26,3 @@ notifications:
     on_success: change  # options: [always|never|change] default: always
     on_failure: always  # options: [always|never|change] default: always
     on_start: false     # default: false
-

data/Gemfile

@@ -3,6 +3,8 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
+  gem 'activesupport', '~> 4.2'
+  gem 'inflecto', '~> 0.0', '>= 0.0.2'
   gem 'codeclimate-test-reporter', require: false
   gem 'simplecov', require: false
 end

data/dry-core.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.1.0'
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
 
   spec.add_development_dependency 'bundler', '~> 1.12'

data/lib/dry-core.rb

@@ -1 +1 @@
-require 'dry-core'
+require 'dry/core'

data/lib/dry/core/deprecations.rb

@@ -29,16 +29,17 @@ module Dry
         # Prints a warning
         #
         # @param [String] msg Warning string
-        def warn(msg)
-          logger.warn(msg.gsub(/^\s+/, ''))
+        def warn(msg, tag: nil)
+          tagged = "[#{tag || 'deprecated'}] #{msg.gsub(/^\s+/, '')}"
+          logger.warn(tagged)
         end
 
         # Wraps arguments with a standard message format and prints a warning
         #
         # @param [Object] name what is deprecated
         # @param [String] msg additional message usually containing upgrade instructions
-        def announce(name, msg)
-          warn(deprecation_message(name, msg))
+        def announce(name, msg, tag: nil)
+          warn(deprecation_message(name, msg), tag: tag)
         end
 
         # @api private
@@ -72,83 +73,116 @@ module Dry
         # Returns the logger used for printing warnings.
         # You can provide your own with .set_logger!
         #
-        # @param [String, Symbol] tag optional prefix for messages
         # @param [IO] output output stream
         #
         # @return [Logger]
-        def logger(tag = nil, output = nil)
+        def logger(output = nil)
           if defined?(@logger)
             @logger
           else
-            set_logger!(output: output, tag: tag)
+            set_logger!(output)
           end
         end
 
         # Sets a custom logger. This is a global settings.
         #
         # @option [IO] output output stream for messages
-        # @option [String, Symbol] tag optional prefix
-        #
-        # TODO: Add support for per-module loggers so that at least
-        #       tag option won't conflict.
-        def set_logger!(output: nil, tag: nil)
+        def set_logger!(output = nil)
           @logger = Logger.new(output || $stdout)
-          @logger.formatter = proc { |_severity, _datetime, _progname, msg|
-            "[#{tag || 'deprecated'}] #{msg}\n"
-          }
+          @logger.formatter = proc { |_severity, _datetime, _progname, msg| "#{msg}\n" }
           @logger
         end
+
+        def [](tag)
+          Tagged.new(tag)
+        end
+      end
+
+      # @api private
+      class Tagged < Module
+        def initialize(tag)
+          @tag = tag
+        end
+
+        def extended(base)
+          base.extend Interface
+          base.deprecation_tag @tag
+        end
       end
 
-      # Mark instance method as deprecated
-      #
-      # @param [Symbol] old_name deprecated method
-      # @param [Symbol] new_name replacement (not required)
-      # @option [String] message optional deprecation message
-      def deprecate(old_name, new_name = nil, message: nil)
-        full_msg = Deprecations.deprecated_method_message(
-          "#{self.name}##{old_name}",
-          new_name ? "#{self.name}##{new_name}" : nil,
-          message
-        )
-
-        if new_name
-          undef_method old_name
-          define_method(old_name) do |*args, &block|
-            Deprecations.warn(full_msg)
-            __send__(new_name, *args, &block)
+      module Interface
+        # Sets/gets deprecation tag
+        #
+        # @option [String,Symbol] tag tag
+        def deprecation_tag(tag = nil)
+          if defined?(@deprecation_tag)
+            @deprecation_tag
+          else
+            @deprecation_tag = tag
           end
-        else
-          aliased_name = :"#{old_name}_without_deprecation"
-          alias_method aliased_name, old_name
-          private aliased_name
-          undef_method old_name
-          define_method(old_name) do |*args, &block|
-            Deprecations.warn(full_msg)
-            __send__(aliased_name, *args, &block)
+        end
+
+        # Issue a tagged warning message
+        #
+        # @param [String] msg warning message
+        def warn(msg)
+          Deprecations.warn(msg, tag: deprecation_tag)
+        end
+
+        # Mark instance method as deprecated
+        #
+        # @param [Symbol] old_name deprecated method
+        # @param [Symbol] new_name replacement (not required)
+        # @option [String] message optional deprecation message
+        def deprecate(old_name, new_name = nil, message: nil)
+          full_msg = Deprecations.deprecated_method_message(
+            "#{self.name}##{old_name}",
+            new_name ? "#{self.name}##{new_name}" : nil,
+            message
+          )
+          mod = self
+
+          if new_name
+            undef_method old_name
+
+            define_method(old_name) do |*args, &block|
+              mod.warn(full_msg)
+              __send__(new_name, *args, &block)
+            end
+          else
+            aliased_name = :"#{old_name}_without_deprecation"
+            alias_method aliased_name, old_name
+            private aliased_name
+            undef_method old_name
+
+            define_method(old_name) do |*args, &block|
+              mod.warn(full_msg)
+              __send__(aliased_name, *args, &block)
+            end
           end
         end
-      end
 
-      # Mark class-level method as deprecated
-      #
-      # @param [Symbol] old_name deprecated method
-      # @param [Symbol] new_name replacement (not required)
-      # @option [String] message optional deprecation message
-      def deprecate_class_method(old_name, new_name = nil, message: nil)
-        full_msg = Deprecations.deprecated_method_message(
-          "#{self.name}.#{old_name}",
-          new_name ? "#{self.name}.#{new_name}" : nil,
-          message
-        )
-
-        meth = new_name ? method(new_name) : method(old_name)
-
-        singleton_class.instance_exec do
-          undef_method old_name
-          define_method(old_name) do |*args, &block|
-            Deprecations.warn(full_msg)
-            meth.call(*args, &block)
+        # Mark class-level method as deprecated
+        #
+        # @param [Symbol] old_name deprecated method
+        # @param [Symbol] new_name replacement (not required)
+        # @option [String] message optional deprecation message
+        def deprecate_class_method(old_name, new_name = nil, message: nil)
+          full_msg = Deprecations.deprecated_method_message(
+            "#{self.name}.#{old_name}",
+            new_name ? "#{self.name}.#{new_name}" : nil,
+            message
+          )
+
+          meth = new_name ? method(new_name) : method(old_name)
+
+          singleton_class.instance_exec do
+            undef_method old_name
+
+            define_method(old_name) do |*args, &block|
+              warn(full_msg)
+              meth.call(*args, &block)
+            end
           end
         end
       end

data/lib/dry/core/extensions.rb

@@ -34,6 +34,14 @@ module Dry
         @__available_extensions__[name] = block
       end
 
+      # Whether an extension is available
+      #
+      # @param [Symbol] name extension name
+      # @return [Boolean] Extension availability
+      def available_extension?(name)
+        @__available_extensions__.key?(name)
+      end
+
       # Enables specified extensions. Already enabled extensions remain untouched
       #
       # @param [Array<Symbol>] extensions list of extension names

data/lib/dry/core/inflector.rb

@@ -0,0 +1,134 @@
+module Dry
+  module Core
+    # Helper module providing thin interface around an inflection backend.
+    module Inflector
+      # List of supported backends
+      BACKENDS = {
+        activesupport: [
+          'active_support/inflector',
+          proc { ::ActiveSupport::Inflector }
+        ],
+        inflecto: [
+          'inflecto',
+          proc { ::Inflecto }
+        ]
+      }.freeze
+
+      # Try to activate a backend
+      #
+      # @api private
+      def self.realize_backend(path, backend_factory)
+        require path
+      rescue LoadError
+        nil
+      else
+        backend_factory.call
+      end
+
+      # Set up first available backend
+      #
+      # @api private
+      def self.detect_backend
+        BACKENDS.inject(nil) do |backend, (_, (path, factory))|
+          backend || realize_backend(path, factory)
+        end || raise(LoadError,
+                     "No inflector library could be found: "\
+                     "please install either the `inflecto` or `activesupport` gem.")
+      end
+
+      # Set preferred backend
+      #
+      # @param [Symbol] name backend name (:activesupport or :inflecto)
+      def self.select_backend(name = nil)
+        if name && !BACKENDS.key?(name)
+          raise NameError, "Invalid inflector library selection: '#{name}'"
+        end
+        @inflector = name ? realize_backend(*BACKENDS[name]) : detect_backend
+      end
+
+      # Inflector accessor. Lazily initializes a backend
+      #
+      # @api private
+      def self.inflector
+        defined?(@inflector) ? @inflector : select_backend
+      end
+
+      # Transform string to camel case
+      #
+      # @example
+      #   Dry::Core::Inflector.camelize('foo_bar') # => 'FooBar'
+      #
+      # @param [String] input input string
+      # @return Transformed string
+      def self.camelize(input)
+        inflector.camelize(input)
+      end
+
+      # Transform string to snake case
+      #
+      # @example
+      #   Dry::Core::Inflector.underscore('FooBar') # => 'foo_bar'
+      #
+      # @param [String] input input string
+      # @return Transformed string
+      def self.underscore(input)
+        inflector.underscore(input)
+      end
+
+      # Get a singlular form of a word
+      #
+      # @example
+      #   Dry::Core::Inflector.singularize('chars') # => 'char'
+      #
+      # @param [String] input input string
+      # @return Transformed string
+      def self.singularize(input)
+        inflector.singularize(input)
+      end
+
+      # Get a plural form of a word
+      #
+      # @example
+      #   Dry::Core::Inflector.pluralize('string') # => 'strings'
+      #
+      # @param [String] input input string
+      # @return Transformed string
+      def self.pluralize(input)
+        inflector.pluralize(input)
+      end
+
+      # Remove namespaces from a constant name
+      #
+      # @example
+      #   Dry::Core::Inflector.demodulize('Deeply::Nested::Name') # => 'Name'
+      #
+      # @param [String] input input string
+      # @return Unnested constant name
+      def self.demodulize(input)
+        inflector.demodulize(input)
+      end
+
+      # Get a constant value by its name
+      #
+      # @example
+      #   Dry::Core::Inflector.constantize('Foo::Bar') # => Foo::Bar
+      #
+      # @param [String] input input constant name
+      # @return Constant value
+      def self.constantize(input)
+        inflector.constantize(input)
+      end
+
+      # Transform a file path to a constant name
+      #
+      # @example
+      #   Dry::Core::Inflector.classify('foo/bar') # => 'Foo::Bar'
+      #
+      # @param [String] input input string
+      # @return Constant name
+      def self.classify(input)
+        inflector.classify(input)
+      end
+    end
+  end
+end

data/lib/dry/core/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Core
-    VERSION = '0.1.0'.freeze
+    VERSION = '0.2.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-core
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Nikita Shilnikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-17 00:00:00.000000000 Z
+date: 2016-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -90,6 +90,7 @@ files:
 - lib/dry/core/constants.rb
 - lib/dry/core/deprecations.rb
 - lib/dry/core/extensions.rb
+- lib/dry/core/inflector.rb
 - lib/dry/core/version.rb
 homepage: https://github.com/dry-rb/dry-code
 licenses:
@@ -104,7 +105,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="