rns 0.0.5 → 0.0.6

data/.gitignore

@@ -1,3 +1,5 @@
+/Gemfile.lock
+
 # rcov generated
 coverage
 

data/README.md

@@ -12,43 +12,33 @@ functional programming in Ruby.  It is inspired by
 ```ruby
 require 'rns'
 
-module Arithmetic
-  class << self
-    def dec(n) n - 1 end
-    def inc(n) n + 1 end
-  end
+Arithmetic = Rns do
+  def dec(n) n - 1 end
+  def inc(n) n + 1 end
 end
 
-module Statistics
-  def self.avg(arr); arr.reduce(:+).to_f / arr.count end
+Statistics = Rns do
+  def avg(arr) arr.reduce(:+).to_f / arr.count end
 end
 
 class Main
-  extend Rns.use(Arithmetic => [:inc])
-  include Rns.use(Statistics => [:avg])
-
-  def self.incremented(n)
-    "#{n} incremented is #{inc n}"
+  Funcs = Rns(Statistics, Arithmetic => [:inc]) do
+    def incremented_avg(nums)
+      avg nums.map(&method(:inc))
+    end
   end
 
   def main
-    puts "#{self.class.incremented 1} and the average of [1,2,3] is #{avg [1,2,3]}"
+    nums = [1, 2, 3]
+    puts "The average of #{nums.inspect} incremented is: #{Funcs.incremented_avg nums}"
   end
 end
 
 Main.new.main
 ```
 
-## Importing Methods into Blocks
-
-```ruby
-Rns::using(Arithmetic => [:inc], Statistics => [:avg]) do
-  puts avg((1..10).to_a.map(&method(:inc)))
-end
-```
-
 Please see the
