sr 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 061f3869f4efe07024e5a09389787a7b587a27e2
+  data.tar.gz: 36eebe8d7ee9d6db3d6ac9201edc0e802cae62f6
+SHA512:
+  metadata.gz: d2b46015eaecf94a3754b5c1a3c60aa64c54657bd552a73ec8f9e7cb13a270536141df2fc10e19e124b8d66fe299d51273b79ea91b79385e310f142b161b657d
+  data.tar.gz: aaa9b5446e9a5f352560f94a6217fb2c18b9d7d39e7f3d9d5ee8befcc6283f69f5411ce02fef041ffddaaec0f4b97b19b7b2363693ec8cbee2d32611ac613433

data/README.md

@@ -0,0 +1,71 @@
+# sr
+
+`sr` is a simple, tiny, hackable REPL for Ruby.
+
+## Usage
+
+Simply call `sr` to use `sr` as a Ruby REPL like `irb` or `pry`:
+
+```sh
+$ sr
+```
+
+`sr` can also be used to include a REPL in your own code (for debugging
+purposes, for example) by requiring 'sr' and calling `SR.repl`:
+
+```ruby
+require 'sr'
+
+class Test
+  def initialize
+    SR.repl
+  end
+end
+```
+
+You may also pass any object to the `SR.repl` method to have `sr` begin in the
+context of that object instead of the default (the top level binding):
+
+```ruby
+class Test
+  def initialize
+    SR.repl(self)
+  end
+end
+```
+
+Within the REPL itself, you can manipulate the current context via the methods
+`SR.bind`, `SR.unbind`, and `SR.reset_binding`:
+
+```
+$ sr
+== main:
+>> SR.bind Object.new
+-> #<Binding:0x81338ed0>
+== #<Object:0x81338f34>:
+>> SR.unbind
+-> #<Binding:0x8124dc78>
+== main:
+>> 
+```
+
+`SR.bind` sets the current context to the given object and pushes the previous
+context onto the context stack; `SR.unbind` retrieves the last object from the
+stack and sets the context to it. `SR.reset_binding` may be used without
+arguments at any time to completely clear the context stack and reset the
+binding to the default (usually the top level binding).
+
+When given an argument, however, `SR.reset_binding` clears the context stack
+and resets the default binding to the _given object_.
+
+## Configuration
+
+`sr` looks for its configuration in the 'sr/config.rb' file within
+**$XDG_CONFIG_DIRS** and **$XDG_CONFIG_HOME**. By default, these files would
+be '/etc/xdg/sr/config.rb' for system-wide configuration and
+'~/.config/sr/config.rb' for user-specific configuration. These files are
+simply Ruby files which are loaded into `sr` via `require`.
+
+## License
+
+`sr` is free and unencumbered software released into the public domain.

data/UNLICENSE.md

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>

data/bin/sr

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$0.start_with?('/') ? require('sr') : require_relative('../lib/sr')
+
+if ARGV.size > 0
+  valid = %w(-h --help).any? { |a| ARGV.first == a }
+  (valid ? $stdout : $stderr).puts <<-END
+sr #{SR::VERSION}
+
+sr is a simple, tiny, hackable REPL for Ruby.
+
+usage: #{$0} [-h|--help]
+END
+  exit valid ? 0 : 1
+end
+
+SR.repl

data/lib/sr.rb

