ruby-optics 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c5a90f6ad934879e9b5522055637df2dc1386b6931c8c69ab7474f5dd1ba5591
+  data.tar.gz: f165845f3ac79940f54071fa66dcbf673157af38dd69ae0094b89acb1c89326c
+SHA512:
+  metadata.gz: 70ee1a8f3f1be4e7f4401c937dea535e19e85f7d39d6e54418fb48c6df93c4d81ac1e5bb1748df0ab6c1f033b6550d96b5a9073256643cd30c45d089b825c99b
+  data.tar.gz: 0f9b3bd70954701427f663839c56a1ae00f35f1592efbf07a87bb956c41ae8938fab9f9df9a484531fe8e6b3884d526ddca379151a2d7cd70f41585063fae2b1

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Daniil Bober
+
+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,15 @@
+# ruby-optics
+
+Simple library with common functional optics for Ruby.
+
+## Links
+
+## Supported Ruby versions
+
+This library officially supports the following Ruby versions:
+
+* MRI >= `2.5.1`
+
+## License
+
+See `LICENSE` file.

data/lib/ruby-optics.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'ruby-optics/optics'
+require 'ruby-optics/record/record'
+
+module Optics
+  VERSION = "0.0.1"
+end

data/lib/ruby-optics/each.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class Each
+  attr_reader :inner_focus
+  attr_reader :outer_focus
+  attr_reader :filter
+
+  Filter = Struct.new(:focus, :blk) do
+    def call(object)
+      blk.(focus.get(object))
+    end
+  end
+
+  def initialize(outer_focus = nil, inner_focus = nil, filter = nil)
+    @outer_focus = outer_focus || Lens.identity
+    @inner_focus = inner_focus || Lens.identity
+    @filter = filter
+  end
+
+  def set(new_value, object)
+    modify_all(object) { |_| new_value }
+  end
+
+  def modify_all(object, &blk)
+    outer_focus.modify(object) { |enumerable|
+      enumerable.map { |a|
+        if !filter.nil?
+          filter.call(a) ? inner_focus.modify(a, &blk) : a
+        else
+          inner_focus.modify(a, &blk)
+        end
+      }
+    }
+  end
+
+  def get_all(object)
+    filtered(outer_focus.get(object)).map { |a| inner_focus.get(a) }
+  end
+
+  def with_filter(focusing_lens, &blk)
+    Each.new(
+      outer_focus = self.outer_focus,
+      inner_focus = self.inner_focus,
+      filter      = Filter.new(focusing_lens, blk)
+    )
+  end
+
+  def compose_lens(lens)
+    Each.new(
+      outer_focus = self.outer_focus,
+      inner_focus = self.inner_focus.compose_lens(lens),
+      filter      = self.filter
+    )
+  end
+
+  def self.with_filter(focusing_lens, &blk)
+    Each.new.with_filter(focusing_lens, &blk)
+  end
+
+  private
+  
+  def filtered(enumerable)
+    return enumerable if filter.nil? 
+
+    enumerable.select { |object| filter.call(object) }
+  end
+end

data/lib/ruby-optics/lens.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'nullable'
+
+class Lens
+  attr_reader :getter
+  attr_reader :setter
+
+  include NullableOptic
+
+  def initialize(getter, setter)
+    @getter = getter
+    @setter = setter
+  end
+
+  def get(obj)
+    getter.(obj)
+  end
+
+  def set(new_val, obj)
+    setter.(new_val, obj)
+  end
+
+  def modify(obj, &blk)
+    setter.(
+      blk.(getter.(obj)),
+      obj
+    )
+  end
+
+  def compose_lens(other_lense)
+    Lens.new(
+      -> (obj) { other_lense.getter.(getter.(obj)) },
+      -> (new_val, obj) {
+        setter.(
+          other_lense.setter.(
+            new_val,
+            getter.(obj)
+          ),
+          obj
+        )
+      }
+    )
+  end
+
+  def each_lens
+    Each.new(outer_focus = self)
+  end
+
+  def self.identity
+    @_identity ||= Lens.new(
+      -> (obj) { obj },
+      -> (new_val, _obj) { new_val }
+    )
+  end
+end

data/lib/ruby-optics/nullable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module NullableOptic
+  def nullable
+    self.class.new(
+      -> (obj) {
+        if obj.nil?
+          nil
+        else
+          getter.(obj)
+        end
+      },
+
+      -> (new_val, obj) {
+        if obj.nil?
+          nil
+        else
+          setter.(new_val, obj)
+        end
+      }
+    )
+  end
+end

