confo-config 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e18009a32d37da15b10c87cff286b37be9ff6a2e
+  data.tar.gz: 0e2ad064b148ef7237ec98722afebb703dd8b2bb
+SHA512:
+  metadata.gz: f759fb4b9277b5f78c559cda2e270d97d2741827f2536e3cb40578d97f902eda3eaceac0906bcef6cc0b898fda0fdf1f0f105712d5fcd1570342d67eb453c548
+  data.tar.gz: d05dbef7d09242b374b5872202349dd315c7899302554e08dd143db3c30b55a5f26f7446d50e588df09bf43aebb69be38425ac63648a44debfec0f8e7cc475ae

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in confo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Yaroslav Konoplov
+
+MIT License
+
+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,35 @@
+# ConfoConfig
+
+## A little configuration DSL
+```ruby
+configuration do
+  autocomplete_limit 20
+  autocomplete_phrase_length 2
+
+  i18n do
+    available_locales [:en, :ru]
+    default_locale :en
+  end
+
+  list do
+    single_actions { can :update, :toggle, :delete, :preview }
+    plural_actions { can :create, :filter, :export, :search }
+
+    highlight { role admin: :red, user: :gray }
+
+    configure(:column, :avatar) { type :photo }
+
+    columns { include :name, :avatar, :role }
+  end
+
+  form do
+    configure(:input, :avatar) { type :photo }
+    actions { can :save, :cancel }
+  end
+end
+```
+
+## Gemfile
+```ruby
+gem 'confo-config', github: 'yivo/confo-config'
+```

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/confo.gemspec

