strum 0.0.55 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 442b975d036c77d40e013582ed6c45f27ed77b1ccd01975dbec3aa89d28c2115
-  data.tar.gz: 6bc0253b8e8b8ab605129e3b34486ca54ba36378528e894d6481b08349af4e38
+  metadata.gz: 2894aeec506a3e5b1c5cccd983228dc14c6f13bc62166aefc6878007fee03275
+  data.tar.gz: 6c49b3f69a66be577487ee919c6de9c8bba55a5ed46d3813ca6a27e5349bcbf3
 SHA512:
-  metadata.gz: 00f7d03f21b91ed6ae174202a7336dacb6c2cef4f2bba369fed16db5812e3188e46938cb0792c170cfe218b4d9cb8df5844109912d000ee89b11f2aad9d5ee01
-  data.tar.gz: 3eee0dc77298cd2e6e2138932de91bde002208d6709d4128bdf26a00f872019f0ea58fac0271891e609d78908d12857f96cdb53113305f5b49a1fbc6fbdd9173
+  metadata.gz: 779accb4860d77be95cbace472f22b0379e87584f89fb84d2f219b7b77c428d5190a268fd0fa5c694151b511d8f16b197da5e9e249c5b9c9d23e3b156fd8679a
+  data.tar.gz: a03cb94bfca668a7d6b24956cd6b4c0445c234f932f8508d966a727e5eb9bac3e5d20e070bbf4dc4307c3c891673786d3f9325d4d27165aa5b917e1b2882d6df

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    strum (0.0.55)
+    strum (0.1.2)
       dry-inflector (~> 0.2.0)
       dry-struct (~> 1.2)
       json-schema (~> 2.8.1)
@@ -16,7 +16,7 @@ GEM
     ast (2.4.0)
     concurrent-ruby (1.1.6)
     diff-lcs (1.3)
-    dry-configurable (0.11.3)
+    dry-configurable (0.11.5)
       concurrent-ruby (~> 1.0)
       dry-core (~> 0.4, >= 0.4.7)
       dry-equalizer (~> 0.2)
@@ -36,7 +36,7 @@ GEM
       dry-equalizer (~> 0.3)
       dry-types (~> 1.3)
       ice_nine (~> 0.11)
-    dry-types (1.3.1)
+    dry-types (1.4.0)
       concurrent-ruby (~> 1.0)
       dry-container (~> 0.3)
       dry-core (~> 0.4, >= 0.4.4)
@@ -51,9 +51,9 @@ GEM
     json-schema (2.8.1)
       addressable (>= 2.4)
     parallel (1.19.1)
-    parser (2.7.0.3)
+    parser (2.7.0.5)
       ast (~> 2.4.0)
-    public_suffix (4.0.3)
+    public_suffix (4.0.4)
     rainbow (3.0.0)
     rake (10.5.0)
     reline (0.1.3)
@@ -64,7 +64,7 @@ GEM
       rspec-mocks (~> 3.9.0)
     rspec-core (3.9.1)
       rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.0)
+    rspec-expectations (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-mocks (3.9.1)
@@ -79,7 +79,7 @@ GEM
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 1.7)
     ruby-progressbar (1.10.1)
-    sequel (5.29.0)
+    sequel (5.30.0)
     sequel-annotate (1.4.0)
       sequel (>= 4)
     thor (0.20.3)

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "strum"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/lib/strum.rb

@@ -2,10 +2,10 @@
 
 require "strum/version"
 require "strum/service"
-require "strum/chain"
 require "strum/pipe"
 require "strum/json"
 require "strum/deep_keys_to_sym"
+require "strum/json_schema"
 
 module Strum
   class Error < StandardError; end

data/lib/strum/json_schema.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "strum/json_schema/validate"
+require "strum/json_schema/cast"
+
+module Strum
+  module JsonSchema
+    class NoValue; end
+  end
+end

