hamachi 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be0e3b8a58a8efb76f493e85f2e034865451805dd57a28f461acee57b15618b9
-  data.tar.gz: d4348290d01e448676f5cff5be31d0246e6651be4d869e320df5c260d3e45421
+  metadata.gz: 7664640e09c9177c316943760e26eb565dd556a22c6ebfb01708e95e57724619
+  data.tar.gz: 17596dac61e26f9d173a129571f999b81ff395faea800a3c9b33a668536820c5
 SHA512:
-  metadata.gz: 8edb8139725830afef0cd9cdda66a4a93a3b7debb3f3753fc57e43c16c3f7d86f38fe8d9768eb3854795e512fcd988c2c761bfab9c7510e6f3f1dbdcdd263cb2
-  data.tar.gz: 04d6c9d8ae09700e9981d1901bf10b9d2bf30c73fc33534d3f69bb9b776d33eabbfca8fe1099e126743eda7d764fa9bbeda0c4179cb148bf706298c6fd185ff7
+  metadata.gz: 5a7424287ab31ad6574dccf647825014d602268ecb5d5d016202782d2c31bac26ef48b3ed4f6cd98ab53473176bf19a2b2aa842ca2dcd8cc05529c9bd5188dea
+  data.tar.gz: '095213ba6c92bedc55b4e97fafa84b1ec1ffad30b3d5990f961f4a28894792ed260590651bb8fee704b3c1250f63105e4a22525b67b8951cd6c2bd7cfeb94913'

data/README.md

@@ -43,7 +43,7 @@ user = User.from_json('{"name": "Alice", "age": 30}')
 user = User.new(name: "Alice", age: 30)
 
 user.name = 'Bob'
-user.age = 8000 # => raises TypeError
+user.age = 120 # => raises RuntimeError: expected age to be 1..100, got 120
 ```
 
 You can define the following types of fields:
@@ -59,23 +59,81 @@ You can define the following types of fields:
 More complex nested models can be created:
 
 ```ruby
-class User < Hamachi::Model
-  field :name, type: String
-  field :friends, type: list(User)
-  field :posts, type: list(Post)
-end
-
 class Post < Hamachi::Model
   field :title, type: String
   field :content, type: String
   field :created_at, type: Timestamp
   field :tags, type: list(String)
 end
