decoratable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6a8eadd3a9f64dd170469d9bf46f9765ce9d411a
+  data.tar.gz: e0daa4b811d58ef5b10b867b89743219b7a3ac0e
+SHA512:
+  metadata.gz: b81d3a486e381d52d909002417d19c2578c63c3c784e5e2ee32357c7fe807eee8b902a5c4d640e7184d9fc4321de13f08f623a18c34c7decf7db01896b1f4208
+  data.tar.gz: c49567ab494c3e5ccd247adc8c0492c4b0186eb7086bbce37a6e579d288ab2b34f9abab76243ad65943d7eb5f2b630aa4c9007480505f0dabae6caf800ba1071

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+  - ruby-head
+  - jruby-head

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ["lib", "test"]
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+task :default => :test

data/decoratable.gemspec

@@ -0,0 +1,20 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "decoratable"
+  spec.version       = "0.0.1"
+  spec.authors       = ["ecin"]
+  spec.email         = ["ecin@copypastel.com"]
+  spec.description   = "Decorate your methods."
+  spec.summary       = "Easily define decorations for your methods. Put a bow on it."
+  spec.homepage      = "https://github.com/ecin/decoratable"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "pry"
+end

data/lib/decoratable.rb

@@ -0,0 +1,159 @@
+require "thread"
+
+# Public: provide an easy way to define decorations
+# that add common behaviour to a method.
+#
+# More info on decorations as implemented in Python:
+# http://en.wikipedia.org/wiki/Python_syntax_and_semantics#Decorators
+#
+# Examples
+#
+#   module Decorations
+#     extend Decoratable
+#
+#     def retryable(tries = 1, options = { on: [RuntimeError] })
+#       attempts = 0
+#
+#       begin
+#         yield
+#       rescue *options[:on]
+#         attempts += 1
+#         attempts > tries ? raise : retry
+#       end
+#     end
+#
+#     def measurable(logger = STDOUT)
+#       start = Time.now
+#       yield
+#     ensure
+#       original_method = __decorated_method__
+#       method_location, line = original_method.source_location
+#       marker = "#{original_method.owner}##{original_method.name}[#{method_location}:#{line}]"
+#       duration = (Time.now - start).round(2)
+#
+#       logger.puts "#{marker} took #{duration}s to run."
+#     end
+#
+#     def debuggable
+#       begin
+#         yield
+#       rescue => e
+#         puts "Caught #{e}!!!"
+#         require "debug"
+#       end
+#     end
+#
+#     def memoizable
+#       key = :"@#{__decorated_method__.name}_cache"
+#
+#       instance_variable_set(key, {}) unless defined?(key)
+#       cache = instance_variable_get(key)
+#
+#       if cache.key?(__args__)
+#         cache[__args__]
+#       else
+#         cache[__args__] = yield
+#       end
+#     end
+#   end
+#
+#   class Client
+#     extend Decorations
+#
+#     # Let's keep track of how long #get takes to run,
+#     # and memoize the return value
+#     measurable
+#     memoizable
+#     def get
+#       …
+#     end
+#
+#     # Rescue and retry any Timeout::Errors, up to 5 times
+#     retryable 5, on: [Timeout::Error]
+#     def post
+#       …
+#     end
+#   end
+module Decoratable
+  @@lock = Mutex.new
+
+  def self.extended(klass)
+    # This #method_added affects all methods defined in the module
+    # that extends Decoratable.
+    def klass.method_added(decoration_name)
+      return unless @@lock.try_lock
+
+      decoration_method = instance_method(decoration_name)
+
+      define_method(decoration_name) do |*decorator_args|
+        # Wrap method_added to decorate the next method definition.
+        self.singleton_class.instance_eval do
+          alias_method "method_added_without_#{decoration_name}", :method_added
+        end
+
+        unless method_defined?(:__decorated_method__)
+          define_method(:__decorated_method__) { @__decorated_method__ }
+        end
+
+        unless method_defined?(:__args__)
+          define_method(:__args__) { @__args__ }
+        end
+
+        unless method_defined?(:__block__)
+          define_method(:__block__) { @__block__ }
+        end
+
+        # This method_added will affect the next decorated method.
+        define_singleton_method(:method_added) do |method_name|
+
+          original_method = instance_method(method_name)
+
+          decoration = Module.new do
+            self.singleton_class.instance_eval do
+              define_method(:name) do
+                "Decoratable::#{decoration_name}(#{method_name})"
+              end
+
+              alias_method :inspect, :name
+              alias_method :to_s, :name
+            end
+
+            define_method(method_name) do |*args, &block|
+              begin
+                # The decoration should have access to the original
+                # method it's modifying, along with the method call's
+                # arguments.
+                @__decorated_method__ = original_method
+                @__args__ = args
+                @__block__ = block
+
+                decoration_method.bind(self).call(*decorator_args) do
+                  super(*args, &block)
+                end
+              ensure
+                @__decorated_method__ = nil
+                @__args__ = nil
+                @__block__ = nil
+              end
+            end
+          end
+
+          # Call aspect before "real" method.
+          prepend decoration
+
+          # Call next method_added link in the chain.
+          __send__("method_added_without_#{decoration_name}", method_name)
+
+          # Remove ourselves from method_added chain.
+          self.singleton_class.instance_eval do
+            alias_method :method_added, "method_added_without_#{decoration_name}"
+            remove_method  "method_added_without_#{decoration_name}"
+          end
+        end
+      end
+    ensure
+      @@lock.unlock if @@lock.locked?
+    end
+  end
+
+end

