ov 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzE1ZGI3NDVhMmZjZjYzOGM0MmMxNzQyZDc5OTA2NWNjN2E2NDk1Ng==
+  data.tar.gz: !binary |-
+    NjI0YTcwZDQ5MWZlYmRhZjhmOGE5OTY5YTk0YjhmZTgxYWMwODczMA==
+SHA512:
+  metadata.gz: !binary |-
+    ZTBhZGEwMmJhNjM3NTE4ZTczMmY4ZmY3MDdjY2I1NzAxMTE2MTkzMjk2M2M5
+    MjllZjU3NjA0Y2Q3YzEwZWI5OGE4ODgxNDNlZDg0MDBiNzc3ZGUzZjc1ODQ5
+    NzgyNGU1ZWNiNDRlNTQzMjk4YTQ2YzZmY2U5M2I2MzY1NGU1ZmI=
+  data.tar.gz: !binary |-
+    ODUzZTZmOWZjMDlkNGIyMjIzODM4YzY1MzMyMjVmY2M3YTcwZTc3NjQxYjBi
+    MDMyYzI2NzY3N2I2MWYxMjZkZGUxZGQ2YjFmNDVlZGU2NTQ3MTEzODFiZmJm
+    NGIyYzhhZDQxYTNlZmI4ZDQ3ZjE0ODBkYzE4MzA4ZDhkODg1Y2M=

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rspec
+.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in Override.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 fntzr
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

data/README.md

