bed 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1377de7e50abf7f48aba8a104bc6fce6be53bc7b5fef46f18a08c34de88f12fb
-  data.tar.gz: ef45d49fa33044142cf8eab1cc1a0caa2fa6f791467396509ac1746d2d96239c
+  metadata.gz: 685203c96b43ba149593ae12988d86524bdcaebed5b42f7c8ebd342a6c975b6a
+  data.tar.gz: 82052332d1e4d22f7b1aeaa40c6896f468b48f7efdac03001bce43c5f5cb7345
 SHA512:
-  metadata.gz: 1ee08f53a9b7ccca782708880be79fb327832029e6e99942016d029446fa0310c7515998b3da521d03eed7ed48926ee577a25cfa0669cec0ed025f59fd44cee5
-  data.tar.gz: 1d74e2f6cb14269c6164b54f95ca4c1bcb8a0893a7f080eedb9573c89fdbe5f1d0c139d991913b1f17f795787bd654f6fdd01b0d7c52a688f15ddfb6e40d21bd
+  metadata.gz: 57f45088cfd56960ee74a6e4519227e69d5c26d7f64a7a9e059e8cad0934a6d4039ffedd2673d5e7cd3aa1b37dd9d2d9dad3dfc9db54d2cd773c48a38e102e5f
+  data.tar.gz: 24ed22e1bfedb4b2155b56ec427300898160e79f9cb8daaa6a9176d2ae076ea5f0f3280ee85efcb55df78d46e6b4d856eda8afbd65a57cbf3ad8d993f64b134e

