pipe_operator 0.0.1

data/Rakefile

@@ -0,0 +1,98 @@
+require "rdoc/task"
+
+task default: :ci
+
+desc "scratchpad"
+task :scratch do
+  require "json"
+  require "net/http"
+  require_relative "lib/pipe_operator/autoload"
+
+  puts "abc".pipe { reverse }        #=> "cba"
+  puts "abc".pipe { reverse.upcase } #=> "CBA"
+
+  # puts [9, 64].map(&Math.|.sqrt.to_i)
+  # puts "single"
+  # puts 256.pipe { Math.sqrt.to_i.to_s }.inspect
+  # puts
+  # puts "multiple"
+  # puts [16, 256].map(&Math.|.sqrt.to_i.to_s).inspect
+
+  # "https://api.github.com/repos/ruby/ruby".| do
+  #   URI.parse
+  #   Net::HTTP.get
+  #   JSON.parse.fetch("stargazers_count")
+  #   yield_self { |n| "Ruby has #{n} stars" }
+  #   Kernel.puts
+  # end
+  # => Ruby has 15115 stars
+
+  # p = ["256", "-16"].pipe do
+  #   map(&:to_i)
+  #   sort
+  #   first
+  #   abs
+  #   Math.sqrt
+  #   to_i
+  # end
+  #
+  # puts p.inspect
+end
+task s: :scratch
+
+desc "run tests, validate styleguide, and generate rdoc"
+task :ci do
+  %w[lint test doc].each do |task|
+    command = "bundle exec rake #{task} --trace"
+    system(command) || raise("#{task} failed")
+    puts "\n"
+  end
+end
+
+desc "validate styleguide"
+task :lint do
+  %w[fasterer rubocop].each do |task|
+    command = "bundle exec #{task}"
+    system(command) || exit(1)
+  end
+end
+task l: :lint
+
+desc "run tests"
+task :test do
+  exec "bundle exec rspec"
+end
+task t: :test
+
+
+RDoc::Task.new :doc do |rdoc|
+  rdoc.title = "pipe_operator"
+
+  rdoc.main = "README.md"
+  rdoc.rdoc_dir = "doc"
+
+  rdoc.options << "--all"
+  rdoc.options << "--hyperlink-all"
+  rdoc.options << "--line-numbers"
+
+  rdoc.rdoc_files.include(
+    "LICENSE",
+    "README.md",
+    "lib/**/*.rb",
+    "lib/*.rb"
+  )
+end
+task d: :doc
+
+desc "pry console"
+task :console do
+  require "base64"
+  require "json"
+  require "net/http"
+  require "pry"
+  require "pry-byebug"
+  require_relative "lib/pipe_operator/autoload"
+
+  PipeOperator.pry
+end
+task c: :console

data/lib/pipe_operator.rb

@@ -0,0 +1,49 @@
+require "fiddle"
+require "forwardable"
+require "pathname"
+require "set"
+
+require_relative "pipe_operator/closure"
+require_relative "pipe_operator/observer"
+require_relative "pipe_operator/pipe"
+require_relative "pipe_operator/proxy"
+require_relative "pipe_operator/proxy_resolver"
+
+module PipeOperator
+  def __pipe__(*args, &block)
+    Pipe.new(self, *args, &block)
+  end
+  alias | __pipe__
+  alias pipe __pipe__
+
+  refine(::BasicObject) { include PipeOperator }
+
+  class << self
+    def gem
+      @gem ||= ::Gem::Specification.load("#{root}/pipe_operator.gemspec")
+    end
+
+    def inspect(object)
+      object.inspect
+    rescue ::NoMethodError
+      singleton = singleton(object)
+      name = singleton.name || singleton.superclass.name
+      id = "0x0000%x" % (object.__id__ << 1)
+      "#<#{name}:#{id}>"
+    end
+
+    def root
+      @root ||= ::Pathname.new(__dir__).join("..")
+    end
+
+    def singleton(object)
+      (class << object; self end)
+    rescue ::TypeError
+      object.class
+    end
+
+    def version
+      @version ||= gem.version.to_s
+    end
+  end
+end