-[tests](https://github.com/alandipert/rns/tree/master/spec/rns) for more
+[tests](https://github.com/alandipert/rns/tree/master/test) for more
 usage examples.
 
 # Rationale

data/Rakefile

@@ -1,13 +1,9 @@
 require 'rubygems'
 require 'bundler'
-require "rspec/core/rake_task"
-require 'rake'
+require 'rake/testtask'
 
-desc "Run all specs"
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern = "spec/**/*_spec.rb"
-  t.ruby_opts = '-Ilib -Ispec -I.'
-  t.rspec_opts = '--color'
+Rake::TestTask.new do |t|
+  t.pattern = "test/*_test.rb"
 end
 
-task :default => :spec
+task :default => :test

data/lib/rns.rb

@@ -1,45 +1,101 @@
+require 'rns/version'
+
+module Kernel
+  # Returns an immutable namespace of functions
+  #
+  # * `imports` can be any number of other namespaces from which to import functions or hashes
+  #   specifying which functions to import.
+  # * The block contains the functions to be `def`ed for the namespace. Since namespaces are
+  #   immutable, instance variable and class variable cannot be set in functions.  In other
+  #   words, `@var = :something` will raise an error.
+  #
+  # Example:
+  #
+  #     StringManipulation = Rns(SomeOtherNs, AnotherNs => [:alternate_case]) do
+  #       def crazify(str)
+  #         "#{alternate_case str}!"
+  #       end
+  #     end
+  #
+  #     StringManipulation.crazify("whoa") #=> "WhOa!"
+  #
+  def Rns(*imports, &block)
+    klass = Class.new(Rns::Namespace, &block)
+    klass.import(imports)
+    klass.freeze.send(:new).freeze
+  end
+end
+
 module Rns
-  class << self
-    def constant_for(module_names)
-      (m, *more) = module_names.map{|n| n.split("::")}.flatten
-      more.reduce(Kernel.const_get(m)){|m, s| m.const_get(s)}
-    end
+  # Error raised while importing methods
+  class ImportError < StandardError
+  end
 
-    def use(use_spec)
-      Module.new.tap {|m| add_methods(m, use_spec) }
-    end
+  # An internal class used to support Kernel#Rns in returning namespaces
+  class Namespace
+    class << self
+      # Use Kernel#Rns instead
+      private :new
+
+      # Imports methods from objects into this namespace class as private instance methods.
+      def import(imports)
+        ns_methods = instance_methods()
+        @_import_hash = array_to_key_value_tuples(imports).reduce({}) do |h, (obj, methods)|
+          if !obj.frozen?
+            raise ImportError, "#{obj} cannot be imported into Namespace because it is not frozen"
+          elsif !obj.class.frozen?
+            raise ImportError, "#{obj} cannot be imported into Namespace because its class is not frozen"
+          end
+
+          (methods || obj.public_methods(false)).each do |method|
+            if ns_methods.include? method
+              raise ImportError, "cannot override #{method} with an import"
+            end
+            h[method.to_sym] = obj.method(method)
+          end
 
-    def process_spec_entry(entry)
-      (k,v) = entry
-      if (v.is_a? Array)
-        v.map{|x| process_spec_entry([k,x])}
-      elsif (v.is_a? Hash)
-        v.map do |x,y|
-          process_spec_entry([constant_for([k, x].map(&:to_s)), y])
+          h
+        end
+
+        file, line = import_call_site(caller)
+        @_import_hash.each do |method, _|
+          # eval is needed because:
+          #   * Module#define_method can't delegate to methods that accept blocks
+          #   * method_missing can, but then imported methods are available publicly
+          module_eval(delegate_to_hash_source(method, :@_import_hash), file, line - 1)
+          private method
         end
-      else
-        [k,v]
       end
-    end
 
-    def process_spec(use_spec)
-      use_spec.map(&method(:process_spec_entry)).
-        flatten.
-        each_slice(2).
-        to_a
-    end
+    private
+      # array_to_key_value_tuples([:a, {:b => 1, :c => 2}, :d])
+      # #=> [[:a, nil], [:b, 1], [:c, 2], [:d, nil]]
+      def array_to_key_value_tuples(array)
+        array.reduce([]) do |tuples, elem|
+          if elem.is_a? Hash
+            tuples + Array(elem)
+          else
+            tuples << [elem, nil]
+          end
+        end
+      end
 
-    def add_methods(to, use_spec)
-      process_spec(use_spec).each do |from, method|
-        to.send(:define_method, method, &from.method(method))
-        to.send(:private, method)
+      # Delegates all calls to a callable stored in an ivar of the class'es
+      def delegate_to_hash_source(method_name, hash_name)
+        <<-EOS
+          def #{method_name}(*args, &block)
+            self.class.instance_variable_get(:#{hash_name}).fetch(:#{method_name}).call(*args, &block)
+          end
+        EOS
       end
-    end
 
-    def using(use_spec, &blk)
-      klass = Class.new
-      add_methods(klass, use_spec)
-      klass.new.instance_eval(&blk)
+      # Given a backtrace, return the file/line where the user imported a method. Skip frames in
+      # Kernel#Rns since the user's import code will be in the frame afterwards.
+      def import_call_site(backtrace)
+        frame = backtrace.detect {|f| f !~ /in `Rns'$/ }
+        file, line = frame.split(':', 2)
+        [file, line.to_i]
+      end
     end
   end
-end
+end

data/lib/rns/version.rb

@@ -1,3 +1,3 @@
 module Rns
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/rns.gemspec

@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  s.add_development_dependency 'rspec'
   s.add_development_dependency 'guard'
   s.add_development_dependency 'guard-rspec'
   s.add_development_dependency 'simplecov'

data/test/rns_test.rb

@@ -0,0 +1,174 @@
+require 'minitest/autorun'
+require 'rns'
+
+class RnsTest < MiniTest::Unit::TestCase
+  Math = Rns do
+    def inc(n)
+      n + 1
+    end
+
+    def dec(n)
+      n - 1
+    end
+  end
+
+  def test_functions_function
+    m = Rns do
+      def add(a, b)
+        a + b
+      end
+
+      def inc(a)
+        add a, 1
+      end
+
+      def dec_block
+        add yield(), -1
+      end
+    end
+
+    assert_equal 42, m.add(20, 22)
+    assert_equal 2, m.inc(1)
+    assert_equal 11, m.dec_block { 12 }
+  end
+
+  def test_private_functions
+    m = Rns do
+      def whoa_dave
+        whoa "Dave"
+      end
+    private
+      def whoa(dude)
+        "Whoa, #{dude}, totally awesome wave"
+      end
+    end
+
+    assert_equal "Whoa, Dave, totally awesome wave", m.whoa_dave
+    assert_raises NoMethodError do
+      m.whoa "Man"
+    end
+  end
+
+  def test_ivars_cant_be_set
+    m = Rns do
+      def set_ivar
+        @ivar = "something"
+      end
+    end
+
+    assert_raises_frozen_error do
+      m.set_ivar
+    end
+    assert_raises_frozen_error do
+      m.instance_variable_set :@ivar, "something"
+    end
+  end
+
+  def test_cvars_cant_be_set
+    m = Rns do
+      def set_cvar
+        @@cvar = "something"
+      end
+    end
+
+    # this fails on 1.8.7
+    assert_raises_frozen_error do
+      m.set_cvar
+    end
+  end
+
+  def test_importing_namespaces
+    ns = Rns(Math) do
+      def double_inc(n)
+        inc inc(n)
+      end
+    end
+
+    assert_equal 3, ns.double_inc(1)
+  end
+
+  def test_importing_namespace_functions
+    ns = Rns(Math => [:dec]) do
+      def double_inc(n)
+        inc inc(n)
+      end
+
+      def double_dec(n)
+        dec dec(n)
+      end
+    end
+
+    assert_equal -1, ns.double_dec(1)
+    assert_raises NoMethodError do
+      ns.double_inc(1)
+    end
+  end
+
+  def test_imported_methods_arent_public
+    ns = Rns(Math => [:dec]) do
+    end
+
+    assert_raises NoMethodError do
+      ns.dec(1)
+    end
+  end
+
+  def test_mutable_objects_cant_be_imported_from
+    assert_raises Rns::ImportError do
+      Rns(IO) {}
+    end
+  end
+
+  def test_objects_of_mutable_classes_cant_be_imported_from
+    assert_raises Rns::ImportError do
+      Rns(Object.new.freeze) {}
+    end
+  end
+
+  def test_imports_cannot_override_functions
+    assert_raises Rns::ImportError do
+      Rns(Math => [:inc]) do
+        def inc
+          "Can I be overridden?"
+        end
+      end
+    end
+  end
+
+  def test_error_backtraces_include_point_of_import
+    ns = Rns do
+      def kablammo!
+        raise "kablammo!"
+      end
+    end
+
+    import_line = __LINE__ + 1
+    ns2 = Rns(ns => [:kablammo!]) do
+      def totally_safe
+        kablammo!
+      end
+    end
+
+    begin
+      ns2.totally_safe
+    rescue => e
+      import_frame = e.backtrace[1]
+      file, line = import_frame.split(':', 2)
+      assert_equal __FILE__, file
+      assert_equal import_line, line.to_i
+    else
+      flunk "Expected an error on import"
+    end
+  end
+
+private
+
+  def assert_raises_frozen_error
+    yield
+  rescue RuntimeError, TypeError => e
+    assert_match /can't modify/i, e.message
+  else
+    flunk "Frozen object exception expected"
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rns
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,24 +9,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-10 00:00:00.000000000 Z
+date: 2012-07-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -88,7 +72,6 @@ files:
 - .rvmrc
 - .travis.yml
 - Gemfile
-- Gemfile.lock
 - Guardfile
 - LICENSE.txt
 - README.md
@@ -96,8 +79,7 @@ files:
 - lib/rns.rb
 - lib/rns/version.rb
 - rns.gemspec
-- spec/rns/rns_spec.rb
-- spec/spec_helper.rb
+- test/rns_test.rb
 homepage: http://github.com/alandipert/rns
 licenses:
 - BSD-new

data/Gemfile.lock

@@ -1,41 +0,0 @@
-PATH
-  remote: .
-  specs:
-    rns (0.0.5)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    diff-lcs (1.1.3)
-    ffi (1.0.11)
-    guard (1.0.2)
-      ffi (>= 0.5.0)
-      thor (~> 0.14.6)
-    guard-rspec (0.7.0)
-      guard (>= 0.10.0)
-    multi_json (1.3.4)
-    rake (0.9.2.2)
-    rspec (2.10.0)
-      rspec-core (~> 2.10.0)
-      rspec-expectations (~> 2.10.0)
-      rspec-mocks (~> 2.10.0)
-    rspec-core (2.10.0)
-    rspec-expectations (2.10.0)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.10.1)
-    simplecov (0.6.2)
-      multi_json (~> 1.3)
-      simplecov-html (~> 0.5.3)
-    simplecov-html (0.5.3)
-    thor (0.14.6)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  guard
-  guard-rspec
-  rake
-  rns!
-  rspec
-  simplecov

data/spec/rns/rns_spec.rb

@@ -1,163 +0,0 @@
-require File.join(File.dirname(__FILE__), *%w[.. spec_helper.rb])
-require 'rns'
-
-module Math
-  def self.identity(x); x end
-
-  module Arithmetic
-    class << self
-      def dec(n) n - one end
-      def inc(n) n + one end
-      def add(x,y) x + y end
-      private
-      def one() 1 end
-    end
-  end
-
-  module Statistics
-    def self.avg(arr); arr.reduce(:+).to_f / arr.count end
-    module Foo
-      def self.blah; :quux end
-    end
-  end
-end
-
-module BlockTakers
-  def self.takes_block(&blk); yield; end
-end
-
-module Util
-  class << self
-    def assoc!(h, k, v)
-      h.tap{|o| o[k] = v}
-    end
-
-    def merge_with(f, *hshs)
-      merge_entry = lambda do |h, (k,v)|
-        if (h.has_key?(k))
-          assoc!(h, k, f[h[k], v])
-        else
-          assoc!(h, k, v)
-        end
-      end
-      merge2 = lambda do |h1,h2|
-        h2.to_a.reduce(h1, &merge_entry)
-      end
-      ([{}] + hshs).reduce(&merge2)
-    end
-  end
-end
-
-class Thing
-  extend Rns.use(Math::Arithmetic => [:inc])
-  include Rns.use(Math::Statistics => [:avg])
-
-  def self.inced_one
-    inc 1
-  end
-
-  def average
-    avg [11, 42, 7]
-  end
-end
-
-describe Rns do
-  context 'adding methods to classes' do
-    it "works" do
-      Thing.new.average.should == 20
-    end
-
-    it "works with private module methods" do
-      Thing.inced_one.should == 2
-    end
-
-    it "should add methods privately" do
-      lambda { Thing.new.avg [11, 42, 7] }.should raise_error(NoMethodError)
-    end
-  end
-
-  context 'adding methods to blocks' do
-
-    it 'computes' do
-      Rns::using(Util => [:merge_with],
-                 Math::Arithmetic => [:inc, :add]) do
-
-        sum = lambda{|*xs| xs.reduce(:+)}
-
-        merge_with(sum, *(1..10).map{|n| {x: n}})[:x].should == 55
-        merge_with(sum,
-                   {x: 10, y: 20},
-                   {x: 3, z: 30}).should == {x: 13, y: 20, z: 30}
-
-        merge_with(lambda{|l,r| l.send(:+, r)},
-                   {:x => [:something]},
-                   {:x => [:else]}).should == {:x => [:something, :else]}
-      end
-    end
-
-    it "works with individual modules" do
-      Rns::using(Math::Arithmetic => [:inc],
-                 Math::Statistics => [:avg]) do
-        avg((1..10).to_a.map(&method(:inc))).should == 6.5
-      end
-    end
-
-    it "works with nested modules" do
-      Rns::using(Math => {:Arithmetic => [:inc],
-                          :Statistics => [:avg]}) do
-        avg((1..10).to_a.map(&method(:inc))).should == 6.5
-      end
-    end
-
-    it "works with mix of module declaration styles" do
-      Rns::using(Math::Arithmetic => [:inc],
-                 Math => [:identity,
-                          {:Statistics => [:avg]}]) do
-        identity(1).should == 1
-        inc(10).should == 11
-        avg((1..10).to_a.map(&method(:inc))).should == 6.5
-      end
-    end
-
-    it "does not modify Object" do
-      Rns::using(Math::Arithmetic => [:inc]) do
-        # do nothing
-      end
-      lambda { Object.new.inc 1 }.should raise_error(NoMethodError)
-    end
-
-    it "does not modify Class" do
-      Rns::using(Math::Arithmetic => [:inc]) do
-        # do nothing
-      end
-      lambda { Class.new.inc 1 }.should raise_error(NoMethodError)
-    end
-
-    it "imports a method that takes a block" do
-      Rns::using(BlockTakers => [:takes_block]) do
-        takes_block do
-          :returned_from_block
-        end.should == :returned_from_block
-      end
-    end
-
-    it 'processes specs correctly' do
-      Rns::using(Rns => [:process_spec]) do
-        process_spec({Math => [:inc, :dec]}).
-          should == [[Math, :inc], [Math, :dec]]
-      end
-
-      Rns::using(Rns => [:process_spec]) do
-        spec = {Math::Arithmetic => [:inc],
-                Math => [:identity,
-                         {:Statistics => [:avg,
-                                          {:Foo => [:blah, :quux]}]}]}
-        process_spec(spec).should == [[Math::Arithmetic, :inc],
-                                      [Math, :identity],
-                                      [Math::Statistics, :avg],
-                                      [Math::Statistics::Foo, :blah],
-                                      [Math::Statistics::Foo, :quux]]
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,7 +0,0 @@
-require File.join(File.dirname(__FILE__), *%w[.. lib rns])
-
-RSpec.configure do |config|
-  config.filter_run :focused => true
-  config.alias_example_to :fit, :focused => true
-  config.run_all_when_everything_filtered = true
-end