lotus-utils 0.0.0 → 0.1.0

data/lib/lotus/utils/string.rb

@@ -0,0 +1,113 @@
+module Lotus
+  module Utils
+    # String on steroids
+    #
+    # @since 0.1.0
+    class String < ::String
+      # Separator between Ruby namespaces
+      #
+      # @example
+      #   Lotus::Utils
+      #
+      # @since 0.1.0
+      # @api private
+      NAMESPACE_SEPARATOR = '::'.freeze
+
+      # Initialize the string
+      #
+      # @param string [::String, Symbol] the value we want to initialize
+      #
+      # @return [String] self
+      #
+      # @since 0.1.0
+      def initialize(string)
+        super(string.to_s)
+      end
+
+      # Return a CamelCase version of the string
+      #
+      # @return [String] the transformed string
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'lotus/utils/string'
+      #
+      #   string = Lotus::Utils::String.new 'lotus_utils'
+      #   string.classify # => 'LotusUtils'
+      def classify
+        split('_').map {|token| token.slice(0).upcase + token.slice(1..-1) }.join
+      end
+
+      # Return a downcased and underscore separated version of the string
+      #
+      # Revised version of `ActiveSupport::Inflector.underscore` implementation 
+      # @see https://github.com/rails/rails/blob/feaa6e2048fe86bcf07e967d6e47b865e42e055b/activesupport/lib/active_support/inflector/methods.rb#L90
+      #
+      # @return [String] the transformed string
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'lotus/utils/string'
+      #
+      #   string = Lotus::Utils::String.new 'LotusUtils'
+      #   string.underscore # => 'lotus_utils'
+      def underscore
+        gsub(NAMESPACE_SEPARATOR, '/').
+          gsub(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          downcase
+      end
+
+      # Return the string without the Ruby namespace of the class
+      #
+      # @return [String] the transformed string
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'lotus/utils/string'
+      #
+      #   string = Lotus::Utils::String.new 'Lotus::Utils::String'
+      #   string.demodulize # => 'String'
+      #
+      #   string = Lotus::Utils::String.new 'String'
+      #   string.demodulize # => 'String'
+      def demodulize
+        split(NAMESPACE_SEPARATOR).last
+      end
+
+      # It iterates thru the tokens and calls the given block.
+      # A token is a substring wrapped by `()` and separated by `|`.
+      #
+      # @param blk [Proc, #call] the block that is called for each token.
+      #
+      # @return [void]
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'lotus/utils/string'
+      #
+      #   string = Lotus::Utils::String.new 'Lotus::(Utils|App)'
+      #   string.tokenize do |token|
+      #     puts token
+      #   end
+      #
+      #   # =>
+      #     'Lotus::Utils'
+      #     'Lotus::App'
+      def tokenize(&blk)
+        template = gsub(/\((.*)\)/, "%{token}")
+        tokens   = Array(( $1 || self ).split('|'))
+
+        tokens.each do |token|
+          blk.call(template % {token: token})
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/lotus/utils/version.rb

@@ -1,5 +1,5 @@
 module Lotus
   module Utils
-    VERSION = "0.0.0"
+    VERSION = '0.1.0'
   end
 end

data/lib/lotus/utils.rb

@@ -1,7 +1,7 @@
-require "lotus/utils/version"
+require 'lotus/utils/version'
 
 module Lotus
+  # Ruby core extentions and Louts utilities
   module Utils
-    # Your code goes here...
   end
 end

data/lotus-utils.gemspec

@@ -4,20 +4,20 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'lotus/utils/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "lotus-utils"
+  spec.name          = 'lotus-utils'
   spec.version       = Lotus::Utils::VERSION
-  spec.authors       = ["Luca Guidi"]
-  spec.email         = ["me@lucaguidi.com"]
-  spec.summary       = %q{Ruby core extentions and class utilities for Lotus}
-  spec.description   = %q{Ruby core extentions and class utilities for Lotus}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.authors       = ['Luca Guidi']
+  spec.email         = ['me@lucaguidi.com']
+  spec.description   = %q{Lotus utilities}
+  spec.summary       = %q{Ruby core extentions and Louts utilities}
+  spec.homepage      = 'http://lotusrb.org'
+  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.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake',    '~> 10'
 end

data/test/callbacks_test.rb

@@ -0,0 +1,213 @@
+require 'test_helper'
+require 'lotus/utils/callbacks'
+
+class Callable
+  def call
+  end
+end
+
+class Action
+  attr_reader :logger
+
+  def initialize
+    @logger = Array.new
+  end
+
+  private
+  def authenticate!
+    logger.push 'authenticate!'
+  end
+
+  def set_article(params)
+    logger.push "set_article: #{ params[:id] }"
+  end
+end
+
+describe Lotus::Utils::Callbacks::Chain do
+  before do
+    @chain = Lotus::Utils::Callbacks::Chain.new
+  end
+
+  describe '#add' do
+    it 'wraps the given callback with a callable object' do
+      @chain.add :symbolize!
+
+      cb = @chain.first
+      cb.must_respond_to(:call)
+    end
+
+    describe 'when a callable object is passed' do
+      before do
+        @chain.add callback
+      end
+
+      let(:callback) { Callable.new }
+
+      it 'includes the given callback' do
+        cb = @chain.first
+        cb.callback.must_equal(callback)
+      end
+    end
+
+    describe 'when a Symbol is passed' do
+      before do
+        @chain.add callback
+      end
+
+      let(:callback) { :upcase }
+
+      it 'includes the given callback' do
+        cb = @chain.first
+        cb.callback.must_equal(callback)
+      end
+
+      it 'guarantees unique entries' do
+        # add the callback again, see before block
+        @chain.add callback
+        @chain.size.must_equal(1)
+      end
+    end
+
+    describe 'when a block is passed' do
+      before do
+        @chain.add(&callback)
+      end
+
+      let(:callback) { Proc.new{} }
+
+      it 'includes the given callback' do
+        cb = @chain.first
+        assert_equal cb.callback, callback
+      end
+    end
+
+    describe 'when multiple callbacks are passed' do
+      before do
+        @chain.add *callbacks
+      end
+
+      let(:callbacks) { [:upcase, Callable.new, Proc.new{}] }
+
+      it 'includes all the given callbacks' do
+        @chain.size.must_equal(callbacks.size)
+      end
+
+      it 'all the included callbacks are callable' do
+        @chain.each do |callback|
+          callback.must_respond_to(:call)
+        end
+      end
+    end
+  end
+
+  describe '#run' do
+    let(:action) { Action.new }
+    let(:params) { Hash[id: 23] }
+
+    describe 'when symbols are passed' do
+      before do
+        @chain.add :authenticate!, :set_article
+        @chain.run action, params
+      end
+
+      it 'executes the callbacks' do
+        authenticate = action.logger.shift
+        authenticate.must_equal 'authenticate!'
+
+        set_article = action.logger.shift
+        set_article.must_equal "set_article: #{ params[:id] }"
+      end
+    end
+
+    describe 'when procs are passed' do
+      before do
+        @chain.add do
+          logger.push 'authenticate!'
+        end
+
+        @chain.add do |params|
+          logger.push "set_article: #{ params[:id] }"
+        end
+
+        @chain.run action, params
+      end
+
+      it 'executes the callbacks' do
+        authenticate = action.logger.shift
+        authenticate.must_equal 'authenticate!'
+
+        set_article = action.logger.shift
+        set_article.must_equal "set_article: #{ params[:id] }"
+      end
+    end
+  end
+end
+
+describe Lotus::Utils::Callbacks::Factory do
+  describe '.fabricate' do
+    before do
+      @callback = Lotus::Utils::Callbacks::Factory.fabricate(callback)
+    end
+
+    describe 'when a callable is passed' do
+      let(:callback) { Callable.new }
+
+      it 'fabricates a Callback' do
+        @callback.must_be_kind_of(Lotus::Utils::Callbacks::Callback)
+      end
+
+      it 'wraps the given callback' do
+        @callback.callback.must_equal(callback)
+      end
+    end
+
+    describe 'when a symbol is passed' do
+      let(:callback) { :symbolize! }
+
+      it 'fabricates a MethodCallback' do
+        @callback.must_be_kind_of(Lotus::Utils::Callbacks::MethodCallback)
+      end
+
+      it 'wraps the given callback' do
+        @callback.callback.must_equal(callback)
+      end
+    end
+  end
+end
+
+describe Lotus::Utils::Callbacks::Callback do
+  before do
+    @callback = Lotus::Utils::Callbacks::Callback.new(callback)
+  end
+
+  let(:callback) { Proc.new{|params| logger.push("set_article: #{ params[:id] }") } }
+
+  it 'executes self within the given context' do
+    context = Action.new
+    @callback.call(context, { id: 23 })
+
+    invokation = context.logger.shift
+    invokation.must_equal("set_article: 23")
+  end
+end
+
+describe Lotus::Utils::Callbacks::MethodCallback do
+  before do
+    @callback = Lotus::Utils::Callbacks::MethodCallback.new(callback)
+  end
+
+  let(:callback) { :set_article }
+
+  it 'executes self within the given context' do
+    context = Action.new
+    @callback.call(context, { id: 23 })
+
+    invokation = context.logger.shift
+    invokation.must_equal("set_article: 23")
+  end
+
+  it 'implements #hash' do
+    cb = Lotus::Utils::Callbacks::MethodCallback.new(callback)
+    cb.send(:hash).must_equal(@callback.send(:hash))
+  end
+end

data/test/class_attribute_test.rb

@@ -0,0 +1,132 @@
+require 'test_helper'
+require 'lotus/utils/class_attribute'
+
+describe Lotus::Utils::ClassAttribute do
+  before do
+    class ClassAttributeTest
+      include Lotus::Utils::ClassAttribute
+      class_attribute :callbacks, :functions, :values
+      self.callbacks = [:a]
+      self.values    = [1]
+    end
+
+    class SubclassAttributeTest < ClassAttributeTest
+      class_attribute :subattribute
+      self.functions    = [:x, :y]
+      self.subattribute = 42
+    end
+
+    class SubSubclassAttributeTest < SubclassAttributeTest
+    end
+
+    class Vehicle
+      include Lotus::Utils::ClassAttribute
+      class_attribute :engines, :wheels
+
+      self.engines = 0
+      self.wheels  = 0
+    end
+
+    class Car < Vehicle
+      self.engines = 1
+      self.wheels  = 4
+    end
+
+    class Airplane < Vehicle
+      self.engines = 4
+      self.wheels  = 16
+    end
+
+    class SmallAirplane < Airplane
+      self.engines = 2
+      self.wheels  = 8
+    end
+  end
+
+  after do
+    [:ClassAttributeTest,
+     :SubclassAttributeTest,
+     :SubSubclassAttributeTest,
+     :Vehicle,
+     :Car,
+     :Airplane,
+     :SmallAirplane].each do |const|
+      Object.send :remove_const, const
+    end
+  end
+
+  it 'sets the given value' do
+    ClassAttributeTest.callbacks.must_equal([:a])
+  end
+
+  it 'the value it is inherited by subclasses' do
+    SubclassAttributeTest.callbacks.must_equal([:a])
+  end
+
+  it 'if the superclass value changes it does not affects subclasses' do
+    ClassAttributeTest.functions = [:y]
+    SubclassAttributeTest.functions.must_equal([:x, :y])
+  end
+
+  it 'if the subclass value changes it does not affects superclass' do
+    SubclassAttributeTest.values = [3,2]
+    ClassAttributeTest.values.must_equal([1])
+  end
+
+  describe 'when the subclass is defined in a different namespace' do
+    before do
+      module Lts
+        module Routing
+          class Resource
+            class Action
+              include Lotus::Utils::ClassAttribute
+              class_attribute :verb
+            end
+
+            class New < Action
+              self.verb = :get
+            end
+          end
+
+          class Resources < Resource
+            class New < Resource::New
+            end
+          end
+        end
+      end
+    end
+
+    it 'refers to the superclass value' do
+      Lts::Routing::Resources::New.verb.must_equal :get
+    end
+  end
+
+  # it 'if the subclass value changes it affects subclasses' do
+  #   values = [3,2]
+  #   SubclassAttributeTest.values = values
+  #   SubclassAttributeTest.values.must_equal(values)
+  #   SubSubclassAttributeTest.values.must_equal(values)
+  # end
+
+  it 'if the subclass defines an attribute it should not be available for the superclass' do
+    -> { ClassAttributeTest.subattribute }.must_raise(NoMethodError)
+  end
+
+  it 'if the subclass defines an attribute it should be available for its subclasses' do
+    SubSubclassAttributeTest.subattribute.must_equal 42
+  end
+
+  it 'preserves values within the inheritance chain' do
+    Vehicle.engines.must_equal 0
+    Vehicle.wheels.must_equal  0
+
+    Car.engines.must_equal 1
+    Car.wheels.must_equal  4
+
+    Airplane.engines.must_equal 4
+    Airplane.wheels.must_equal  16
+
+    SmallAirplane.engines.must_equal 2
+    SmallAirplane.wheels.must_equal  8
+  end
+end

data/test/class_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+require 'lotus/utils/class'
+
+describe Lotus::Utils::Class do
+  describe '.load!' do
+    before do
+      module App
+        module Layer
+          class Step
+          end
+        end
+
+        module Service
+          class Point
+          end
+        end
+
+        class ServicePoint
+        end
+      end
+    end
+
+    it 'loads the class from the given static string' do
+      Lotus::Utils::Class.load!('App::Layer::Step').must_equal(App::Layer::Step)
+    end
+
+    it 'raises error for missing constant' do
+      -> { Lotus::Utils::Class.load!('MissingConstant') }.must_raise(NameError)
+    end
+
+    it 'loads the class from given string, by interpolating tokens' do
+      Lotus::Utils::Class.load!('App::Service(::Point|Point)').must_equal(App::Service::Point)
+    end
+
+    it 'loads the class from given string, by interpolating string tokens and respecting their order' do
+      Lotus::Utils::Class.load!('App::Service(Point|::Point)').must_equal(App::ServicePoint)
+    end
+
+    it 'loads the class from given string, by interpolating tokens and not stopping after first fail' do
+      Lotus::Utils::Class.load!('App::(Layer|Layer::)Step').must_equal(App::Layer::Step)
+    end
+
+    it 'loads class from given string and namespace' do
+      Lotus::Utils::Class.load!('(Layer|Layer::)Step', App).must_equal(App::Layer::Step)
+    end
+  end
+end

data/test/hash_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+require 'lotus/utils/hash'
+
+describe Lotus::Utils::Hash do
+  it 'acts as a Ruby standard Hash' do
+    hash = Lotus::Utils::Hash.new
+    hash.must_be_kind_of(::Hash)
+
+    ::Hash.new.methods.each do |m|
+      hash.must_respond_to(m)
+    end
+  end
+
+  it 'holds values passed to the constructor' do
+    hash = Lotus::Utils::Hash.new('foo' => 'bar')
+    hash['foo'].must_equal('bar')
+  end
+
+  describe '#symbolize!' do
+    it 'symbolize keys' do
+      hash = Lotus::Utils::Hash.new('fub' => 'baz')
+      hash.symbolize!
+
+      hash['fub'].must_be_nil
+      hash[:fub].must_equal('baz')
+    end
+
+    it 'symbolize nested hashes' do
+      hash = Lotus::Utils::Hash.new('nested' => {'key' => 'value'})
+      hash.symbolize!
+
+      hash[:nested][:key].must_equal('value')
+    end
+  end
+end

data/test/io_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'lotus/utils/io'
+
+class IOTest
+  TEST_CONSTANT = 'initial'
+end
+
+describe Lotus::Utils::IO do
+  describe '.silence_warnings' do
+    it 'lowers verbosity of stdout' do
+      begin
+        position = STDOUT.tell
+
+        Lotus::Utils::IO.silence_warnings do
+          IOTest::TEST_CONSTANT = 'redefined'
+        end
+
+        IOTest::TEST_CONSTANT.must_equal('redefined')
+        STDOUT.tell.must_equal(position)
+      rescue Errno::ESPIPE
+        puts 'Skipping this test, IO#tell is not supported in this environment'
+
+        Lotus::Utils::IO.silence_warnings do
+          IOTest::TEST_CONSTANT = 'redefined'
+        end
+      end
+    end
+  end
+end

data/test/path_prefix_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+require 'lotus/utils/path_prefix'
+
+describe Lotus::Utils::PathPrefix do
+  it 'exposes itself as a string' do
+    prefix = Lotus::Utils::PathPrefix.new
+    prefix.must_equal ''
+  end
+
+  it 'adds root prefix only when needed' do
+    prefix = Lotus::Utils::PathPrefix.new('/fruits')
+    prefix.must_equal '/fruits'
+  end
+
+  describe '#join' do
+    it 'joins a string' do
+      prefix = Lotus::Utils::PathPrefix.new('fruits')
+      prefix.join('peaches').must_equal '/fruits/peaches'
+    end
+
+    it 'joins a prefixed string' do
+      prefix = Lotus::Utils::PathPrefix.new('fruits')
+      prefix.join('/cherries').must_equal '/fruits/cherries'
+    end
+
+    it 'joins a string when the root is blank' do
+      prefix = Lotus::Utils::PathPrefix.new
+      prefix.join('tea').must_equal '/tea'
+    end
+
+    it 'joins a prefixed string when the root is blank' do
+      prefix = Lotus::Utils::PathPrefix.new
+      prefix.join('/tea').must_equal '/tea'
+    end
+  end
+
+  describe '#relative_join' do
+    it 'joins a string without prefixing with separator' do
+      prefix = Lotus::Utils::PathPrefix.new('fruits')
+      prefix.relative_join('peaches').must_equal 'fruits/peaches'
+    end
+
+    it 'joins a prefixed string without prefixing with separator' do
+      prefix = Lotus::Utils::PathPrefix.new('fruits')
+      prefix.relative_join('/cherries').must_equal 'fruits/cherries'
+    end
+
+    it 'joins a string when the root is blank without prefixing with separator' do
+      prefix = Lotus::Utils::PathPrefix.new
+      prefix.relative_join('tea').must_equal 'tea'
+    end
+
+    it 'joins a prefixed string when the root is blank and removes the prefix' do
+      prefix = Lotus::Utils::PathPrefix.new
+      prefix.relative_join('/tea').must_equal 'tea'
+    end
+
+    it 'joins a string with custom separator' do
+      prefix = Lotus::Utils::PathPrefix.new('fruits')
+      prefix.relative_join('cherries', '_').must_equal 'fruits_cherries'
+    end
+
+    it 'joins a prefixed string without prefixing with custom separator' do
+      prefix = Lotus::Utils::PathPrefix.new('fruits')
+      prefix.relative_join('_cherries', '_').must_equal 'fruits_cherries'
+    end
+  end
+end