plumb 0.0.4 → 0.0.6

data/bench/parametric_schema.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require 'parametric'
+require 'money'
+require 'monetize'
+
+PARAMETRIC_MONEY_EXP = /(\W{1}|\w{3})?[\d+,.]/
+
+Parametric.policy(:nullable_money) do
+  coerce do |value, _key, _context|
+    money = case value
+            when String
+              value = value.strip
+              if value.blank?
+                nil
+              elsif value =~ PARAMETRIC_MONEY_EXP
+                Monetize.parse!(value.gsub(',', ''))
+              else
+                raise ArgumentError, "#{value} is not a monetary amount"
+              end
+            when Numeric
+              Monetize.parse!(value.to_s)
+            when Money
+              value
+            when NilClass
+              nil
+            else
+              raise ArgumentError, "don't know how to coerce #{value.inspect} into Money"
+            end
+
+    if money && money.currency != Money.default_currency
+      raise ArgumentError,
+            "expected #{Money.default_currency.name} as currency, but got #{money.currency.name}"
+    end
+
+    money
+  end
+
+  meta_data do
+    { type: :number, config_type: :nullable_money }
+  end
+end
+
+Parametric.policy(:nullable_date) do
+  # rubocop:disable Style/RedundantBegin
+  coerce do |value, _key, _context|
+    begin
+      value = value.to_s.strip
+      value == '' ? nil : Date.parse(value)
+    rescue Date::Error
+      nil
+    end
+  end
+  # rubocop:enable Style/RedundantBegin
+
+  meta_data do
+    { type: :date, config_type: :nullable_date }
+  end
+end
+
+PARAMETRIC_DATE_EXP = /\A\d{4}-\d{2}-\d{2}\z/
+PARAMETRIC_DATE_INFINITY = 'infinity'
+PARAMETRIC_IS_DATE = ->(value) { value.is_a?(::Date) || (value.is_a?(::String) && value =~ PARAMETRIC_DATE_EXP) }
+PARAMETRIC_PARSE_DATE = ->(value) { value.is_a?(::Date) ? value : ::Date.parse(value) }
+
+Parametric.policy :nullable_date_range do
+  validate do |value, _key, _context|
+    if value.blank? || value.is_a?(Switcher::DateRange)
+      true
+    else
+      value.is_a?(Hash) && !!(PARAMETRIC_IS_DATE.call(value[:min]) && (value[:max].nil? || PARAMETRIC_IS_DATE.call(value[:max] || value[:max] == PARAMETRIC_DATE_INFINITY)))
+    end
+  end
+
+  coerce do |value, _key, _context|
+    if value.is_a?(Switcher::DateRange)
+      value
+    elsif value.blank? || (value[:min].blank? && value[:max].blank?)
+      nil
+    else
+      min = value[:min].present? ? PARAMETRIC_PARSE_DATE.call(value[:min]) : nil
+      max = value[:max].present? && value[:max] != PARAMETRIC_DATE_INFINITY ? PARAMETRIC_PARSE_DATE.call(value[:max]) : nil
+      Switcher::DateRange.new(min, max)
+    end
+  end
+
+  meta_data do
+    { type: :object, config_type: :nullable_date_range }
+  end
+end
+
+PARAMETRIC_INT_EXP = /^\d+$/
+
+Parametric.policy(:nullable_integer) do
+  coerce do |value, _key, _context|
+    if value.to_s =~ PARAMETRIC_INT_EXP
+      value.to_i
+    else
+      nil
+    end
+  end
+
+  meta_data do
+    { type: :integer, config_type: :nullable_integer }
+  end
+end
+
+PARAMETRIC_FLOAT_EXP = /^\d+(\.\d+)?$/
+
+Parametric.policy(:nullable_number) do
+  coerce do |value, _key, _context|
+    if value.to_s =~ PARAMETRIC_FLOAT_EXP
+      value.to_f
+    else
+      nil
+    end
+  end
+
+  meta_data do
+    { type: :number, config_type: :nullable_number }
+  end
+end
+
+Parametric.policy :size do
+  message do |opts, object|
+    "must have size of #{opts}, but got #{object.size}"
+  end
+
+  validate do |opts, object, _key, _payload|
+    size = object.size
+    (opts[:min].nil? || size >= opts[:min]) && (opts[:max].nil? || size <= opts[:max])
+  end
+end
+
+Parametric.policy(:nullable_string) do
+  coerce do |value, _key, _context|
+    if value.to_s.strip != ''
+      value.to_s
+    else
+      nil
+    end
+  end
+
+  meta_data do
+    { type: :string, config_type: :nullable_string }
+  end
+end
+
+module ParametricSchema
+  TERM = Parametric::Schema.new do
+    field(:name).type(:string).default('')
+    field(:url).type(:string).default('')
+    field(:terms_text).type(:string).default('')
+    field(:start_date).type(:nullable_date)
+    field(:end_date).type(:nullable_date)
+  end
+  TV_COMPONENT = Parametric::Schema.new do
+    field(:slug).type(:string) # .policy(:parameterize).present
+    field(:name).type(:string).present
+    field(:search_tags).type(:array).default([])
+    field(:description).type(:string)
+    field(:channels).type(:integer).default(0)
+    field(:discount_price).type(:nullable_money).default(Money.zero)
+    field(:discount_period).type(:nullable_integer)
+    field(:ongoing_price).type(:nullable_money)
+    field(:contract_length).type(:nullable_integer)
+    field(:upfront_cost).type(:nullable_money)
+    field(:commission).type(:nullable_money)
+  end
+  RECORD = Parametric::Schema.new do
+    field(:supplier_name).type(:string).present
+    field(:start_date).type(:nullable_date).meta(example: nil, admin_ui: true)
+    field(:end_date).type(:nullable_date).meta(example: nil, admin_ui: true)
+    field(:countdown_date).type(:nullable_date).meta(example: nil)
+    field(:name).type(:string).present.meta(example: 'Visa Platinum', admin_ui: true)
+    field(:upfront_cost_description).type(:string).default('')
+    field(:tv_channels_count).type(:integer).default(0)
+    field(:terms).type(:array).policy(:size, min: 1).default([]).schema TERM
+    field(:tv_included).type(:boolean)
+    field(:additional_info).type(:string)
+    field(:product_type).type(:nullable_string) # computed on ingestion
+    field(:annual_price_increase_applies).type(:boolean).default(false)
+    field(:annual_price_increase_description).type(:string).default('')
+    field(:broadband_components).type(:array).default([]).schema do
+      field(:name).type(:string)
+      field(:technology).type(:string)
+      field(:technology_tags).type(:array).default([])
+      field(:is_mobile).type(:boolean).default(false) # computed on ingestion based on technology
+      field(:description).type(:string)
+      field(:download_speed_measurement).type(:string).default('')
+      field(:download_speed).type(:nullable_number).default(0)
+      field(:upload_speed_measurement).type(:string)
+      field(:upload_speed).type(:nullable_number).default(0)
+      field(:download_usage_limit).type(:nullable_integer).default(nil)
+      field(:discount_price).type(:nullable_money)
+      field(:discount_period).type(:nullable_integer)
+      field(:speed_description).type(:string).default('')
+      field(:ongoing_price).type(:nullable_money)
+      field(:contract_length).type(:nullable_integer)
+      field(:upfront_cost).type(:nullable_money)
+      field(:commission).type(:nullable_money)
+    end
+    field(:tv_components).type(:array).default([]).schema TV_COMPONENT
+    field(:call_package_types).type(:array).default([]).meta(example: ['Everything']) # computed on ingestion
+    field(:phone_components).type(:array).default([]).schema do
+      field(:name).type(:string)
+      field(:description).type(:string)
+      field(:discount_price).type(:nullable_money)
+      field(:discount_period).type(:nullable_integer)
+      field(:ongoing_price).type(:nullable_money)
+      field(:contract_length).type(:nullable_integer)
+      field(:upfront_cost).type(:nullable_money)
+      field(:commission).type(:nullable_money)
+      field(:call_package_type).type(:array).default([])
+    end
+    field(:payment_methods).type(:array).default([])
+    field(:discounts).type(:array).default([]).schema do
+      field(:period).type(:integer)
+      field(:price).type(:nullable_money)
+    end
+    field(:ongoing_price).type(:nullable_money).meta(admin_ui: true)
+    field(:contract_length).type(:nullable_integer)
+    field(:upfront_cost).type(:nullable_money)
+    field(:year_1_price).type(:nullable_money).meta(admin_ui: true)
+    field(:savings).type(:nullable_money).meta(admin_ui: true)
+    field(:commission).type(:nullable_money)
+    field(:max_broadband_download_speed).type(:integer).default(0)
+  end
+end

