modeling 0.0.5 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3cc5b79ca0d36340e35381ab51d1b4d09486812bb8479267128a557e0130c01
-  data.tar.gz: b8ff810f7317108cbf1b8ef7290355041a8d29d20ecb3a57ad47f66fd3edc2f2
+  metadata.gz: b86aef2212da331d45efd4c2d32352647c876f25f4379772496398c3880c2af6
+  data.tar.gz: 8def3789e08b6f41a3a7c72df81f4e967f95e8e37eb4412d6578ba66a943b654
 SHA512:
-  metadata.gz: 6044d7ac29c9b23834aa7a848dc10c11430be05262bcaab38ad5417ee7a605d515a1d66bce01f6ff639750e566826856e39ed4aa46a33ffb26f36b71011970bb
-  data.tar.gz: 3a94d368fc0e022e2aaffccfb10247cfab48a7df9da53150a7a618b21cac7c529dbe906cd8c36169831dd499a9db93e586947147528ec4d17aba67260eb15341
+  metadata.gz: d6787537af7b26e954b46fca5ab1bdb3787bf6d0b411462a3dc866eb604328dc881ccb65b1b177957d47be721a53ec63cf5a598a64293c665a228e5dcf6acdc6
+  data.tar.gz: 1648de4591f2f127ad829e8e0a490ef6600f1fae0467534d9104286978b50c04cc3a4ff1be382fc2ffc7390e9822e026c2987f16704a047a14778aaa75f16545

data/lib/modeling/model_field.rb

@@ -1,23 +1,27 @@
 module Modeling
+  class Exception < ::Exception
+  end
+
   class ModelField
-    def initialize name, filter, create_attr, writer, reader, tester
+    def initialize name, initialize_argument, instance_variable, writer, reader, tester
       @name = name
-      @filter = filter
-      @create_attr = create_attr
+      @initialize_argument = initialize_argument
+      @instance_variable = instance_variable
       @writer = writer
       @reader = reader
       @tester = tester
+      @instance_variable_name = "@#{name}".to_sym
     end
 
     attr :name
-    attr :filter
+    attr :instance_variable_name
 
-    def attribute_name
-      "@#{name}"
+    def initialize_argument?
+      @initialize_argument
     end
 
-    def create_attr?
-      @create_attr
+    def instance_variable?
+      @instance_variable
     end
 
     def writer?
@@ -37,52 +41,43 @@ module Modeling
         case argument
         when ModelField
           argument
-        when Symbol
-          from_symbol argument, filter
-        when String
-          from_string argument, filter
-        when Array
-          from_array argument, filter
-        when Hash
-          from_hash argument
+        when Symbol, String
+          parse_model_field argument
         else
-          raise "Unsupported argument #{argument}"
+          raise Exception.new "Unsupported argument #{argument} of #{argument.class} class."
         end
       end
 
-      def from_symbol argument, filter
-        at = argument.start_with? "@"
-        bang = argument.end_with? "!"
-        hook = argument.end_with? "?"
-        rail = argument.end_with? "="
-        bald = !(at || bang || hook || rail)
-        name = argument.to_s[/\w+/].to_sym
-        ModelField.new name, filter, bald || hook || at || rail, bald || rail, bald || hook, false
-      end
-
-      def from_string argument, filter
-        if argument =~ /(\w+)\s*(:?\/([traw\s]*))/
-          ModelField.new $1.to_sym, filter, $2.include?("a"), $2.include?("w"), $2.include?("r"), $2.include?("t")
-        else 
-          raise "Invalid argument string format '#{argument}'"
+      def parse_model_field argument
+        initialize_argument = instance_variable = reader = writer = tester = false
+        name_start = (0...argument.length).each do |i|
+          case a = argument[i]
+          when "R" then reader = true
+          when "W" then writer = true
+          when "T" then tester = true
+          when "V" then instance_variable = true
+          when "A" then initialize_argument = true
+          when "@" then instance_variable = initialize_argument = true
+          when "_" then break i + 1
+          else
+            if a.upcase != a
+              break i
+            else raise Exception.new "Invalid model field '#{argument}' - unknown option '#{a}'"
+            end
+          end
+        end
+        case name_start
+        when 0
+          initialize_argument = instance_variable = reader = writer = true
+          name = argument
+        when Integer
+          name = argument[name_start..]
+        else raise Exception.new "Invalid model field '#{argument}' - field name is missing"
         end
-      end
-
-      def from_array argument, filter
-        name = argument.shift.to_sym
-        ModelField.new name, filter, argument.include?(:attr), argument.include?(:writer), 
-          argument.include?(:reader), argument.include?(:tester)
-      end
 