data/lib/decoratable/countable.rb

@@ -0,0 +1,26 @@
+require "decoratable"
+
+module Countable
+  extend Decoratable
+
+  module Helper
+    def define_reader(object, key)
+      unless object.respond_to?(key)
+        object.define_singleton_method(key) { instance_variable_get(:"@#{key}") }
+      end
+    end
+
+    module_function :define_reader
+  end
+
+  def countable
+    key = :"#{__decorated_method__.name}_call_count"
+    Helper.define_reader(self, key)
+
+    instance_variable = :"@#{key}"
+    count = instance_variable_get(instance_variable).to_i
+    instance_variable_set(instance_variable, count + 1)
+
+    yield
+  end
+end

data/lib/decoratable/debuggable.rb

@@ -0,0 +1,11 @@
+require "decoratable"
+
+module Debuggable
+  extend Decoratable
+
+  def debuggable(options = { on: [RuntimeError] })
+    yield
+  rescue *options[:on]
+    require "debug"
+  end
+end

data/lib/decoratable/hintable.rb

@@ -0,0 +1,22 @@
+require "decoratable"
+
+module Hintable
+  extend Decoratable
+
+  def hintable(*classes, require_block: false)
+    argument_names = __decorated_method__.parameters.map { |(_, param)| param }
+    checks = __args__.zip(classes, argument_names)
+
+    # check args for types
+    failed_check = checks.find { |arg, klass, _| !arg.is_a?(klass) }
+    if failed_check
+      raise ArgumentError, "#{failed_check[2]} expected argument of type #{failed_check[1]}, was #{failed_check[0].class} (#{failed_check[0].inspect})"
+    end
+
+    if require_block && __block__.nil?
+      raise ArgumentError, "#{__decorated_method__.name} requires a block"
+    end
+
+    yield
+  end
+end

data/lib/decoratable/memoizable.rb

@@ -0,0 +1,15 @@
+require "decoratable"
+
+module Memoizable
+  extend Decoratable
+
+  def memoizable
+    key = :"@#{__decorated_method__.name}_cache"
+
+    if instance_variable_defined?(key)
+      instance_variable_get key
+    else
+      instance_variable_set key, yield
+    end
+  end
+end

data/lib/decoratable/pryable.rb

@@ -0,0 +1,12 @@
+require "decoratable"
+
+module Pryable
+  extend Decoratable
+
+  def pryable(options = { on: [RuntimeError] })
+    yield
+  rescue *options[:on]
+    require "pry"
+    binding.pry
+  end
+end

data/lib/decoratable/retryable.rb

@@ -0,0 +1,16 @@
+require "decoratable"
+
+module Retryable
+  extend Decoratable
+
+  def retryable(tries = 1, options = { on: [RuntimeError] } )
+    attempts = 0
+
+    begin
+      yield
+    rescue *options[:on]
+      attempts += 1
+      attempts > tries ? raise : retry
+    end
+  end
+end