data/bed.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require_relative "lib/bed/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "bed"
+  spec.version = Bed::VERSION
+  spec.platform = Gem::Platform::RUBY
+  spec.authors = ["David Gillis"]
+  spec.email = ["david.gillis@hey.com"]
+  spec.summary = "A simple, modern schema library built on top of Data class"
+  spec.description = "Bed is a simple, modern schema library built on top of Data. It provides a simple, declarative way to define schemas for your data, and a way to validate that data against those schemas."
+  spec.required_ruby_version = ">= 3.0.0"
+  spec.homepage = "https://github.com/gillisd/bed"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.license = "MIT"
+
+  spec.files = Dir.glob([
+    "lib/**/*",
+    "README.md",
+    "LICENSE.txt",
+    "*.gemspec"
+  ]).reject { |f| File.directory?(f) }
+  
+  spec.bindir = "exe"
+  spec.executables = Dir.glob("exe/*").map { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", ">= 6.0"
+  spec.add_dependency "json"
+end

data/lib/bed/builder.rb

@@ -0,0 +1,23 @@
+module Bed
+  class Builder
+    def initialize(schema, &block)
+      @schema = schema
+    end
+
+    def define_methods
+      @schema.deconstruct_keys(nil).each do |key, value|
+        case value
+        in Data
+          Bed::Builder.new()
+        end
+
+      end
+    end
+
+    def member?(name)
+      @schema.members.include?(name)
+    end
+
+
+  end
+end

data/lib/bed/caster.rb

@@ -0,0 +1,46 @@
+module Bed
+  class Caster
+    def self.cast(buildable)
+      new(buildable).cast
+    end
+
+    def initialize(buildable)
+      @buildable = buildable
+    end
+
+    def cast
+      raise TypeError, "#{@buildable} does not respond to to_h" unless @buildable.respond_to?(:to_h)
+
+      attributes = @buildable.to_h.transform_values do |value|
+        case value
+        in Hash
+          self.class.cast(value)
+        in Array
+          value.map do |v|
+            begin
+              self.class.cast(v)
+            rescue TypeError
+              v
+            end
+          end
+        else
+          value
+        end
+      end
+
+      cache_key = [attributes.keys]
+
+      Thread.current[:__bed_cast_cache] ||= {}
+      Thread.current[:__bed_cast_cache][cache_key] ||= (
+        Data.define(*attributes.keys, &method(:definition))
+      )
+      Thread.current[:__bed_cast_cache][cache_key].new(**attributes)
+    end
+
+    private
+
+    def definition(instance)
+      instance
+    end
+  end
+end

data/lib/bed/data.rb

@@ -0,0 +1,21 @@
+module Bed
+  if defined?(::Data)
+    Data = ::Data
+  else
+    Data = ::Struct
+    Data.class_eval do
+      def self.define(*args, &block)
+        new(*args, &block)
+      end
+
+      def []=(key, value)
+        self[key] = value
+      end
+
+      def to_data
+        self
+      end
+    end
+  end
+end
+

data/lib/bed/definition.rb

@@ -0,0 +1,139 @@
+class Object
+  class << self
+    alias_method :original_method_missing, :method_missing
+
+    def method_missing(method_name, *args, &block)
+      if method_name == :String
+        puts "Intercepted call to String with argument: #{args.first}"
+        define_method(args.first) do
+          "This is a dynamically defined method: #{args.first}"
+        end
+      else
+        original_method_missing(method_name, *args, &block)
+      end
+    end
+  end
+end
+
+module Bed
+  class Schema
+    attr_reader :fields
+
+    def initialize(fields)
+      @fields = fields
+    end
+
+    def pattern
+      fields.map { |_, v| v.is_a?(Schema) ? v.pattern : '_' }.join(', ')
+    end
+  end
+
+  class Type
+    class << self
+      attr_reader :schema
+
+      def define(schema)
+        @schema = schema
+        Data.define(*schema.fields.keys) do
+
+          def initialize(...)
+            super
+            validate
+          end
+
+          define_method(:deconstruct) do
+            self.class.schema.fields.keys.map do |key|
+              value = public_send(key)
+              if value.is_a?(Data) && value.class.respond_to?(:schema)
+                value.deconstruct
+              else
+                value
+              end
+            end
+          end
+
+          define_method(:deconstruct_keys) do |keys = nil|
+            keys ||= self.class.schema.fields.keys
+            keys.each_with_object({}) do |key, hash|
+              if self.class.schema.fields.key?(key)
+                value = public_send(key)
+                hash[key] = if value.is_a?(Data) && value.class.respond_to?(:schema)
+                              value.deconstruct_keys
+                            else
+                              value
+                            end
+              end
+            end
+          end
+
+          define_method(:to_hash) do
+            self.class.schema.fields.keys.each_with_object({}) do |key, hash|
+              value = public_send(key)
+              hash[key] = if value.is_a?(Data) && value.class.respond_to?(:schema)
+                            value.to_hash
+                          else
+                            value
+                          end
+            end
+          end
+
+          define_method(:validate) do
+            pattern = "case self\nin [#{self.class.schema.pattern}]\ntrue\nelse\nfalse\nend"
+            eval(pattern)
+          end
+
+          # Class variable to store the schema
+          class_variable_set(:@@schema, schema)
+
+          # Class method to access the schema
+          define_singleton_method(:schema) do
+            class_variable_get(:@@schema)
+          end
+        end
+      end
+    end
+  end
+
+  Field = Data.define(:name, :type, :required, :enable_default, :default_value, :allow_nil) do
+    def initialize(name:, type:, required: true, enable_default: false, default_value: nil, allow_nil: false)
+      super
+    end
+  end
+
+  class SchemaBuilder
+    attr_reader :fields
+
+    def initialize
+      @fields = {}
+    end
+
+    Object.constants.each do |const|
+      define_method(const) do |field_name, **args|
+        define_field(Object.const_get(const), field_name, **args)
+      end
+    end
+
+    def compile(&block)
+      instance_eval(&block)
+    end
+
+    def to_schema
+      Schema.new(@fields)
+    end
+
+    def define_field(type, field_name, required: true, enable_default: false, default_value: nil, allow_nil: false)
+      @fields[field_name] = Field.new(name: field_name, type: type, required: required, enable_default: enable_default, default_value: default_value, allow_nil: allow_nil)
+    end
+
+    private
+
+    def const_missing(type)
+      Object.const_get(type)
+    end
+
+    def method_missing(type, *args)
+      field_name = args.first
+      @fields[field_name] = Object.const_get(type)
+    end
+  end
+end

data/lib/bed/flex/builder.rb

@@ -0,0 +1,157 @@
+module Bed
+  module Flex
+    class Builder
+      def initialize(*args, **kwargs, &blk)
+        @whitelisted_attributes = []
+        @attributes = {}
+        @locked = false
+        @converged = false
+        result = if block_given?
+                   block = blk
+                   if block.arity.zero?
+                     instance_eval(&block)
+                   else
+                     yield self
+                   end
+                 end
+
+        converge(result) if should_converge?(result)
+        @locked = true
+      end
+
+      def converge(value)
+        @converged = true
+        @attributes[:_converged] = value
+      end
+
+      def get(path)
+        path.to_s.split('.').inject(self) { |obj_self, attr| obj_self.public_send(attr) }
+      end
+
+      def to_h
+        return @attributes[:_converged] if @converged
+        @attributes.transform_values { |v| v.is_a?(Builder) ? v.to_h : v }
+      end
+
+      # alias_method :inspect, :to_h
+      alias_method :to_s, :to_h
+
+      def deep_dup
+        self.class.new.tap do |new_builder|
+          @attributes.each do |key, value|
+            new_builder.send(:"#{key}=", value.is_a?(Builder) ? value.deep_dup : value.dup)
+          end
+        end
+      end
+
+      def pretty_print(pp)
+        pp.object_address_group(self) do
+          pp.seplist(@attributes, -> { pp.text ',' }) do |k, v|
+            pp.breakable
+            pp.group(1) do
+              pp.text k.to_s
+              pp.text ':'
+              pp.breakable
+              pp.pp v
+            end
+          end
+        end
+      end
+
+      private alias_method :old_inspect, :inspect
+
+      def inspect
+        case @attributes
+        in {} then '{}'
+        in { _converged: value } then value
+        else
+          old_inspect
+        end
+      end
+
+      # def to_ary
+      #   [to_h]
+      # end
+      def []=(name, value)
+        set_attribute(name, value)
+      end
+
+      private
+
+      def should_converge?(result)
+        case [@attributes, result]
+          # E.g.
+          # b.foo do
+          #   b.bar 'a string'
+          # end
+        in {}, Builder | nil then false
+        # E.g.
+        # b.foo do
+        #   'a string'
+        # end
+        in {}, _ then true
+        else false
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        return false if name == :to_ary
+        @whitelisted_attributes.empty? || @whitelisted_attributes.include?(name) || super
+      end
+
+      def method_missing(name, *args, &block)
+        return super if !@whitelisted_attributes.empty? && !@whitelisted_attributes.include?(name)
+
+        if name.end_with?('=')
+          attribute_name = name.to_s.chomp('=').to_sym
+          set_attribute(attribute_name, args.first)
+        else
+          get_or_set_attribute(name, *args, &block)
+        end
+      end
+
+      def to_ary
+        [inspect]
+      end
+
+      def get_or_set_attribute(name, *args, &block)
+        if args.empty? && !block
+          value = @attributes[name]
+
+          if value.nil? && @locked
+            raise NoMethodError, "#{name} is not defined"
+          end
+        else
+          value = if block
+                    if block.arity == 0
+                      args.size > 0 ? [*args,->{Builder.new(&block)}] : Builder.new(&block)
+                    else
+                      Builder.new.tap { |b| block.call(b) }
+                    end
+                  else
+                    args.size == 1 ? args.first : args
+                  end
+          set_attribute(name, value)
+        end
+      end
+
+      def set_attribute(name, value)
+        @attributes[name.to_sym] = value
+
+        define_attribute_method(name)
+        self
+      end
+
+      def define_attribute_method(name)
+        singleton_class.define_method(name) do |*args, &block|
+          if args.empty? && !block
+            name.to_s
+            @attributes[name]
+          else
+            get_or_set_attribute(name, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class Bed
-  VERSION = "0.1.0"
+module Bed
+  VERSION = '0.2.1'
 end

data/lib/bed.rb

@@ -1,9 +1,63 @@
 # frozen_string_literal: true
 
-require 'bed/schema'
+require 'json'
+require 'active_support/all'
+require_relative 'bed/data'
+require_relative 'bed/definition'
+require_relative 'bed/caster'
+require_relative 'bed/flex/builder'
 require_relative "bed/version"
 
-class Bed
+module Bed
   class Error < StandardError; end
-  # Your code goes here...
+
+  def self.define(**kwargs)
+    schema = Schema.new(kwargs)
+    Type.define(schema)
+  end
+
+  def self.schema(&block)
+    if block_given?
+      builder = SchemaBuilder.new
+      builder.compile(&block)
+      schema = builder.to_schema
+      define(**schema.fields)
+    else
+      self
+    end
+  end
+
+  def self.flex(&block)
+    buildable = Flex::Builder.new(&block)
+    Caster.cast(buildable)
+  end
+
+  def self.infer_file(pathname)
+    infer(pathname)
+  end
+
+  def self.infer(inferrable)
+    buildable = get_buildable(inferrable)
+
+    Caster.cast(buildable)
+  end
+
+  def self.get_buildable(inferrable)
+    if looks_like_json?(inferrable)
+      return JSON.parse(inferrable, symbolize_names: true)
+    end
+
+    case inferrable
+    in String
+      JSON.load_file(inferrable, symbolize_names: true)
+    in Hash
+      inferrable
+    else
+      raise ArgumentError, "inferrable must be a String, Hash, JSON file path, or JSON string"
+    end
+  end
+
+  def self.looks_like_json?(str)
+    str.start_with?('{') || str.start_with?('[')
+  end
 end

metadata

@@ -1,15 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: bed
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - David Gillis
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-26 00:00:00.000000000 Z
-dependencies: []
+date: 2024-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Bed is a simple, modern schema library built on top of Data. It provides
   a simple, declarative way to define schemas for your data, and a way to validate
   that data against those schemas.
@@ -19,20 +46,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
-- Rakefile
+- bed.gemspec
 - lib/bed.rb
-- lib/bed/schema.rb
+- lib/bed/builder.rb
+- lib/bed/caster.rb
+- lib/bed/data.rb
+- lib/bed/definition.rb
+- lib/bed/flex/builder.rb
 - lib/bed/version.rb
-- sig/bed.rbs
 homepage: https://github.com/gillisd/bed
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/gillisd/bed
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -47,8 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.0.dev
 specification_version: 4
 summary: A simple, modern schema library built on top of Data class
 test_files: []

data/CODE_OF_CONDUCT.md

@@ -1,47 +0,0 @@
-# Code of Conduct
-
-## Our Commitment
-
-We are committed to fostering a respectful and productive environment for all project contributors.
-
-## Expected Behavior
-
-Contributors are expected to:
-
-- Treat others with respect and professionalism
-- Provide and accept constructive feedback graciously
-- Own their actions and decisions
-- Prioritize the needs of the project
-- Keep discussions and contributions focused on the project or task at hand
-
-## Unacceptable Behavior
-
-The following behaviors are considered unacceptable:
-
-- Harassment or discrimination of any kind
-- Offensive comments or personal attacks
-- Sharing others' private information without consent
-- Any conduct deemed inappropriate in a professional setting
-- Engaging in political discussions
-- Integrating personal political views into contributions
-
-## Enforcement
-
-Project maintainers are responsible for enforcing these standards. They may take appropriate action in response to any
-behavior that violates this Code of Conduct, including temporary or permanent bans from project communication channels
-or from contributing to the project itself.
-
-## Reporting Violations
-
-Violations can be reported to the repository owner or project maintainers.
-
-All reports will be reviewed promptly and treated confidentially.
-
-## Scope
-
-This Code of Conduct applies to all communication channels related to the project and when representing the project in
-public spaces.
-
-## Attribution
-
-This Code of Conduct is adapted from the Contributor Covenant, version 2.1.

data/Rakefile

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "minitest/test_task"
-
-Minitest::TestTask.create
-
-task default: :test

data/lib/bed/schema.rb

@@ -1,99 +0,0 @@
-class Bed::Schema < Data
-  def self.define_with_types(**kwargs)
-    puts 'defining...'
-    old_kwdargs = kwargs
-    kwargs = kwargs.transform_values do |v|
-      v.superclass == Data ? v.new : v
-    end
-
-    keys = kwargs.keys
-
-    puts kwargs
-
-    init_block = Proc.new do
-      define_method :initialize do |args = nil|
-        case args
-        in Hash
-          super(**kwargs.merge(args))
-        in Array
-          super(kwargs.merge(args))
-        else
-          super(**kwargs)
-        end
-
-        unless args.nil?
-          # raise ArgumentError, 'Invalid arguments' unless validate
-        end
-      end
-
-      alias_method :_deconstruct, :deconstruct
-
-      define_method :deconstruct do
-        puts 'deconstructing...'
-        val = _deconstruct
-        case val
-        in *beginning, Class => data, *ending
-          [*beginning, *data.deconstruct, *ending]
-        in [*rest, Data => data]
-          [*rest, *data.deconstruct]
-        in [Data => data, *rest]
-          [*data.deconstruct, *rest]
-        else
-          _deconstruct
-        end
-      end
-
-      alias_method :_deconstruct_keys, :deconstruct_keys
-
-      define_method :deconstruct_keys do |keys = self.class.schema.keys|
-        puts keys
-        _deconstruct_keys(keys)
-        # _deconstruct_keys(keys).transform_values do |v|
-        #   v.respond_to?(:deconstruct_keys) ? v.deconstruct_keys(keys) : v
-        # end
-      end
-
-      define_method :to_hash do
-        to_h.transform_values do |v|
-          v.respond_to?(:to_hash) ? v.to_hash : v
-        end
-      end
-
-      define_method :validate do
-        arr = self.class.new.deconstruct
-        pattern = <<-RUBY
-          case self
-            in #{arr}
-             true
-            else
-             false
-           end
-        RUBY
-        eval(pattern)
-      end
-
-      define_singleton_method :schema do
-        old_kwdargs
-      end
-
-      define_singleton_method :create_nested_objects do |grouped_data|
-        grouped_data.to_a.reverse.reduce(nil) do |inner, (klass, values)|
-          args = values.map(&:first)
-          args << inner if inner
-          klass.new(*args)
-        end
-      end
-
-      define_singleton_method :go do
-        schema.values.map { |v| v.respond_to?(:superclass) && v.superclass == Data ? v.go : self }.flatten
-      end
-
-      define_singleton_method :reconstruct do |*args|
-        grouped = args.zip(go).group_by(&:last)
-
-        create_nested_objects(grouped)
-      end
-    end
-    Data.define(*keys, &init_block)
-  end
-end

data/sig/bed.rbs

@@ -1,4 +0,0 @@
-module Bed
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end