-      def from_hash argument
-        name = argument[:name] || argument.keys.first
-        filter = argument[:filter] || argument[name]
-        parsed = parse name, filter
-        ModelField.new parsed.name, parsed.filter, argument[:attr] || parsed.create_attr?,
-          argument[:writer] || parsed.writer?, argument[:reader] || parsed.reader?,
-          argument[:tester] || parsed.tester?
+        raise Exception.new "Invalid model field #{argument} - field name '#{name}' is invalid" unless name =~ /\w+/
+        ModelField.new name.to_sym, initialize_argument, instance_variable, writer, reader, tester
       end
-
     end
   end
 end

data/lib/modeling/module.rb

@@ -4,59 +4,53 @@ module Modeling
 
   attr_accessor :model_fields
 
-  def model *fields, **filtered_fields, &initializer
-    self.model_fields = model_fields = fields.map{ ModelField.parse _1 } + 
-      filtered_fields.map{ ModelField.parse _1, _2 }
+  def model *fields, &initializer
+    self.model_fields = model_fields = fields.map{ ModelField.parse _1 }
     define_initialize self, &initializer
-    model_fields.each do |f|
-      attr_writer f.name if f.writer?
-      attr_reader f.name if f.reader?
-      attr_tester f.name if f.tester?
+    model_fields.each do |field|
+      attr_writer field.name if field.writer?
+      attr_reader field.name if field.reader?
+      attr_tester "#{field.name}?".to_sym, field.instance_variable_name if field.tester?
     end
   end
+  
+  private
 
-  def attr_tester symbol
-    define_method "#{symbol}?" do
-      !!instance_variable_get(symbol)
+  def attr_tester tester, instance_variable
+    define_method tester do
+      instance_variable_get(instance_variable) ? true : false
     end
   end
-  
-  private
 
-  def self.model_arguments fields, *a, **na
-    fields.zip(a).map do |f, arg| 
-      value = na.key?(f.name) ? na[f.name] : arg
-      if !f.filter.nil? && !(f.filter === value)
-        if f.filter.respond_to? :from
-          value = f.filter.from value
-        else
-          raise ArgumentError.new "#{value}(#{value.class}) does not match #{f.filter}"
-        end
-      end
-      [f.name, value]
+  def self.initialize_arguments fields, *a, **na
+    fields.filter(&:initialize_argument?).zip(a).map do |field, arg| 
+      name = field.name
+      value = na.key?(name) ? na[name] : arg 
+      [name, value]
     end.to_h
   end
 
   def define_initialize initializer_class, &initializer
     define_method :initialize do |*a, **na, &b|
       model_fields = initializer_class.model_fields
-      model_arguments = Modeling.model_arguments model_fields, *a, **na
-      super_call = proc do |*asc, **nasc, &bsc|
-        if asc.empty? && nasc.empty? && !bsc
-          super(*(a[model_arguments.size..] || []), **na.except(*model_arguments.keys), &b)
+      initialize_arguments = Modeling.initialize_arguments model_fields, *a, **na
+      super_initialize = proc do |*as, **nas, &bs|
+        if as.empty? && nas.empty? && !bs
+          super(*(a[initialize_arguments.size..] || []), **na.except(*initialize_arguments.keys), &b)
         else
-          super(*asc, **nasc, &bsc)
+          super(*as, **nas, &bs)
         end
       end
-      model_fields.each do |f|
-        instance_variable_set f.attribute_name, model_arguments[f.name] if f.create_attr?
+      model_fields.each do |field|
+        if field.instance_variable?
+          instance_variable_set field.instance_variable_name, initialize_arguments[field.name]
+        end
       end
       if initializer
-        instance_exec super_call, **model_arguments, &initializer
+        instance_exec super_initialize, **initialize_arguments, &initializer
       else
-        super_call.call
+        super(*(a[initialize_arguments.size..] || []), **na.except(*initialize_arguments.keys), &b)
       end
     end
   end
-
 end

data/lib/modeling/version.rb

@@ -1,3 +1,3 @@
 module Modeling
-  VERSION = "0.0.5"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: modeling
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.1
 platform: ruby
 authors:
 - Łukasz Pomietło
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-20 00:00:00.000000000 Z
+date: 2024-12-04 00:00:00.000000000 Z
 dependencies: []
-description: "  Enables writting class initializers and attribute accessors in one
-  line. \n  Struct class alternative. Keyword & positional arguments mixing. Optional
-  initializer arguments filtering.\n"
+description: "Adds the ability to quickly model classes. Definitions of instance variables
+  and access methods are reduced to one line. \nCreating an instance of the modeled
+  class is significantly slower (~20x), so its use for classes whose instances are
+  created frequently is not recommended.\n"
 email: oficjalnyadreslukasza@gmail.com
 executables: []
 extensions: []
@@ -43,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: A concise way to define the class shape