data/lib/strum/json_schema/cast.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "strum/service"
+
+module Strum
+  module JsonSchema
+    class Cast
+      include Strum::Service
+
+      def call
+        output(casted(input, args[:schema]))
+      end
+
+      def audit
+        add_error(:schema, :not_found) if !args[:schema].is_a?(Hash)
+      end
+
+      protected
+
+        def casted(input_data, schema, path = [])
+          item = custom_dig(input_data, path)
+
+          return item if item.is_a?(NoValue)
+
+          case schema[:type]
+          when Array
+            schema[:type].reduce(nil) do |type, x|
+              new_schema = schema.clone
+              new_schema[:type] = x
+              type || casted(input_data, new_schema, path)
+            end
+          when "object"
+            if item.is_a?(Hash) && schema[:properties].is_a?(Hash)
+              item.map { |key, val| (prop = schema[:properties][key]) ? [key, casted(input_data, prop, path + [key])] : [key, val]}.filter { |pair| !pair[1].is_a?(NoValue) }.to_h
+            end
+          when "array"
+            if item.is_a?(Array) && schema[:items].is_a?(Hash)
+              (0..(item.length - 1)).reduce([]) { |res, idx| res << casted(input_data, schema[:items], path + [idx]) }
+            end
+          when "string"
+            item.to_s
+          when "integer", "number"
+            if item.is_a?(Numeric)
+              item
+            elsif item.is_a?(String) || item.is_a?(Symbol)
+              (item.to_s.to_f % 1) > 0 ? item.to_s.to_f : item.to_s.to_i
+            end
+          when "boolean"
+            item.to_s.downcase == "true"
+          when "jsonb"
+            if Module.constants.include?(:Sequel) && Sequel.methods.include?(:pg_jsonb_wrap)
+              Sequel.pg_jsonb_wrap(item)
+            else
+              add_error(:schema, "jsonb type is not supported")
+            end
+          when nil, ""
+            item
+          else
+            add_error(:schema, :invalid_type)
+          end
+        end
+
+        def custom_dig(obj, path)
+          path.reduce(obj) { |item, x| item.fetch(x) { |_it| return NoValue.new } }
+        end
+    end
+  end
+end