data/bench/plumb_hash.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'plumb'
+require 'date'
+require 'money'
+require 'monetize'
+
+module PlumbHash
+  include Plumb::Types
+
+  BLANK_ARRAY = [].freeze
+  BLANK_STRING = ''
+  MONEY_EXP = /(\W{1}|\w{3})?[\d+,.]/
+
+  PARSE_MONEY = proc do |result|
+    value = Monetize.parse!(result.value.to_s.gsub(',', ''))
+    result.valid(value)
+  end
+
+  BlankStringOrDate = Forms::Nil | Forms::Date
+
+  Money = Any[::Money] \
+    | (String.present >> PARSE_MONEY) \
+    | (Numeric >> PARSE_MONEY)
+
+  Term = Hash[
+    name: String.default(BLANK_STRING),
+    url: String.default(BLANK_STRING),
+    terms_text: String.default(BLANK_STRING),
+    start_date?: BlankStringOrDate.nullable,
+    end_date?: BlankStringOrDate.nullable
+  ]
+
+  TvComponent = Hash[
+    slug: String,
+    name: String.present,
+    search_tags: Array[String].default(BLANK_ARRAY),
+    description: String.default(BLANK_STRING),
+    channels: Integer.default(0),
+    discount_price: Money.default(::Money.zero.freeze)
+  ]
+
+  Record = Hash[
+    supplier_name: String.present,
+    start_date: BlankStringOrDate.nullable.metadata(admin_ui: true),
+    end_date: BlankStringOrDate.nullable.metadata(admin_ui: true),
+    countdown_date: BlankStringOrDate.nullable,
+    name: String.present,
+    upfront_cost_description: String.default(BLANK_STRING),
+    tv_channels_count: Integer.default(0),
+    terms: Array[Term].policy(size: 1..).default(BLANK_ARRAY),
+    tv_included: Boolean,
+    additional_info: String,
+    product_type: String.nullable,
+    annual_price_increase_applies: Boolean.default(false),
+    annual_price_increase_description: String.default(BLANK_STRING),
+    broadband_components: Array[
+      name: String,
+      technology: String,
+      is_mobile: Boolean.default(false),
+      desciption: String,
+      technology_tags: Array[String].default(BLANK_ARRAY),
+      download_speed_measurement: String.default(BLANK_STRING),
+      download_speed: Numeric.default(0),
+      upload_speed_measurement: String.default(BLANK_STRING),
+      upload_speed: Numeric.default(0),
+      download_usage_limit: Integer.nullable,
+      discount_price: Money.nullable,
+      discount_period: Integer.nullable,
+      speed_description: String.default(BLANK_STRING),
+      ongoing_price: Money.nullable,
+      contract_length: Integer.nullable,
+      upfront_cost: Money.nullable,
+      commission: Money.nullable
+    ],
+    tv_components: Array[TvComponent].default(BLANK_ARRAY),
+    call_package_types: Array[String].default(BLANK_ARRAY).metadata(example: ['Everything']),
+    phone_components: Array[
+      name: String,
+      description: String,
+      discount_price: Money.nullable,
+      discount_period: Integer.nullable,
+      ongoing_price: Money.nullable,
+      contract_length: Integer.nullable,
+      upfront_cost: Money.nullable,
+      commission: Money.nullable,
+      call_package_type: Array[String].default(BLANK_ARRAY)
+    ].default(BLANK_ARRAY),
+    payment_methods: Array[String].default(BLANK_ARRAY),
+    discounts: Array[period: Integer, price: Money.nullable],
+    ongoing_price: Money.nullable.metadata(admin_ui: true),
+    contract_length: Integer.nullable,
+    upfront_cost: Money.nullable,
+    year_1_price: Money.nullable.metadata(admin_ui: true),
+    savings: Money.nullable.metadata(admin_ui: true),
+    commission: Money.nullable,
+    max_broadband_download_speed: Integer.default(0)
+  ]
+end

