striuct 0.6.1 → 0.9.0

data/lib/striuct/instancemethods/object.rb

@@ -1,66 +1,68 @@
-class Striuct; module InstanceMethods
+# frozen_string_literal: true
 
-  # @group Basic Methods for Ruby's Object
+class Striuct
+  module InstanceMethods
+    # @group Basic Methods for Ruby's Object
 
-  # @return [self]
-  def freeze
-    @db.freeze; @locks.freeze
-    super
-  end
+    # @return [self]
+    def freeze
+      @db.freeze; @locks.freeze
+      super
+    end
 
-  private
+    private
 
-  def initialize(*values)
-    _initialize_database
+    def initialize(*values)
+      _initialize_database
 
-    replace_values(*values)
-    excess_autonyms = _autonyms.last(size - values.size)
-    _set_defaults(*excess_autonyms)
+      replace_values(*values)
+      excess_autonyms = _autonyms.last(size - values.size)
+      _set_defaults(*excess_autonyms)
 
-    each_autonym do |autonym|
-      _check_must autonym
+      each_autonym do |autonym|
+        _check_must(autonym)
+      end
     end
-  end
 
-  def initialize_for_pairs(pairs)
-    _initialize_database
-    
-    excess_autonyms = _autonyms.dup
-    pairs.each_pair do |key, value|
-      autonym = autonym_for_key key
-      self[autonym] = value
-      excess_autonyms.delete autonym
-    end
+    def initialize_for_pairs(pairs)
+      _initialize_database
 
-    _set_defaults(*excess_autonyms)
+      excess_autonyms = _autonyms.dup
+      pairs.each_pair do |key, value|
+        autonym = autonym_for_key(key)
+        self[autonym] = value
+        excess_autonyms.delete(autonym)
+      end
 
-    excess_autonyms.each do |autonym|
-      _check_must autonym
+      _set_defaults(*excess_autonyms)
+
+      excess_autonyms.each do |autonym|
+        _check_must(autonym)
+      end
     end
-  end
-  
-  def initialize_copy(original)
-    @db, @locks = @db.dup, {}
-  end
 
-  def _initialize_database
-    @db, @locks = {}, {}
-  end
+    def initialize_copy(original)
+      @db, @locks = @db.dup, {}
+    end
 
-  def _check_frozen
-    raise "can't modify frozen #{self.class}" if frozen?
-  end
+    def _initialize_database
+      @db, @locks = {}, {}
+    end
 
-  def _check_locked(key)
-    raise "can't modify locked member `#{key}`" if locked? key
-  end
+    def _check_frozen
+      raise "can't modify frozen #{self.class}" if frozen?
+    end
 
-  def _check_must(key)
-    if must?(key) && !assigned?(key)
-      raise InvalidOperationError, "`#{key}` require a value under `must` option"
+    def _check_locked(key)
+      raise "can't modify locked member `#{key}`" if locked?(key)
     end
-  end
 
-  # @endgroup
+    def _check_must(key)
+      if must?(key) && !assigned?(key)
+        raise InvalidOperationError, "`#{key}` require a value under `must` option"
+      end
+    end
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/requirements.rb

@@ -1,19 +1,15 @@
-require 'forwardable'
-require 'keyvalidatable'
+# frozen_string_literal: true
 
-class Striuct; module InstanceMethods
+class Striuct
+  module InstanceMethods
+    extend Forwardable
 
-  extend Forwardable
-
-  # hide Forwardable's public/protected class_macro
-  private_class_method(*Forwardable.instance_methods)
-
-  include KeyValidatable
-
-end; end
+    # hide Forwardable's public/protected class_macro
+    private_class_method(*Forwardable.instance_methods)
+  end
+end
 
 require_relative 'delegate_class_methods'
-require_relative 'keyvalidatable'
 require_relative 'object'
 require_relative 'compare'
 require_relative 'to_s'
@@ -27,4 +23,4 @@ require_relative 'setter'
 require_relative 'assign'
 require_relative 'lock'
 require_relative 'validation'
-require_relative 'safety'
+require_relative 'safety'

data/lib/striuct/instancemethods/safety.rb

@@ -1,12 +1,14 @@
-class Striuct; module InstanceMethods
+# frozen_string_literal: true
 
-  # @group Safety
-  
-  # freezed, fixed familar members, all members passed any condition
-  def secure?
-    (frozen? || all_locked?) && self.class.closed? && strict?
-  end
+class Striuct
+  module InstanceMethods
+    # @group Safety
 
