sober_swag 0.1.0

data/lib/sober_swag/nodes/primitive.rb

@@ -0,0 +1,29 @@
+module SoberSwag
+  module Nodes
+    ##
+    # Root node of the tree
+    class Primitive < Base
+      def initialize(value)
+        @value = value
+      end
+
+      attr_reader :value
+
+      def map(&block)
+        self.class.new(block.call(value))
+      end
+
+      def deconstruct
+        [value]
+      end
+
+      def deconstruct_keys(_)
+        { value: value }
+      end
+
+      def cata(&block)
+        block.call(self.class.new(value))
+      end
+    end
+  end
+end

data/lib/sober_swag/nodes/sum.rb

@@ -0,0 +1,6 @@
+module SoberSwag
+  module Nodes
+    class Sum < Binary
+    end
+  end
+end

data/lib/sober_swag/nodes.rb

@@ -0,0 +1,20 @@
+module SoberSwag
+  ##
+  # Base namespace for all nodes.
+  # These nodes are compiled into an actual swagger definition
+  # via a catamorphism, which I promise is not nearly as scary as it sounds.
+  # Sort of.
+  module Nodes
+    autoload :Base, 'sober_swag/nodes/base'
+    autoload :Enum, 'sober_swag/nodes/enum'
+    autoload :Binary, 'sober_swag/nodes/binary'
+    autoload :Primitive, 'sober_swag/nodes/primitive'
+    autoload :NullablePrimitive, 'sober_swag/nodes/nullable_primitive'
+    autoload :Sum, 'sober_swag/nodes/sum'
+    autoload :Array, 'sober_swag/nodes/array'
+    autoload :Object, 'sober_swag/nodes/object'
+    autoload :Attribute, 'sober_swag/nodes/attribute'
+    autoload :OneOf, 'sober_swag/nodes/one_of'
+    autoload :List, 'sober_swag/nodes/list'
+  end
+end

data/lib/sober_swag/parser.rb

@@ -0,0 +1,73 @@
+module SoberSwag
+  class Parser
+    def initialize(node)
+      @node = node
+      @found = Set.new
+    end
+
+    def to_syntax
+      case @node
+      when Dry::Types::Array::Member
+        Nodes::List.new(bind(Parser.new(@node.member)))
+      when Dry::Types::Enum
+        Nodes::Enum.new(@node.values)
+      when Dry::Types::Schema
+        Nodes::Object.new(
+          @node.map { |attr| bind(Parser.new(attr)) }
+        )
+      when Dry::Types::Schema::Key
+        Nodes::Attribute.new(
+          @node.name,
+          @node.required?,
+          bind(Parser.new(@node.type))
+        )
+      when Dry::Types::Sum
+        left = bind(Parser.new(@node.left))
+        right = bind(Parser.new(@node.right))
+        # special case booleans to just return the left value
+        # this is because modeling a boolean as a sum type of
+        # TrueClass and FalseClass is kinda weird, because they're
+        # considered different types instead of different constructors,
+        # which we don't want to do
+        is_bool = [left, right].all? do |e|
+          e.respond_to?(:value) && [TrueClass, FalseClass].include?(e.value)
+        end
+        if is_bool
+          left
+        else
+          Nodes::Sum.new(left, right)
+        end
+      when Dry::Types::Constrained
+        bind(Parser.new(@node.type))
+      when Dry::Types::Nominal
+        # start off with the moral equivalent of NodeTree[String]
+        Nodes::Primitive.new(@node.primitive)
+      else
+        # Inside of this case we have a class that is some user-defined type
+        # We put it in our array of found types, and consider it a primitive
+        @found.add(@node)
+        Nodes::Primitive.new(@node)
+      end
+    end
+
+    def run_parser
+      [to_syntax, found]
+    end
+
+    ##
+    # What other types did we find while parsing this type?
+    attr_reader :found
+
+    ##
+    # Call `.to_syntax` on another node, putting any new classes it finds
+    # in the list of classes we found in the process.
+    #
+    # If you're a big Haskell nerd, then this is >>=.
+    def bind(other)
+      result = other.to_syntax
+      @found += other.found
+      result
+    end
+
+  end
+end

