eigindir 0.0.1

data/lib/eigindir.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require_relative "eigindir/patches"
+require_relative "eigindir/coercer"
+require_relative "eigindir/api"
+
+# Module Eigindir provides PORO attributes declaration and coersion
+#
+# @example
+#   class Foo
+#     include Eigindir
+#
+#     attribute(
+#       :foo,
+#       writer: proc { |val| val.to_i + 1 },
+#       reader: proc { |val| val.to_s     }
+#     )
+#   end
+#
+# @author Andrew Kozin <Andrew.Kozin@gmail.com>
+#
+# @api public
+module Eigindir
+  using Patches
+
+  # Returns the hash of the object's attributes
+  #
+  # @return [Hash]
+  def attributes
+    __readers.zip(__readers.map(&method(:public_send))).to_h
+  end
+
+  # Assigns attributes from hash
+  #
+  # Unknown attributes are ignored
+  #
+  # @param [Hash] options
+  #
+  # @return [self] itself
+  def attributes=(options)
+    options
+      .normalize
+      .slice(*__writers)
+      .each { |key, value| public_send :"#{ key }=", value }
+  end
+
+  # @!parse extend Eigindir::API
+  # @private
+  def self.included(klass)
+    klass.extend API
+  end
+
+  private
+
+  def __readers
+    self.class.__send__ :__readers
+  end
+
+  def __writers
+    self.class.__send__ :__writers
+  end
+
+end # module Eigindir

data/lib/eigindir/api.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+module Eigindir
+
+  # The module provides class-level API
+  #
+  # @author Andrew Kozin <Andrew.Kozin@gmail.com>
+  module API
+
+    # Declares the attribute
+    #
+    # @param  (see #attribute_reader)
+    # @option (see #attribute_reader)
+    # @option [Proc, Symbol, String] :reader
+    #   The coercer to be used by method getter
+    # @option [Proc, Symbol, String] :writer
+    #   The coercer to be used by method writer
+    #
+    # @return [undefined]
+    def attribute(name, coerce: nil, reader: nil, writer: nil, strict: nil)
+      attribute_reader name, coerce: (reader || coerce), strict: strict
+      attribute_writer name, coerce: (writer || coerce), strict: strict
+    end
+
+    # @!method attribute_reader(name, coerce: nil, strict: nil)
+    # Declares the attribute getter
+    #
+    # @param  [Symbol, String] name
+    #   The name of the attribute
+    # @option [Proc, Symbol, String] :coerce
+    #   The coercer for the attribute
+    # @option [Boolean] :strict
+    #   Whether +nil+ should be coerced
+    #
+    # @return [undefined]
+    def attribute_reader(name, **options)
+      __declare_reader name, Coercer.new(options)
+      __readers << name.to_sym
+    end
+
+    # @!method attribute_writer(name, coerce: nil, strict: nil)
+    # Declares the attribute writer
+    #
+    # @param  (see #attribute_reader)
+    # @option (see #attribute_reader)
+    #
+    # @return [undefined]
+    def attribute_writer(name, **options)
+      __declare_writer name, Coercer.new(options)
+      __writers << name.to_sym
+    end
+
+    private
+
+    def __readers
+      @__readers ||= []
+    end
+
+    def __writers
+      @__writers ||= []
+    end
+
+    def __declare_reader(name, coercer)
+      return attr_reader(name) unless coercer
+      define_method(name) do
+        coercer.call self, instance_variable_get(:"@#{ name }")
+      end
+    end
+
+    def __declare_writer(name, coercer)
+      return attr_writer(name) unless coercer
+      define_method("#{ name }=") do |value|
+        instance_variable_set :"@#{ name }", coercer.call(self, value)
+      end
+    end
+
+  end # module API
+
+end # module Eigindir

