prop_initializer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 29c51456a07fe5ba7a95870bb2cb7e1a1b586b845c0a74878d3b273bee8dbaae
+  data.tar.gz: a670f466ba0374a53a2f642de194317713a92ea1b081e777f509f354d56a5a67
+SHA512:
+  metadata.gz: d99b4d83625d31aa5c900fc54f3f9251cc7ec389ee11d16bc9d770e736816fc1f549876727500f1a68a53a1e12346ca6637db592457dbd8857ea126f9a45da77
+  data.tar.gz: f68cf05fcc1701e3ca85088b9e41f88622eaf071b20f93d949027899e768aeba05151a364d5e9455472c5e1410c2e93d2429c7060792f5147f424d2b3b213357

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Paul Bob
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# PropInitializer
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "prop_initializer"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install prop_initializer
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/prop_initializer/null.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PropInitializer::Null
+	def self.inspect
+		"PropInitializer::Null"
+	end
+
+	freeze
+end

data/lib/prop_initializer/properties/schema.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# @api private
+class PropInitializer::Properties::Schema
+	include Enumerable
+
+	def initialize(properties_index: {}, sorted_properties: [])
+		@properties_index = properties_index
+		@sorted_properties = sorted_properties
+		@mutex = Mutex.new
+	end
+
+	attr_reader :properties_index
+
+	def [](key)
+		@properties_index[key]
+	end
+
+	def <<(value)
+		@mutex.synchronize do
+			@properties_index[value.name] = value
+			# ruby's sort is unstable, this trick makes it stable
+			n = 0
+			@sorted_properties = @properties_index.values.sort_by! { |it| n += 1; [it, n] }
+		end
+
+		self
+	end
+
+	def dup
+		self.class.new(
+			properties_index: @properties_index.dup,
+			sorted_properties: @sorted_properties.dup,
+		)
+	end
+
+	def each(&)
+		@sorted_properties.each(&)
+	end
+
+	def size
+		@sorted_properties.size
+	end
+
+	def generate_initializer(buffer = +"")
+		buffer << "def initialize(#{generate_initializer_params})\n"
+		generate_initializer_body(buffer)
+		buffer << "" \
+			"  after_initialize if respond_to?(:after_initialize)\n" \
+			"end\n"
+	end
+
+	def generate_to_h(buffer = +"")
+		buffer << "def to_h\n" << "  {\n"
+
+		sorted_properties = @sorted_properties
+		i, n = 0, sorted_properties.size
+		while i < n
+			property = sorted_properties[i]
+			buffer << "    " << property.name.name << ": @" << property.name.name << ",\n"
+			i += 1
+		end
+
+		buffer << "  }\n" << "end\n"
+	end
+
+	private
+
+	def generate_initializer_params(buffer = +"")
+		sorted_properties = @sorted_properties
+		i, n = 0, sorted_properties.size
+		while i < n
+			property = sorted_properties[i]
+
+			case property.kind
+			when :*
+				buffer << "*" << property.escaped_name
+			when :**
+				buffer << "**" << property.escaped_name
+			when :&
+				buffer << "&" << property.escaped_name
+			when :positional
+				if property.default?
+					buffer << property.escaped_name << " = PropInitializer::Null"
+				else
+					buffer << property.escaped_name << " = nil"
+				end
+			when :keyword
+				if property.default?
+					buffer << property.name.name << ": PropInitializer::Null"
+				else
+					buffer << property.name.name << ": nil"
+				end
+			else
+				raise "You should never see this error."
+			end
+
+			i += 1
+			buffer << ", " if i < n
+		end
+
+		buffer
+	end
+
+	def generate_initializer_body(buffer = +"")
+		buffer << "  properties = self.class.prop_initializer_properties.properties_index\n"
+		generate_initializer_handle_properties(@sorted_properties, buffer)
+	end
+
+	def generate_initializer_handle_properties(properties, buffer = +"")
+		i, n = 0, properties.size
+		while i < n
+			properties[i].generate_initializer_handle_property(buffer)
+			i += 1
+		end
+
+		buffer
+	end
+end

data/lib/prop_initializer/properties.rb