data/lib/strum/json_schema/validate.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "strum/service"
+require "json-schema"
+
+module Strum
+  module JsonSchema
+    class Validate
+      include Strum::Service
+
+      def call
+        array_errors = JSON::Validator.fully_validate(args[:schema], input, errors_as_objects: true)
+        array_errors.each { |error| add_error(*parse_json_schema_error(error)) }
+        output(input)
+      end
+
+      def audit
+        add_error(:schema, :not_found) if !args[:schema].is_a?(Hash)
+      end
+
+      protected
+
+        def parse_json_schema_error(error)
+          id = error[:fragment].sub(/#/, "input")
+          keys = id.split("/")
+          last_key = keys.map { |key| key =~ /[0-9]+/ ? "[#{key}]" : ".#{key}" }.join[1..-1]
+          value = error[:message][0, error[:message].index(/ in schema/)].sub(error[:fragment], last_key)
+          [last_key.to_sym, value]
+        end
+    end
+  end
+end

data/lib/strum/pipe.rb

@@ -4,25 +4,35 @@ module Strum
   class Pipe
     include Strum::Service
 
-    def self.call(*units, input: {}, unit_input: {}, &block)
+    def self.call(*units, args: {}, input: {}, unit_input: {}, &block)
       pipe_payload = if input.is_a?(Hash) && unit_input.is_a?(Hash)
                        unit_input.merge(input)
                      else
                        input
                     end
-      new(pipe_payload).execute(*units, input, unit_input, &block)
+      new(pipe_payload, args).execute(*units, input, unit_input, &block)
     end
 
     def execute(*units, pipe_inputs, pipe_unit_inputs, &block)
       audit
       yield(self) if valid? && block_given?
       output(pipe_inputs)
-      while (unit = units.shift) && valid?
+      continue = true
+      while (unit = units.shift) && valid? && continue
         service, service_params = unit
         service_params ||= {}
         raise Strum::Error, "Unit options must be a Hash" unless service_params.is_a?(Hash)
 
         service_options = service_params[:input] || {}
+        result_place = service_params[:to]
+        unit_args = case service_params[:args]
+                    when Hash
+                      service_params[:args]
+                    when Symbol, String
+                      { service_params[:args] => service_params[:args] }
+                    else
+                      {}
+                    end
         clean_output = service_params[:clean_output] || false
         unit_payload = if !clean_output && service_options.is_a?(Hash) && pipe_unit_inputs.is_a?(Hash) && output_value.is_a?(Hash)
                          pipe_unit_inputs.merge(service_options).merge(output_value)
@@ -30,17 +40,30 @@ module Strum
                          output_value
                        end
 
-        service.public_send(:call, unit_payload) do |m|
-          service_handlers[:on].each do |k, proc|
-            m.on(k) { |r| proc.call(r) }
+        service.public_send(:call, unit_payload, args.merge(unit_args)) do |m|
+          service_handlers[:on].each do |key, _handler|
+            m.on(key) { |r| hook(k, r) }
           end
-          m.success do |result|
-            if !clean_output && result.is_a?(Hash) && output_value.is_a?(Hash)
-              output(output_value.merge(result))
+
+          service_handlers[:success].each do |key, _handler|
+            if key
+              m.success(key) do |result|
+                output(key, result)
+                continue = false
+              end
             else
-              output(result)
+              m.success do |result|
+                if result_place
+                  inputs[result_place] = result
+                elsif !clean_output && result.is_a?(Hash) && output_value.is_a?(Hash)
+                  output(output_value.merge(result))
+                elsif result
+                  output(result)
+                end
+              end
             end
           end
+
           m.failure { |errors| add_errors(errors) }
         end
       end

data/lib/strum/service.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "json-schema"
 
 module Strum
   # Module
@@ -14,19 +13,18 @@ module Strum
 
     # Internal: Interactor class methods.
     module ClassMethods
-      def call(_input = nil, &block)
-        new(_input).execute(&block)
+      def call(_input, **args, &block)
+        new(_input, args).execute(&block)
       end
     end
 
     # Instance methods
-    def initialize(_input)
+    def initialize(_input, **args)
       self.strum_errors = {}
       self.service_handlers = { on: {}, success: {}, failure: {} }
       self.outputs = {}
-      self._input = _input
-      self._input.freeze
-      self.input = self._input.dup
+      self.inputs = args.merge(default: _input)
+      self._inputs = inputs.dup.freeze
     end
 
     def execute
@@ -72,7 +70,7 @@ module Strum
 
     protected
 
-      attr_accessor :_input, :input, :strum_errors, :outputs, :service_handlers
+      attr_accessor :inputs, :_inputs, :strum_errors, :outputs, :service_handlers
 
       def call
         raise Failure, "call method must be implemented"
@@ -80,6 +78,22 @@ module Strum
 
       def audit; end
 
+      def input
+        inputs[:default]
+      end
+
+      def input=(value)
+        inputs[:default] = value
+      end
+
+      def _input
+        _inputs[:default]
+      end
+
+      def args
+        inputs.slice(*inputs.keys - [:default])
+      end
+
       def output_value(key = :default)
         @outputs[key]
       end
@@ -122,7 +136,7 @@ module Strum
 
       def sliced(*keys)
         if input.is_a?(Hash)
-          @input = input.slice(*keys)
+          self.input = input.slice(*keys)
         else
           add_error(:input, :must_be_hash)
         end
@@ -130,7 +144,7 @@ module Strum
 
       def sliced_list(*keys)
         if input.is_a?(Array)
-          @input = input.map do |item|
+          self.input = input.map do |item|
             if item.is_a?(Hash)
               item = item.slice(*keys)
             else
@@ -142,25 +156,12 @@ module Strum
         end
       end
 
-      def validated(schema:, list: false)
-        array_errors = JSON::Validator.fully_validate(schema, @input, errors_as_objects: true, list: list)
-        array_errors.each{|error| add_error(*self.parse_json_schema_error(error))}
-      end
-
-      def parse_json_schema_error(error)
-        pos_match = error[:fragment].match(/([0-9]+)[\/]?/)
-        pos = pos_match.is_a?(Array) ? pos_match[1] : "_"
-        key = error[:fragment].sub(/#\//, "").sub(/([0-9]+)[\/]?/, "")
-        value = "Item ##{pos}. " + error[:message][0, error[:message].index(/ in schema/)].sub(/#\//, "").sub(/([0-9]+)[\/]?/, "")
-        [key.to_sym, value]
-      end
-
       def array!
         self.input = [*input]
       end
 
     private
-    
+
       def key_to_sym(key)
         key.to_sym
       rescue StandardError
@@ -168,8 +169,9 @@ module Strum
       end
 
       def valid_result
-        handler = service_handlers[:success][((outputs.keys << nil) & service_handlers[:success].keys).first]
-        handler.is_a?(Proc) ? handler.call(outputs[:default] || outputs) : outputs[:default] || outputs
+        handler_key = ((outputs.keys << nil) & service_handlers[:success].keys).first
+        handler = service_handlers[:success][handler_key]
+        handler.is_a?(Proc) ? handler.call(outputs[handler_key] || outputs[:default]) : outputs[handler_key] || outputs[:default]
       end
 
       def invalid_result

data/lib/strum/templates/service_crud/%resources_name%/detect.rb.tt

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+<%- namespace_names.each_with_index do |c,i| -%>
+<%= '  ' * i %>module <%= c %>
+<%- end -%>
+<%= ident %>module <%= resources_class_name %>
+<%= ident %>  # Strum service
+<%= ident %>  # You service description here...
+<%= ident %>  class Find
+<%= ident %>    include Strum::Service
+
+<%= ident %>    def call
+<%= ident %>      if (<%= resources_name %> = <%= resources_class_name %>::Search(input)).count.eql?(1)
+<%= ident %>        output(resources_name: <%= resources_name %>.first)
+<%= ident %>      elsif <%= resources_name %>.count > 1
+<%= ident %>        add_error(:<%= resource_name %>, :criteria_wrong)
+<%= ident %>      else
+<%= ident %>        add_error(:<%= resource_name %>, :not_found)
+<%= ident %>      end
+<%= ident %>    end
+
+<%= ident %>    def audit
+<%= ident %>      @input = @input.slice(:id)
+<%= ident %>      required(:id)
+<%= ident %>    end
+<%= ident %>  end
+<%= ident %>end
+<%- (namespace_names.size - 1).downto(0) do |i| -%>
+<%= '  ' * i %>end
+<%- end -%>

data/lib/strum/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Strum
-  VERSION = "0.0.55"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strum
 version: !ruby/object:Gem::Version
-  version: 0.0.55
+  version: 0.1.3
 platform: ruby
 authors:
 - Serhiy Nazarov
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-07 00:00:00.000000000 Z
+date: 2020-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -164,7 +164,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.4.0
-description: 
+description:
 email:
 - sn@nazarov.com.ua
 executables:
@@ -181,6 +181,7 @@ files:
 - Gemfile.lock
 - README.md
 - Rakefile
+- bin/console
 - bin/strum
 - lib/strum.rb
 - lib/strum/Rakefile
@@ -201,6 +202,9 @@ files:
 - lib/strum/deep_keys_to_sym.rb
 - lib/strum/json.rb
 - lib/strum/json_deserializer.rb
+- lib/strum/json_schema.rb
+- lib/strum/json_schema/cast.rb
+- lib/strum/json_schema/validate.rb
 - lib/strum/json_serializer.rb
 - lib/strum/object_to_hash.rb
 - lib/strum/pipe.rb
@@ -236,6 +240,7 @@ files:
 - lib/strum/templates/service/%resource_filename%.rb.tt
 - lib/strum/templates/service_crud/%resources_name%/create.rb.tt
 - lib/strum/templates/service_crud/%resources_name%/delete.rb.tt
+- lib/strum/templates/service_crud/%resources_name%/detect.rb.tt
 - lib/strum/templates/service_crud/%resources_name%/find.rb.tt
 - lib/strum/templates/service_crud/%resources_name%/search.rb.tt
 - lib/strum/templates/service_crud/%resources_name%/update.rb.tt
@@ -248,7 +253,7 @@ metadata:
   homepage_uri: https://code.qpard.com/strum/strum
   source_code_uri: https://code.qpard.com/strum/strum
   changelog_uri: https://code.qpard.com/strum/strum/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -264,7 +269,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Light ruby framework.
 test_files: []