-  # @endgroup
+    # freezed, fixed familiar members, all members passed any condition
+    def secure?
+      (frozen? || all_locked?) && self.class.closed? && strict?
+    end
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/setter.rb

@@ -1,54 +1,55 @@
-class Striuct; module InstanceMethods
-
-  # @group Setter
-
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  # @return value
-  def []=(key, value)
-    autonym = autonym_for_key key
-    _set autonym, value
-  rescue Validation::InvalidWritingError
-    $!.set_backtrace([
-      "#{$!.backtrace[-1].sub(/[^:]+\z/){''}}in `[#{key.inspect}(#{autonym})]=': #{$!.message}",
-      $!.backtrace[-1]
-    ])
-
-    raise
-  end
+# frozen_string_literal: true
+
+class Striuct
+  module InstanceMethods
+    # @group Setter
+
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    # @return value
+    def []=(key, value)
+      autonym = autonym_for_key(key)
+      _set(autonym, value)
+    rescue InvalidWritingError
+      $!.set_backtrace(
+        ["#{$!.backtrace[-1].sub(/[^:]+\z/) { '' }}in `[#{key.inspect}(#{autonym})]=': #{$!.message}", $!.backtrace[-1]]
+      )
+
+      raise
+    end
 
-  alias_method :assign, :[]=
+    alias_method :assign, :[]=
 
-  private
+    private
 
-  # @param [Symbol] autonym - MUST already converted to native autonym
-  # @return value
-  def _set(autonym, value)
-    _check_frozen
-    _check_locked autonym
+    # @param [Symbol] autonym - MUST already converted to native autonym
+    # @return value
+    def _set(autonym, value)
+      _check_frozen
+      _check_locked(autonym)
 
-    if with_adjuster? autonym
-      begin
-        value = instance_exec value, &adjuster_for(autonym)
-      rescue Exception
-        raise ::Validation::UnmanagebleError
+      if with_adjuster?(autonym)
+        begin
+          value = instance_exec(value, &adjuster_for(autonym))
+        rescue Exception
+          raise InvalidAdjustingError
+        end
       end
-    end
 
-    if with_safety_setter?(autonym) and !accept?(autonym, value)
-      raise ::Validation::InvalidWritingError,
-            "#{value.inspect} is deficient for #{autonym} in #{self.class}"
-    end
+      if with_safety_setter?(autonym) && !accept?(autonym, value)
+        raise InvalidWritingError,
+              "#{value.inspect} is deficient for #{autonym} in #{self.class}"
+      end
 
