ori 0.1.0

data/spec/list_method_spec.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "::ORI::ListMethod" do
+  klass = ::ORI::ListMethod
+
+  describe "#access" do
+    meth = :access
+
+    it "generally works" do
+      inputs = []
+      inputs << [{:obj => ::Sample::BasicInheritance::Son, :method_name => "grandpa_protected", :inspector => "protected_instance_methods"}, "#"]
+      inputs << [{:obj => ::Sample::BasicInheritance::Son, :method_name => "grandpa_protected_singleton", :inspector => "protected_methods"}, "::"]
+      inputs.each do |attrs, expected|
+        r = klass.new(attrs)
+        ##p "r", r
+        r.send(meth).should == expected
+      end
+    end
+  end
+
+  describe "#format" do
+    meth = :format
+
+    it "generally works" do
+      inputs = []
+      inputs << [{:obj => 5, :method_name => "%", :inspector => "public_methods"}, [/\bFixnum#%/]]
+      inputs << [{:obj => 5, :method_name => "between?", :inspector => "public_methods"}, [/\bFixnum\b/, /\bComparable\b/, /#between\?/]]
+      inputs << [{:obj => 5, :method_name => "puts", :inspector => "private_methods"}, [/\bFixnum\b/, /\bKernel\b/, /private/]]
+      inputs << [{:obj => nil, :method_name => "to_s", :inspector => "public_methods"}, [/\bNilClass#to_s/]]
+      inputs << [{:obj => Hash, :method_name => "<", :inspector => "public_methods"}, [/\bHash\b/, /\bModule\b/, /</]]
+      inputs << [{:obj => [], :method_name => "&", :inspector => "public_methods"}, [/\bArray#&/]]
+      inputs << [{:obj => Kernel, :method_name => "puts", :inspector => "public_methods"}, [/\bKernel::puts/]]
+      inputs << [{:obj => ::Sample::BasicExtension::OtherMo, :method_name => "public_meth", :inspector => "public_methods"}, [/\bSample::BasicExtension::OtherMo\b/, /\bSample::BasicExtension::Mo\b/, /::public_meth/]]
+      inputs << [{:obj => ::Sample::BasicExtension::OtherMo, :method_name => "protected_meth", :inspector => "protected_methods"}, [/\bSample::BasicExtension::OtherMo\b/, /\bSample::BasicExtension::Mo\b/, /::protected_meth/]]
+      inputs << [{:obj => ::Sample::BasicExtension::OtherMo, :method_name => "private_meth", :inspector => "private_methods"}, [/\bSample::BasicExtension::OtherMo\b/, /\bSample::BasicExtension::Mo\b/, /::private_meth/]]
+
+      inputs.each do |attrs, checks|
+        r = klass.new(attrs)
+        ##p "r", r
+        checks.each do |re|
+          ##p "re", re
+          r.send(meth, :color => false).should match re
+        end
+      end
+    end
+
+    it "supports colored and plain output" do
+      inputs = []
+      inputs << {:obj => 5, :method_name => "%", :inspector => "public_methods"}
+      inputs << {:obj => 5, :method_name => "between?", :inspector => "public_methods"}
+      inputs << {:obj => 5, :method_name => "puts", :inspector => "private_methods"}
+      inputs << {:obj => nil, :method_name => "to_s", :inspector => "public_methods"}
+      inputs << {:obj => Hash, :method_name => "<", :inspector => "public_methods"}
+      inputs << {:obj => [], :method_name => "&", :inspector => "public_methods"}
+      inputs << {:obj => Kernel, :method_name => "puts", :inspector => "public_methods"}
+
+      inputs.each do |attrs|
+        r = klass.new(attrs)
+        ##p "r", r
+        r.send(meth, :color => true).should match Regexp.new(Regexp.escape(attrs[:method_name]))
+        r.send(meth, :color => true).should match Regexp.new(Regexp.escape("\e"))
+        r.send(meth, :color => false).should match Regexp.new(Regexp.escape(attrs[:method_name]))
+        r.send(meth, :color => false).should_not match Regexp.new(Regexp.escape("\e"))
+      end
+    end
+  end # #format
+
+  describe "#own?" do
+    meth = :own?
+
+    it "generally works" do
+      inputs = []
+      inputs << [{:obj => 5, :method_name => "%", :inspector => "public_methods"}, true]
+      inputs << [{:obj => 5, :method_name => "between?", :inspector => "public_methods"}, false]
+      inputs << [{:obj => Kernel, :method_name => "puts", :inspector => "public_methods"}, true]
+      inputs << [{:obj => Kernel, :method_name => "dup", :inspector => "public_instance_methods"}, true]
+
+      inputs.each do |attrs, expected|
+        r = klass.new(attrs)
+        ##p "r", r
+        r.send(meth).should == expected
+      end
+    end
+  end # #own?
+
+  describe "#ri_topics" do
+    meth = :ri_topics
+
+    include HelperMethods
+
+    it "generally works" do
+      r = glm(5, "#is_a?")
+      r.ri_topics.should include ["Fixnum", "#", "is_a?"]
+      r.ri_topics.should include ["Object", "#", "is_a?"]
+
+      r = glm(Hash, "#[]")
+      r.ri_topics.should include ["Hash", "#", "[]"]
+
+      r = glm(Sample::BasicInheritance::Son, "grandpa_public")
+      r.ri_topics.should include ["Sample::BasicInheritance::Son", "#", "grandpa_public"]
+      r.ri_topics.should include ["Sample::BasicInheritance::Grandpa", "#", "grandpa_public"]
+
+      r = glm(Sample::BasicInheritance::Son, "grandpa_public_singleton")
+      r.ri_topics.should include ["Sample::BasicInheritance::Son", "::", "grandpa_public_singleton"]
+      r.ri_topics.should include ["Sample::BasicInheritance::Papa", "::", "grandpa_public_singleton"]
+      r.ri_topics.should include ["Sample::BasicInheritance::Grandpa", "::", "grandpa_public_singleton"]
+
+      r = glm(Sample::BasicExtension::Klass, "public_meth")
+      r.ri_topics.should include ["Sample::BasicExtension::Klass", "::", "public_meth"]
+      r.ri_topics.should include ["Sample::BasicExtension::Mo", "#", "public_meth"]
+    end
+
+    it "does not contain duplicates" do
+      r = glm(Module, "#public")
+      r.ri_topics.should == r.ri_topics.uniq
+    end
+  end # #ri_topics
+end

data/spec/request_spec.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "::ORI::Request" do
+  klass = ::ORI::Request
+
+  it "generally works" do
+    # NOTE: Order is: self, method, list, error. Thinnest first, fattest last. Then errors.
+
+    r = klass.parse()
+    r.self?.should == true
+    r.glm_options[:objs].should == []
+
+    ###
+
+    r = klass.parse(:puts)
+    r.method?.should == true
+    r.glm_options[:all].should == true
+    "puts".should match r.glm_options[:re]
+    ##p "r.glm_options", r.glm_options
+
+    r = klass.parse("#puts")
+    r.method?.should == true
+    r.glm_options[:all].should == true
+    "puts".should match r.glm_options[:re]
+    r.glm_options[:access].should == "#"
+
+    r = klass.parse("::puts")
+    r.method?.should == true
+    r.glm_options[:all].should == true
+    "puts".should match r.glm_options[:re]
+    r.glm_options[:access].should == "::"
+
+    ###
+
+    r = klass.parse(/kk/)
+    r.list?.should == true
+    r.glm_options[:objs].should == []
+    r.glm_options[:re].should == /kk/
+
+    r = klass.parse(/kk/, :all, :own)
+    r.glm_options[:all].should == true
+    r.glm_options[:own].should == true
+    r.glm_options[:objs].should == []
+    r.glm_options[:re].should == /kk/
+
+    ###
+
+    r = klass.parse(//, :join => 1)
+    r.list?.should == true
+    r.glm_options.should_not have_key(:join)
+    r.glm_options[:objs].should == [1]
+    r.glm_options[:re].should == //
+
+    r = klass.parse(//, :join => [1])
+    r.list?.should == true
+    r.glm_options.should_not have_key(:join)
+    r.glm_options[:objs].should == [1]
+    r.glm_options[:re].should == //
+
+    r = klass.parse(//, :join => [1, [2]])
+    r.list?.should == true
+    r.glm_options.should_not have_key(:join)
+    r.glm_options[:objs].should == [1, [2]]
+    r.glm_options[:re].should == //
+
+    ###
+
+    r = klass.parse(5678)
+    r.error?.should == true
+    r.message.should match /5678/
+  end
+end

data/spec/site/NOTES

@@ -0,0 +1,3 @@
+These specs depend on a particular OS, environment and setup.
+
+They SHOULD pass, but if the setup is incorrect, they may fail.

data/spec/site/library_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+require "rbconfig"
+
+describe "ORI::Library" do
+  klass = ::ORI::Library
+
+  # NOTES:
+  # * We recreate object every time if we are not specifically testing caching.
+  # * We rely upon AutoConfig to detect OS settings.
+
+  autoconf = ::ORI::AutoConfig.new((k = "host_os") => RbConfig::CONFIG[k])
+  fresh = klass.new({
+    (k = :frontend) => autoconf.send(k),
+    (k = :shell_escape) => autoconf.send(k),
+  })
+  ##p "fresh", fresh
+
+  describe "#lookup" do
+    meth = :lookup
+
+    it "generally works" do
+      r = fresh.dup
+      r.lookup("Object#is_a?").should_not be_nil
+
+      r = fresh.dup
+      r.lookup("Object#is_kk?").should be_nil
+
+      r = fresh.dup
+      r.lookup("Object#kakamakaka").should be_nil
+    end
+  end
+end

data/spec/site/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "../spec_helper")

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# Library files.
+require File.join(File.dirname(__FILE__), "../lib/ori")
+
+# Samples.
+Dir[File.join(File.dirname(__FILE__), "../samples/**/*.rb")].each {|fn| require fn}
+
+module HelperMethods
+  # Quickly fetch ONE named ListMethod of <tt>obj</tt>.
+  #
+  #   glm(Hash, "::[]")
+  #   glm(Hash, "#[]")
+  def glm(obj, method_name)
+    req = ::ORI::Request.parse(method_name)
+    raise ArgumentError, "glm: Not a method request" if not req.method?
+
+    req.glm_options[:objs].unshift(obj)
+    ar = ::ORI::Internals.get_list_methods(req.glm_options)
+    if ar.size < 1
+      raise "glm: No methods found"
+    elsif ar.size > 1
+      raise "glm: #{ar.size} methods found, please be more specific"
+    end
+
+    ar[0]
+  end
+end

data/spec/tools_spec.rb

@@ -0,0 +1,109 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "::ORI::Tools" do
+  mod = ::ORI::Tools
+
+  describe ".ansi" do
+    meth = :ansi
+
+    it "returns empty string if no attrs are given" do
+      mod.send(meth).should == ""
+    end
+
+    it "refuses to take unknown attributes" do
+      proc do
+        mod.send(meth, :kaka)
+      end.should raise_error(ArgumentError)
+    end
+
+    it "generally works" do
+      mod.send(meth, :red).should == "\e[31m"
+      mod.send(meth, :red, :on_green).should == "\e[31;42m"
+    end
+  end # .ansi
+
+  describe ".get_methods" do
+    meth = :get_methods
+
+    it "allows to fetch own methods only" do
+      ar = mod.send(meth, ::Sample::BasicInheritance::Son, :inspector_arg => false)
+      ##p "ar", ar
+      h = Hash[*ar.flatten(1)]
+      ##p "h", h
+
+      h["public_instance_methods"].should == ["son_public"]
+      h["protected_instance_methods"].should == ["son_protected"]
+      h["private_instance_methods"].should == ["son_private"]
+      h["public_methods"].should include("son_public_singleton", "papa_public_singleton", "grandpa_public_singleton")
+      h["protected_methods"].should include("son_protected_singleton", "papa_protected_singleton", "grandpa_protected_singleton")
+      h["private_methods"].should include("son_private_singleton", "papa_private_singleton", "grandpa_private_singleton")
+    end
+
+    it "supports MAV mode" do
+      ar = mod.send(meth, ::Sample::BasicInheritance::Son, :to_mav => true)
+      ##p "ar", ar
+      ar.should include(["son_public", "#", :public], ["son_protected", "#", :protected], ["son_private", "#", :private])
+      ar.should include(["son_public_singleton", "::", :public], ["son_protected_singleton", "::", :protected], ["son_private_singleton", "::", :private])
+      ar.should include(["papa_public", "#", :public], ["papa_protected", "#", :protected], ["papa_private", "#", :private])
+      ar.should include(["papa_public_singleton", "::", :public], ["papa_protected_singleton", "::", :protected], ["papa_private_singleton", "::", :private])
+
+      ar = mod.send(meth, ::Sample::BasicExtension::OtherMo, :to_mav => true)
+      ar.should include(["public_meth", "::", :public], ["protected_meth", "::", :protected], ["private_meth", "::", :private])
+
+      ar = mod.send(meth, ::Sample::BasicExtension::Klass, :to_mav => true)
+      ar.should include(["public_meth", "::", :public], ["protected_meth", "::", :protected], ["private_meth", "::", :private])
+    end
+  end # .get_methods
+
+  describe ".get_module_name" do
+    meth = :get_module_name
+
+    it "works for normal classes and modules" do
+      mod.send(meth, Kernel).should == "Kernel"
+      mod.send(meth, String).should == "String"
+    end
+
+    it "works for class singletons" do
+      klass = class << String; self; end
+      mod.send(meth, klass).should == "String"
+    end
+
+    it "works for module singletons" do
+      klass = class << Enumerable; self; end
+      mod.send(meth, klass).should == "Enumerable"
+    end
+
+    it "works for instance singletons" do
+      klass = class << "kk"; self; end
+      mod.send(meth, klass).should == "String"
+
+      klass = class << []; self; end
+      mod.send(meth, klass).should == "Array"
+
+      klass = class << (class << []; self; end); self; end
+      mod.send(meth, klass).should == "Class"
+    end
+
+    it "works for namespaced names" do
+      klass = class << ::Sample::BasicExtension::Mo; self; end
+      mod.send(meth, klass).should == "Sample::BasicExtension::Mo"
+
+      klass = class << ::Sample::BasicExtension::Klass; self; end
+      mod.send(meth, klass).should == "Sample::BasicExtension::Klass"
+
+      klass = class << ::Sample::BasicExtension::Klass.new; self; end
+      mod.send(meth, klass).should == "Sample::BasicExtension::Klass"
+    end
+  end # .get_module_name
+
+  describe ".shell_escape" do
+    meth = :shell_escape
+
+    it "generally works" do
+      mod.send(meth, "").should == "''"
+      mod.send(meth, "one two").should == "one\\ two"
+      mod.send(meth, "one\ntwo").should == "one'\n'two"
+      mod.send(meth, "Kernel#`").should == "Kernel\\#\\`"
+    end
+  end # .shell_escape
+end # ::ORI::Tools

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: ori
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Alex Fortuna
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-02 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: Object-Oriented RI for IRB Console
+email: alex.r@askit.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.html
+- README.md
+files: 
+- MIT-LICENSE
+- README.html
+- README.md
+- Rakefile
+- VERSION.yml
+- lib/misc/method_aliases.rb
+- lib/ori.rb
+- lib/ori/auto_config.rb
+- lib/ori/colorize.rb
+- lib/ori/config.rb
+- lib/ori/extensions.rb
+- lib/ori/extensions/object/ri.rb
+- lib/ori/internals.rb
+- lib/ori/library.rb
+- lib/ori/list_method.rb
+- lib/ori/request.rb
+- lib/ori/tools.rb
+- ori.gemspec
+- samples/NOTES
+- samples/basic_extension.rb
+- samples/basic_inheritance.rb
+- samples/self_singletons.rb
+- samples/singleton_class_includes_module.rb
+- spec/auto_config_spec.rb
+- spec/colorize_spec.rb
+- spec/inspector_spec.rb
+- spec/internals_spec.rb
+- spec/list_method_spec.rb
+- spec/request_spec.rb
+- spec/site/NOTES
+- spec/site/library_spec.rb
+- spec/site/spec_helper.rb
+- spec/spec_helper.rb
+- spec/tools_spec.rb
+has_rdoc: true
+homepage: http://github.com/dadooda/ori
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Object-Oriented RI for IRB Console
+test_files: 
+- spec/auto_config_spec.rb
+- spec/colorize_spec.rb
+- spec/inspector_spec.rb
+- spec/internals_spec.rb
+- spec/list_method_spec.rb
+- spec/request_spec.rb
+- spec/site/library_spec.rb
+- spec/site/spec_helper.rb
+- spec/spec_helper.rb
+- spec/tools_spec.rb