data/lib/sober_swag/path/integer.rb

@@ -0,0 +1,21 @@
+module SoberSwag
+  module Path
+    class Integer < Node
+
+      def initialize; end;
+
+      def jumpable?
+        true
+      end
+
+      def param?
+        true
+      end
+
+      def param_type
+        SoberSwag::Types::Paramter::Integer
+      end
+
+    end
+  end
+end

data/lib/sober_swag/path/lit.rb

@@ -0,0 +1,41 @@
+module SoberSwag
+  class Path
+    class Lit
+      ##
+      # Parse a literal path fragment
+      def initialize(lit)
+        @lit = lit
+      end
+
+      attr_reader :lit
+
+      def param?
+        false
+      end
+
+      def param_type
+        nil
+      end
+
+      def param_key
+        nil
+      end
+
+      ##
+      # Constant to avoid a bunch of array allocation
+      MATCH_SUCC = [:match, nil].freeze
+      ##
+      # Constant to avoid a bunch of array allocation
+      MATHC_FAIL = [:fail].freeze
+
+      def match(param)
+        if param == lit
+          MATCH_SUCC
+        else
+          MATCH_FAIL
+        end
+      end
+
+    end
+  end
+end

data/lib/sober_swag/path/literal.rb

@@ -0,0 +1,29 @@
+module SoberSwag
+  module Path
+    ##
+    # One literal text fragment, basically
+    class Literal < Node
+      ##
+      # Make a new text node
+      # @param text [String]
+      def initialize(text)
+        @text = text
+      end
+
+      attr_reader :text
+
+      ##
+      # We can make a jump table out of this node!
+      def jumpable?
+        true
+      end
+
+      ##
+      # This doesn't read a parameter type.
+      def param?
+        false
+      end
+
+    end
+  end
+end

data/lib/sober_swag/path/param.rb

@@ -0,0 +1,33 @@
+module SoberSwag
+  class Path
+    ##
+    # Parse a parameter
+    class Param
+      def initialize(name, type)
+        @name = name
+        @type = type
+      end
+
+      def param?
+        true
+      end
+
+      def param_key
+        @name
+      end
+
+      def param_type
+        @type
+      end
+
+      def match(param)
+        if (m = @type.try(param)).success?
+          [:match, m]
+        else
+          [:fail]
+        end
+      end
+
+    end
+  end
+end

data/lib/sober_swag/path.rb

@@ -0,0 +1,8 @@
+module SoberSwag
+  class Path
+
+    autoload(:Lit, 'sober_swag/path/lit')
+    autoload(:Param, 'sober_swag/path/param')
+
+  end
+end

data/lib/sober_swag/serializer/array.rb

@@ -0,0 +1,21 @@
+module SoberSwag
+  module Serializer
+    ##
+    # Make a serialize of arrays out of a serializer of the elements
+    class Array < Base
+      def initialize(element_serializer)
+        @element_serializer = element_serializer
+      end
+
+      attr_reader :element_serializer
+
+      def serialize(object, options = {})
+        object.map { |a| element_serializer.serialize(a, options) }
+      end
+
+      def type
+        SoberSwag::Types::Array.of(element_serializer.type)
+      end
+    end
+  end
+end

data/lib/sober_swag/serializer/base.rb