data/examples/command_objects.rb

@@ -26,9 +26,6 @@ module Types
   # Turn integers into Money objects (requires the money gem)
   Amount = Integer.build(Money)
 
-  # A naive email check
-  Email = String[/\w+@\w+\.\w+/]
-
   # A valid customer type
   Customer = Hash[
     name: String.present,

data/examples/concurrent_downloads.rb

@@ -12,9 +12,6 @@ require 'digest/md5'
 module Types
   include Plumb::Types
 
-  # Turn a string into an URI
-  URL = String[/^https?:/].build(::URI, :parse)
-
   # a Struct to hold image data
   Image = ::Data.define(:url, :io)
 
@@ -24,7 +21,7 @@ module Types
   # required by all Plumb steps.
   # URI => Image
   Download = Plumb::Step.new do |result|
-    io = URI.open(result.value)
+    io = ::URI.open(result.value)
     result.valid(Image.new(result.value.to_s, io))
   end
 
@@ -81,7 +78,7 @@ cache = Types::Cache.new('./examples/data/downloads')
 # 1). Take a valid URL string.
 # 2). Attempt reading the file from the cache. Return that if it exists.
 # 3). Otherwise, download the file from the internet and write it to the cache.
-IdempotentDownload = Types::URL >> (cache.read | (Types::Download >> cache.write))
+IdempotentDownload = Types::Forms::URI::HTTP >> (cache.read | (Types::Download >> cache.write))
 
 # An array of downloadable images,
 # marked as concurrent so that all IO operations are run in threads.

data/examples/event_registry.rb

@@ -11,19 +11,14 @@ require 'debug'
 module Types
   include Plumb::Types
 
-  # Turn an ISO8601 sring into a Time object
-  ISOTime = String.build(::Time, :parse)
+  # Turn an ISO8601 string into a Time object
+  ISOTime = String.build(::Time, :parse).policy(:rescue, ArgumentError)
 
   # A type that can be a Time object or an ISO8601 string >> Time
   Time = Any[::Time] | ISOTime
 
-  # A UUID string
-  UUID = String[/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i]
-
   # A UUID string, or generate a new one
-  AutoUUID = UUID.default { SecureRandom.uuid }
-
-  Email = String[URI::MailTo::EMAIL_REGEXP]
+  AutoUUID = UUID::V4.default { SecureRandom.uuid }
 end
 
 # A superclass and registry to define event types
@@ -57,7 +52,7 @@ end
 #  user_created.stream_id == create_user.stream_id
 #
 # ## JSON Schemas
-# Plumb data structs support `.to_json_schema`, to you can document all events in the registry with something like
+# Plumb data structs support `.to_json_schema`, so you can document all events in the registry with something like
 #
 #   Event.registry.values.map(&:to_json_schema)
 #
@@ -66,17 +61,22 @@ class Event < Types::Data
   attribute :stream_id, Types::String.present
   attribute :type, Types::String
   attribute(:created_at, Types::Time.default { ::Time.now })
-  attribute? :causation_id, Types::UUID
-  attribute? :correlation_id, Types::UUID
+  attribute? :causation_id, Types::UUID::V4
+  attribute? :correlation_id, Types::UUID::V4
   attribute :payload, Types::Static[nil]
 
   def self.registry
     @registry ||= {}
   end
 
+  # Custom node_name to trigger specialiesed JSON Schema visitor handler.
+  def self.node_name = :event
+
   def self.define(type_str, &payload_block)
     type_str.freeze unless type_str.frozen?
     registry[type_str] = Class.new(self) do
+      def self.node_name = :data
+
       attribute :type, Types::Static[type_str]
       attribute :payload, &payload_block if block_given?
     end
@@ -99,22 +99,29 @@ end
 # Example command and events for a simple event-sourced system
 #
 # ## Commands
-# CreateUser = Event.define('users.create') do
-#   attribute :name, Types::String.present
-#   attribute :email, Types::Email
-# end
-#
-# UpdateUserName = Event.define('users.update_name') do
-#   attribute :name, Types::String.present
-# end
+CreateUser = Event.define('users.create') do
+  attribute :name, Types::String.present
+  attribute :email, Types::Email
+end
+
+UpdateUserName = Event.define('users.update_name') do
+  attribute :name, Types::String.present
+end
 #
 # ## Events
-# UserCreated = Event.define('users.created') do
-#   attribute :name, Types::String
-#   attribute :email, Types::Email
-# end
-#
-# UserNameUpdated = Event.define('users.name_updated') do
-#   attribute :name, Types::String
-# end
+UserCreated = Event.define('users.created') do
+  attribute :name, Types::String
+  attribute :email, Types::Email
+end
+
+UserNameUpdated = Event.define('users.name_updated') do
+  attribute :name, Types::String
+end
+
+# Register a JSON Schema visitor handlers to render Event.registry as a "AnyOf" list of event types
+Plumb::JSONSchemaVisitor.on(:event) do |node, props|
+  props.merge('type' => 'object', 'anyOf' => node.registry.values.map { |v| visit(v) })
+end
+
+p Plumb::JSONSchemaVisitor.call(Event)
 # debugger

data/examples/weekdays.rb

@@ -4,7 +4,7 @@ require 'bundler'
 Bundler.setup(:examples)
 require 'plumb'
 
-#   bundle exec examples/weekdays.rb
+#   bundle exec ruby examples/weekdays.rb
 #
 # Data types to represent and parse an array of days of the week.
 # Input data can be an array of day names or numbers, ex.
@@ -52,7 +52,7 @@ p Types::DayName.parse('TueSday')                   # => "tuesday
 p Types::Week.parse([3, 2, 1, 4, 5, 6, 7])          # => [1, 2, 3, 4, 5, 6, 7]
 p Types::Week.parse([1, 'Tuesday', 3, 4, 5, 'saturday', 7]) # => [1, 2, 3, 4, 5, 6, 7]
 
-# p Types::Week[[1, 1, 3, 4, 5, 6, 7]] # raises Plumb::TypeError: repeated days
+# p Types::Week[[1, 1, 3, 4, 5, 6, 7]] # raises Plumb::ParseError: repeated days
 #
 # Or use these types as part of other composite types, ex.
 #

data/lib/plumb/attributes.rb

@@ -110,6 +110,7 @@ module Plumb
     #
     def self.included(base)
       base.send(:extend, ClassMethods)
+      base.define_singleton_method(:__plumb_struct_class__) { base }
     end
 
     attr_reader :errors, :attributes
@@ -155,10 +156,10 @@ module Plumb
     private
 
     def assign_attributes(attrs = BLANK_HASH)
-      raise ArgumentError, 'Must be a Hash of attributes' unless attrs.is_a?(::Hash)
+      raise ArgumentError, 'Must be a Hash of attributes' unless attrs.respond_to?(:to_h)
 
       @errors = BLANK_HASH
-      result = self.class._schema.resolve(attrs)
+      result = self.class._schema.resolve(attrs.to_h)
       @attributes = result.value
       @errors = result.errors unless result.valid?
     end
@@ -180,14 +181,15 @@ module Plumb
       # @return [Plumb::Result::Valid, Plumb::Result::Invalid]
       def call(result)
         return result if result.value.is_a?(self)
-        return result.invalid(errors: ['Must be a Hash of attributes']) unless result.value.is_a?(Hash)
+        return result.invalid(errors: ['Must be a Hash of attributes']) unless result.value.respond_to?(:to_h)
 
-        instance = new(result.value)
-        instance.valid? ? result.valid(instance) : result.invalid(instance, errors: instance.errors)
+        instance = new(result.value.to_h)
+        instance.valid? ? result.valid(instance) : result.invalid(instance, errors: instance.errors.to_h)
       end
 
       # Person = Data[:name => String, :age => Integer, title?: String]
       def [](type_specs)
+        type_specs = type_specs._schema if type_specs.is_a?(Plumb::HashClass)
         klass = Class.new(self)
         type_specs.each do |key, type|
           klass.attribute(key, type)
@@ -203,18 +205,21 @@ module Plumb
       # attribute(:name, String)
       # attribute(:friends, Types::Array) { attribute(:name, String) }
       # attribute(:friends, Types::Array) # same as Types::Array[Types::Any]
+      # attribute(:friends, []) # same as Types::Array[Types::Any]
       # attribute(:friends, Types::Array[Person])
+      # attribute(:friends, [Person])
       #
       def attribute(name, type = Types::Any, &block)
         key = Key.wrap(name)
         name = key.to_sym
         type = Composable.wrap(type)
+
         if block_given? # :foo, Array[Data] or :foo, Struct
-          type = Types::Data if type == Types::Any
+          type = __plumb_struct_class__ if type == Types::Any
           type = Plumb.decorate(type) do |node|
             if node.is_a?(Plumb::ArrayClass)
               child = node.children.first
-              child = Types::Data if child == Types::Any
+              child = __plumb_struct_class__ if child == Types::Any
               Types::Array[build_nested(name, child, &block)]
             elsif node.is_a?(Plumb::Step)
               build_nested(name, node, &block)
@@ -227,6 +232,10 @@ module Plumb
         end
 
         @_schema = _schema + { key => type }
+        __plumb_define_attribute_method__(name)
+      end
+
+      def __plumb_define_attribute_method__(name)
         define_method(name) { @attributes[name] }
       end