-    @db[autonym] = value
-  rescue ::Validation::InvalidError
-    unless /in \[\]=/ =~ caller[1].slice(/([^:]+)\z/)
-      $!.backtrace.delete_if{|s|/#{Regexp.escape(File.dirname __FILE__)}/ =~ s}
-      $!.backtrace.first.sub!(/([^:]+)\z/){"in `#{autonym}='"}
-    end
-  
-    raise
-  end
+      @db[autonym] = value
+    rescue InvalidValueError
+      unless /in \[\]=/.match?(caller(2..2).first.slice(/([^:]+)\z/))
+        $!.backtrace.delete_if { |s| /#{Regexp.escape(File.dirname(__FILE__))}/ =~ s }
+        $!.backtrace.first.sub!(/([^:]+)\z/) { "in `#{autonym}='" }
+      end
 
-  # @endgroup
+      raise
+    end
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/to_s.rb

@@ -1,43 +1,45 @@
-class Striuct; module InstanceMethods
+# frozen_string_literal: true
 
-  # @group To Strings
-  
-  # @return [String]
-  def inspect
-    "#<struct' #{self.class}".tap {|s|
-      each_pair do |autonym, value|
-        suffix = (with_default?(autonym) && default?(autonym)) ? '/default' : nil
-        label_valid = valid?(autonym) ? nil : :invalid
-        label_lock = locked?(autonym) ? :locked : nil
-        label_must = must?(autonym) ? :must : nil
-        labels = [label_valid, label_lock, label_must].select{|_|_}
+class Striuct
+  module InstanceMethods
+    # @group To Strings
 
-        s << " #{autonym}=#{value.inspect}#{suffix}"
-        unless labels.empty?
-          s << '('
-          s << labels.join(', ')
-          s << ')'
+    # @return [String]
+    def inspect
+      (+"#<struct' #{self.class}").tap { |s|
+        each_pair do |autonym, value|
+          suffix = (with_default?(autonym) && default?(autonym)) ? '/default' : nil
+          label_valid = valid?(autonym) ? nil : :invalid
+          label_lock = locked?(autonym) ? :locked : nil
+          label_must = must?(autonym) ? :must : nil
+          labels = [label_valid, label_lock, label_must].select { |elm| elm }
+
+          s << " #{autonym}=#{value.inspect}#{suffix}"
+          unless labels.empty?
+            s << '('
+            s << labels.join(', ')
+            s << ')'
+          end
+          s << ','
         end
-        s << ','
-      end
-      
-      s.chop!
-      s << '>'
-    }
-  end
 
-  # @return [String]
-  def to_s
-    "#<struct' #{self.class}".tap {|s|
-      each_pair do |autonym, value|
-        s << " #{autonym}=#{value.inspect},"
-      end
-      
-      s.chop!
-      s << '>'
-    }
-  end
+        s.chop!
+        s << '>'
+      }
+    end
 
-  # @endgroup
+    # @return [String]
+    def to_s
+      (+"#<struct' #{self.class}").tap { |s|
+        each_pair do |autonym, value|
+          s << " #{autonym}=#{value.inspect},"
+        end
+
+        s.chop!
+        s << '>'
+      }
+    end
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/validation.rb

@@ -1,35 +1,52 @@
-class Striuct; module InstanceMethods
-
-  # @group Validation
-  
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  # @param value
-  # true if passed under any condition
-  def accept?(key, value)
-    autonym = autonym_for_key key
-    return true unless restrict? autonym
-  
-    begin  
-      _valid? condition_for(autonym), value
-    rescue Exception
-      false
+# frozen_string_literal: true
+
+class Striuct
+  module InstanceMethods
+    # @group Validation
+
+    # @param [Proc, Method, #===] pattern
+    # @param [Object] value
+    def _valid?(pattern, value)
+      !!(
+        case pattern
+        when Proc
+          instance_exec(value, &pattern)
+        when Method
+          pattern.call(value)
+        else
+          pattern === value
+        end
+      )
     end
-  end
 
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  # @param value - if no argument and use current assigned value
-  # true if passed under any condition
-  def sufficient?(key, value=self[key])
-    accept? key, value
-  end
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    # @param value
+    # true if passed under any condition
+    def accept?(key, value)
+      autonym = autonym_for_key(key)
+      return true unless restrict?(autonym)
+
+      begin
+        _valid?(condition_for(autonym), value)
+      rescue Exception
+        false
+      end
+    end
 
-  alias_method :valid?, :sufficient?
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    # @param value - if no argument and use current assigned value
+    # true if passed under any condition
+    def sufficient?(key, value=self[key])
+      accept?(key, value)
+    end
 
-  # all members passed under any condition
-  def strict?
-    each_pair.all?{|autonym, value|sufficient? autonym, value}
-  end
+    alias_method :valid?, :sufficient?
 
-  # @endgroup
+    # all members passed under any condition
+    def strict?
+      each_pair.all? { |autonym, value| sufficient?(autonym, value) }
+    end
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/values.rb

@@ -1,58 +1,60 @@
-class Striuct; module InstanceMethods
-
-  # @group Behavior under Values
-
-  # @param [Integer, #to_int, Range] _keys
-  # @return [Array]
-  def values_at(*_keys)
-    [].tap {|r|
-      _keys.each do |key|
-        case key
-        when ->v{v.respond_to? :to_int}
-          r << fetch_by_index(key)
-        when Range
-          key.each do |idx|
-            raise TypeError unless idx.respond_to? :to_int
-
-            r << fetch_by_index(idx)
+# frozen_string_literal: true
+
+class Striuct
+  module InstanceMethods
+    # @group Behavior under Values
+
+    # @param [Integer, #to_int, Range] keys
+    # @return [Array]
+    def values_at(*keys)
+      [].tap { |r|
+        keys.each do |key|
+          case key
+          when ->v { v.respond_to?(:to_int) }
+            r << fetch_by_index(key)
+          when Range
+            key.each do |idx|
+              raise TypeError unless idx.respond_to?(:to_int)
+
+              r << fetch_by_index(idx)
+            end
+          else
+            raise TypeError
           end
-        else
-          raise TypeError
         end
-      end
-    }
-  end
+      }
+    end
 
-  # @return [Array]
-  # @raise [ArgumentError] if the keys contains an unmacthed
-  #     key and no block is given
-  def fetch_values(*_keys, &block)
-    _keys.map {|key|
-      if has_key? key
-        fetch_by_key(key)
-      else
-        if block_given?
-          block.call
+    # @return [Array]
+    # @raise [ArgumentError] if the keys contains an unmatched
+    #     key and no block is given
+    def fetch_values(*keys, &block)
+      keys.map { |key|
+        if key?(key)
+          fetch_by_key(key)
         else
-          raise ArgumentError, "`#{key}' is not matched"
+          if block
+            yield
+          else
+            raise ArgumentError, "`#{key}' is not matched"
+          end
         end
+      }
+    end
+
+    # @return [self]
+    def replace_values(*values)
+      unless values.size <= size
+        raise ArgumentError, "struct size differs (max: #{size})"
       end
-    }
-  end
 
-  # @return [self]
-  def replace_values(*values)
-    unless values.size <= size
-      raise ArgumentError, "struct size differs (max: #{size})"
-    end
+      values.each_with_index do |value, index|
+        _set(autonym_for_index(index), value)
+      end
 
-    values.each_with_index do |value, index|
-      _set autonym_for_index(index), value
+      self
     end
-    
-    self
-  end
-
-  # @endgroup
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/singleton_class.rb

@@ -1,13 +1,9 @@
-require 'validation'
+# frozen_string_literal: true
 
 class Striuct
-
   class << self
-    
     alias_method :new_instance, :new
     private :new_instance
-    
-    # @group Constructors for Subclassies 
 
     # @param [Symbol, String] autonyms
     # @yieldreturn [Class]
@@ -15,8 +11,8 @@ class Striuct
     def new(*autonyms, &block)
       # warning for Ruby's Struct.new user
       first = autonyms.first
-      if first.instance_of?(String) and /\A[A-Z]/ =~ first
-        warn "no define constant first-arg(#{first}), the Struct behavior is not supported in Striuct"
+      if first.instance_of?(String) && /\A[A-Z]/ =~ first
+        warn("no define constant first-arg(#{first}), the Struct behavior is not supported in Striuct")
       end
 
       Class.new(self) {
@@ -24,42 +20,53 @@ class Striuct
           add_member autonym
         end
 
-        class_eval(&block) if block_given?
+        class_eval(&block) if block
       }
     end
 
     # @yieldreturn [Class] (see Striuct.new) - reject floating class
     # @return [void]
     def define(&block)
-      raise ArgumentError, 'block not supplied' unless block_given?
+      raise ArgumentError, 'block not supplied' unless block
 
-      new(&block).tap {|subclass|
+      new(&block).tap { |subclass|
         subclass.class_eval {
           raise 'not yet finished' if @autonyms.empty?
+
           close
         }
       }
     end
 
-    # @groupend
+    # Return `true` if given object is sufficient as an adjuster role
+    def adjustable?(object)
+      case object
+      when Proc
+        object.arity == 1
+      else
+        if object.respond_to?(:to_proc)
+          object.to_proc.arity == 1
+        else
+          false
+        end
+      end
+    end
 
     private
-    
+
     def inherited(subclass)
-      ret = super subclass
+      ret = super(subclass)
 
       subclass.class_eval {
         extend ClassMethods
         include Enumerable
-        include Validation
+        extend Eqq::Buildable
         include InstanceMethods
-        
+
         _init
       }
 
       ret
     end
-
   end
-
-end
+end

data/lib/striuct/structs.rb

@@ -1,7 +1,7 @@
-class Striuct
+# frozen_string_literal: true
 
+class Striuct
   # namespace for .to_struct_class, #to_struct
   module Structs
   end
-
-end
+end

data/lib/striuct.rb

@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
 # striuct - Struct++
 # Copyright (c) 2011-2012 Kenichi Kamiya
 
 # @abstract
 class Striuct
-
   class Error < StandardError; end
   class InvalidOperationError < Error; end
-
+  class InvalidValueError < Error; end
+  class InvalidWritingError < InvalidValueError; end
+  class InvalidReadingError < InvalidValueError; end
+  class InvalidAdjustingError < InvalidValueError; end
 end
 
-require_relative 'striuct/requirements'
+require_relative 'striuct/bootstrap'