+
+class User < Hamachi::Model
+  field :name, type: String
+  field :friends, type: list(User)
+  field :posts, type: list(Post)
+end
 ```
 
+## Notes
+
+A model has type-checked fields.
+
+This class can be used to create a flexible and type-safe representation of
+JSON data. It provides a convenient way to create and validate data models
+in Ruby, making it easier to build complex applications.
+
+The Model class extends the built-in Hash class and is designed to enforce
+type constraints on data objects that can be created from JSON snapshots. It
+defines custom syntax for declaring and validating fields, with support for
+common data types suchs enums, lists, and nullable types.
+
+Example usage
+
+    class Person < Model
+      field %{name}, type: String
+      field %{gender}, type: (enum :male, :female)
+      field %{age}, type: 1..100
+    end
+
+    anna = Person.new(
+      name: 'Anna',
+      gender: :female,
+      age: 29,
+    )
+
+Type checking in the Model framework is based on a combination of built-in
+Ruby functionality and custom matchers that are optimized for working with
+complex data structures.
+
+- The framework relies on the === operator, which is a built-in method in
+  Ruby that checks whether a given value is a member of a class or matches
+  a pattern, such as a regular-expression or a range of numbers
+- In addition the framework provides a set of custom matchers that are
+  optimized for working with more complex data structures. These matchers
+  include support for lists, nullable types, enumerations, and more.
+
+Another way to extend the type checking capabilities is by subclassing the
+Matcher class. This allows developers to create custom matchers that can
+validate complex data structures or enforce domain-specific rules on the
+values of fields in a model. This provides a powerful extension point that
+allows developers to meet the needs of their specific use cases, and can
+help ensure data quality and consistency in their applications.
+
+Customizing serialization is an important aspect of working with data models,
+and the Model framework provides a flexible way to achieve this through the
+to_json and from_snapshot methods. These methods allow developers to control
+how data is represented in JSON format, which can be important ensure that
+the serialized data is compatible with external systems or APIs.
+
+In summary, the Model framework provides a powerful and flexible way to
+define and enforce the structure of data models in a Ruby application, and
+offers a variety of extension points for customizing the behavior of the
+framework to meet the needs of specific use cases.
+
+Hackety hacking, frens!
+
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at [link to GitHub repo](https://github.com/yourusername/your-repo).  This project encourages collaboration and appreciates contributions. Feel free to contribute to the project by reporting bugs or submitting pull requests.
+Bug reports and pull requests are welcome on GitHub at [link to GitHub repo](https://github.com/akuhn/hamachi).  This project encourages collaboration and appreciates contributions. Feel free to contribute to the project by reporting bugs or submitting pull requests.
 
 ## License
 

data/lib/hamachi/ext.rb

@@ -0,0 +1,3 @@
+require 'hamachi/source/enumerable_ext'
+
+Enumerable.include Hamachi::EnumerableExt

data/lib/hamachi/model.rb

@@ -1,284 +1,3 @@
-require 'json'
+require 'hamachi'
 
-# A model has type-checked fields.
-#
-# This class can be used to create a flexible and type-safe representation of
-# JSON data. It provides a convenient way to create and validate data models
-# in Ruby, making it easier to build complex applications.
-#
-# The Model class extends the built-in Hash class and is designed to enforce
-# type constraints on data objects that can be created from JSON snapshots. It
-# defines custom syntax for declaring and validating fields, with support for
-# common data types suchs enums, lists, and nullable types.
-#
-# Example usage
-#
-#   class Person < Model
-#     field %{name}, type: String
-#     field %{gender}, type: (enum :male, :female)
-#     field %{age}, type: 1..100
-#   end
-#
-#   anna = Person.new(
-#     name: 'Anna',
-#     gender: :female,
-#     age: 29,
-#   )
-#
-# Type checking in the Model framework is based on a combination of built-in
-# Ruby functionality and custom matchers that are optimized for working with
-# complex data structures.
-#
-# - The framework relies on the === operator, which is a built-in method in
-#   Ruby that checks whether a given value is a member of a class or matches
-#   a pattern, such as a regular-expression or a range of numbers
-# - In addition the framework provides a set of custom matchers that are
-#   optimized for working with more complex data structures. These matchers
-#   include support for lists, nullable types, enumerations, and more.
-#
-# Another way to extend the type checking capabilities is by subclassing the
-# Matcher class. This allows developers to create custom matchers that can
-# validate complex data structures or enforce domain-specific rules on the
-# values of fields in a model. This provides a powerful extension point that
-# allows developers to meet the needs of their specific use cases, and can
-# help ensure data quality and consistency in their applications.
-#
-# Customizing serialization is an important aspect of working with data models,
-# and the Model framework provides a flexible way to achieve this through the
-# to_json and from_snapshot methods. These methods allow developers to control
-# how data is represented in JSON format, which can be important ensure that
-# the serialized data is compatible with external systems or APIs.
-#
-# In summary, the Model framework provides a powerful and flexible way to
-# define and enforce the structure of data models in a Ruby application, and
-# offers a variety of extension points for customizing the behavior of the
-# framework to meet the needs of specific use cases.
-#
-# Hackety hacking, frens!
-#
-#
-
-
-class Hamachi::Model < Hash
-
-  NULL = Object.new
-
-  def initialize(snapshot, options = {})
-    update(snapshot) unless options.fetch(:ignore_undeclared_fields, false)
-
-    self.class.fields.each do |name, field|
-      value = snapshot.fetch(name, field.default_value)
-      self[name] = field.from_snapshot(value, options)
-    end
-
-    check_types if options.fetch(:check_types, true)
-    freeze if options.fetch(:freeze, false)
-  end
-
-  def self.from_snapshot(snapshot, options = {})
-    return snapshot unless Hash === snapshot
-    unless snapshot.keys.all? { |name| Symbol === name }
-      raise "expected names to be symbols, got other"
-    end
-    self.new snapshot, options
-  end
-
-  def self.from_json(str)
-    snapshot = JSON.parse str, symbolize_names: true
-    self.from_snapshot(snapshot, {})
-  end
-
-  def check_types
-    self.class.fields.each do |name, field|
-      if not field === self[name]
-        raise "expected #{name} to be #{field}, got #{self[name].inspect}"
-      end
-    end
-  end
-
-  def prune_default_values
-    self.class.fields.each do |name, field|
-      case value = self[name]
-      when field.default_value
-        self.delete(name)
-      when Model
-        value.prune_default_values
-      when Array
-        value.each { |each| each.prune_default_values if Model === each }
-      end
-    end
-
-    return self
-  end
-
-  def self.fields
-    @fields ||= {}
-  end
-
-  def self.field(name, options)
-    raise "expected #{name} to be undefined, got method" if method_defined?(name.to_sym)
-
-    field = options.fetch(:type)
-    field = Matcher.new(field) unless Matcher === field
-    field.initialize_options(options).freeze
-    self.fields[name.to_sym] = field
-
-    class_eval %{
-      def #{name}
-        self[:#{name}]
-      end
-    }
-
-    class_eval %{
-      def #{name}=(value)
-        field = self.class.fields[:#{name}]
-        if not field === value
-          raise "expected #{name} to be \#{field}, got \#{value.inspect}"
-        end
-        self[:#{name}] = value
-      end
-    }
-  end
-
-  def self.define(&block) # for anonymous inline models
-    Class.new Hamachi::Model, &block
-  end
-
-  def self.to_s
-    name ? name : "model(#{fields.map { |name, field| "#{name}:#{field}"}.join(',')})"
-  end
-
-
-  # --- Helper methods for type declarations ------------------
-
-  def self.enum(*symbols)
-    EnumMatcher.new(symbols)
-  end
-
-  def self.list(type)
-    ListMatcher.new(type)
-  end
-
-  def self.nullable(type)
-    NullableMatcher.new(type)
-  end
-
-  def self.model(&block)
-    Hamachi::Model.define(&block)
-  end
-
-  def self.positive(type)
-    PositiveMatcher.new(type)
-  end
-
-  def self.positive_or_zero(type)
-    PositiveOrZeroMatcher.new(type)
-  end
-
-
-  # --- Matcher classes ---------------------------------------
-
-  class Matcher
-    def initialize(type)
-      @type = type
-    end
-
-    def initialize_options(options)
-    end
-
-    def ===(value)
-      @type === value
-    end
-
-    def default_value
-      nil
-    end
-
-    def to_s
-      @type.to_s
-    end
-
-    def from_snapshot(data, options)
-      if @type == Symbol
-        data.to_sym if data
-      elsif Class === @type && @type.respond_to?(:from_snapshot)
-        @type.from_snapshot(data, options)
-      else
-        data
-      end
-    end
-  end
-
-  class EnumMatcher < Matcher
-    def ===(value)
-      @type.any? { |each| each === value }
-    end
-
-    def to_s
-      "enum(#{@type.map(&:inspect).join(', ')})"
-    end
-
-    def from_snapshot(data, options)
-      String === data ? data.to_sym : data
-    end
-  end
-
-  class ListMatcher < Matcher
-    def initialize_options(options)
-      @option_empty = options.fetch(:empty, true)
-    end
-
-    def ===(value)
-      return false unless Array === value
-      return false if value.empty? unless @option_empty
-      value.all? { |each| @type === each }
-    end
-
-    def default_value
-      []
-    end
-
-    def to_s
-      "list(#{@type}#{', empty: false' unless @option_empty})"
-    end
-
-    def from_snapshot(data, options)
-      data && data.map { |each| super(each, options) }
-    end
-  end
-
-  class NullableMatcher < Matcher
-    def ===(value)
-      @type === value || value.nil?
-    end
-
-    def to_s
-      "nullable(#{@type})"
-    end
-  end
-
-  class PositiveMatcher < Matcher
-    def ===(value)
-      @type === value && value.positive?
-    end
-
-    def to_s
-      "positive(#{@type})"
-    end
-  end
-
-  # FIXME: make this matcher class a module that can be included here
-
-  class PositiveOrZeroMatcher < Matcher
-    def ===(value)
-      @type === value && !value.negative?
-    end
-
-    def to_s
-      "positive_or_zero(#{@type})"
-    end
-  end
-
-  Boolean = enum(true, false)
-  Timestamp = Regexp.new(/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\d\d\dZ$/)
-end
+Model = Hamachi::Model

data/lib/hamachi/source/enumerable_ext.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Extension for arrays and other enumerables. It provides convenient and
+# reusable functionality to manipulate and analyze enumerable objects in
+# a concise and expressive manner.
+
+
+module Hamachi
+  module EnumerableExt
+    def index_by
+      raise unless block_given?
+
+      index = Hash.new
+      self.each { |each| index[yield each] = each }
+      index
+    end
+
+    def freq
+      h = Hash.new(0)
+      if block_given?
+        each { |each| h[yield each] += 1 }
+      else
+        each { |each| h[each] += 1 }
+      end
+      h.sort_by(&:last).to_h
+    end
+
+    def where(patterns)
+      each.select { |each| patterns.all? { |symbol, pattern| pattern === each.send(symbol) }}
+    end
+
+    def wherent(patterns)
+      each.reject { |each| patterns.all? { |symbol, pattern| pattern === each.send(symbol) }}
+    end
+  end
+end

data/lib/hamachi/source/field.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+
+module Hamachi
+
+  class Field
+    def initialize(type)
+      @type = type
+    end
+
+    def initialize_options(options)
+    end
+
+    def ===(value)
+      @type === value
+    end
+
+    def default_value
+      nil
+    end
+
+    def to_s
+      @type.to_s
+    end
+
+    def from_snapshot(data, options = nil)
+      if @type == Symbol
+        data.to_sym if data
+      elsif Class === @type && @type.respond_to?(:from_snapshot)
+        @type.from_snapshot(data, options)
+      else
+        data
+      end
+    end
+  end
+
+  class EnumField < Field
+    def initialize(*symbols)
+      super symbols
+    end
+
+    def ===(value)
+      @type.any? { |each| each === value }
+    end
+
+    def to_s
+      "enum(#{@type.map(&:inspect).join(?,)})"
+    end
+
+    def from_snapshot(data, options)
+      String === data ? data.to_sym : data
+    end
+  end
+
+  class ListField < Field
+    def initialize_options(options)
+      @option_empty = options.fetch(:empty, true)
+    end
+
+    def ===(value)
+      return false unless Array === value
+      return false if value.empty? unless @option_empty
+      value.all? { |each| @type === each }
+    end
+
+    def default_value
+      []
+    end
+
+    def to_s
+      "list(#{@type}#{', empty: false' unless @option_empty})"
+    end
+
+    def from_snapshot(data, options)
+      data && data.map { |each| super(each, options) }
+    end
+  end
+
+  class NullableField < Field
+    def ===(value)
+      @type === value || value.nil?
+    end
+
+    def to_s
+      "nullable(#{@type})"
+    end
+  end
+end

data/lib/hamachi/source/model.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'json'
+
+
+module Hamachi
+  class Model < Hash
+
+    # ------- schema declaration ---------------------------------------
+
+    def self.fields
+      @fields ||= {}
+    end
+
+    def self.field(name, options)
+      raise ArgumentError, "method ##{name} already defined" if method_defined?(name)
+      raise ArgumentError, "method ##{name}= already defined" if method_defined?("#{name}=")
+
+      field = options.fetch(:type)
+      field = Field.new(field) unless Field === field
+      field.initialize_options(options).freeze
+      self.fields[name.to_sym] = field
+
+      class_eval %{
+        def #{name}
+          self[:#{name}]
+        end
+      }
+
+      class_eval %{
+        def #{name}=(value)
+          field = self.class.fields[:#{name}]
+          if not field === value
+            raise "expected #{name} to be \#{field}, got \#{value.inspect}"
+          end
+          self[:#{name}] = value
+        end
+      }
+
+      return self
+    end
+
+    def self.schema(&block) # for anonymous inline models
+      Class.new Hamachi::Model, &block
+    end
+
+    def self.to_s
+      name ? name : "schema(#{fields.map { |name, field| "#{name}:#{field}"}.join(',')})"
+    end
+
+    def self.register_type(name, field_class)
+      singleton_class.send(:define_method, name) do |*args|
+        field_class.new(*args)
+      end
+    end
+
+    register_type :list, ListField
+    register_type :nullable, NullableField
+    register_type :enum, EnumField
+
+    Boolean = enum(true, false)
+
+
+    # ------- initialization -------------------------------------------
+
+    def initialize(snapshot, options = {})
+      update(snapshot) if options.fetch(:include_unknown_fields, true)
+
+      self.class.fields.each do |name, field|
+        value = snapshot.fetch(name, field.default_value)
+        self[name] = field.from_snapshot(value, options)
+      end
+
+      validate_fields! if options.fetch(:validate_fields, true)
+      freeze if options.fetch(:freeze, false)
+    end
+
+    def self.from_snapshot(snapshot, options = {})
+      return snapshot unless Hash === snapshot
+      self.new snapshot, options
+    end
+
+    def self.parse(string, options = {})
+      snapshot = JSON.parse(string, symbolize_names: true)
+      if Array === snapshot
+        snapshot.map { |each| from_snapshot each, options }
+      else
+        from_snapshot snapshot, options
+      end
+    end
+
+
+    # ------- validation -----------------------------------------------
+
+    def valid?
+      gen_error_messages { return false }
+      return true
+    end
+
+    def validate_fields!
+      gen_error_messages { |error| raise error }
+    end
+
+    private
+
+    def gen_error_messages
+      self.class.fields.each do |name, field|
+        if not field === self[name]
+          yield "expected #{name} to be #{field}, got #{self[name].inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/hamachi/version.rb

@@ -1,5 +1,32 @@
 # frozen_string_literal: true
 
 module Hamachi
-  VERSION = "0.1.0"
+  VERSION = "0.3.1"
 end
+
+__END__
+
+# Major version bump when breaking changes or new features
+# Minor version bump when backward-compatible changes or enhancements
+# Patch version bump when backward-compatible bug fixes, security updates etc
+
+
+0.3.1
+
+- Rename check_types to valid? and validate_fields!
+- Reorganize tests and write more tests
+
+0.3.0
+
+- Rename Matcher class to Field class
+- Rename Model.register_matcher to Model.register_type
+
+0.2.0
+
+- Require 'hamachi/model' to import model as top-level constant
+- Require 'hamachi/ext' to extend arrays and other enumerables
+- New function Model.register_matcher
+
+0.1.0
+
+- Initial import from internal project.

data/lib/hamachi.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "hamachi/version"
-require "hamachi/model"
-
-
-module Hamachi
-  # pass
-end
+require 'hamachi/version'
+require 'hamachi/source/field'
+require 'hamachi/source/model'

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: hamachi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Adrian Kuhn
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-02 00:00:00.000000000 Z
+date: 2023-06-10 00:00:00.000000000 Z
 dependencies: []
-description:
+description: 
 email:
 - akuhn@iam.unibe.ch
 executables: []
@@ -19,7 +19,11 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/hamachi.rb
+- lib/hamachi/ext.rb
 - lib/hamachi/model.rb
+- lib/hamachi/source/enumerable_ext.rb
+- lib/hamachi/source/field.rb
+- lib/hamachi/source/model.rb
 - lib/hamachi/version.rb
 homepage: https://github.com/akuhn/hamachi
 licenses: []
@@ -27,7 +31,7 @@ metadata:
   homepage_uri: https://github.com/akuhn/hamachi
   source_code_uri: https://github.com/akuhn/hamachi
   changelog_uri: https://github.com/akuhn/hamachi/blob/master/lib/hamachi/version.rb
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -42,8 +46,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: Flexible and type-safe representation of JSON data.
 test_files: []