@@ -0,0 +1,38 @@
+module SoberSwag
+  module Serializer
+    class Base
+
+      ##
+      # Return a new serializer that is an *array* of elements of this serializer.
+      def array
+        SoberSwag::Serializer::Array.new(self)
+      end
+
+      ##
+      # Returns a serializer that will pass `nil` values on unscathed
+      def optional
+        SoberSwag::Serializer::Optional.new(self)
+      end
+
+      ##
+      # If I am a serializer for type 'a', and you give me a way to turn 'a's into 'b's,
+      # I can give you a serializer for type 'b' by running the funciton you gave.
+      # For example, if I am a serializer for {String}, and you know how to turn
+      # an {Int} into a {String}, I can now serialize {Int}s (by turning them into a string).
+      #
+      # Note that the *declared* type of this is *not* changed: from a user's perspective,
+      # they see a "string"
+      def via_map(&block)
+        SoberSwag::Serializer::Mapped.new(self, block)
+      end
+
+      ##
+      # Serializer lets you get a serializer from things that might be classes
+      # because of the blueprint naming hack.
+      def serializer
+        self
+      end
+
+    end
+  end
+end

data/lib/sober_swag/serializer/conditional.rb

@@ -0,0 +1,49 @@
+module SoberSwag
+  module Serializer
+    ##
+    # Conditionally serialize one thing *or* the other thing via deciding on a condition.
+    # This works by taking three elements: a "decision" proc, a "left" serializer, and a "right" serializer.
+    # The decision proc takes in both the object to be serialized *and* the options hash, and returns a
+    # `[:left, val]` object, or a `[:right, val]` object, which
+    # then get passed on to the appropriate serializer.
+    #
+    # This is a very weird, not-very-Ruby-like abstraction, *upon which* we can build abstractions that are actually use for users.
+    # It lets you build abstractions like "Use this serializer if a type has this class, otherwise use this other one."
+    # When composed together, you can make arbitrary decision trees.
+    class Conditional < Base
+      ##
+      # Error thrown when a chooser proc returns a non left-or-right value.
+      class BadChoiceError < Error; end
+
+      def initialize(chooser, left, right)
+        @chooser = chooser
+        @left = left
+        @right = right
+      end
+
+      attr_reader :chooser, :left, :right
+
+      def serialize(object, options = {})
+        tag, val = chooser.call(object, options)
+        if tag == :left
+          left.serialize(val, options)
+        elsif tag == :right
+          right.serialize(val, options)
+        else
+          raise BadChoiceError, "result of chooser proc was not a left or right, but a #{val.class}"
+        end
+      end
+
+      ##
+      # Since this could potentially serialize one of two alternatives,
+      # the "type" we serialize two is *either* one alternative or the other.
+      def type
+        if left.type == right.type
+          left.type
+        else
+          left.type | right.type
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/serializer/field_list.rb

@@ -0,0 +1,44 @@
+module SoberSwag
+  module Serializer
+    ##
+    # Extract out a hash from a list of
+    # name/serializer pairs.
+    class FieldList < Base
+
+      def initialize(field_list)
+        @field_list = field_list
+      end
+
+      attr_reader :field_list
+
+      ##
+      # Alias to make writing primitive stuff much easier
+      def primitive(symbol)
+        SoberSwag::Serializer.Primitive(SoberSwag::Types.const_get(symbol))
+      end
+
+
+      def serialize(object, options)
+        field_list.map { |field|
+          [field.name, field.serializer.serialize(object, options)]
+        }.to_h
+      end
+
+      def type
+        @type ||= make_struct_type!
+      end
+
+      private
+
+      def make_struct_type!
+        f = field_list
+        Class.new(Dry::Struct) do
+          f.each do |field|
+            attribute field.name, field.serializer.type
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/sober_swag/serializer/mapped.rb

@@ -0,0 +1,29 @@
+module SoberSwag
+  module Serializer
+    ##
+    # A new serializer by mapping over the serialization function
+    class Mapped < Base
+
+      def initialize(base, map_f)
+        @base = base
+        @map_f = map_f
+      end
+
+      def serialize(object, options)
+        @base.serialize(@map_f.call(object), options)
+      end
+
+      def type
+        @base.type
+      end
+
+      ##
+      # I have no freaking clue if ruby optimizes proc composition,
+      # but we at least save some node traversals here
+      def via_map(&block)
+        SoberSwag::Serializer::Mapped.new(@base, @map_f >> block)
+      end
+
+    end
+  end
+end