data/lib/eigindir/coercer.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module Eigindir
+
+  # Class Coercer creates the proc to be called by attribute getter and setter
+  #
+  # @author Andrew Kozin <Andrew.Kozin@gmail.com>
+  #
+  # @api private
+  class Coercer
+
+    # Checks the coercer validity and creates its istance
+    #
+    # @option [Proc, Symbol, String, NilClass] :coerce
+    # @option [Boolean] :strict
+    #
+    # @return [Eigindir::Coercer]
+    def self.new(coerce: nil, strict: nil)
+      super if coerce
+    end
+
+    # @private
+    def initialize(coerce: nil, strict: nil)
+      @coerce = coerce
+      @strict = strict
+      check_type
+      check_arity
+    end
+
+    # Coerces a value in a context of some instance
+    #
+    # @param [Object] instance
+    #   The object whose method is used to coerce value
+    # @param [Object] value
+    #   The value to coerce
+    #
+    # @return [Object] the coerced value
+    def call(instance, value)
+      proc.call(instance, value) if value || strict
+    end
+
+    private
+
+    attr_reader :coerce, :strict, :proc
+
+    def proc
+      coerce.instance_of?(Proc) ? proc_coercer : method_coercer
+    end
+
+    def method_coercer
+      ->(instance, value) { instance.__send__ coerce, value }
+    end
+
+    def proc_coercer
+      ->(_, value) { coerce.call value }
+    end
+
+    def check_type
+      return if [Proc, String, Symbol].include? coerce.class
+      fail TypeError.new "#{ coerce } is not a Proc, Symbol, or String"
+    end
+
+    def check_arity
+      return unless coerce.instance_of?(Proc) && coerce.arity != 1
+      fail ArgumentError.new "Coercer should take exactly one argument"
+    end
+
+  end # class Coercer
+
+end # module Eigindir

data/lib/eigindir/patches.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Eigindir
+
+  # @api private
+  module Patches
+
+    refine Hash do
+
+      # Returns a new hash whose keys are symbolized
+      #
+      # @example
+      #   { "foo" => "foo", "bar" => { "baz" => "baz" } }.normalize
+      #   # => { foo: "foo", bar: { "baz" => "baz" } }
+      #
+      # @return [Hash]
+      def normalize
+        keys.map(&:to_sym).zip(values).to_h
+      end
+
+      # Returns a new hash with given keys only
+      #
+      # @example
+      #   { foo: "foo", bar: "bar" }.slice(:foo, :baz)
+      #   # => { foo: "foo" }
+      #
+      # @param [Array] list The keys to slice from the hash
+      #
+      # @return [Hash]
+      def slice(*list)
+        sliced_keys = keys & list
+        sliced_keys.zip(values_at(*sliced_keys)).to_h
+      end
+
+    end # refine Hash
+
+  end # module Patches
+
+end # module Eigindir

data/lib/eigindir/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module Eigindir
+
+  # The semantic version of the module.
+  # @see http://semver.org/ Semantic versioning 2.0
+  VERSION = "0.0.1".freeze
+
+end # module Eigindir

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+begin
+  require "hexx-suit"
+  Hexx::Suit.load_metrics_for(self)
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.load_metrics_for(self)
+end
+
+# Loads the code under test
+require "eigindir"

data/spec/tests/eigindir/api_spec.rb