@@ -0,0 +1,78 @@
+# Ov
+
+Create a multimethods in Ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ov'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ov
+
+## Usage
+
+Firstly include `Ov` in you class
+
+```ruby 
+class MyClass        
+  include Ov 
+end
+```  
+
+After define method with types:
+
+```ruby  
+class MyClass
+  include Ov   
+  
+  #with Fixnum type 
+  let :cool_method, Fixnum do |num|
+    num * 100
+  end 
+  
+  #with String type
+  let :cool_method, String do |str|
+    str << "!"
+  end 
+end
+
+#And now
+my_class = MyClass.new
+my_class.cool_method(3)     # => 300
+my_class.cool_method("foo") # => foo!  
+```
+
+Any Type
+----------
+
+```ruby  
+class MyClass 
+  include Ov
+  let :cool_method, Any do |any|
+    any
+  end 
+end
+
+my_class = MyClass.new
+my_class.cool_method(1)     => 1 
+my_class.cool_method("foo") => "foo"
+```
+
+Examples
+--------
+see [link](https://github.com/fntzr/ov/blob/master/samples/example.rb)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "rubygems"
+require "rake"
+require "rspec/core/rake_task"
+
+desc "Run spec"
+RSpec::Core::RakeTask.new 'spec' do |t|
+  t.verbose = false
+end 
+
+task :default => 'spec'
+  

data/lib/ov/exception.rb

@@ -0,0 +1,5 @@
+##
+#
+# Throw when +method+ with given +types+ not defined 
+#
+class NotImplementError < Exception ; end

data/lib/ov/ov_any.rb

@@ -0,0 +1,4 @@
+module Ov
+  class Any # :nodoc:
+  end
+end

data/lib/ov/ov_array.rb

@@ -0,0 +1,44 @@
+module Ov
+  class OA < Array 
+    attr_accessor :complete, :result
+    #find in self
+    #find in ancestors
+    #find types
+    #find any types
+    def where(method)
+      @complete, @result = nil, nil
+      z = find_or_next(method) { |method| 
+        self.find{|m| m.eql?(method) }
+      }.find_or_next(method) { |method|
+        self.find{|m| m.eql0?(method) }
+      }.find_or_next(method) { |method|
+        self.find{|m| m.like?(method) }
+      }.find_or_next(method) {|method| 
+        self.find{|m| m.like0?(method) }
+      }.get
+    end
+
+    def find_or_next(method, &block)
+      return self if @complete
+      ev_block = yield(method)
+      @complete, @result = true, ev_block if ev_block
+      self
+    end
+
+    alias :get :result
+
+    private 
+    
+    def compare(a, b)
+      return false if a.size != b.size
+      !a.zip(b).map do |arr| 
+        first, last = arr 
+        true if (first == Ov::Any) || (last == Ov::Any) || (first == last)  
+      end.include?(nil)
+    end
+
+    def compare0(a, b)
+
+    end
+  end
+end

data/lib/ov/ov_method.rb

@@ -0,0 +1,50 @@
+module Ov 
+  class OverrideMethod # :nodoc: 
+    attr_accessor :types, :body, :name, :owner, :ancestors
+
+    # +name+ (Symbol) : name for method
+    # +types+ (Array) : array with types, for method arguments
+    # +body+ (Proc)   : block called with method
+    def initialize(name, types, owner, body = proc{})
+      @name, @types, @owner, @body = name, types, owner, body
+      @ancestors = owner.ancestors.find_all do |ancestor| 
+        ancestor.method_defined?(:__overridable_methods) && ancestor.class == Class
+      end 
+    end
+
+    def eql?(other)
+      return true if @name == other.name && @types == other.types && @owner == other.owner
+      false
+    end
+
+    def eql0?(other)
+      @ancestors.find{|a|  
+        a.__overridable_methods.find{|m| 
+          m.name == other.name && m.types == other.types 
+        }
+      }
+    end
+
+    def like?(other)
+      return compare?(types, other.types) if @name == other.name
+      false
+    end
+
+    def like0?(other)
+      @ancestors.find{|a| 
+        a.__overridable_methods.find{|m| 
+          m.like?(other) 
+        }
+      }
+    end
+
+    private 
+    def compare?(a, b)
+      return false if a.size != b.size
+      !a.zip(b).map { |arr|
+        first, last = arr 
+        true if (first == Ov::Any) || (last == Ov::Any) || (first == last)  
+      }.include?(nil)
+    end
+  end
+end

data/lib/ov/version.rb

@@ -0,0 +1,3 @@
+module Ov
+  VERSION = "0.0.1"
+end

data/lib/ov.rb

@@ -0,0 +1,110 @@
+require "ov/version"
+require "ov/ov_array"
+require "ov/ov_method"
+require "ov/ov_any"
+require "ov/exception"
+
+
+##
+# `Ov` module provides functional for creating methods 
+# with types in Ruby.
+#
+#
+# == Usage
+#   
+# Firstly include `Ov` in you class
+#  
+#   class MyClass        
+#     include Ov 
+#   end
+#
+# After define method with types:
+#   
+#   class MyClass
+#     include Ov   
+#     
+#     # with Fixnum type 
+#     let :cool_method, Fixnum do |num|
+#       num * 100
+#     end 
+#     
+#     # with String type
+#     let :cool_method, String do |str|
+#       str << "!"
+#     end 
+#   end
+#   
+# And now
+#      
+#   my_class = MyClass.new
+#   my_class.cool_method(3)     # => 300
+#   my_class.cool_method("foo") # => foo!  
+# 
+# == Any Type
+#  
+#   class MyClass 
+#     include Ov
+#     let :cool_method, Any do |any|
+#       any
+#     end 
+#   end
+#   
+#   my_class = MyClass.new
+#   my_class.cool_method(1)     # => 1 
+#   my_class.cool_method("foo") # => "foo"
+#
+# Is the same so ruby `def` 
+#
+#
+module Ov
+  def self.included(base) # :nodoc:
+    base.extend(self)
+    base.class_eval do
+      class_variable_set(:@@__overridable_methods, OA.new)
+    end
+  end
+
+  def __overridable_methods # :nodoc:
+    send(:class_variable_get, :@@__overridable_methods)
+  end
+
+  ##
+  # Create new method with +name+ and +types+
+  # When method called +block+ will be executed
+  #
+  # +name+ is symbol
+  #
+  # +types+ types for method
+  #
+  def let(name, *types, &block)
+    
+    __overridable_methods << OverrideMethod.new(name, types, self, block)
+    
+    if !self.method_defined?(name)
+      self.instance_exec do
+        message = if self.class == Module 
+          :define_singleton_method
+        else
+          :define_method
+        end  
+        self.send(message, name) do |*args, &block|
+          types = *args.map(&:class)
+          owner = if self.class == Module
+            self
+          else
+            self.class
+          end
+            
+          method = OverrideMethod.new(name, types, owner) 
+
+          z = owner.__overridable_methods.where(method)
+          raise NotImplementError.new("Method `#{name}` in `#{self}` class with types `#{types}` not implemented.") if z.nil?
+          instance_exec(*args, &z.body)  
+        end
+      end
+    end   
+  end
+end
+
+
+

data/ov.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ov/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ov"
+  spec.version       = Ov::VERSION
+  spec.authors       = ["fntzr"]
+  spec.email         = ["fantazuor@gmail.com"]
+  spec.description   = %q{write overridable methods for fun :)}
+  spec.summary       = %q{ov gem provides hacks for write polymorphic methods in Ruby.}
+  spec.homepage      = "https://github.com/fntzr/ov"
+  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 "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14.0"
+end

