striuct 0.4.4.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 746edaaaf527160fde69fb136722ff8861375af7
-  data.tar.gz: 17062017c2bec73985602a5c4069ffec47acc3f6
+SHA256:
+  metadata.gz: d820670e757190ed2db502b8d6e0c53a7689f299262695f3ca18cec69dd5270b
+  data.tar.gz: 8a27cca712c9a63c2a5207090a6a8d0d8dcecd24a13bf07fa16c243a3b24c366
 SHA512:
-  metadata.gz: 7c3897a36c553fcc2f760581e7b844cb81256e08b774efc4d81ca7ae6d24a811fbb2431a842acd24cd69bafdc045c58ba3ea46674b089eaf639f5acef7a89482
-  data.tar.gz: 57a64de8a4faa2a740856f770f121f9ade2d924d3a2f99625d2ed3dd369b4f7ddf4a23d8d3e00f2485c9fc82e12dae8038cd37a6df453627c383486a1bd6c6af
+  metadata.gz: c90d1e6cc1ac20015660134d88d863dc935d6db44128e0f49f7c807b6b357d4821055d989e9e9e3a8bb4c49382acbab04509bf0445389a454c72c3fb729cbd85
+  data.tar.gz: a7154a914174099a8b5d32fe4b534811c14187f3fb9e8735cba701764b7d9aee640de1c276711dcedb85915f33efc9fecac87dde0ae8a09d704d0bbf84f3f11b

data/MIT-LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2011 Kenichi Kamiya
+
+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

@@ -1,51 +1,40 @@
-striuct
-=======
+# striuct
 