@@ -0,0 +1,395 @@
+# encoding: utf-8
+
+describe Eigindir::API do
+
+  let(:coercer) { ->(value) { value.to_s } }
+  let(:klass) do
+    Class.new do
+      extend Eigindir::API
+
+      private
+
+      def coercer(value)
+        value.to_s
+      end
+    end
+  end
+
+  subject { klass.new }
+
+  shared_examples "adding readonly attribute :foo" do
+
+    it "declares the getter" do
+      expect(subject).to respond_to :foo
+    end
+
+    it "doesn't declare the setter" do
+      expect(subject).not_to respond_to :foo=
+    end
+
+  end # shared example
+
+  shared_examples "adding writeonly attribute :foo" do
+
+    it "declares the setter" do
+      expect(subject).to respond_to :foo=
+    end
+
+    it "doesn't declare the getter" do
+      expect(subject).not_to respond_to :foo
+    end
+
+  end # shared example
+
+  shared_examples "making :foo to coerce something" do
+
+    it "coerces the getter" do
+      subject.instance_eval "@foo = 1"
+      expect(subject.foo).to eq "1"
+    end
+
+    it "doesn't coerce nil" do
+      expect(subject.foo).to be_nil
+    end
+
+  end # shared example
+
+  shared_examples "making :foo to coerce anything" do
+
+    it "coerces the getter" do
+      subject.instance_eval "@foo = 1"
+      expect(subject.foo).to eq "1"
+    end
+
+    it "doesn't coerce nil" do
+      expect(subject.foo).to eq ""
+    end
+
+  end # shared example
+
+  shared_examples "making :foo= to coerce something" do
+
+    it "coerces the setter" do
+      subject.foo = 1
+      expect(subject.instance_eval "@foo").to eq "1"
+    end
+
+    it "doesn't coerce nil" do
+      subject.foo = nil
+      expect(subject.instance_eval "@foo").to be_nil
+    end
+
+  end # shared example
+
+  shared_examples "making :foo= to coerce anything" do
+
+    it "coerces the setter" do
+      subject.foo = 1
+      expect(subject.instance_eval "@foo").to eq "1"
+    end
+
+    it "coerces nil" do
+      subject.foo = nil
+      expect(subject.instance_eval "@foo").to eq ""
+    end
+
+  end # shared example
+
+  shared_examples "reporting a wrong coercer arity" do
+
+    it "fails with ArgumentError" do
+      expect { subject }.to raise_error ArgumentError
+    end
+
+    it "returns a proper error message" do
+      begin
+        subject
+      rescue => error
+        expect(error.message).to eq "Coercer should take exactly one argument"
+      end
+    end
+
+  end # shared example
+
+  shared_examples "reporting a wrong coercer type" do
+
+    it "fails with TypeError" do
+      expect { subject }.to raise_error TypeError
+    end
+
+    it "returns a proper error message" do
+      begin
+        subject
+      rescue => error
+        expect(error.message).to eq "1 is not a Proc, Symbol, or String"
+      end
+    end
+
+  end # shared example
+
+  describe ".attribute_reader" do
+
+    context "without coercer" do
+
+      before { klass.attribute_reader :foo }
+
+      it_behaves_like "adding readonly attribute :foo"
+
+    end # context
+
+    context "with proc coercer" do
+
+      before { klass.attribute_reader :foo, coerce: coercer.to_proc }
+
+      it_behaves_like "adding readonly attribute :foo"
+      it_behaves_like "making :foo to coerce something"
+
+    end # context
+
+    context "with lambda coercer" do
+
+      before { klass.attribute_reader :foo, coerce: coercer }
+
+      it_behaves_like "adding readonly attribute :foo"
+      it_behaves_like "making :foo to coerce something"
+
+    end # context
+
+    context "with a symbolic coercer" do
+
+      before { klass.attribute_reader :foo, coerce: :coercer }
+
+      it_behaves_like "adding readonly attribute :foo"
+      it_behaves_like "making :foo to coerce something"
+
+    end # context
+
+    context "with a string coercer" do
+
+      before { klass.attribute_reader :foo, coerce: "coercer" }
+
+      it_behaves_like "adding readonly attribute :foo"
+      it_behaves_like "making :foo to coerce something"
+
+    end # context
+
+    context "in a strict mode" do
+
+      before { klass.attribute_reader :foo, coerce: coercer, strict: true }
+
+      it_behaves_like "adding readonly attribute :foo"
+      it_behaves_like "making :foo to coerce anything"
+
+    end # context
+
+    context "with coercer that has a wrong type" do
+
+      subject { klass.attribute_reader :foo, coerce: 1 }
+
+      it_behaves_like "reporting a wrong coercer type"
+
+    end # context
+
+    context "with coercer that takes no attributes" do
+
+      subject { klass.attribute_reader :foo, coerce: proc { 1 } }
+
+      it_behaves_like "reporting a wrong coercer arity"
+
+    end # context
+
+    context "with coercer that takes more than one attribute" do
+
+      subject { klass.attribute_reader :foo, coerce: proc { |_, _| 1 } }
+
+      it_behaves_like "reporting a wrong coercer arity"
+
+    end # context
+
+    context "without method name" do
+
+      it "fails with ArgumentError" do
+        expect { klass.attribute_reader }.to raise_error ArgumentError
+      end
+
+    end # context
+
+  end # describe .attribute_reader
+
+  describe ".attribute_writer" do
+
+    context "without coercer" do
+
+      before { klass.attribute_writer :foo }
+
+      it_behaves_like "adding writeonly attribute :foo"
+
+    end # context
+
+    context "with proc coercer" do
+
+      before { klass.attribute_writer :foo, coerce: coercer.to_proc }
+
+      it_behaves_like "adding writeonly attribute :foo"
+      it_behaves_like "making :foo= to coerce something"
+
+    end # context
+
+    context "with lambda coercer" do
+
+      before { klass.attribute_writer :foo, coerce: coercer }
+
+      it_behaves_like "adding writeonly attribute :foo"
+      it_behaves_like "making :foo= to coerce something"
+
+    end # context
+
+    context "with a symbolic coercer" do
+
+      before { klass.attribute_writer :foo, coerce: :coercer }
+
+      it_behaves_like "adding writeonly attribute :foo"
+      it_behaves_like "making :foo= to coerce something"
+
+    end # context
+
+    context "with a string coercer" do
+
+      before { klass.attribute_writer :foo, coerce: "coercer" }
+
+      it_behaves_like "adding writeonly attribute :foo"
+      it_behaves_like "making :foo= to coerce something"
+
+    end # context
+
+    context "in a strict mode" do
+
+      before { klass.attribute_writer :foo, coerce: coercer, strict: true }
+
+      it_behaves_like "adding writeonly attribute :foo"
+      it_behaves_like "making :foo= to coerce anything"
+
+    end # context
+
+    context "with coercer of a wrong type" do
+
+      subject { klass.attribute_writer :foo, coerce: 1 }
+
+      it_behaves_like "reporting a wrong coercer type"
+
+    end # context
+
+    context "with coercer that takes no attributes" do
+
+      subject { klass.attribute_writer :foo, coerce: proc { 1 } }
+
+      it_behaves_like "reporting a wrong coercer arity"
+
+    end # context
+
+    context "with coercer that takes more than one attribute" do
+
+      subject { klass.attribute_writer :foo, coerce: proc { |_, _| 1 } }
+
+      it_behaves_like "reporting a wrong coercer arity"
+
+    end # context
+
+    context "without method name" do
+
+      it "fails with ArgumentError" do
+        expect { klass.attribute_writer }.to raise_error ArgumentError
+      end
+
+    end # context
+
+  end # describe .attribute_reader
+
+  describe ".attribute" do
+
+    let(:other) { proc { |value| value.to_i } }
+
+    context "without coercers" do
+
+      after { klass.attribute :foo }
+
+      it "calls .attribute_writer without coercer" do
+        expect(klass).to receive(:attribute_writer)
+          .with(:foo, coerce: nil, strict: nil)
+          .once
+      end
+
+      it "calls .attribute_reader without coercer" do
+        expect(klass).to receive(:attribute_reader)
+          .with(:foo, coerce: nil, strict: nil)
+          .once
+      end
+
+    end # context
+
+    context "with :coerce" do
+
+      after { klass.attribute :foo, coerce: coercer, strict: true }
+
+      it "calls .attribute_writer with coercer" do
+        expect(klass)
+          .to receive(:attribute_writer)
+          .with(:foo, coerce: coercer, strict: true)
+          .once
+      end
+
+      it "calls .attribute_reader with coercer" do
+        expect(klass)
+          .to receive(:attribute_reader)
+          .with(:foo, coerce: coercer, strict: true)
+          .once
+      end
+
+    end # context
+
+    context "with :writer" do
+
+      after do
+        klass.attribute :foo, coerce: coercer, writer: other, strict: true
+      end
+
+      it "calls .attribute_writer with specific coercer" do
+        expect(klass)
+          .to receive(:attribute_writer)
+          .with(:foo, coerce: other, strict: true)
+          .once
+      end
+
+      it "calls .attribute_reader with common coercer" do
+        expect(klass).to receive(:attribute_reader)
+          .with(:foo, coerce: coercer, strict: true)
+          .once
+      end
+
+    end # context
+
+    context "with :reader" do
+
+      after do
+        klass.attribute :foo, coerce: coercer, reader: other, strict: true
+      end
+
+      it "calls .attribute_writer with common coercer" do
+        expect(klass)
+          .to receive(:attribute_writer)
+          .with(:foo, coerce: coercer, strict: true)
+          .once
+      end
+
+      it "calls .attribute_reader with specific coercer" do
+        expect(klass)
+          .to receive(:attribute_reader)
+          .with(:foo, coerce: other, strict: true)
+          .once
+      end
+
+    end # context
+
+  end # describe .attribute
+
+end # describe Eigindir::API