data/lib/pipe_operator/autoload.rb

@@ -0,0 +1,3 @@
+require_relative "../pipe_operator"
+
+BasicObject.send(:include, PipeOperator)

data/lib/pipe_operator/closure.rb

@@ -0,0 +1,66 @@
+module PipeOperator
+  class Closure < ::Proc
+    RESERVED = %i[
+      ==
+      []
+      __send__
+      call
+      class
+      kind_of?
+    ].freeze
+
+    (::Proc.instance_methods - RESERVED).each(&method(:private))
+
+    def self.curry(curry, search, args)
+      index = curry.index(search)
+      prefix = index ? curry[0...index] : curry
+      suffix = index ? curry[index - 1..-1] : []
+
+      (prefix + args + suffix).map do |object|
+        self === object ? object.call : object
+      end
+    end
+
+    def self.new(pipe = nil, method = nil, *curry, &block)
+      return super(&block) unless pipe && method
+
+      search = Pipe.open || pipe
+
+      closure = super() do |*args, &code|
+        code ||= block
+        curried = curry(curry, search, args)
+        value = pipe.__call__.__send__(method, *curried, &code)
+        closure.__chain__(value)
+      end
+    end
+
+    def initialize(*) # :nodoc:
+      @__chain__ ||= []
+      super
+    end
+
+    def __chain__(*args)
+      return @__chain__ if args.empty?
+
+      @__chain__.reduce(args[0]) do |object, chain|
+        method, args, block = chain
+        object.__send__(method, *args, &block)
+      end
+    end
+
+    def __shift__
+      closure = self.class.new do |*args, &block|
+        args.shift
+        value = call(*args, &block)
+        closure.__chain__(value)
+      end
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      __chain__ << [method, args, block]
+      self
+    end
+  end
+end

data/lib/pipe_operator/observer.rb

@@ -0,0 +1,13 @@
+module PipeOperator
+  module Observer
+    def singleton_method_added(method)
+      ProxyResolver.new(self).proxy.define(method)
+      super
+    end
+
+    def singleton_method_removed(method)
+      ProxyResolver.new(self).proxy.undefine(method)
+      super
+    end
+  end
+end

data/lib/pipe_operator/pipe.rb

@@ -0,0 +1,87 @@
+module PipeOperator
+  class Pipe < ::BasicObject
+    undef :equal?
+    undef :instance_eval
+    undef :singleton_method_added
+    undef :singleton_method_removed
+    undef :singleton_method_undefined
+
+    def self.new(object, *args)
+      if block_given?
+        super.__call__
+      elsif args.none? || Closure === args[0]
+        super
+      else
+        super(object).__send__(*args)
+      end
+    end
+
+    def self.open(pipe = nil)
+      @pipeline ||= []
+      @pipeline << pipe if pipe
+      block_given? ? yield : @pipeline.last
+    ensure
+      @pipeline.pop if pipe
+    end
+
+    def initialize(object, *args, &block)
+      @args = args
+      @block = block
+      @object = object
+      @pipeline = []
+    end
+
+    def __call__
+      if defined?(@pipe)
+        return @pipe
+      elsif @block
+        ProxyResolver.new(::Object).proxy
+        @args.each { |arg| ProxyResolver.new(arg).proxy }
+        Pipe.open(self) { instance_exec(*@args, &@block) }
+      end
+
+      @pipe = @object
+      @pipeline.each { |closure| @pipe = closure.call(@pipe) }
+      @pipe
+    end
+
+    def inspect
+      return method_missing(__method__) if Pipe.open
+      inspect = ::PipeOperator.inspect(@object)
+      "#<#{Pipe.name}:#{inspect}>"
+    end
+
+    protected
+
+    def __pop__(pipe)
+      index = @pipeline.rindex(pipe)
+      @pipeline.delete_at(index) if index
+    end
+
+    def __push__(pipe)
+      @pipeline << pipe
+      pipe
+    end
+
+    def |(*)
+      self
+    end
+
+    private
+
+    def method_missing(method, *curry, &block)
+      closure = Closure.new(self, method, *curry, &block)
+
+      pipe = Pipe.open
+      pipe && [*curry, block].each { |o| pipe.__pop__(o) }
+
+      if pipe == self
+        __push__(closure.__shift__)
+      elsif pipe
+        pipe.__push__(closure)
+      else
+        closure
+      end
+    end
+  end
+end

data/lib/pipe_operator/proxy.rb

@@ -0,0 +1,58 @@
+module PipeOperator
+  class Proxy < ::Module
+    def initialize(object, singleton)
+      @object = object if singleton.singleton_class?
+      @singleton = singleton
+      super()
+    end
+
+    def define(method)
+      if ::Proc == @object && method == :new
+        return method
+      elsif ::Symbol == @singleton && method == :to_proc
+        return method
+      elsif ::Module === @object
+        namespace = @object.name.to_s.split("::").first
+        return method if namespace == "PipeOperator"
+      end
+
+      define_method(method) do |*args, &block|
+        if Pipe.open
+          Pipe.new(self).__send__(method, *args, &block)
+        else
+          super(*args, &block)
+        end
+      end
+    end
+
+    def definitions
+      instance_methods(false).sort
+    end
+
+    def inspect
+      inspect =
+        if @singleton.singleton_class?
+          ::PipeOperator.inspect(@object)
+        else
+          "#<#{@singleton.name}>"
+        end
+
+      "#<#{self.class.name}:#{inspect}>"
+    end
+
+    def prepended(*)
+      if is_a?(Proxy)
+        methods = @singleton.instance_methods(false)
+        methods.each { |method| define(method) }
+      end
+
+      super
+    end
+
+    def undefine(method)
+      remove_method(method)
+    rescue ::NameError # ignore
+      method
+    end
+  end
+end

data/lib/pipe_operator/proxy_resolver.rb

@@ -0,0 +1,71 @@
+module PipeOperator
+  class ProxyResolver
+    AUTOLOAD = ENV["PIPE_OPERATOR_AUTOLOAD"] == "1"
+    FROZEN = ENV["PIPE_OPERATOR_FROZEN"] == "1"
+    REBIND = ENV["PIPE_OPERATOR_REBIND"] == "1"
+
+    def initialize(object, resolved = ::Set.new)
+      @object = object
+      @resolved = resolved
+      @singleton = ::PipeOperator.singleton(object)
+    end
+
+    def proxy
+      proxy = find_existing_proxy
+      return proxy if proxy && !REBIND
+      proxy ||= create_proxy
+      rebind_nested_constants
+      proxy
+    end
+
+    private
+
+    def find_existing_proxy
+      @singleton.ancestors.each do |existing|
+        break if @singleton == existing
+        return existing if Proxy === existing
+      end
+    end
+
+    def create_proxy
+      Proxy.new(@object, @singleton).tap do |proxy|
+        @resolved.add(proxy)
+
+        if !@singleton.frozen?
+          @singleton.prepend(Observer).prepend(proxy)
+        elsif FROZEN
+          id = @singleton.__id__ * 2
+          unfreeze = ~(1 << 3)
+          ::Fiddle::Pointer.new(id)[1] &= unfreeze
+          @singleton.prepend(Observer).prepend(proxy)
+          @singleton.freeze
+        end
+      end
+    end
+
+    def rebind_nested_constants
+      context = ::Module === @object ? @object : @singleton
+
+      context.constants.map do |constant|
+        next unless context.const_defined?(constant, AUTOLOAD)
+
+        constant = silence_deprecations do
+          context.const_get(constant, false) rescue next
+        end
+
+        next if constant.eql?(@object) # recursion
+        next unless @resolved.add?(constant)
+
+        self.class.new(constant, @resolved).proxy
+      end
+    end
+
+    def silence_deprecations
+      stderr = $stderr
+      $stderr = ::StringIO.new
+      yield
+    ensure
+      $stderr = stderr
+    end
+  end
+end