bluepine 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9decc5e24159b2da22bb444768643364dc66c402856eed434d1f44cbb1fa807f
+  data.tar.gz: 6309d91631be3713316a21b5aea15b36738ac2afef45658bfa8a2853265bd72a
+SHA512:
+  metadata.gz: 2738f638bef59a74fb2e3f917997fb3a99a08210e718fe96d1355be228f323af51a11553575986318aadb97c927a9296f487a7a967a739b8ac0800204b364d3a
+  data.tar.gz: 66fa03e1670e1cd513bae15fb6f3d1b2463f151616dfc0d238ef266ddc0b77ec361a7c3644c5d91a6d8b39c2835f82dafdde2b604550d2bc366c5e5239635729

data/lib/bluepine.rb

@@ -0,0 +1,35 @@
+require 'active_support/concern'
+require 'active_model'
+
+require "bluepine/version"
+require "bluepine/functions"
+require "bluepine/assertions"
+require "bluepine/error"
+
+require "bluepine/registry"
+require "bluepine/resolvable"
+
+# attributes
+require "bluepine/attributes"
+
+# endpoint
+require "bluepine/endpoint"
+
+# serializer
+require "bluepine/serializer"
+
+# generators
+require "bluepine/generators"
+
+# validators
+require "bluepine/validator"
+
+# resolver
+require "bluepine/resolver"
+
+module Bluepine
+  module API
+    module Spec
+    end
+  end
+end

data/lib/bluepine/assertions.rb

@@ -0,0 +1,80 @@
+module Bluepine
+  # Declarative way to deal with errors
+  module Assertions
+    Error       = Class.new(StandardError)
+    KeyError    = Class.new(Error)
+    SubsetError = Class.new(Error)
+
+    extend self
+    def self.included(object)
+      object.extend(self)
+    end
+
+    # Usage
+    #
+    # Use default error message
+    #
+    #   assert valid?
+    #
+    # Use custom error message
+    #
+    #   assert valid?, "Invalid value"
+    #
+    # Use custom Error class
+    #
+    #   assert valid?, ValidationError, "Invalid value"
+    def assert(object, *msgs)
+      raises Error, msgs << "#{object.class} is not a truthy" unless object
+    end
+
+    def assert_not(object, *msgs)
+      raises Error, msgs << "#{object.class} is not a falsey" if object
+    end
+
+    def assert_kind_of(classes, object, *msgs)
+      classes = normalize_array(classes)
+      found   = classes.find { |klass| object.kind_of?(klass) }
+
+      raises Error, msgs << "#{object.class} must be an instance of #{classes.map(&:name).join(', ')}" unless found
+    end
+
+    alias_method :assert_kind_of_either, :assert_kind_of
+
+    # Usage
+    #
+    #   assert_in ["john", "joe"], "joe"
+    #   assert_in { amount: 1 }, :amount
+    def assert_in(list, value, *msgs)
+      raises KeyError, msgs << "#{value.class} - #{value} is not in the #{list.keys}" if list.respond_to?(:key?) && !list.key?(value)
+      raises KeyError, msgs << "#{value.class} - #{value} is not in the #{list}" if list.kind_of?(Array) && !list.include?(value)
+    end
+
+    def assert_subset_of(parent, subset, *msgs)
+      rest = subset - parent
+      raises SubsetError, msgs << "#{rest} are not subset of #{parent}" if rest.present?
+    end
+
+    private
+
+    def normalize_array(values)
+      values.respond_to?(:each) ? values : [values]
+    end
+
+    # allow caller to pass custom Error
+    def raises(error, msgs = [])
+      error, msg = msgs unless msgs.first.kind_of?(String)
+
+      # Error class has its own error message and caller
+      # doesn't specify custom message
+      if msgs.length == 2
+        if error.respond_to?(:message)
+          msg = error.message
+        elsif error.respond_to?(:new)
+          msg = error.new&.message
+        end
+      end
+
+      raise error, msg || msgs.last
+    end
+  end
+end

data/lib/bluepine/attributes.rb

@@ -0,0 +1,92 @@
+require_relative "registry"
+require_relative "attributes/visitor"
+require_relative "serializers/serializable"
+require_relative "validators/normalizable"
+require_relative "validators/validatable"
+
+# Attributes
+require_relative "attributes/boolean_attribute"
+require_relative "attributes/string_attribute"
+require_relative "attributes/number_attribute"
+require_relative "attributes/integer_attribute"
+require_relative "attributes/float_attribute"
+require_relative "attributes/array_attribute"
+require_relative "attributes/object_attribute"
+require_relative "attributes/schema_attribute"
+require_relative "attributes/date_attribute"
+require_relative "attributes/time_attribute"
+require_relative "attributes/currency_attribute"
+require_relative "attributes/uri_attribute"
+require_relative "attributes/ip_address_attribute"
+
+module Bluepine
+  # Attributes registry holds the references to all attributes
+  #
+  # @see .create
+  module Attributes
+    include Bluepine::Assertions
+    KeyError  = Bluepine::Error.create "Attribute %s already exists"
+
+    @registry = Registry.new({}, error: KeyError) do |id, name, options, block|
+      attribute = get(id)
+      attribute.new(name, options, &block)
+    end
+
+    class << self
+      # Holds reference to all attribute objects
+      #
+      # @return [Registry]
+      attr_accessor :registry
+
+      # Creates new attribute (Delegates to Registry#create).
+      #
+      # @return [Attribute]
+      #
+      # @example Creates primitive attribute
+      #   Attributes.create(:string, :username, required: true)
+      #
+      # @example Creates compound attribute
+      #   Attributes.create(:object, :user) do
+      #     string :username
+      #   end
+      def create(type, name, options = {}, &block)
+        registry.create(type, name, options, &block)
+      end
+
+      # Registers new Attribute (alias for Registry#register)
+      #
+      # @example
+      #   register(:custom, CustomAttribute)
+      def register(type, klass, override: false)
+        registry.register(type, klass, override: override)
+      end
+
+      def key?(key)
+        registry.key?(key)
+      end
+    end
+
+    ALL = {
+      string:       StringAttribute,
+      number:       NumberAttribute,
+      integer:      IntegerAttribute,
+      float:        FloatAttribute,
+      boolean:      BooleanAttribute,
+      object:       ObjectAttribute,
+      array:        ArrayAttribute,
+      schema:       SchemaAttribute,
+      time:         TimeAttribute,
+      date:         DateAttribute,
+      uri:          URIAttribute,
+      currency:     CurrencyAttribute,
+      ip_address:   IPAddressAttribute,
+    }.freeze
+
+    SCALAR_TYPES     = %i[string number integer float boolean].freeze
+    NATIVE_TYPES     = SCALAR_TYPES + %i[array object].freeze
+    NON_SCALAR_TYPES = ALL.keys - SCALAR_TYPES
+
+    # register pre-defined attributes
+    ALL.each { |name, attr| register(name, attr) }
+  end
+end