data/samples/myarray.rb

@@ -0,0 +1,32 @@
+require 'ov'
+
+# Array 
+class MyArray 
+  include Ov
+  attr_accessor :arr
+  
+
+  let :initialize do
+    @arr = []
+  end
+
+  let :initialize, Fixnum do |fx|
+    @arr = fx.times.map { nil }
+  end 
+
+  let :initialize, Fixnum, Any do |fx, any|
+    @arr = fx.times.map { any }
+  end
+ 
+end
+
+p MyArray.new()
+p MyArray.new(3)
+p MyArray.new(3, true)
+
+
+
+
+
+
+

data/samples/pm.rb

@@ -0,0 +1,51 @@
+require "ov"
+
+module Matching
+  def match(*args, &block)
+    z = Module.new do 
+      include Ov
+      extend self
+      def try(*args, &block)
+        let :anon_method, *args, &block
+      end
+      def otherwise(&block)
+        let :otherwise, &block
+      end
+      instance_eval &block
+    end
+    begin
+      z.anon_method(*args)
+    rescue NotImplementError => e 
+      z.otherwise
+    end  
+  end
+end
+
+
+include Matching
+
+
+
+match("String", [123]) do 
+  try(String, Array) {|str, arr| p "#{str} #{arr}" }
+  try(String) {|str| p "#{str}"  }
+  otherwise { p "none" }
+end
+
+require "net/http"
+
+match(Net::HTTP.get_response(URI("http://google.com"))) do
+  try(Net::HTTPOK) {|r| p r.header }
+  try(Net::HTTPMovedPermanently) {|r| p r.header }
+  otherwise { p "error" }
+end
+
+
+
+
+
+
+
+
+
+

data/samples/rack.rb

@@ -0,0 +1,47 @@
+require "ov"
+require "rack"
+
+#curl -X POST http://localhost:9292
+#curl -X GET http://localhost:9292
+
+class Post ; end 
+class Get  ; end
+
+class Rack::Request
+  def req_method
+    return Post.new if post?
+    Get.new 
+  end   
+end
+
+class RackExample
+  include Ov
+  def call(env)
+    response(Rack::Request.new(env).req_method)
+    #[200, {"Content-Type" => "text/html"}, ["POST"]]
+  end
+
+  let :response, Get do |r|
+    # processing get
+    [200, {"Content-Type" => "text/html"}, ["GET"]]
+  end
+
+  let :response, Post do |r|
+    # processing post
+    [200, {"Content-Type" => "text/html"}, ["POST"]]
+  end 
+
+end
+
+if __FILE__ == $0
+  Rack::Handler::Thin.run RackExample.new, :Port => 9292  
+end
+
+
+
+
+
+
+
+
+

data/samples/service.rb

@@ -0,0 +1,36 @@
+require 'ov'
+
+
+module SO
+  def self.get(request)
+    if Random.rand(10) > 6 
+      Result.new("#{request}")
+    else 
+      Fail.new
+    end
+  end
+end
+
+class Result
+  attr_accessor :string
+  def initialize(string)
+    @string = string
+  end
+
+  alias :[] :string  
+end
+class Fail
+end
+
+class M 
+  include Ov
+  
+  let :process, Fail do ; [] end 
+  let :process, Result do |r| ; r[] ; end
+end
+
+
+m = M.new
+10.times { |i|
+  p m.process(SO.get("#{i}"))
+}

data/spec/fixtures/fixture_classes.rb

