striuct 0.6.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a5238390f14805baa497d1cd3acec45fc10faa233ce94af4782aa5570606b56
-  data.tar.gz: e703ea310209502b772938d9eee312e26fcfdec30189c41e071107b125574ebb
+  metadata.gz: 1a14fe7f8c251b39c9e7a8d65fc96b62519a6e271eb5765b043f92cfe1b8bc3b
+  data.tar.gz: be0b9456cee901dc7d0079e5661de91cda71b52cdae47fa1277cd7b833310126
 SHA512:
-  metadata.gz: 4650584be9988e6f8ed9b1a58cfa5912d099aed4377e035750ee158216fa8bc06c46c53386bc5b1188dd302847112c337d750ac1a103810bd83ab25ae5f920c4
-  data.tar.gz: 3edc0199746228322c017bf8eefc619352a53882cf908d9e525392faaa43a5314ec37529ce97cfc7b40917d2dbca5da393cb5580b3d8c1ae673cdeea22efdf42
+  metadata.gz: a7600df197c958a8fc6f37cfec1f0bff19ec3c1542f469ed12f927193f060c8e1a4c211d6c0d3411d344e9562714b7c8cf159469409c4635d0018abd5c855bcd
+  data.tar.gz: 03b8604868221c485c16c99ce1e428da36f2c5f9db6c0458957f460f0a16aaba55753043cb65901df1f695fc5c9bf069d0b09dae9aa88f50081200844d3ca9c1

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,52 +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)
-[![Dependency Status](https://gemnasium.com/kachick/striuct.svg)](https://gemnasium.com/kachick/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.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
 
@@ -57,13 +45,14 @@ 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
@@ -75,7 +64,7 @@ end
 
 foo = Foo.new
 
-# nil <-> unaasigned
+# nil <-> unassigned
 foo.foo                  #=> nil
 foo.assigned?(:foo)      #=> false
 foo.foo = nil
@@ -93,7 +82,7 @@ foo.with_adjuster = '5'
 foo.with_adjuster        #=> 5                # Casted via adjuster
 ```
 
-### Overview - Case 3
+#### Case 3
 
 ```ruby
 class UseMustOption < Striuct
@@ -103,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 - [2.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://www.rubydoc.info/github/kachick/striuct)
-* [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/{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.pattern?(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,114 +1,116 @@
-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
-    
-    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.pattern?(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