data/lib/bluepine/attributes/array_attribute.rb

@@ -0,0 +1,11 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class ArrayAttribute < Attribute
+      def native_type
+        "array"
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/attribute.rb

@@ -0,0 +1,130 @@
+module Bluepine
+  module Attributes
+    # An abstract Attribute based class.
+    #
+    # @abstract
+    class Attribute
+      include Bluepine::Assertions
+      include Bluepine::Serializers::Serializable
+      include Bluepine::Validators::Normalizable
+      include Bluepine::Validators::Validatable
+
+      class_attribute :options
+      attr_reader     :name
+
+      # Assigns default class attribute values
+      self.options    = {}.freeze
+
+      def initialize(name, options = {})
+        @name    = name
+        @options = self.class.options.merge(options)
+      end
+
+      def options
+        @options.merge({
+          name:         @name,
+          match:        match,
+          method:       method,
+          type:         type,
+          native_type:  native_type,
+          of:           of,
+          in:           send(:in),
+          if:           @options[:if],
+          unless:       @options[:unless],
+          null:         null,
+          spec:         spec,
+          spec_uri:     spec_uri,
+          format:       format,
+          private:      private,
+          deprecated:   deprecated,
+          required:     required,
+          default:      default,
+          description:  description,
+          attributes:   attributes.values&.map(&:options),
+        })
+      end
+
+      def type
+        self.class.name.demodulize.chomp("Attribute").underscore
+      end
+
+      def match
+        @options[:match]
+      end
+
+      def method
+        @options[:method] || @name
+      end
+
+      def of
+        @options[:of]
+      end
+
+      def in
+        @options[:in]
+      end
+
+      def if
+        @options[:if]
+      end
+
+      def unless
+        @options[:unless]
+      end
+
+      def null
+        @options.fetch(:null, false)
+      end
+
+      def native_type
+        type
+      end
+
+      def format
+        @options[:format]
+      end
+
+      def spec
+        nil
+      end
+
+      def spec_uri
+        nil
+      end
+
+      def attributes
+        {}
+      end
+
+      # deprecated attribute should be listed in schema
+      def deprecated
+        @options.fetch(:deprecated, false)
+      end
+
+      def private
+        @options.fetch(:private, false)
+      end
+
+      def required
+        @options.fetch(:required, false)
+      end
+
+      def default
+        @options[:default]
+      end
+
+      def description
+        @options[:description]
+      end
+
+      # Should not be listed in schema or serialize this attribute
+      def serializable?
+        !private
+      end
+
+      def value(value)
+        value.nil? ? default : value
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/boolean_attribute.rb

@@ -0,0 +1,22 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    # @example Registers custom normalizer that accepts "on" as truth value
+    #   BooleanAttribute.normalizer = ->(x) { ["on", true].include?(x) ? true : false }
+    #
+    # @example Registers custom serializer
+    #   BooleanAttribute.serialize = ->(x) { x == "on" ? true : false }
+    class BooleanAttribute < Attribute
+      self.serializer = ->(v) { ActiveModel::Type::Boolean.new.cast(v) }
+
+      def native_type
+        "boolean"
+      end
+
+      def in
+        @options.fetch(:in, [true, false])
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/currency_attribute.rb

@@ -0,0 +1,19 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class CurrencyAttribute < StringAttribute
+      def format
+        super || type
+      end
+
+      def spec
+        "ISO 4217"
+      end
+
+      def spec_uri
+        "https://en.wikipedia.org/wiki/ISO_4217"
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/date_attribute.rb

@@ -0,0 +1,11 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class DateAttribute < StringAttribute
+      def format
+        super || "date"
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/float_attribute.rb

@@ -0,0 +1,13 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class FloatAttribute < NumberAttribute
+      self.serializer = ->(v) { v.to_f }
+
+      def format
+        super || "float"
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/integer_attribute.rb

@@ -0,0 +1,14 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class IntegerAttribute < NumberAttribute
+      self.serializer = ->(v) { v.to_i }
+
+      # JSON schema supports `integer` type
+      def native_type
+        "integer"
+      end
+    end
+  end
+end