data/lib/ruby-optics/optics.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'lens'
+require_relative 'nullable'
+require_relative 'each'
+
+module Optics
+  def self.hash_lens(*keys)
+    head, *tail = keys
+
+    [build_hash_lens(head), *tail].reduce { |result_lens, key|
+      result_lens.compose_lens(build_hash_lens(key))
+    }
+  end
+
+  def self.indiffirent_access_hash_lens(*keys)
+    head, *tail = keys
+    opts = { indiffirent_access: true }
+
+    [build_hash_lens(head, opts), *tail].reduce { |result_lens, key|
+      result_lens.compose_lens(build_hash_lens(key, opts))
+    }
+  end
+
+  def self.struct_lens(*method_names)
+    head, *tail = method_names
+
+    [build_struct_lens(head), *tail].reduce { |result_lens, key|
+      result_lens.compose_lens(build_struct_lens(key))
+    }
+  end
+
+  private
+
+  def self.build_hash_lens(key, indiffirent_access: false)
+    ::Lens.new(
+      -> (hash) {
+        if indiffirent_access
+          case key
+          when String
+            val = hash[key]
+            val.nil? ? hash[key.to_sym] : val
+          when Symbol
+            val = hash[key]
+            val.nil? ? hash[key.to_s] : val
+          else
+            hash[key]
+          end
+        else
+          hash[key]
+        end
+      },
+      -> (new_value, hash) { hash.merge(key => new_value) }
+    ).nullable
+  end
+
+  def self.build_struct_lens(method_name)
+    ::Lens.new(
+      -> (struct) { struct[method_name] },
+      -> (new_value, struct) {
+        struct.class.new(
+          *struct.members.map { |member|
+            (member == method_name) ? new_value : struct[member]
+          }
+        )
+      }
+    )
+  end
+end

data/lib/ruby-optics/record/record.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'record_lens'
+
+module Record
+  def initialize(args_hash)
+    defined_attributes = self.class.instance_variable_get(
+      :"@_record_attributes_defs"
+    ) || []
+    
+    defined_attributes.each do |defined_attribute_params|
+      attribute_name = defined_attribute_params[:attribute_name]
+      attribute_argument = args_hash[attribute_name]
+      if attribute_argument.nil?
+        if defined_attribute_params[:nullable]
+          instance_variable_set(
+            :"@#{attribute_name}",
+            defined_attribute_params[:default]
+          )
+        else
+          raise ArgumentError.new(
+            "Attribute with name #{attribute_name} is not provided"
+          )
+        end
+      else
+        instance_variable_set(
+          :"@#{attribute_name}",
+          attribute_argument
+        )
+      end
+    end
+  end
+
+  def copy_with(args_hash)
+    self.class.new(
+      _current_attributes.merge(
+        args_hash.reject { |k, v| !_current_attributes.keys.include?(k) }
+      )
+    )
+  end
+
+  def ==(another_record)
+    return false unless another_record.is_a?(self.class)
+  
+    another_record_attributes = another_record.send(:_current_attributes)
+
+    _current_attributes == another_record_attributes
+  end
+
+  alias_method :eql?, :==
+
+  def hash
+    [self.class, _current_attributes].hash
+  end
+
+  def self.included(base)
+    base.define_singleton_method(:attribute) do |attribute_name, nullable: false, default: nil|
+      @_record_attributes_defs ||= []
+      @_record_attributes_defs << {
+        attribute_name: attribute_name,
+        nullable:       nullable,
+        default:        default
+      }
+
+      base.attr_reader(attribute_name)
+    end
+
+    base.instance_variable_set(:"@_lenses", {})
+
+    base.define_singleton_method(:lens) do |*attribute_names|
+      head, *tail = attribute_names
+      fst_lens = (@_lenses[head] ||= RecordLens.build(head))
+
+      return fst_lens if tail.empty?
+
+      [fst_lens, *tail].reduce { |result_lens, attribute_name|
+        result_lens.compose_lens(RecordLens.build(attribute_name))
+      }
+    end
+  end
+
+  private
+
+  def _current_attributes
+    defined_attributes = self.class.instance_variable_get(
+      :"@_record_attributes_defs"
+    ) || []
+
+    defined_attributes
+      .map { |attribute_params| attribute_params[:attribute_name] }
+      .map { |attr_name| [attr_name, instance_variable_get(:"@#{attr_name}")] }
+      .to_h
+  end
+end

data/lib/ruby-optics/record/record_lens.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RecordLens
+  def self.build(attribute_name)
+    Lens.new(
+      -> (record) { record.send(attribute_name) },
+      -> (new_attr_value, record) {
+        record.copy_with(attribute_name => new_attr_value)
+      }
+    )
+  end
+end

data/ruby-optics.gemspec

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'ruby-optics'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ruby-optics'
+  spec.authors       = ["Daniil Bober"]
+  spec.email         = ["cardinal.ximinez.again@gmail.com"]
+  spec.license       = 'MIT'
+  spec.version       = Optics::VERSION.dup
+  spec.homepage      = "https://github.com/boberdaniil/ruby-optics"
+  spec.summary       = "Common optics for Ruby"
+  spec.description   = spec.summary
+  spec.files         = Dir["LICENSE", "README.md", "ruby-optics.gemspec", "lib/**/*"]
+  spec.bindir        = 'bin'
+  spec.executables   = []
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = ">= 2.4.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: ruby-optics
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniil Bober
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Common optics for Ruby
+email:
+- cardinal.ximinez.again@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/ruby-optics.rb
+- lib/ruby-optics/each.rb
+- lib/ruby-optics/lens.rb
+- lib/ruby-optics/nullable.rb
+- lib/ruby-optics/optics.rb
+- lib/ruby-optics/record/record.rb
+- lib/ruby-optics/record/record_lens.rb
+- ruby-optics.gemspec
+homepage: https://github.com/boberdaniil/ruby-optics
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Common optics for Ruby
+test_files: []