data/test/decoratable/countable_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+require "decoratable/countable"
+
+describe Countable do
+
+  before do
+    klass = Class.new do
+      extend Countable
+
+      countable
+      def call; end
+    end
+
+    @object = klass.new
+  end
+
+  it "keeps count of how many times a method is called" do
+    3.times { @object.call }
+    @object.call_call_count.must_equal 3
+  end
+end

data/test/decoratable/hintable_test.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+require "decoratable/hintable"
+
+describe Hintable do
+
+  before do
+    klass = Class.new do
+      extend Hintable
+
+      hintable(Integer, require_block: true)
+      def call(a); end
+    end
+
+    @object = klass.new
+  end
+
+  it "checks argument types" do
+    proc { @object.call(:a) }.must_raise ArgumentError, /#{Regexp.escape("a expected argument of type Integer, was Symbol (:a)")}/
+  end
+
+  it "checks for a required block" do
+    proc { @object.call(1) }.must_raise ArgumentError, /call requires a block/
+  end
+
+  it "steps out of the way for the correct arguments" do
+    @object.call(1) { }
+  end
+end

data/test/decoratable/memoizable_test.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+require "decoratable/memoizable"
+
+describe Memoizable do
+
+  before do
+    klass = Class.new do
+      extend Memoizable
+
+      memoizable
+      def call
+        @count ||= 0
+        @count += 1
+      end
+    end
+
+    @object = klass.new
+  end
+
+  it "memoizes a function's return value" do
+    3.times { @object.call }
+
+    # If method was memoized, the counter shouldn't have incremented
+    @object.call.must_equal 1
+  end
+
+end

data/test/decoratable/pryable_test.rb

@@ -0,0 +1,47 @@
+require "test_helper"
+
+require "decoratable/pryable"
+
+describe Pryable do
+
+  # stub Binding#pry for test; I'm sorry
+  class Binding
+    @@pry_count = 0
+
+    def self.pry_count
+      @@pry_count
+    end
+
+    def pry
+      @@pry_count += 1
+    end
+  end
+
+  before do
+    klass = Class.new do
+      extend Pryable
+
+      pryable(on: [NoMethodError, ArgumentError])
+      def call
+        @count ||= 0
+
+        case @count
+        when 0 then raise NoMethodError
+        when 1 then raise ArgumentError
+        else raise RuntimeError
+        end
+
+      ensure
+        @count += 1
+      end
+    end
+
+    @object = klass.new
+  end
+
+  it "enters a pry session for the specified exceptions" do
+    proc { 3.times { @object.call } }.must_raise RuntimeError
+    Binding.pry_count.must_equal 2
+  end
+
+end

data/test/decoratable/retryable_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+require "decoratable/retryable"
+
+describe Retryable do
+
+  before do
+    klass = Class.new do
+      extend Retryable
+
+      retryable(3, on: [RuntimeError, ArgumentError])
+      def call
+        @count ||= 0
+
+        case @count
+        when 0 then raise RuntimeError
+        when 1 then raise ArgumentError
+        when 2 then raise NoMethodError
+        else raise NameError
+        end
+      ensure
+        @count += 1
+      end
+    end
+
+    @object = klass.new
+  end
+
+  it "retries a specific number of times on specific errors" do
+    proc { @object.call }.must_raise NoMethodError
+  end
+
+end

data/test/decoratable_test.rb