@@ -0,0 +1,128 @@
+require_relative 'sr/core_patches'
+require_relative 'sr/version'
+require 'readline'
+require 'sxdg/as_xdg'
+
+# `sr` is a simple, tiny, hackable REPL for Ruby.
+module SR
+  class << self
+    # @return [Binding] the currently bound SR context
+    attr_reader :context
+
+    # @return [Hash{Class=>#call}] the hash of exception handlers
+    attr_reader :handlers
+
+    # @return [Hash{Symbol=>#call,#to_s}] the hash of prompts to display; valid
+    #   keys are `:error`, `:input`, `:more`, and `:return`; valid values must
+    #   respond to `#to_s`
+    attr_reader :prompt
+  end
+
+  # The array of known configuration files for SR which should be loaded when
+  # the read-eval-print loop is started.
+  CONFIGURATION_FILES = (XDG_CONFIG_DIRS + [XDG_CONFIG_HOME]).map! do |dir|
+    (File.expand_path(dir) + '/sr/config.rb').freeze
+  end.select! { |file| File.exist?(file) }.freeze
+
+  # The regular expression used to determine whether or not a syntax error is
+  # a valid continuation which should prompt for more user input.
+  CONTINUATION_REGEXP =
+    /unterminated (?:regexp|string)|unexpected end-of-input|tIDENTIFIER/
+
+  @prompt = {
+    error:  proc { |e| "!! #{e.class}: #{e.message}" },
+    input:  proc { "== #{@context.receiver}:\n>> " },
+    more:   '..   ',
+    return: proc { |v| "-> #{v.inspect}" },
+  }
+
+  @handlers = {
+    SyntaxError => proc do |e, i|
+      e.message =~ CONTINUATION_REGEXP ? read_eval_print(i) : report(e)
+    end,
+    Interrupt => proc do |_, _, m|
+      m ? (puts ; read_eval_print) : @enabled = false
+    end,
+    SystemExit => proc { @enabled = false },
+    Exception => proc { |e| report(e) },
+  }
+
+  @context = @ORIGINAL_CONTEXT = TOPLEVEL_BINDING
+
+  @stack = []
+  
+  # @return [Array<Binding>] a copy of the SR context stack
+  def self.stack
+    @stack.dup
+  end
+
+  # @param object [#__binding__] the object to bind the SR context to
+  # @return [Binding] the new SR context
+  def self.bind(object)
+    @stack.push(@context)
+    @context = object.__binding__
+  end
+  class << self ; alias_method :context=, :bind ; end
+
+  # @return [Binding] the previous binding in the SR context stack or the
+  #   default context if no previous binding exists
+  def self.unbind
+    @context = @stack.empty? ? @ORIGINAL_CONTEXT : @stack.pop
+  end
+
+  # @param context [#__binding__] the context to use as the new default
+  #   context; defaults to the top level binding if no context given
+  # @return [Binding] the reset binding context
+  def self.reset_binding(context = nil)
+    @stack.clear
+    context  = context.__binding__ unless context.nil?
+    @context = @ORIGINAL_CONTEXT = context ? context : TOPLEVEL_BINDING
+  end
+
+  # @param key [Symbol] the key of the @prompt hash to call or fetch
+  # @param args [Array<Object>] the arguments to be passed to the value of the
+  #   given key if the value is a proc
+  # @return [String] the prompt to display
+  private_class_method def self.call_prompt(key, *args)
+    prompt = @prompt[key]
+    prompt.respond_to?(:call) ? prompt.call(*args) : (prompt || '?? ')
+  end
+
+  # @param ex [Exception] the exception to report
+  # @return [void]
+  private_class_method def self.report(ex)
+    @context.local_variable_set(:_, ex)
+    $stderr.puts call_prompt(:error, ex) if @prompt[:error]
+  end
+
+  # @return [Array<Boolean>] an array representing whether or not each
+  #   configuration file was loaded by `require`
+  private_class_method def self.load_configuration
+    CONFIGURATION_FILES.map(&method(:require))
+  end
+
+  # @param more [String] the previous input to be evaluated along with the
+  #   given input
+  # @return [Object] the return value of the given input
+  private_class_method def self.read_eval_print(more = nil)
+    input = "#{Readline.readline(call_prompt(more ? :more : :input), true)}\n"
+    input = "#{more}#{input}" if more
+    value = @context.eval("_ = #{input}")
+    puts call_prompt(:return, value) if @prompt[:return]
+  rescue *@handlers.keys => ex
+    @handlers.find { |(c,_)| ex.is_a?(c) }[1].call(ex, input, more)
+  end
+
+  # Loads the configuration for SR, resets the default binding to the given
+  # `context`, and starts the read-eval-print loop.
+  #
+  # @param context [#__binding__] the object providing the default context for
+  #   `sr`; defaults to the top level binding if no context given
+  # @return [void]
+  def self.repl(context = nil)
+    load_configuration
+    reset_binding(context) unless context.nil?
+    @enabled = true
+    read_eval_print while @enabled
+  end
+end

data/lib/sr/core_patches.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class BasicObject
+  #  Used by `sr` to allow the same general access to `BasicObject` instances
+  #  that `Object#__binding__` permits for all other objects.
+  #
+  # @return [Binding] an unclean `Binding` instance representing the current
+  #   binding of this object
+  def __binding__
+    (class << self ; self end).class_eval <<-END
+      def __fallback_binding__
+        ::Kernel.binding
+      end
+    END
+    self.__fallback_binding__
+  end
+
+  # @return [String] a simple inspection string
+  def inspect
+    '#<BasicObject>'
+  end
+  alias_method :to_s, :inspect
+end
+
+class Object
+  # Used extensively by `sr` -- this method is essentially what allows
+  # interactive code to reach into the state of objects at runtime.
+  #
+  # @return [Binding] a clean `Binding` instance representing the current
+  #   binding of this object
+  def __binding__
+    is_a?(Module) ? class_eval('binding') : binding
+  end
+end
+
+module Kernel
+  # @return [Binding] the top level binding
+  def main
+    TOPLEVEL_BINDING
+  end
+end
+
+class << TOPLEVEL_BINDING
+  # @note this method exists entirely for aesthetic purposes (when the default
+  #   input prompt calls `@context.receiver` to get a name for the current
+  #   binding/context)
+  # @return [String] a simple inspection string
+  def to_s
+    'main'
+  end
+end

data/lib/sr/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SR
+  # Semantic version of `sr`.
+  VERSION = '1.0.0'
+end

data/sr.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'sr/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'sr'
+  spec.version     = SR::VERSION
+  spec.summary     = 'sr is a simple, tiny, hackable REPL for Ruby.'
+  spec.description = spec.summary
+
+  spec.authors  = ['Robin Owen']
+  spec.email    = ['vthrenody@gmail.com']
+  spec.homepage = 'https://github.com/vthrenody/sr'
+
+  spec.files        = %w(sr.gemspec) + Dir['*.md', 'lib/**/*.rb']
+  spec.executables  = 'sr'
+  spec.require_path = 'lib'
+  spec.license      = 'Unlicense'
+
+  spec.add_runtime_dependency 'sxdg', '~> 1.0'
+  spec.add_development_dependency 'sgem', '~> 1.0'
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: sr
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Robin Owen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sxdg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: sgem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: sr is a simple, tiny, hackable REPL for Ruby.
+email:
+- vthrenody@gmail.com
+executables:
+- sr
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- UNLICENSE.md
+- bin/sr
+- lib/sr.rb
+- lib/sr/core_patches.rb
+- lib/sr/version.rb
+- sr.gemspec
+homepage: https://github.com/vthrenody/sr
+licenses:
+- Unlicense
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: sr is a simple, tiny, hackable REPL for Ruby.
+test_files: []