@@ -0,0 +1,55 @@
+class Test
+  include Ov
+  
+  let :my_instance_method, Array, String do |arr, str|
+    arr << str
+    arr
+  end  
+  
+  let :my_instance_method, String do |str| 
+    str
+  end
+
+  let :my_instance_method, Fixnum do |fixnum|
+    my_instance_method([], my_instance_method("bar"))
+  end  
+end
+
+class TestInitialize
+  include Ov
+  attr_reader :arg 
+  let :initialize, String do |str|
+    str << "foo"
+    @arg = str
+  end
+  let :initialize, Fixnum do |fx|
+    @arg = fx*100
+  end
+end
+
+
+class TestException
+  include Ov
+  let :some_method, Fixnum do |fx|
+  end
+end
+
+class Test0 < Test 
+  let :my_instance_method, String do |str| 
+    "foo"
+  end
+end
+
+class TestWithoutArguments 
+  include Ov
+  let :my_instance_method do 
+    "foo"
+  end
+end
+
+class TestAny
+  include Ov
+  let :my_instance_method, Any do |any| 
+    any
+  end
+end

data/spec/override_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Ov do 
+  context "instance methods" do 
+    context "#my_instance_method" do 
+      let(:test){Test.new}
+      
+      it "return array" do 
+        result = test.my_instance_method(["foo", "bar"], "baz")
+        result.should eq ["foo", "bar", "baz"]
+      end
+
+     it "return string" do 
+        result = test.my_instance_method("baz")
+        result.should eq "baz"
+     end
+
+      it "return overridable method" do
+        result = test.my_instance_method(1)
+        result.should eq ["bar"]
+      end
+    end
+  end
+
+  context "override initialize method" do
+    it "return new instance with #this method" do 
+      test = TestInitialize.new("bar")
+      test.arg.should eq "barfoo"
+      test.class.should eq TestInitialize
+    
+      test0 = TestInitialize.new(1)
+      test0.arg.should eq 100
+      test0.class.should eq TestInitialize
+    end
+  end
+
+  context "exceptions" do 
+    let(:test){TestException.new}
+    it "throw NotImplementError when method not defined" do 
+      expect { test.some_method("foo") }.to raise_error(NotImplementError)
+    end
+  end
+
+  context "inheritance" do 
+    let(:test){Test0.new}
+    it "should call parent method" do 
+      result = test.my_instance_method(["foo", "bar"], "baz")
+      result.should eq ["foo", "bar", "baz"]
+    end
+    it "should call own method" do 
+      result = test.my_instance_method("baz")
+      result.should eq "foo"
+    end
+  end
+
+  
+  context "call without argument" do
+    let(:test) {TestWithoutArguments.new}
+    it do 
+      result = test.my_instance_method
+      result.should eq "foo"
+    end
+  end
+ 
+  context "call with Any argument" do
+    let(:test) {TestAny.new}
+    it do 
+      test.my_instance_method(1).should eq 1
+      test.my_instance_method("foo").should eq "foo"
+      test.my_instance_method(:foo).should eq :foo
+    end
+  
+    it "exception when many arguments or without arguments" do 
+      expect{ test.my_instance_method(1,2,3)}.to raise_error(NotImplementError)
+      expect{ test.my_instance_method()}.to raise_error(NotImplementError)
+    end   
+  end 
+end
+
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'ov'
+require 'fixtures/fixture_classes'
+

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: ov
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- fntzr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+description: write overridable methods for fun :)
+email:
+- fantazuor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ov.rb
+- lib/ov/exception.rb
+- lib/ov/ov_any.rb
+- lib/ov/ov_array.rb
+- lib/ov/ov_method.rb
+- lib/ov/version.rb
+- ov.gemspec
+- samples/myarray.rb
+- samples/pm.rb
+- samples/rack.rb
+- samples/service.rb
+- spec/fixtures/fixture_classes.rb
+- spec/override_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/fntzr/ov
+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.1.5
+signing_key: 
+specification_version: 4
+summary: ov gem provides hacks for write polymorphic methods in Ruby.
+test_files:
+- spec/fixtures/fixture_classes.rb
+- spec/override_spec.rb
+- spec/spec_helper.rb
+has_rdoc: