verse-schema 1.0.0

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+# Load custom tasks
+Dir.glob("#{File.dirname(__FILE__)}/lib/tasks/**/*.rake").each { |r| load r }
+
+task default: %i[spec rubocop]

data/benchmarks/troubleshoot.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Troubleshoot performances
+require "bundler"
+
+Bundler.require
+
+require "verse/schema"
+
+# Good real life example struggling in term of perfs
+ShiftEntrySchema = Verse::Schema.define do
+  field :from, Time
+  field :to, Time
+
+  field? :project_id, [Integer, NilClass]
+
+  field :productive, TrueClass
+  field :billable, TrueClass
+
+  field(:details, String).default("")
+
+  rule :from, "from should be less than to" do |object|
+    next object[:from] <= object[:to]
+  end
+
+  rule :project_id, "Project id must be set if productive set to true" do |object|
+    if object[:productive] && object[:project_id].nil?
+      next false
+    end
+
+    true
+  end
+
+  rule :project_id, "Billable must have a project_id" do |object|
+    if object[:billable] && object[:project_id].nil?
+      next false
+    end
+
+    true
+  end
+end
+
+ShiftEntry = ShiftEntrySchema.dataclass do
+  def duration
+    to - from
+  end
+end
+
+require "ruby-prof"
+
+GC.compact
+
+def run_profiler
+  RubyProf.start
+
+  100_000.times do
+    ShiftEntry.new({ "to" => "2024-10-16 12:00:00",
+                     "from" => "2024-10-16 04:00:00",
+                     "details" => "Worked on the project",
+                     "billable" => true,
+                     "productive" => true,
+                     "project_id" => 1 })
+  end
+
+  # Stop profiling
+  result = RubyProf.stop
+
+  # Print a flat report to the console (or choose other report formats)
+  printer = RubyProf::GraphPrinter.new(result)
+  printer.print($stdout, min_percent: 3) # Adjust min_percent to filter results
+end
+
+run_profiler

data/lib/tasks/readme.rake

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "readme_doc_extractor"
+
+namespace :readme do
+  desc "Generate README.md from specs"
+  task :generate do
+    # Ensure RSpec is loaded
+    require "rspec"
+
+    # Load the application
+    require_relative "../../lib/verse/schema"
+
+    # Load the spec environment
+    require_relative "../../spec/spec_helper"
+
+    # Load all the spec files
+    Dir["#{File.dirname(__FILE__)}/../../spec/**/*_spec.rb"].each { |f| require f }
+
+    # Extract documentation from specs
+    doc_extractor = ReadmeDocExtractor.new
+    examples = doc_extractor.extract_from_specs
+
+    # Debug output
+    puts "Found #{examples.keys.size} sections:"
+    examples.each do |section, section_examples|
+      puts "  - #{section}: #{section_examples.size} examples"
+    end
+
+    # Generate README from template
+    template_path = File.join(File.dirname(__FILE__), "../../templates/README.md.erb")
+
+    # Generate the README
+    readme_content = doc_extractor.generate_readme(template_path)
+
+    # Write to README.md
+    File.write(File.join(File.dirname(__FILE__), "../../README.md"), readme_content)
+
+    puts "README.md generated successfully"
+  end
+
+  desc "Generate a chapter of the README from specs"
+  task :generate_chapter, [:chapter_name] do |_t, args|
+    chapter_name = args[:chapter_name]
+
+    if chapter_name.nil? || chapter_name.empty?
+      puts "Please provide a chapter name"
+      puts "Usage: rake readme:generate_chapter[chapter_name]"
+      exit 1
+    end
+
+    # Ensure RSpec is loaded
+    require "rspec"
+
+    # Load the application
+    require_relative "../../lib/verse/schema"
+
+    # Load the spec environment
+    require_relative "../../spec/spec_helper"
+
+    # Load all the spec files
+    Dir["#{File.dirname(__FILE__)}/../../spec/**/*_spec.rb"].each { |f| require f }
+
+    # Extract documentation from specs
+    doc_extractor = ReadmeDocExtractor.new
+    examples = doc_extractor.extract_from_specs
+
+    # Check if the chapter exists
+    unless examples.key?(chapter_name)
+      puts "Chapter '#{chapter_name}' not found"
+      puts "Available chapters: #{examples.keys.join(", ")}"
+      exit 1
+    end
+
+    # Generate chapter content
+    chapter_content = <<~MARKDOWN
+      ### #{chapter_name}
+
+      #{examples[chapter_name].map { |example| "```ruby\n#{example}\n```" }.join("\n\n")}
+    MARKDOWN
+
+    # Write to a temporary file
+    temp_file = File.join(File.dirname(__FILE__), "../../tmp/#{chapter_name.downcase.gsub(/\s+/, "_")}.md")
+
+    # Create the tmp directory if it doesn't exist
+    tmp_dir = File.dirname(temp_file)
+    FileUtils.mkdir_p(tmp_dir) unless File.directory?(tmp_dir)
+
+    File.write(temp_file, chapter_content)
+
+    puts "Chapter '#{chapter_name}' generated successfully at #{temp_file}"
+    puts "You can now copy this content to your README.md file"
+  end
+end

data/lib/tasks/readme_doc_extractor.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "erb"
+
+class ReadmeDocExtractor
+  attr_reader :chapters
+
+  def initialize
+    @chapters = {}
+  end
+
+  # Extract documentation from specs tagged with :readme
+  def extract_from_specs
+    # Load RSpec configuration
+    RSpec.configure do |config|
+      config.formatter = "progress"
+      config.color = false
+    end
+
+    # Find all specs tagged with :readme
+    readme_specs = find_readme_specs
+
+    # Run the specs and collect examples
+    run_specs(readme_specs)
+
+    # Return the chapters organized hierarchically
+    @chapters
+  end
+
+  # Generate README content from the extracted chapters and a template
+  def generate_readme(template_path)
+    # Load the template
+    template = File.read(template_path)
+
+    # Create a binding with the chapters
+    chapters_binding = binding
+
+    # Render the template with ERB
+    ERB.new(template, trim_mode: "-").result(chapters_binding)
+  end
+
+  private
+
+  # Find all specs tagged with :readme
+  def find_readme_specs
+    puts "Looking for specs tagged with :readme"
+
+    # Load all spec files
+    puts "Loading spec files..."
+    Dir["#{File.dirname(__FILE__)}/../../spec/**/*_spec.rb"].each do |f|
+      puts "  - Loading #{f}"
+      require f
+    end
+
+    # Find specs tagged with :readme
+    readme_specs = RSpec.world.example_groups.select do |group|
+      group.metadata[:readme]
+    end
+
+    puts "Found #{readme_specs.size} readme specs"
+    readme_specs.each do |group|
+      puts "  - #{group.description}"
+    end
+
+    # Return the specs
+    readme_specs.map { |group| [group, group.examples] }.to_h
+  end
+
+  # Run the specs and collect examples into chapters and sections
+  def run_specs(readme_specs)
+    readme_specs.each_key do |group|
+      collect_chapter_from_group(group)
+    end
+  end
+
+  # Collect chapter and its sections from a group
+  def collect_chapter_from_group(group)
+    chapter_name = group.description.to_s
+    puts "Collecting chapter: #{chapter_name}"
+    return unless group.metadata[:readme]
+
+    @chapters[chapter_name] = {}
+
+    # Process child groups (sections)
+    puts "  Chapter has #{group.children.size} sections (children)"
+    group.children.each do |child|
+      section_name = child.description.to_s
+      puts "  - Processing section: #{section_name}, readme_section: #{child.metadata[:readme_section]}"
+      next unless child.metadata[:readme_section]
+
+      @chapters[chapter_name][section_name] ||= []
+
+      # Process examples in this section
+      puts "    Section has #{child.examples.size} examples"
+      child.examples.each do |example|
+        puts "    - Example: #{example.description}"
+        next if example.metadata[:skip]
+
+        # Extract code from the example
+        code = extract_code_from_example(example)
+        if code
+          puts "      Extracted code (#{code.lines.count} lines)"
+          @chapters[chapter_name][section_name] << code
+        else
+          puts "      No code extracted"
+        end
+      end
+    end
+  end
+
+   # Extract code from an example
+  def extract_code_from_example(example)
+    # Get the example block directly using instance_variable_get
+    example_block = example.instance_variable_get(:@example_block)
+    return nil unless example_block
+
+    # Get the source code of the block
+    block_source = example_block.source
+    return nil unless block_source
+
+    # Clean up the code (only handle indentation)
+    clean_code(block_source)
+  end
+
+  # Clean up the code - only handle indentation
+  def clean_code(code)
+    # Remove trailing whitespace from each line
+    code = code.gsub(/[ \t]+$/, "")
+
+    # Fix indentation by processing each line individually
+    lines = code.lines
+    non_empty_lines = lines.reject { |line| line.strip.empty? }
+    min_indent = non_empty_lines.map { |line| line[/^ */].size }.min || 0
+
+    # Remove rubocop comments
+    lines = lines.reject { |line| line =~ /# *rubocop:.*/ }
+    # Remove lines with :nodoc:
+    lines = lines.reject { |line| line =~ /# *:nodoc:/ }
+
+    # Remove the minimum indentation from each line
+    if min_indent > 0
+      lines = lines.map do |line|
+        if line.strip.empty?
+          line
+        else
+          line.sub(/^ {#{min_indent}}/, "")
+        end
+      end
+      code = lines.join
+    end
+
+    # Ensure the code ends with a newline
+    code += "\n" unless code.end_with?("\n")
+
+    code
+  end
+end

data/lib/verse/schema/base.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "./field"
+require_relative "./result"
+require_relative "./error_builder"
+require_relative "./post_processor"
+require_relative "./invalid_schema_error"
+
+module Verse
+  module Schema
+    # Abstract base class for all schemas types.
+    class Base
+      attr_reader :post_processors
+
+      # Initialize a new schema.
+      def initialize(post_processors: nil)
+        @post_processors   = post_processors
+      end
+
+      def rule(fields = nil, message = "rule failed", &block)
+        pp = PostProcessor.new do |value, error|
+          case block.arity
+          when 1, -1, -2 # -1/-2 are for dealing with &:method block.
+            error.add(fields, message) unless instance_exec(value, &block)
+          when 2
+            error.add(fields, message) unless instance_exec(value, error, &block)
+          else
+            # :nocov:
+            raise ArgumentError, "invalid block arity"
+            # :nocov:
+          end
+
+          value
+        end
+
+        if @post_processors
+          @post_processors.attach(pp)
+        else
+          @post_processors = pp
+        end
+
+        self
+      end
+
+      def transform(&block)
+        callback = proc do |value, error_builder|
+          stop if error_builder.errors.any?
+          instance_exec(value, error_builder, &block)
+        end
+
+        if @post_processors
+          @post_processors.attach(
+            PostProcessor.new(&callback)
+          )
+        else
+          @post_processors = PostProcessor.new(&callback)
+        end
+
+        self
+      end
+
+      def valid?(input) = validate(input).success?
+
+      def validate(input, error_builder: nil, locals: {}) = raise NotImplementedError
+
+      def new(arg)
+        result = validate(arg)
+        return result.value if result.success?
+
+        raise InvalidSchemaError, result.errors
+      end
+    end
+  end
+end
+
+require_relative "./collection"
+require_relative "./dictionary"
+require_relative "./scalar"
+require_relative "./selector"
+require_relative "./struct"

data/lib/verse/schema/coalescer/register.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+
+module Verse
+  module Schema
+    module Coalescer
+      # open hash, deep symbolize keys
+      def self.deep_symbolize_keys(value)
+        case value
+        when Array
+          value.map{ |x| deep_symbolize_keys(x) }
+        when Hash
+          value.map do |k, v|
+            [k.to_sym, deep_symbolize_keys(v)]
+          end.to_h
+        else
+          value
+        end
+      end
+
+      register(String) do |value|
+        case value
+        when String
+          value
+        when Numeric
+          value.to_s
+        else
+          raise Coalescer::Error, "must be a string"
+        end
+      end
+
+      register(Integer) do |value|
+        Integer(value)
+      rescue TypeError, ArgumentError
+        raise Coalescer::Error, "must be an integer"
+      end
+
+      register(Float) do |value|
+        Float(value)
+      rescue TypeError, ArgumentError
+        raise Coalescer::Error, "must be a float"
+      end
+
+      register(Symbol) do |value|
+        case value
+        when Symbol
+          next value
+        when Numeric
+          value.to_s.to_sym
+        when String
+          raise Coalescer::Error, "must be a symbol" if value.empty?
+
+          value.to_sym
+        else
+          raise Coalescer::Error, "must be a symbol"
+        end
+      end
+
+      register(Time) do |value|
+        case value
+        when Time
+          value
+        when String
+          # Optimization: Try specific format first, fallback to general parse
+          begin
+            # Attempt fast parsing with the common format used in JSON
+            format = "%Y-%m-%d %H:%M:%S"
+            Time.strptime(value, format)
+          rescue ArgumentError # Raised by strptime on format mismatch
+            # Fallback to slower, more general parsing if strptime failed
+            Time.parse(value)
+          end
+        else
+          raise Coalescer::Error, "must be a datetime"
+        end
+      rescue ArgumentError
+        raise Coalescer::Error, "must be a datetime"
+      end
+
+      register(Date) do |value|
+        case value
+        when Date
+          value
+        when String
+          Date.parse(value)
+        else
+          raise Coalescer::Error, "must be a date"
+        end
+      rescue Date::Error
+        raise Coalescer::Error, "must be a date"
+      end
+
+      register(Hash) do |value|
+        # Open hash without contract.
+
+        raise Coalescer::Error, "must be a hash" unless value.is_a?(Hash)
+
+        Coalescer.deep_symbolize_keys(value)
+      end
+
+      register(Array) do |value|
+        raise Coalescer::Error, "must be an array" unless value.is_a?(Array)
+
+        value
+      end
+
+      register(nil, NilClass) do |value|
+        next nil if value.nil? || value == ""
+
+        raise Coalescer::Error, "must be nil"
+      end
+
+      register(TrueClass, FalseClass, true, false) do |value|
+        case value
+        when TrueClass, FalseClass
+          value
+        when String
+          next true if %w[t y true yes].include?(value)
+          next false if %[f n false no].include?(value)
+
+          raise Coalescer::Error, "must be a boolean"
+        when Numeric
+          value != 0
+        else
+          raise Coalescer::Error, "must be a boolean"
+        end
+      end
+    end
+  end
+end

data/lib/verse/schema/coalescer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Verse
+  module Schema
+    module Coalescer
+      Error = Class.new(StandardError)
+
+      @mapping = {}
+
+      DEFAULT_MAPPER = lambda do |type|
+        if type == Base
+          proc do |value, opts, locals:|
+            opts[:schema].validate(value, locals:)
+          end
+        elsif type.is_a?(Base)
+          proc do |value, _opts, locals:|
+            type.validate(value, locals:)
+          end
+        elsif type.is_a?(Class)
+          proc do |value|
+            next value if value.is_a?(type)
+
+            raise Error, "invalid cast to `#{type}` for `#{value}`"
+          end
+        else
+          proc do |value|
+            raise Error, "invalid cast to `#{type}` for `#{value}`"
+          end
+        end
+      end
+
+      class << self
+        def register(*mapping, &block)
+          mapping.each do |key|
+            @mapping[key] = block
+          end
+        end
+
+        def transform(value, type, opts = {}, locals: {})
+          if type.is_a?(Array)
+            # fast-path for when the type match already
+            type.each do |t|
+              return value if t.is_a?(Class) && value.is_a?(t)
+            end
+
+            converted = nil
+
+            last_error_message = nil
+
+            found = false
+
+            type.each do |t|
+              converted = @mapping.fetch(t) do
+                DEFAULT_MAPPER.call(t)
+              end.call(value, opts, locals:)
+
+              if !converted.is_a?(Result) ||
+                 (converted.is_a?(Result) && converted.success?)
+                found = true
+                break
+              end
+            rescue StandardError => e
+              last_error_message = e.message
+              # next
+            end
+
+            return converted if found || converted.is_a?(Result)
+
+            raise Error, (last_error_message || "invalid cast")
+          else
+            @mapping.fetch(type) do
+              DEFAULT_MAPPER.call(type)
+            end.call(value, opts, locals:)
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "./coalescer/register"