dry-core 0.4.7

data/lib/dry/core/descendants_tracker.rb

@@ -0,0 +1,76 @@
+require 'concurrent/array'
+
+module Dry
+  module Core
+    # An implementation of descendants tracker, heavily inspired
+    # by the descendants_tracker gem.
+    #
+    # @example
+    #
+    #   class Base
+    #     extend Dry::Core::DescendantsTracker
+    #   end
+    #
+    #   class A < Base
+    #   end
+    #
+    #   class B < Base
+    #   end
+    #
+    #   class C < A
+    #   end
+    #
+    #   Base.descendants # => [C, B, A]
+    #   A.descendants # => [C]
+    #   B.descendants # => []
+    #
+    module DescendantsTracker
+      class << self
+        # @api private
+        def setup(target)
+          target.instance_variable_set(:@descendants, Concurrent::Array.new)
+        end
+
+        private
+
+        # @api private
+        def extended(base)
+          super
+
+          DescendantsTracker.setup(base)
+        end
+      end
+
+      # Return the descendants of this class
+      #
+      # @example
+      #   descendants = Parent.descendants
+      #
+      # @return [Array<Class>]
+      #
+      # @api public
+      attr_reader :descendants
+
+      protected
+
+      # @api private
+      def add_descendant(descendant)
+        ancestor = superclass
+        if ancestor.respond_to?(:add_descendant, true)
+          ancestor.add_descendant(descendant)
+        end
+        descendants.unshift(descendant)
+      end
+
+      private
+
+      # @api private
+      def inherited(descendant)
+        super
+
+        DescendantsTracker.setup(descendant)
+        add_descendant(descendant)
+      end
+    end
+  end
+end

data/lib/dry/core/errors.rb

@@ -0,0 +1,11 @@
+module Dry
+  module Core
+    class InvalidClassAttributeValue < StandardError
+      def initialize(name, value)
+        super(
+          "Value #{value.inspect} is invalid for class attribute #{name.inspect}"
+        )
+      end
+    end
+  end
+end

data/lib/dry/core/extensions.rb

@@ -0,0 +1,61 @@
+require 'set'
+
+module Dry
+  module Core
+    # Define extensions that can be later enabled by the user.
+    #
+    # @example
+    #
+    #   class Foo
+    #     extend Dry::Core::Extensions
+    #
+    #     register_extension(:bar) do
+    #        def bar; :bar end
+    #     end
+    #   end
+    #
+    #   Foo.new.bar # => NoMethodError
+    #   Foo.load_extensions(:bar)
+    #   Foo.new.bar # => :bar
+    #
+    module Extensions
+      # @api private
+      def self.extended(obj)
+        super
+        obj.instance_variable_set(:@__available_extensions__, {})
+        obj.instance_variable_set(:@__loaded_extensions__, Set.new)
+      end
+
+      # Register an extension
+      #
+      # @param [Symbol] name extension name
+      # @yield extension block. This block guaranteed not to be called more than once
+      def register_extension(name, &block)
+        @__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
+      def load_extensions(*extensions)
+        extensions.each do |ext|
+          block = @__available_extensions__.fetch(ext) do
+            raise ArgumentError, "Unknown extension: #{ext.inspect}"
+          end
+          unless @__loaded_extensions__.include?(ext)
+            block.call
+            @__loaded_extensions__ << ext
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/core/inflector.rb

@@ -0,0 +1,138 @@
+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 }
+        ],
+        dry_inflector: [
+          'dry/inflector',
+          proc { Dry::Inflector.new }
+        ],
+        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/memoizable.rb

@@ -0,0 +1,68 @@
+module Dry
+  module Core
+    module Memoizable
+      MEMOIZED_HASH = {}.freeze
+
+      module ClassInterface
+        def memoize(*names)
+          prepend(Memoizer.new(self, names))
+        end
+
+        def new(*)
+          obj = super
+          obj.instance_variable_set(:'@__memoized__', MEMOIZED_HASH.dup)
+          obj
+        end
+      end
+
+      def self.included(klass)
+        super
+        klass.extend(ClassInterface)
+      end
+
+      attr_reader :__memoized__
+
+      # @api private
+      class Memoizer < Module
+        attr_reader :klass
+        attr_reader :names
+
+        # @api private
+        def initialize(klass, names)
+          @names = names
+          @klass = klass
+          define_memoizable_names!
+        end
+
+        private
+
+        # @api private
+        def define_memoizable_names!
+          names.each do |name|
+            meth = klass.instance_method(name)
+
+            if meth.parameters.size > 0
+              define_method(name) do |*args|
+                name_with_args = :"#{name}_#{args.hash}"
+
+                if __memoized__.key?(name_with_args)
+                  __memoized__[name_with_args]
+                else
+                  __memoized__[name_with_args] = super(*args)
+                end
+              end
+            else
+              define_method(name) do
+                if __memoized__.key?(name)
+                  __memoized__[name]
+                else
+                  __memoized__[name] = super()
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/core/version.rb

@@ -0,0 +1,5 @@
+module Dry
+  module Core
+    VERSION = '0.4.7'.freeze
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: dry-core
+version: !ruby/object:Gem::Version
+  version: 0.4.7
+platform: ruby
+authors:
+- Nikita Shilnikov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A toolset of small support modules used throughout the dry-rb ecosystem.
+email:
+- fg@flashgordon.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".inch.yml"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dry-core.gemspec
+- lib/dry-core.rb
+- lib/dry/core.rb
+- lib/dry/core/cache.rb
+- lib/dry/core/class_attributes.rb
+- lib/dry/core/class_builder.rb
+- lib/dry/core/constants.rb
+- lib/dry/core/deprecations.rb
+- lib/dry/core/descendants_tracker.rb
+- lib/dry/core/errors.rb
+- lib/dry/core/extensions.rb
+- lib/dry/core/inflector.rb
+- lib/dry/core/memoizable.rb
+- lib/dry/core/version.rb
+homepage: https://github.com/dry-rb/dry-core
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A toolset of small support modules used throughout the dry-rb ecosystem.
+test_files: []