data/lib/sober_swag/serializer/optional.rb

@@ -0,0 +1,29 @@
+module SoberSwag
+  module Serializer
+    class Optional < Base
+
+      def initialize(inner)
+        @inner = inner
+      end
+
+      attr_reader :inner
+
+      def serialize(object, options = {})
+        if object.nil?
+          object
+        else
+          inner.serialize(object, options)
+        end
+      end
+
+      def type
+        inner.type.optional
+      end
+
+      def optional(*)
+        raise ArgumentError, 'no nesting optionals please'
+      end
+
+    end
+  end
+end

data/lib/sober_swag/serializer/primitive.rb

@@ -0,0 +1,15 @@
+module SoberSwag
+  module Serializer
+    class Primitive < Base
+      def initialize(type)
+        @type = type
+      end
+
+      attr_reader :type
+
+      def serialize(object, options = {})
+        object
+      end
+    end
+  end
+end

data/lib/sober_swag/serializer.rb

@@ -0,0 +1,23 @@
+module SoberSwag
+  module Serializer
+    autoload(:Base, 'sober_swag/serializer/base')
+    autoload(:Primitive, 'sober_swag/serializer/primitive')
+    autoload(:Conditional, 'sober_swag/serializer/conditional')
+    autoload(:Array, 'sober_swag/serializer/array')
+    autoload(:Mapped, 'sober_swag/serializer/mapped')
+    autoload(:Optional, 'sober_swag/serializer/optional')
+    autoload(:FieldList, 'sober_swag/serializer/field_list')
+
+    class << self
+      ##
+      # Use a "Primitive" serializer, which *does not* actually do any type-changing, and instead passes
+      # in values raw.
+      #
+      # @param contained {Class} Dry::Type to use
+      def Primitive(contained)
+        SoberSwag::Serializer::Primitive.new(contained)
+      end
+    end
+
+  end
+end

data/lib/sober_swag/types.rb

@@ -0,0 +1,5 @@
+module SoberSwag
+  class Types
+    include ::Dry::Types()
+  end
+end

data/lib/sober_swag/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SoberSwag
+  VERSION = '0.1.0'
+end

data/lib/sober_swag.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bundler'
+Bundler.setup
+require 'dry-struct'
+require 'dry-types'
+require 'sober_swag/types'
+require 'sober_swag/version'
+require 'active_support/inflector'
+
+##
+# Root namespace
+module SoberSwag
+  class Error < StandardError; end
+
+  autoload :Parser, 'sober_swag/parser'
+  autoload :Serializer, 'sober_swag/serializer'
+  autoload :Blueprint, 'sober_swag/blueprint'
+  autoload :Nodes, 'sober_swag/nodes'
+  autoload :Compiler, 'sober_swag/compiler'
+  autoload :Controller, 'sober_swag/controller'
+
+  ##
+  # Define a struct of something.
+  # Useful to prevent weirdness from autoloading.
+  def self.struct(parent = Dry::Struct, &block)
+    Class.new(parent, &block)
+  end
+end

data/sober_swag.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sober_swag/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sober_swag'
+  spec.version       = SoberSwag::VERSION
+  spec.authors       = ['Anthony Super']
+  spec.email         = ['asuper@sondermind.com']
+
+  spec.summary       = 'Generate swagger types from dry-types'
+  spec.description   = 'Parse data, don\'t write docs'
+  spec.homepage      = 'https://github.com/SonderMindOrg/sober_swag'
+  spec.license       = 'MIT'
+
+  spec.metadata['allowed_push_host'] = "https://rubygems.org"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'dry-struct', '~> 1.0'
+  spec.add_dependency 'dry-types', '~> 1.2'
+  spec.add_dependency 'activesupport'
+
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end