@@ -0,0 +1,19 @@
+require File.expand_path('../lib/confo/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'confo-config'
+  spec.version       = Confo::VERSION
+  spec.authors       = ['Yaroslav Konoplov']
+  spec.email         = ['yaroslav@inbox.com']
+  spec.summary       = 'Little configuration framework'
+  spec.description   = 'Little configuration framework'
+  spec.homepage      = 'http://github.com/yivo/confo-config'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '~> 4.0' # 4.0 <= version < 5.0
+end

data/lib/confo/collection.rb

@@ -0,0 +1,80 @@
+module Confo
+  class Collection
+    include Enumerable
+
+    attr_reader :behaviour_options
+
+    def initialize(behaviour_options = {}, &block)
+      @behaviour_options = behaviour_options
+      configure(&block) if block
+    end
+
+    def define(id, options = nil, construct_options = nil, &block)
+      id        = convert_id(id)
+      config    = storage[id]
+      config  ||= begin
+        config_class  = Confo.call(self, :config_class, id, construct_options)
+        config        = Confo.call(self, :construct_config, config_class, id, construct_options)
+        storage[id]   = config
+        config.set(:name, id)
+        config
+      end
+
+      config.set(options)       if options
+      config.configure(&block)  if block
+      config
+    end
+
+    def get(id)
+      define(id)
+    end
+
+    def set(id, config)
+      storage[convert_id(id)] = config
+    end
+
+    alias []  get
+    alias []= set
+
+    def configure(*args, &block)
+      args.present? ? define(*args).configure(&block) : instance_eval(&block)
+    end
+
+    def exists?(id)
+      storage[convert_id(id)].present?
+    end
+
+    def each(&block)
+      storage.each { |k, v| block.call(v) }
+    end
+
+    def to_a
+      storage.values
+    end
+
+    def to_hash
+      storage.reduce({}) do |memo, (id, instance)|
+        memo[id] = Confo.convert_to_hash(instance)
+        memo
+      end
+    end
+
+    protected
+
+    def config_class(config_id, config_options)
+      config_options.try(:[], :class_name).try(:safe_constantize) || Config
+    end
+
+    def construct_config(config_class)
+      config_class.new
+    end
+
+    def storage
+      @storage ||= ActiveSupport::OrderedHash.new
+    end
+
+    def convert_id(id)
+      id.to_sym
+    end
+  end
+end

data/lib/confo/concerns/options_manager.rb

@@ -0,0 +1,184 @@
+module Confo
+  module OptionsManager
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Define option accessors.
+      def option_accessor(*names)
+        names.each do |name|
+          define_option_functional_accessor(name)
+          define_option_writer(name)
+        end
+      end
+
+      def define_option_functional_accessor(name)
+        define_method("#{name}") do |*args|
+          if args.size > 0
+            raw_set(name, args.first)
+            self
+          else
+            raw_get(name)
+          end
+        end
+      end
+
+      def define_option_writer(name)
+        define_method("#{name}=") do |value|
+          raw_set(name, value)
+          self
+        end
+      end
+    end
+
+    # Returns option value:
+    #   obj.get(:option)    => 'value'
+    #   obj.get('option')   => 'value'
+    #
+    #   obj.set :option, -> { 'value' }
+    #   obj.get(:option)    => 'value'
+    #
+    #   obj.set :option, -> (arg) { 'value' }
+    #   obj.get(:option)    => -> (arg) { 'value' }
+    def get(option)
+      public_get(option)
+    end
+
+    # Alias for +get+.
+    alias [] get
+
+    protected
+
+    # Method to get an option.
+    # If there is an option accessor defined then it will be used.
+    # In other cases +raw_get+ will be used.
+    def public_get(option)
+      respond_to?(option) ? send(option) : raw_get(option)
+    end
+
+    # Internal method to get an option.
+    # If value is callable without arguments
+    # it will be called and result will be returned.
+    def raw_get(option)
+      value = storage[option]
+      Confo.callable_without_arguments?(value) ? value.call : value
+    end
+
+    public
+
+    # Sets option:
+    #   obj.set(:option, 'value')
+    #   obj.set('option', 'value')
+    #   obj.set({ foo: '1', bar: '2', baz: -> { 3 } })
+    def set(arg, *args)
+      if arg.kind_of?(Hash)
+        arg.each { |k, v| public_set(k, v) }
+      elsif args.size > 0
+        public_set(arg, args.first)
+      end
+      self
+    end
+
+    # Alias for +set+.
+    alias []= set
+
+    protected
+
+    # Method to set an option.
+    # If there is an option accessor defined then it will be used.
+    # In other cases +raw_set+ will be used.
+    def public_set(option, value)
+      method = "#{option}="
+      respond_to?(method) ? send(method, value) : raw_set(option, value)
+    end
+
+    # Internal method to set option.
+    def raw_set(option, value)
+      storage[option] = value
+    end
+
+    public
+
+    # Sets option only if it is not set yet:
+    #   obj.set_at_first(:option, 1)
+    #   obj.get(:option)      => 1
+    #   obj.set_at_first(:option, 2)
+    #   obj.get(:option)      => 1
+    def set_at_first(*args)
+      set?(*args)
+      self
+    end
+
+    # Alias for +set_at_first+.
+    alias init set_at_first
+
+    # Option accessor in functional style:
+    #   obj.option(:option, 'value')
+    #   obj.option(:option)   => 'value'
+    def option(option, *args)
+      args.size > 0 ? set(option, args.first) : get(option)
+    end
+
+    # Checks if option is set.
+    # Works similar to set if value passed but sets only uninitialized options.
+    def set?(arg, *rest_args)
+      if arg.kind_of?(Hash)
+        arg.each { |k, v| set(k, v) unless set?(k) }
+        nil
+      elsif rest_args.size > 0
+        set(arg, rest_args.first) unless set?(arg)
+        true
+      else
+        storage.has_key?(arg)
+      end
+    end
+
+    # If you expect computed value you can pass arguments to it:
+    #   obj.set :calculator, -> (num) { num * 2 }
+    #   obj.result_of :calculator, 2    => 4
+    def result_of(option, *args)
+      Confo.result_of(get(option), *args)
+    end
+
+    # Unsets option.
+    def unset(option)
+      storage.delete(option)
+      self
+    end
+
+    # Returns option names as array of symbols.
+    def keys
+      storage.reduce([]) do |memo, k, v|
+        memo << k.to_sym
+        memo
+      end
+    end
+
+    # Returns option values as array.
+    def values
+      storage.values
+    end
+
+    # Returns all options at once.
+    #   obj.options => { option: 'value' }
+    def options
+      options = storage.dup
+      options.each { |k, v| options[k] = get(k) }
+      options
+    end
+
+    protected
+
+    def storage
+      @storage ||= OptionsStorage.new
+    end
+  end
+
+  class OptionsStorage < Hash
+    def to_hash
+      new_hash = {}
+      each { |k, v| new_hash[k.kind_of?(String) ? k.to_sym : k] = Confo.convert_to_hash(v) }
+      Hash.new(default).merge!(new_hash)
+    end
+  end
+end

data/lib/confo/concerns/subconfigs_manager.rb

@@ -0,0 +1,101 @@
+module Confo
+  module SubconfigsManager
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def includes_config(arg, options = {})
+        @subconfigs_options ||= {}
+
+        # Support different syntaxes:
+        #   includes_config :actions
+        #   includes_config of: :actions
+        #   includes_config for: :actions
+        name          = (arg.kind_of?(Hash) ? arg[:of] || arg[:for] : arg).to_sym
+        new_options   = @subconfigs_options[name]
+        new_options ||= { name: name, fallback_class_name: 'Confo::Config' }
+        new_options.merge!(options)
+
+        @subconfigs_options[name] = new_options
+
+        define_subconfig_reader(name, new_options)
+        self
+      end
+
+      def subconfigs_options
+        all_options = @subconfigs_options ? @subconfigs_options.dup : {}
+        if superclass.respond_to?(:subconfigs_options)
+          superclass.subconfigs_options.each do |name, options|
+            new_options = {}
+            new_options.merge!(options[name]) if options[name]
+            new_options.merge!(options)
+            options[name] = new_options
+          end
+        end
+        all_options
+      end
+
+      def define_subconfig_reader(subconfig_name, subconfig_options)
+        define_method(subconfig_name) do |options = nil, overrides = nil, &block|
+          subconfig_internal(subconfig_name, options, overrides, &block)
+        end
+      end
+    end
+
+    def subconfigs
+      unless @all_subconfigs_loaded
+        self.class.subconfigs_options.each { |name, options| subconfig(name) }
+        @all_subconfigs_loaded = true
+      end
+      subconfig_instances
+    end
+
+    def subconfig(subconfig_name, options = nil, overrides = nil, &block)
+      respond_to?(subconfig_name) ?
+        send(subconfig_name, options, overrides, &block) :
+        subconfig_internal(subconfig_name, options, overrides, &block)
+    end
+
+    def subconfig_exists?(subconfig_name)
+      subconfig_instances.exists?(subconfig_name)
+    end
+
+    protected
+
+    def subconfig_instances
+      @subconfig_instances ||= Collection.new
+    end
+
+    def subconfig_internal(subconfig_name, options = nil, overrides = nil, &block)
+      unless subconfig_exists?(subconfig_name)
+        subconfig_options   = self.class.subconfigs_options[subconfig_name].try(:dup) || {}
+        subconfig_options.merge!(overrides) if overrides
+
+        subconfig_class     = Confo.call(self, :subconfig_class, subconfig_name, subconfig_options)
+        subconfig_instance  = Confo.call(self, :construct_subconfig, subconfig_class, subconfig_options)
+
+        subconfig_instance.set(:name, subconfig_name) unless subconfig_instance.kind_of?(Collection)
+        subconfig_instances.set(subconfig_name, subconfig_instance)
+      end
+      subconfig_instance = subconfig_instances.get(subconfig_name)
+      subconfig_instance.set(options)       if options
+      subconfig_instance.configure(&block)  if block
+      subconfig_instance
+    end
+
+    def construct_subconfig(subconfig_class)
+      subconfig_class.new
+    end
+
+    def subconfig_class(subconfig_name, subconfig_options)
+      if class_name = subconfig_options[:class_name]
+        class_name.to_s.camelize
+      else
+        guess_subconfig_class_name(subconfig_name)
+      end.safe_constantize || subconfig_options.fetch(:fallback_class_name, 'Confo::Config').constantize
+    end
+
+    def guess_subconfig_class_name(subconfig_name)
+      "#{subconfig_name.to_s.camelize}Config"
+    end
+  end
+end

data/lib/confo/config.rb

@@ -0,0 +1,121 @@
+require_relative '../confo.rb'
+
+module Confo
+  class Config
+    include OptionsManager
+    include SubconfigsManager
+
+    attr_reader :behaviour_options
+
+    def initialize(behaviour_options = {}, &block)
+      @behaviour_options = behaviour_options
+      preconfigure
+      configure(&block) if block
+    end
+
+    def configure(*args, &block)
+      case args.size
+
+        # Current config configuration:
+        #   object.configure {  }
+        when 0
+          instance_eval(&block) if block
+          self
+
+        when 1, 2, 3
+          arg1, arg2, arg3  = args
+          arg1_hash         = arg1.kind_of?(Hash)
+
+          # Hash-based collection syntax:
+          #   object.configure(property: :id) {  }
+          #   object.configure(property: :id, {option: :value}) {  }
+          #
+          # Full definition syntax:
+          #   object.configure(:property, :id) {  }
+          #   object.configure(:property, :id, {option: :value}) {  }
+          if arg1_hash || (args.size == 2 && arg2.kind_of?(Hash) == false)
+            subconfig_name  = (arg1_hash ? arg1.keys.first : arg1).to_s.pluralize
+            config_id       = arg1_hash ? arg1.values.first : arg2
+            options         = arg1_hash ? arg2 : arg3
+            subconfig(subconfig_name, options, fallback_class_name: 'Confo::Collection')
+              .configure(config_id, &block)
+          else
+
+            # Subconfig configuration:
+            #   object.configure(:description)
+            #   object.configure(:description, {option: :value})
+            subconfig(arg1, arg2, &block)
+          end
+
+        else self
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      case args.size
+        when 0
+          if block
+            # Wants to configure subconfig:
+            #   object.description {  }
+            subconfig(name, &block)
+          else
+
+            # Wants one of the following:
+            #   - access subconfig
+            #   - access option
+            subconfig_exists?(name) ? subconfig(name) : option(normalize_option(name))
+          end
+
+        when 1
+          arg = args.first
+
+          # Wants to access collection:
+          #   object.properties :id {  }
+          if (arg.is_a?(String) || arg.is_a?(Symbol)) && subconfig_exists?(name)
+            subconfig(name.to_s.pluralize, arg, &block)
+          else
+
+            # Wants to access option:
+            #   object.cache = :none
+            #   object.cache :none
+            option(normalize_option(name), arg)
+          end
+
+        else
+          option(normalize_option(name), *args)
+      end
+    end
+
+    def to_hash
+      {}.merge!(options.to_hash).merge!(subconfigs.to_hash)
+    end
+
+    protected
+
+    def preconfigure
+      preconfigurator_class = lookup_preconfigurator_class
+      if preconfigurator_class
+        preconfigurator_class.instance.preconfigure(self)
+        true
+      else
+        false
+      end
+    end
+
+    def lookup_preconfigurator_class
+      guess_preconfigurator_class_name.safe_constantize
+    end
+
+    def configurable_component_name
+      self.class.name.demodulize.sub(/Config\Z/, '')
+    end
+
+    def guess_preconfigurator_class_name
+      "#{configurable_component_name}Preconfigurator"
+    end
+
+    def normalize_option(name)
+      name.to_s.sub(/=+\Z/, '').to_sym
+    end
+  end
+end

data/lib/confo/preconfigurator.rb

@@ -0,0 +1,12 @@
+module Confo
+  class Preconfigurator
+    include Singleton
+
+    def preconfigure(config)
+      raise PreconfiguratorNotImplementedError
+    end
+  end
+
+  class PreconfiguratorNotImplementedError < ::StandardError
+  end
+end

data/lib/confo/version.rb

@@ -0,0 +1,3 @@
+module Confo
+  VERSION = '1.0.0'
+end

data/lib/confo-config.rb

@@ -0,0 +1 @@
+require_relative 'confo.rb'

data/lib/confo.rb

@@ -0,0 +1,43 @@
+require 'active_support/all'
+require 'confo/version'
+require 'confo/concerns/options_manager'
+require 'confo/concerns/subconfigs_manager'
+require 'confo/config'
+require 'confo/collection'
+require 'confo/preconfigurator'
+
+module Confo
+  class << self
+    def result_of(value, *args)
+      if value.respond_to?(:call)
+        _args_ = value.arity < 0 ? args : args[0...value.arity]
+        value.call(*args)
+      else
+        value
+      end
+    end
+
+    def callable_without_arguments?(obj)
+      obj.respond_to?(:call) && (!obj.respond_to?(:arity) || obj.arity == 0)
+    end
+
+    def convert_to_hash(value)
+      if value.is_a?(Hash)
+        value.to_hash
+      elsif value.is_a?(Array)
+        value.map { |e| convert_to_hash(e) }
+      else
+        value.respond_to?(:to_hash) ? value.to_hash : value
+      end
+    end
+
+    def call_method_with_floating_arguments(object, method, *args)
+      callable      = object.method(method)
+      arity         = callable.arity
+      resized_args  = arity < 0 ? args : args[0...arity]
+      callable.call(*resized_args)
+    end
+
+    alias call call_method_with_floating_arguments
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: confo-config
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yaroslav Konoplov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Little configuration framework
+email:
+- yaroslav@inbox.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- confo.gemspec
+- lib/confo-config.rb
+- lib/confo.rb
+- lib/confo/collection.rb
+- lib/confo/concerns/options_manager.rb
+- lib/confo/concerns/subconfigs_manager.rb
+- lib/confo/config.rb
+- lib/confo/preconfigurator.rb
+- lib/confo/version.rb
+homepage: http://github.com/yivo/confo-config
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Little configuration framework
+test_files: []