-[![Build Status](https://secure.travis-ci.org/kachick/striuct.png)](http://travis-ci.org/kachick/striuct)
+![Build Status](https://github.com/kachick/striuct/actions/workflows/test_behaviors.yml/badge.svg?branch=main)
 [![Gem Version](https://badge.fury.io/rb/striuct.png)](http://badge.fury.io/rb/striuct)
 
-Description
------------
-
 Struct++
 
-Features
---------
+## Usage
 
-### Strict
+Require Ruby 2.6 or later
 
-* Easy and Flexible Validations
-* Prevent to conflict member names
-* Lock setters for each member
+Add this line to your `Gemfile`
 
-### Useful
-
-* Hook just before setters
-* Default value
-* Member aliasing
-* Inheritable
-* Handling between nil <-> unassigned
-* More flendly API for Hash
+```ruby
+gem 'striuct', '>= 0.8.0', '< 0.9.0'
+```
 
-### Onepoint
+Then add below code into your Ruby code
 
-* Base API looks like Struct
-* Pure Ruby :)
+```ruby
+require 'striuct'
+```
 
-Usage
------
+### Overview
 
-### Overview - Case 1
+#### Case 1
 
 ```ruby
 require 'striuct'
 
 class Person < Striuct
-  member :fullname, AND(String, /\A.+\z/)     # Flexible Validation
-  alias_member :name, :fullname               # Use other name
+  member :full_name, AND(String, /\A.+\z/)     # Flexible Validation
+  alias_member :name, :full_name               # Use other name
 end
 
-class User < Person                           # Inheritable
+# Inheritable
+class User < Person
   member :id, Integer,                        # Looks typed validation
               default_proc: ->{User.next_id}  # With default value
 
@@ -56,26 +45,26 @@ class User < Person                           # Inheritable
 end
 
 john = User.new 'john'
-john[:name]              #=> 'john' 
+john[:name]              #=> 'john'
 john.name = ''           #=> Exception        # Validate with setter
 john.id                  #=> 1
 ken = User[name: 'ken']                       # Construct from hash
 ken.id                   #=> 2
 ```
-### Overview - Case 2
+
+#### Case 2
 
 ```ruby
 class Foo < Striuct
   member :foo
-  member :bar, Numeric,                       # First validation under Numeric
-               inference: true                # And use inference Validation
+  member :bar, Numeric
   member :with_adjuster, Integer,
                          &->v{Integer v}      # Use adjuster before a setter
 end
 
 foo = Foo.new
 
-# nil <-> unaasigned
+# nil <-> unassigned
 foo.foo                  #=> nil
 foo.assigned?(:foo)      #=> false
 foo.foo = nil
@@ -85,7 +74,6 @@ foo.assigned?(:foo)      #=> true
 foo.lock(:foo)
 foo.foo = nil            #=> error
 
-# Inference Validation
 foo.bar = 1.2            #=> pass             # memorize 1.2's class is Float
 foo.bar = 1              #=> error            # 1 is not Float
 
@@ -94,7 +82,7 @@ foo.with_adjuster = '5'
 foo.with_adjuster        #=> 5                # Casted via adjuster
 ```
 
-### Overview - Case 3
+#### Case 3
 
 ```ruby
 class UseMustOption < Striuct
@@ -104,37 +92,32 @@ end
 UseMustOption.new #=> InvalidOperationError "`foo` require a value under `must` option "
 ```
 
+## Features
 
-### How to build flexible conditions ?
-
-* That from validation library.  
-  See the [validation-API](http://kachick.github.com/validation/yard/frames.html)
-
-Requirements
--------------
+### Strict
 
-* Ruby - [1.9.2 or later](http://travis-ci.org/#!/kachick/striuct)
+* Easy and Flexible Validations
+  * Basically use `#===` for the validation
+  * The pattern builder DSL is just using [eqq](https://github.com/kachick/eqq)
+  * When passed the Proc, it will be evaluated in the instance context
+* Prevent to conflict member names
+* Lock setters for each member
 
-Install
--------
+### Useful
 
-```bash
-gem install striuct
-```
+* Hook just before setters
+* Default value
+* Member aliasing
+* Inheritable
+* Handling between nil <-> unassigned
+* Similar API for Hash
 
-Link
-----
+### Finally
 
-* [code](https://github.com/kachick/striuct)
-* [wiki](https://github.com/kachick/striuct/wiki)
-* [API](http://kachick.github.com/striuct/yard/frames.html)
-* [issues](https://github.com/kachick/striuct/issues)
-* [CI](http://travis-ci.org/#!/kachick/striuct)
-* [gem](https://rubygems.org/gems/striuct)
+* Base API looks like Struct
+* Pure Ruby :)
 
-License
---------
+## Link
 
-The MIT X11 License  
-Copyright (c) 2011 Kenichi Kamiya  
-See MIT-LICENSE for further details.
+* [Repository](https://github.com/kachick/striuct)
+* [API documents](https://kachick.github.io/striuct/)

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'

data/lib/striuct/{requirements.rb → bootstrap.rb}

@@ -1,5 +1,9 @@
-require 'validation'
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'eqq'
+
 require_relative 'structs'
 require_relative 'classmethods/requirements'
 require_relative 'instancemethods/requirements'
-require_relative 'singleton_class'
+require_relative 'singleton_class'

data/lib/striuct/classmethods/README.md

@@ -1,10 +1,10 @@
 Note
 =====
 
-This dir's tree is diveded under roles/features.  
+This dir's tree is divided under roles/features.
 Not only divided by CONSTANT names.
 
 CONSTANT
 --------
 
-* attributes - Attributes
+* attributes - Attributes

data/lib/striuct/classmethods/adjustment.rb

@@ -1,15 +1,79 @@
-class Striuct; module ClassMethods
-
-  # @group Adjuster
-  
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  def adjuster_for(key)
-    autonym = autonym_for_key key
-    raise KeyError unless with_adjuster? autonym
-    
-    _attributes_for(autonym).adjuster
-  end
+# frozen_string_literal: true
+
+class Striuct
+  module ClassMethods
+    # @group Adjuster
+
+    # Adjuster Builders
+    # Apply adjuster when passed pattern.
+    # @param pattern [Proc, Method, #===]
+    # @param adjuster [Proc, #to_proc]
+    # @return [Proc]
+    def WHEN(pattern, adjuster)
+      unless Eqq.valid?(pattern)
+        raise ArgumentError, 'wrong object for pattern'
+      end
+
+      unless Striuct.adjustable?(adjuster)
+        raise ArgumentError, 'wrong object for adjuster'
+      end
+
+      ->v { _valid?(pattern, v) ? adjuster.call(v) : v }
+    end
+
+    # Sequential apply all adjusters.
+    # @param adjuster1 [Proc, #to_proc]
+    # @param adjuster2 [Proc, #to_proc]
+    # @param adjusters [Proc, #to_proc]
+    # @return [Proc]
+    def INJECT(adjuster1, adjuster2, *adjusters)
+      adjusters = [adjuster1, adjuster2, *adjusters]
 
-  # @endgroup
+      unless adjusters.all? { |f| adjustable?(f) }
+        raise ArgumentError, 'wrong object for adjuster'
+      end
 
-end; end
+      ->v {
+        adjusters.reduce(v) { |ret, adjuster| adjuster.call(ret) }
+      }
+    end
+
+    # Accept any parser when that respond to parse method.
+    # @param parser [#parse]
+    # @return [Proc]
+    def PARSE(parser)
+      if !::Integer.equal?(parser) && !parser.respond_to?(:parse)
+        raise ArgumentError, 'wrong object for parser'
+      end
+
+      ->v {
+        if ::Integer.equal?(parser)
+          ::Kernel.Integer(v)
+        else
+          parser.parse(
+            case v
+            when String
+              v
+            when ->_ { v.respond_to?(:to_str) }
+              v.to_str
+            when ->_ { v.respond_to?(:read) }
+              v.read
+            else
+              raise TypeError, 'wrong object for parsing source'
+            end
+          )
+        end
+      }
+    end
+
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    def adjuster_for(key)
+      autonym = autonym_for_key(key)
+      raise KeyError unless with_adjuster?(autonym)
+
+      _attributes_for(autonym).adjuster
+    end
+
+    # @endgroup
+  end
+end

data/lib/striuct/classmethods/attributes.rb

@@ -1,112 +1,116 @@
-class Striuct; module ClassMethods
-
-  # Attributes for autonym of each member
-  class Attributes
-
-    VALUES   = [ :condition,
-                 :adjuster  ].freeze
-
-    BOOLEANS = [ :inference,
-                 :must,
-                 :safety_setter,
-                 :safety_getter ].freeze
-    
-    def initialize
-      @hash =  { inference:     false,
-                 must:          false,
-                 safety_setter: false,
-                 safety_getter: false }
-    end
-    
-    VALUES.each do |role|
-      define_method :"with_#{role}?" do
-        @hash.has_key? role
+# frozen_string_literal: true
+
+class Striuct
+  module ClassMethods
+    # Attributes for autonym of each member
+    class Attributes
+      VALUES   = [:condition,
+                  :adjuster].freeze
+
+      BOOLEANS = [
+        :must,
+        :safety_setter,
+        :safety_getter
+      ].freeze
+
+      def initialize
+        @hash = {
+          must: false,
+          safety_setter: false,
+          safety_getter: false
+        }
       end
-      
-      define_method role do
-        @hash.fetch role
+
+      VALUES.each do |role|
+        define_method :"with_#{role}?" do
+          @hash.key?(role)
+        end
+
+        define_method role do
+          @hash.fetch(role)
+        end
       end
-    end
 
-    def condition=(condition)
-      unless ::Validation.conditionable? condition
-        raise TypeError, 'wrong object for condition' 
+      def condition=(condition)
+        unless Eqq.valid?(condition)
+          raise TypeError, 'wrong object for condition'
+        end
+
+        @hash[:condition] = condition
       end
 
-      @hash[:condition] = condition
-    end
+      def adjuster=(adjuster)
+        unless Striuct.adjustable?(adjuster)
+          raise ArgumentError, 'wrong object for adjuster'
+        end
 
-    def adjuster=(adjuster)
-      unless ::Validation.adjustable? adjuster
-        raise ArgumentError, 'wrong object for adjuster'
+        @hash[:adjuster] = adjuster
       end
 
-      @hash[:adjuster] = adjuster
-    end
+      BOOLEANS.each do |role|
+        define_method :"with_#{role}?" do
+          @hash.fetch(role)
+        end
+
+        define_method :"#{role}=" do |arg|
+          raise TypeError unless arg.equal?(true) || arg.equal?(false)
 
-    BOOLEANS.each do |role|
-      define_method :"with_#{role}?" do
-        @hash.fetch role
+          @hash[role] = arg
+        end
       end
-      
-      define_method :"#{role}=" do |arg|
-        raise TypeError unless arg.equal?(true) or arg.equal?(false)
 
-        @hash[role] = arg
-      end   
-    end
+      def with_default?
+        @hash.key?(:default_value)
+      end
 
-    def with_default?
-      @hash.has_key? :default_value
-    end
+      def default_value
+        @hash.fetch(:default_value)
+      end
 
-    def default_value
-      @hash.fetch :default_value
-    end
+      def default_type
+        @hash.fetch(:default_type)
+      end
 
-    def default_type
-      @hash.fetch :default_type
-    end
+      # @param [Symbol] type - :value / :lazy
+      def set_default(value, type)
+        raise TypeError unless type.equal?(:value) || type.equal?(:lazy)
 
-    # @param [Symbol] type - :value / :lazy
-    def set_default(value, type)
-      raise TypeError unless type.equal?(:value) or type.equal?(:lazy)
-      check_default_lazy_proc value if type.equal?(:lazy)
-      
-      @hash[:default_type] = type
-      @hash[:default_value] = value
-    end
+        check_default_lazy_proc(value) if type.equal?(:lazy)
 
-    def check_default_lazy_proc(_proc)
-      raise TypeError unless _proc.respond_to? :call
-      arity = _proc.arity
-      unless arity <= 2
-        raise ArgumentError, "wrong number of block parameter #{arity} for 0..2"
+        @hash[:default_type] = type
+        @hash[:default_value] = value
       end
-    end
 
-    def freeze
-      ret = super
-      @hash.freeze
-      ret
-    end
+      def check_default_lazy_proc(proc)
+        raise TypeError unless proc.respond_to?(:call)
 
-    def dup
-      ret = super
-      @hash = @hash.dup
-      ret
-    end
-    
-    private
-    
-    def initialize_copy(original)
-      ret = super original
-      @hash = @hash.dup
-      ret
-    end
+        arity = proc.arity
+        unless arity <= 2
+          raise ArgumentError, "wrong number of block parameter #{arity} for 0..2"
+        end
+      end
 
-  end
+      def freeze
+        ret = super
+        @hash.freeze
+        ret
+      end
+
+      def dup
+        ret = super
+        @hash = @hash.dup
+        ret
+      end
 
-  private_constant :Attributes
+      private
 
-end; end
+      def initialize_copy(original)
+        ret = super(original)
+        @hash = @hash.dup
+        ret
+      end
+    end
+
+    private_constant :Attributes
+  end
+end