@@ -0,0 +1,150 @@
+require "test_helper"
+
+require "decoratable"
+require "decoratable/memoizable"
+require "decoratable/countable"
+require "decoratable/hintable"
+
+require "logger"
+
+describe Decoratable do
+
+  # Test-only decorations
+  module Decorations
+    extend Decoratable
+
+    include Countable
+    include Hintable
+    include Memoizable
+
+    def measurable(logger = Logger.new(STDOUT))
+      current = Time.now
+      yield
+    ensure
+      original_method = __decorated_method__
+      method_location, line = original_method.source_location
+      marker = "#{original_method.owner}##{original_method.name}[#{method_location}:#{line}]"
+      duration = (Time.now - current).round(2)
+
+      logger.info "#{marker} took #{duration}s to run."
+    end
+
+    def auditable
+      name = __decorated_method__.name
+
+      key = :"@audit_log"
+      audit_log = instance_variable_get(key) || []
+      audit_log << name
+      instance_variable_set(key, audit_log)
+
+      yield
+    end
+  end
+
+  it "decorates a method" do
+    klass = Class.new do
+      extend Decorations
+
+      countable
+      def call; end
+    end
+
+    object = klass.new
+    3.times { object.call }
+    object.call_call_count.must_equal 3
+  end
+
+  it "can pass configuration arguments to the decoration" do
+    logger = mock_logger
+    klass = Class.new do
+      extend Decorations
+
+      measurable(logger)
+      def initialize; end
+    end
+
+    klass.new
+    logger.verify
+  end
+
+  it "can have multiple decorations on a method" do
+    klass = Class.new do
+      extend Decorations
+
+      countable
+      memoizable
+      def call
+        @counter ||= 0
+        @counter += 1
+      end
+    end
+
+    object = klass.new
+    3.times { object.call }
+
+    # Check countable() works
+    object.call_call_count.must_equal 3
+
+    # Check memoizable() works
+    object.call.must_equal 1
+  end
+
+  it "only decorates the next defined method" do
+    klass = Class.new do
+      extend Decorations
+
+      attr_reader :call2_call_count
+
+      countable
+      def call; end
+      def call2; end
+    end
+
+    object = klass.new
+    3.times { object.call }
+    3.times { object.call2 }
+
+    object.call_call_count.must_equal 3
+    object.call2_call_count.must_equal nil
+  end
+
+  it "allows access to the original decorated method" do
+    klass = Class.new do
+      extend Decorations
+
+      attr_reader :audit_log
+
+      auditable
+      def initialize; end
+
+      auditable
+      def call; end
+    end
+
+    object = klass.new
+    object.call
+    object.audit_log.must_equal [:initialize, :call]
+  end
+
+  it "gives access to the arguments and blocks of the original method call" do
+    klass = Class.new do
+      extend Decorations
+
+      hintable(Integer, String, require_block: true)
+      def call(a, b); end
+    end
+
+    object = klass.new
+    proc { object.call(:a, 1) }.must_raise ArgumentError, /#{Regexp.escape("a expected argument of type Integer, was Symbol (:a)")}/
+    proc { object.call(1, :b) }.must_raise ArgumentError, /#{Regexp.escape("b expected argument of type String, was Symbol (:b)")}/
+    proc { object.call(1, "") }.must_raise ArgumentError, /call requires a block/
+  end
+
+  def mock_logger
+    logger = Minitest::Mock.new
+    logger.expect(:info, nil) do |message|
+      message =~ /took \d+\.\d+s to run/
+    end
+    logger
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require "minitest/autorun"
+require "minitest/mock"
+require "minitest/pride"
+require "pry"

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: decoratable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ecin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: Decorate your methods.
+email:
+- ecin@copypastel.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".travis.yml"
+- Gemfile
+- Rakefile
+- decoratable.gemspec
+- lib/decoratable.rb
+- lib/decoratable/countable.rb
+- lib/decoratable/debuggable.rb
+- lib/decoratable/hintable.rb
+- lib/decoratable/memoizable.rb
+- lib/decoratable/pryable.rb
+- lib/decoratable/retryable.rb
+- test/decoratable/countable_test.rb
+- test/decoratable/hintable_test.rb
+- test/decoratable/memoizable_test.rb
+- test/decoratable/pryable_test.rb
+- test/decoratable/retryable_test.rb
+- test/decoratable_test.rb
+- test/test_helper.rb
+homepage: https://github.com/ecin/decoratable
+licenses:
+- MIT
+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.4.3
+signing_key: 
+specification_version: 4
+summary: Easily define decorations for your methods. Put a bow on it.
+test_files:
+- test/decoratable/countable_test.rb
+- test/decoratable/hintable_test.rb
+- test/decoratable/memoizable_test.rb
+- test/decoratable/pryable_test.rb
+- test/decoratable/retryable_test.rb
+- test/decoratable_test.rb
+- test/test_helper.rb
+has_rdoc: