mshakhan-fruby 0.0.1

data/LICENSE

@@ -0,0 +1,15 @@
+ DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                   Version 2, December 2004
+
+Copyright (C) 2004 Sam Hocevar
+ 14 rue de Plaisance, 75014 Paris, France
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. You just DO WHAT THE FUCK YOU WANT TO.
+
+http://sam.zoy.org/wtfpl/COPYING

data/README.rdoc

@@ -0,0 +1,18 @@
+== Description
+
+Some functional programming features for ruby.
+
+== Usage
+
+Now implemented only *defun* method. You can use it like this:
+
+  module Math
+    class << self
+      include FRuby::Definer
+      defun(:fact, Fixnum) { |n| n * fact(n - 1) }
+      defun(:fact, 0) { 1 }
+      defun(:fact, 1) { 1 }
+    end
+  end
+
+  Math::fact(5) #=> 120

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'lib/version'
+
+GEM_NAME = 'fruby'
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM_NAME
+  s.version = FRuby::VERSION
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.rdoc', 'LICENSE']
+  s.summary = 'Some functional programming features for ruby'
+  s.description = s.summary
+  s.author = 'Mikhail Shakhanov'
+  s.email = 'mshakhan@gmail.com'
+  s.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{lib,spec}/**/*")
+  s.require_path = "lib"
+
+  s.add_dependency 'rake'
+  s.add_dependency 'rspec'
+    
+  s.required_ruby_version = ">= 1.8.4"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.rdoc', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.rdoc"
+  rdoc.title = "FRuby Docs"
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.options << '--line-numbers'
+end
+
+desc 'Run specs'
+task :spec do
+  spec_path = ENV['SPEC_PATH'] || 'spec'
+  system("spec #{spec_path} -c")
+end
+
+desc "Generate *.gemspec file"
+task :gemspec do
+  path = File.join(File.dirname(__FILE__), "#{GEM_NAME}.gemspec")
+  puts %{Writing "#{path}"}
+  File.open(path, "w") { |file| file.write(spec.to_ruby) }
+end

data/lib/definer.rb

@@ -0,0 +1,80 @@
+module FRuby
+  # This module implements "pattern matching" function definition style
+  #
+  # Author::      Mikhail Shakhanov  (mailto:mshakhan@gmail.com)
+  # Copyright::   Copyright (c) 2009 mshakhan
+  # License::     WTFPL
+  module Definer
+    def self.included(base)
+      super
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      # Defines method in "pattern-matching" style
+      #
+      # ==== Examples
+      #
+      #   class Test
+      #     include FRuby::Definer   
+      #     defun(:my_method)             { 'empty args' }
+      #     defun(:my_method, Fixnum)     { |n| n }
+      #     defun(:my_method, 0)          { 'zero' }
+      #   end
+      #   
+      #   c = C.new
+      #   c.my_method     # => 'empty args'
+      #   c.my_method(42) # => 42
+      #   c.my_method(0)  # => 'zero'
+      #
+      # ==== Parameters
+      #
+      # * <tt>name</tt> - Method name. Should be a Symbol or a String
+      # * <tt>formal_args</tt> - Method's formal parameters. Might be a classes or a values
+      # * <tt>&block</tt> - Method definition
+      def defun(name, *formal_args, &block)
+        define_or_append_condition(name, lambda { |*args| 
+            FRuby::Matcher::match(formal_args, args)
+          }, &block)
+      end
+
+      private
+      def append_condition(method_name, condition, &block)
+        condition_method_name = define_condition_method(method_name, &block)
+        old_method_name = Utils::rand_condition_method_name(method_name)
+        alias_method old_method_name, method_name
+        private old_method_name
+        
+        define_method method_name do |*args|
+          if condition.call(*args)
+            method(condition_method_name).call(*args)
+          else
+            method(old_method_name).call(*args)
+          end
+        end
+      end
+
+      def define_or_append_condition(method_name, condition, &block)
+        unless Utils::has_instance_method?(self, method_name)
+          condition_method_name = define_condition_method(method_name, &block)
+          define_method method_name do |*args|
+            if condition.call(*args)
+              method(condition_method_name).call(*args)
+            end
+          end
+        else
+          append_condition(method_name, condition, &block)
+        end
+      end
+
+      def define_condition_method(method_name, &block)
+        condition_method_name = Utils::rand_condition_method_name(method_name)
+        define_method(condition_method_name, &block)
+        private condition_method_name.to_sym
+        condition_method_name
+      end
+    end
+  end
+end

data/lib/ext.rb

@@ -0,0 +1,49 @@
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def present?
+    !blank?
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  def blank?
+    false
+  end
+end
+
+class Array
+  def blank?
+    self.compact.empty?
+  end
+end
+
+class Hash
+  alias_method :blank?, :empty?
+end
+
+class String
+  def blank?
+    self.strip.size == 0
+  end
+end
+
+class Numeric
+  def blank?
+    false
+  end
+end

data/lib/fruby.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH << File.dirname(__FILE__)
+
+require 'version'
+require 'ext'
+require 'utils'
+require 'matcher'
+require 'definer'

data/lib/matcher.rb

@@ -0,0 +1,41 @@
+module FRuby
+  module Matcher extend self
+    def match(p1, p2)
+      match_by_value(p1, p2) or match_by_class(p1, p2)
+    end
+
+    def match_by_value(p1, p2)
+      if p1.is_a?(Array) and p2.is_a?(Array)
+        match_arrays_by_value(p1, p2)
+      else
+        p1 == p2 || (p1.blank? && p2.blank?)
+      end
+    end
+
+    def match_by_class(cls, p)
+      if cls.is_a?(Array) and p.is_a?(Array)
+        match_arrays_by_class(cls, p)
+      else
+        p.present? and cls == p.class
+      end
+    end
+
+    def match_arrays_by_value(p1, p2)
+      # TODO Think about it. Does [], [nil] and nil are equals to empty args?
+      p1 = p1.flatten.compact
+      p2 = p2.flatten.compact
+      return false if p1.size != p2.size
+      return true if p1.blank? and p2.blank?
+      Utils::multiple_all?(p1, p2) do |a1, a2|
+        match_by_value(a1, a2)
+      end
+    end
+
+    def match_arrays_by_class(cls, p)
+      return false if cls.size != p.size
+      Utils::multiple_all?(cls, p) do |a1, a2|
+        match_by_class(a1, a2)
+      end
+    end
+  end
+end

data/lib/utils.rb

@@ -0,0 +1,25 @@
+module FRuby
+  module Utils extend self
+    def rand_condition_method_name(prefix, size = 8)
+      alphabet = ('a'..'z').to_a + ('A'..'Z').to_a + (0..9).to_a
+      "__#{prefix}_condition_#{Array.new(size) { alphabet[rand(alphabet.size)] }.join}__"
+    end
+
+    def has_instance_method?(obj, method_name)
+      obj.instance_methods.include? method_name.to_s
+    end
+
+    def multiple_each(*args, &block)
+      args.first.size.times do |index|
+        block.call(args.map { |arg| arg[index] })
+      end
+    end
+
+    def multiple_all?(*args, &block)
+      multiple_each(*args) do |*each_args|
+        return false unless block.call(*each_args)
+      end
+      true
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module FRuby
+  VERSION = '0.0.1'
+end

data/spec/definer_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'fruby')
+
+class DefinerTest
+  include FRuby::Definer
+
+  defun(:test) { :empty } # empty args (no args, nil, [], [nil])
+  defun(:test, String) { |s| s }
+  defun(:test, 0) { :zero }
+end
+
+
+describe FRuby::Definer do
+  before :each do 
+    @inst = DefinerTest.new
+  end
+
+  it "Should return :empty if empty args" do
+    @inst.test.should       == :empty
+    @inst.test(nil).should  == :empty
+    @inst.test([]).should   == :empty
+  end
+
+  it "Should return passed string if string passed" do
+    @inst.test('string').should == 'string'
+  end
+
+  it "Should return :zero string if 0 passed" do
+    @inst.test(0).should == :zero
+  end
+
+  it "Condition methods should be private" do
+    DefinerTest.public_instance_methods.grep(/^test/).size.should == 1
+  end
+end
+

data/spec/matcher_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'fruby')
+
+describe FRuby::Matcher do
+  it "Should match equal objects" do
+    FRuby::Matcher::match(0, 0).should == true
+    FRuby::Matcher::match([0, 1, 2], [0, 1, 2]).should == true
+  end
+
+  it "Should match by class" do
+    FRuby::Matcher::match(Fixnum, 0).should == true
+    FRuby::Matcher::match([Fixnum, String], [0, 'a']).should == true
+  end
+
+  it "Should match empty objects" do # but what is empty object?
+    FRuby::Matcher::match([], [nil]).should == true
+    FRuby::Matcher::match(nil, []).should == true
+    FRuby::Matcher::match(nil, '').should == true
+  end
+
+  it "Should not match not equal objects" do
+    FRuby::Matcher::match(0, 1).should_not == true
+  end
+end
+

data/spec/utils_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'fruby')
+
+class UtilsTest
+  def method_exists; end
+end
+
+describe FRuby::Utils do
+  it "Should return true if class has an instance method by string and symbol" do
+    FRuby::Utils::has_instance_method?(UtilsTest, 'method_exists').should == true
+    FRuby::Utils::has_instance_method?(UtilsTest, :method_exists).should == true
+  end
+
+  it "Should return false if class has not an instance method by string and symbol" do
+    FRuby::Utils::has_instance_method?(UtilsTest, 'method_doesnt_exists').should_not == true
+    FRuby::Utils::has_instance_method?(UtilsTest, :method_doesnt_exists).should_not == true
+  end
+end
+

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: mshakhan-fruby
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- mshakhan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-21 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Some functional programming features for ruby
+email: mshakhan@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/definer.rb
+- lib/version.rb
+- lib/fruby.rb
+- lib/utils.rb
+- lib/matcher.rb
+- lib/ext.rb
+- spec/matcher_spec.rb
+- spec/definer_spec.rb
+- spec/utils_spec.rb
+has_rdoc: true
+homepage: 
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.4
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Some functional programming features for ruby
+test_files: []
+