@@ -0,0 +1,83 @@
+module PropInitializer::Properties
+  def prop(name, kind: :keyword, reader: false, writer: false, predicate: false, default: nil, &coercion)
+    if default && !(Proc === default || default.frozen?)
+      raise ArgumentError.new("The default must be a frozen object or a Proc.")
+    end
+
+    unless PropInitializer::Property::VISIBILITY_OPTIONS.include?(reader)
+      raise ArgumentError.new("The reader must be one of #{PropInitializer::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+    end
+
+    unless PropInitializer::Property::VISIBILITY_OPTIONS.include?(writer)
+      raise ArgumentError.new("The writer must be one of #{PropInitializer::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+    end
+
+    unless PropInitializer::Property::VISIBILITY_OPTIONS.include?(predicate)
+        raise ArgumentError.new(p"The predicate must be one of #{PropInitializer::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+    end
+
+    if reader && :class == name
+      raise ArgumentError.new(
+        "The `:class` property should not be defined as a reader because it breaks Ruby's `Object#class` method, which PropInitializer itself depends on.",
+      )
+    end
+
+    unless PropInitializer::Property::KIND_OPTIONS.include?(kind)
+      raise ArgumentError.new("The kind must be one of #{PropInitializer::Property::KIND_OPTIONS.map(&:inspect).join(', ')}.")
+    end
+
+    property = __prop__initializer_property_class__.new(
+      name:,
+      kind:,
+      reader:,
+      writer:,
+      predicate:,
+      default:,
+      coercion:,
+    )
+
+    prop_initializer_properties << property
+    __define_prop_initializer_methods__(property)
+    include(__prop__initializer_extension__)
+  end
+
+  def prop_initializer_properties
+    return @prop_initializer_properties if defined?(@prop_initializer_properties)
+
+    if superclass.is_a?(PropInitializer)
+      @prop_initializer_properties = superclass.prop_initializer_properties.dup
+    else
+      @prop_initializer_properties = PropInitializer::Properties::Schema.new
+    end
+  end
+
+  private
+
+  def __prop__initializer_property_class__
+    PropInitializer::Property
+  end
+
+  def __define_prop_initializer_methods__(new_property)
+    __prop__initializer_extension__.module_eval(
+      __generate_prop_initializer_methods__(new_property),
+    )
+  end
+
+  def __prop__initializer_extension__
+    if defined?(@__prop__initializer_extension__)
+      @__prop__initializer_extension__
+    else
+      @__prop__initializer_extension__ = Module.new
+    end
+  end
+
+  def __generate_prop_initializer_methods__(new_property, buffer = +"")
+    buffer << "# frozen_string_literal: true\n"
+    prop_initializer_properties.generate_initializer(buffer)
+    prop_initializer_properties.generate_to_h(buffer)
+    new_property.generate_writer_method(buffer) if new_property.writer
+    new_property.generate_reader_method(buffer) if new_property.reader
+    new_property.generate_predicate_method(buffer) if new_property.predicate
+    buffer
+  end
+end

data/lib/prop_initializer/property.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+class PropInitializer::Property
+	ORDER = { :positional => 0, :* => 1, :keyword => 2, :** => 3, :& => 4 }.freeze
+	RUBY_KEYWORDS = %i[alias and begin break case class def do else elsif end ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield].to_h { |k| [k, "__#{k}__"] }.freeze
+
+	VISIBILITY_OPTIONS = Set[false, :private, :protected, :public].freeze
+	KIND_OPTIONS = Set[:positional, :*, :keyword, :**, :&].freeze
+
+	include Comparable
+
+	def initialize(name:, kind:, reader:, writer:, predicate:, default:, coercion:)
+		@name = name
+		@kind = kind
+		@reader = reader
+		@writer = writer
+		@predicate = predicate
+		@default = default
+		@coercion = coercion
+	end
+
+	attr_reader :name, :kind, :reader, :writer, :predicate, :default, :coercion
+
+	def optional?
+		default?
+	end
+
+	def required?
+		!optional?
+	end
+
+	def keyword?
+		@kind == :keyword
+	end
+
+	def positional?
+		@kind == :positional
+	end
+
+	def splat?
+		@kind == :*
+	end
+
+	def double_splat?
+		@kind == :**
+	end
+
+	def block?
+		@kind == :&
+	end
+
+	def default?
+		nil != @default
+	end
+
+	def param
+		case @kind
+		when :*
+			"*#{escaped_name}"
+		when :**
+			"**#{escaped_name}"
+		when :&
+			"&#{escaped_name}"
+		when :positional
+			escaped_name
+		when :keyword
+			"#{@name.name}:"
+		else
+			raise "You should never see this error."
+		end
+	end
+
+	def <=>(other)
+		ORDER[@kind] <=> ORDER[other.kind]
+	end
+
+	def coerce(value, context:)
+		context.instance_exec(value, &@coercion)
+	end
+
+	def ruby_keyword?
+		!!RUBY_KEYWORDS[@name]
+	end
+
+	def escaped_name
+		RUBY_KEYWORDS[@name] || @name.name
+	end
+
+	def default_value
+		case @default
+			when Proc then @default.call
+			else @default
+		end
+	end
+
+	def generate_reader_method(buffer = +"")
+		buffer <<
+			(@reader ? @reader.name : "public") <<
+			"\ndef " <<
+			@name.name <<
+			"\n  value = @" <<
+			@name.name <<
+			"\n  value\nend\n"
+	end
+
+	def generate_writer_method(buffer = +"")
+		buffer <<
+			(@writer ? @writer.name : "public") <<
+			" def " <<
+			@name.name <<
+			"=(value)\n" <<
+			"  @#{@name.name} = value\nend\n"
+	end
+	
+	def generate_predicate_method(buffer = +"")
+		buffer <<
+			(@predicate ? @predicate.name : "public") <<
+			" def " <<
+			@name.name <<
+			"?\n" <<
+			"  !!@" <<
+			@name.name <<
+			"\n" <<
+			"end\n"
+	end
+
+	def generate_initializer_handle_property(buffer = +"")
+		buffer << "  # " << @name.name << "\n" <<
+			"  property = properties[:" << @name.name << "]\n"
+
+		if @kind == :keyword && ruby_keyword?
+			generate_initializer_escape_keyword(buffer)
+		end
+
+		if default?
+			generate_initializer_assign_default(buffer)
+		end
+
+		if @coercion
+			generate_initializer_coerce_property(buffer)
+		end
+
+		generate_initializer_assign_value(buffer)
+	end
+
+	private
+
+	def generate_initializer_escape_keyword(buffer = +"")
+		buffer <<
+			escaped_name <<
+			" = binding.local_variable_get(:" <<
+			@name.name <<
+			")\n"
+	end
+
+	def generate_initializer_coerce_property(buffer = +"")
+		buffer <<
+			escaped_name <<
+			"= property.coerce(" <<
+			escaped_name <<
+			", context: self)\n"
+	end
+
+	def generate_initializer_assign_default(buffer = +"")
+		buffer <<
+			"  if " <<
+			((@kind == :&) ? "nil" : "PropInitializer::Null") <<
+			" == " <<
+			escaped_name <<
+			"\n    " <<
+			escaped_name <<
+			" = property.default_value\n  end\n"
+	end
+
+	def generate_initializer_assign_value(buffer = +"")
+		buffer <<
+			"  @" <<
+			@name.name <<
+			" = " <<
+			escaped_name <<
+			"\n"
+	end
+end

data/lib/prop_initializer/railtie.rb

@@ -0,0 +1,4 @@
+module PropInitializer
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/prop_initializer/version.rb

@@ -0,0 +1,3 @@
+module PropInitializer
+  VERSION = "0.1.0"
+end

data/lib/prop_initializer.rb

@@ -0,0 +1,11 @@
+require "prop_initializer/version"
+require "prop_initializer/railtie"
+
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module PropInitializer
+  # Your code goes here...
+end

data/lib/tasks/prop_initializer_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :prop_initializer do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: prop_initializer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Bob
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.18
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.18
+description: PropInitializer provides an easy way to define properties for Ruby classes
+  with options for defaults and customization. It simplifies the Literal gem's functionality
+  by removing strict type requirements and adapting the initializer process for flexibility.
+email:
+- paul.ionut.bob@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/prop_initializer.rb
+- lib/prop_initializer/null.rb
+- lib/prop_initializer/properties.rb
+- lib/prop_initializer/properties/schema.rb
+- lib/prop_initializer/property.rb
+- lib/prop_initializer/railtie.rb
+- lib/prop_initializer/version.rb
+- lib/tasks/prop_initializer_tasks.rake
+homepage: https://github.com/avo-hq/prop_initializer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/avo-hq/prop_initializer
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.5
+signing_key: 
+specification_version: 4
+summary: A flexible property initializer for Ruby classes inspired by the Literal
+  gem.
+test_files: []