scaruby 0.0.5 → 0.0.6

data/lib/scaruby/concurrent.rb

@@ -1,46 +1,46 @@
-# -*- encoding: utf-8 -*-
-
-module Scaruby
-
-  class Future
-
-    attr_accessor :result, :mutex
-
-    def initialize(mutex)
-      assert_type(mutex, Mutex)
-      @mutex = mutex
-      @result = nil
-    end
-
-    def get
-      @mutex.synchronize {
-        @result
-      }
-    end
-
-  end
-
-  module ConcurrentOps
-
-    def spawn(&block)
-      Thread.new do
-        yield 
-      end
-    end
-
-    def future(&block)
-      f = Future.new(Mutex.new)
-      Thread.new do
-        f.mutex.synchronize do
-          f.result = yield
-        end
-      end
-      f
-    end
-
-  end
-
-end
-
-include Scaruby::ConcurrentOps
-
+# -*- encoding: utf-8 -*-
+
+module Scaruby
+
+  class Future
+
+    attr_accessor :result, :mutex
+
+    def initialize(mutex)
+      assert_type(mutex, Mutex)
+      @mutex = mutex
+      @result = nil
+    end
+
+    def get
+      @mutex.synchronize {
+        @result
+      }
+    end
+
+  end
+
+  module ConcurrentOps
+
+    def spawn(&block)
+      Thread.new do
+        yield
+      end
+    end
+
+    def future(&block)
+      f = Future.new(Mutex.new)
+      Thread.new do
+        f.mutex.synchronize do
+          f.result = yield
+        end
+      end
+      f
+    end
+
+  end
+
+end
+
+include Scaruby::ConcurrentOps
+

data/lib/scaruby/core_ext/enumerable.rb

@@ -5,7 +5,7 @@ require 'scaruby/seq'
 module Enumerable
   def method_missing(name, *args, &block)
     result = Scaruby::Seq.new(self).send(name, *args, &block)
-    if result.is_a?(Scaruby::Seq) then
+    if result.is_a?(Scaruby::Seq)
       result.to_a
     else
       result

data/lib/scaruby/core_ext/hash.rb

@@ -5,7 +5,7 @@ require 'scaruby/map'
 class Hash
   def method_missing(name, *args, &block)
     result = Scaruby::Map.new(self).send(name, *args, &block)
-    if result.is_a?(Scaruby::Map) then
+    if result.is_a?(Scaruby::Map)
       result.to_hash
     else
       result

data/lib/scaruby/io.rb

@@ -1,62 +1,62 @@
-# -*- encoding: utf-8 -*-
-
-require 'net/http'
-require 'uri'
-
-module Scaruby
-  module IO
-    class Source
-
-      attr :string_io
-
-      def initialize(string_io)
-        assert_type(string_io, StringIO)
-        @string_io = string_io
-      end
-
-      def self.from_bytes(bytes, encoding='UTF-8')
-        content = bytes.to_a.pack('c*').force_encoding(encoding)
-        Source.new(StringIO.new(content))
-      end
-
-      def self.from_file(file, encoding='UTF-8')
-        content = ''
-        File::open(file, "r:#{encoding}") do |file|
-          while line = file.gets
-            content += line
-          end
-        end
-        Source.new(StringIO.new(content))
-      end
-
-      def self.from_url(url, encoding='UTF-8')
-        uri = URI.parse(url)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.is_a?(URI::HTTPS)
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-        http.start {|http|
-          req = Net::HTTP::Get.new(uri.request_uri)
-          res = http.request(req)
-          Source.new(StringIO.new(res.body))
-        }
-      end
-
-      def get_lines
-        Seq.new(@string_io.map {|line| line })
-      end
-
-      def to_seq
-        chars = []
-        while @string_io.eof? do
-          chars.push(@string_io.getc)
-        end
-        Seq.new(chars)
-      end
-
-    end
-  end
-end
-
-include Scaruby::IO
-
+# -*- encoding: utf-8 -*-
+
+require 'net/http'
+require 'uri'
+
+module Scaruby
+  module IO
+    class Source
+
+      attr :string_io
+
+      def initialize(string_io)
+        assert_type(string_io, StringIO)
+        @string_io = string_io
+      end
+
+      def self.from_bytes(bytes, encoding='UTF-8')
+        content = bytes.to_a.pack('c*').force_encoding(encoding)
+        Source.new(StringIO.new(content))
+      end
+
+      def self.from_file(file, encoding='UTF-8')
+        content = ''
+        File::open(file, "r:#{encoding}") do |file|
+          while line = file.gets
+            content += line
+          end
+        end
+        Source.new(StringIO.new(content))
+      end
+
+      def self.from_url(url, encoding='UTF-8')
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.is_a?(URI::HTTPS)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        http.start { |http|
+          req = Net::HTTP::Get.new(uri.request_uri)
+          res = http.request(req)
+          Source.new(StringIO.new(res.body))
+        }
+      end
+
+      def get_lines
+        Seq.new(@string_io.map { |line| line })
+      end
+
+      def to_seq
+        chars = []
+        while @string_io.eof? do
+          chars.push(@string_io.getc)
+        end
+        Seq.new(chars)
+      end
+
+    end
+  end
+end
+
+include Scaruby::IO
+

data/lib/scaruby/map.rb

@@ -1,141 +1,141 @@
-# -*- encoding: utf-8 -*-
-
-module Scaruby
-  class Map < Hash
-
-    attr :hash
-    
-    def each(&block)
-      @hash.each do |k,v|
-        yield k, v
-      end
-      nil
-    end
-
-    def self.empty
-      {}
-    end
-
-    def initialize(hash)
-      assert_type(hash, Hash)
-      @hash = hash
-    end
-
-    def to_hash
-      @hash
-    end
-
-    def to_a
-      @hash.to_a
-    end
-
-    def contains(key)
-      @hash.include?(key)
-    end
-
-    def count(&predicate)
-      @hash.count(&predicate)
-    end
-
-    def exists(&predicate)
-      @hash.any?(&predicate)
-    end
-
-    def filter(&predicate)
-      Map.new(@hash.reject {|k,v| ! yield k, v })
-    end
-
-    def filter_keys(&predicate)
-      Map.new(@hash.reject {|k,v| ! yield k })
-    end
-
-    def filter_not(&predicate)
-      Map.new(@hash.reject {|k,v| yield k, v })
-    end
-
-    def find(&predicate)
-      Option.new(@hash.find(&predicate))
-    end
-
-    def forall(&predicate)
-      @hash.all?(&predicate)
-    end
-
-    def foreach(&block)
-      @hash.each do |k,v| 
-        yield k, v 
-      end
-      nil
-    end
-
-    def get_or_else(key, default_value)
-      value = @hash[key]
-      value.nil? ? default_value : value
-    end
-
-    def is_empty
-      @hash.nil? || @hash.empty?
-    end
-
-    def key_set
-      @hash.keys
-    end
-
-    def lift
-      AppliableProc.new {|k| Option.new(@hash[k]) }
-    end
-
-    def map(&block)
-      #Map.new(Hash[*@hash.to_a.collect {|k,v| yield k, v }.flatten])
-      Map.new(Hash[*@hash.to_a.map {|k,v| yield k, v }.flatten])
-    end
-
-    def minus(*keys)
-      copied = @hash.dup
-      keys.each do |key|
-        copied.delete(key)
-      end
-      Map.new(copied)
-    end
-
-    def plus(elems)
-      copied = @hash.dup
-      elems.each do |elm|
-        k,v = elm[0], elm[1]
-        copied[k] = v
-      end
-      Map.new(copied)
-    end
-
-    def mk_string(*args)
-      case args.size
-      when 0
-        start_part, sep, end_part = '{', ', ', '}'
-      when 1
-        start_part, sep, end_part = '', args[0], ''
-      when 2
-        raise 'Illegal number of arguments (2)'
-      else
-        start_part, sep, end_part = args[0], args[1], args[2]
-      end
-      #start_part + @hash.to_a.collect {|k,v| k.to_s + '=>' + v.to_s }.join(sep) + end_part
-      start_part + @hash.to_a.map {|k,v| k.to_s + '=>' + v.to_s }.join(sep) + end_part
-    end
-
-    def non_empty
-      ! is_empty
-    end
-
-    def updated(k, v)
-      copied = @hash.dup
-      copied[k] = v
-      Map.new(copied)
-    end
-
-    def unzip
-      Seq.new([@hash.keys,@hash.values])
-    end
-
-  end
-end
-
+# -*- encoding: utf-8 -*-
+
+module Scaruby
+  class Map < Hash
+
+    attr :hash
+
+    def each(&block)
+      @hash.each do |k, v|
+        yield k, v
+      end
+      nil
+    end
+
+    def self.empty
+      {}
+    end
+
+    def initialize(hash)
+      assert_type(hash, Hash)
+      @hash = hash
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def to_a
+      @hash.to_a
+    end
+
+    def contains(key)
+      @hash.include?(key)
+    end
+
+    def count(&predicate)
+      @hash.count(&predicate)
+    end
+
+    def exists(&predicate)
+      @hash.any?(&predicate)
+    end
+
+    def filter(&predicate)
+      Map.new(@hash.reject { |k, v| !yield k, v })
+    end
+
+    def filter_keys(&predicate)
+      Map.new(@hash.reject { |k, v| !yield k })
+    end
+
+    def filter_not(&predicate)
+      Map.new(@hash.reject { |k, v| yield k, v })
+    end
+
+    def find(&predicate)
+      Option.new(@hash.find(&predicate))
+    end
+
+    def forall(&predicate)
+      @hash.all?(&predicate)
+    end
+
+    def foreach(&block)
+      @hash.each do |k, v|
+        yield k, v
+      end
+      nil
+    end
+
+    def get_or_else(key, default_value)
+      value = @hash[key]
+      value.nil? ? default_value : value
+    end
+
+    def is_empty
+      @hash.nil? || @hash.empty?
+    end
+
+    def key_set
+      @hash.keys
+    end
+
+    def lift
+      AppliableProc.new { |k| Option.new(@hash[k]) }
+    end
+
+    def map(&block)
+      #Map.new(Hash[*@hash.to_a.collect {|k,v| yield k, v }.flatten])
+      Map.new(Hash[*@hash.to_a.map { |k, v| yield k, v }.flatten])
+    end
+
+    def minus(*keys)
+      copied = @hash.dup
+      keys.each do |key|
+        copied.delete(key)
+      end
+      Map.new(copied)
+    end
+
+    def plus(elems)
+      copied = @hash.dup
+      elems.each do |elm|
+        k, v = elm[0], elm[1]
+        copied[k] = v
+      end
+      Map.new(copied)
+    end
+
+    def mk_string(*args)
+      case args.size
+        when 0
+          start_part, sep, end_part = '{', ', ', '}'
+        when 1
+          start_part, sep, end_part = '', args[0], ''
+        when 2
+          raise 'Illegal number of arguments (2)'
+        else
+          start_part, sep, end_part = args[0], args[1], args[2]
+      end
+      #start_part + @hash.to_a.collect {|k,v| k.to_s + '=>' + v.to_s }.join(sep) + end_part
+      start_part + @hash.to_a.map { |k, v| k.to_s + '=>' + v.to_s }.join(sep) + end_part
+    end
+
+    def non_empty
+      !is_empty
+    end
+
+    def updated(k, v)
+      copied = @hash.dup
+      copied[k] = v
+      Map.new(copied)
+    end
+
+    def unzip
+      Seq.new([@hash.keys, @hash.values])
+    end
+
+  end
+end
+

data/lib/scaruby/option.rb

@@ -1,38 +1,46 @@
-# -*- encoding: utf-8 -*-
-
-module Scaruby
-  class Option
-
-    attr :value
-
-    def self.apply(value)
-      Option.new(value)
-    end
-
-    def initialize(value)
-      @value = value
-    end
-
-    def is_defined
-      @value != nil
-    end
-
-    def get
-      if is_defined then 
-        @value 
-      else 
-        raise NoSuchElementException 
-      end
-    end
-
-    def get_or_else(default_value)
-      is_defined ? get : default_value
-    end
-
-    def map(&block) 
-      is_defined ? Option.new(yield @value) : self
-    end
-
-  end
-end
-
+# -*- encoding: utf-8 -*-
+
+module Scaruby
+  class Option
+
+    attr :value
+
+    def self.apply(value)
+      Option.new(value)
+    end
+
+    def initialize(value)
+      @value = value
+    end
+
+    def is_empty
+      @value == nil
+    end
+
+    def is_defined
+      @value != nil
+    end
+
+    def get
+      if is_defined
+        @value
+      else
+        raise NoSuchElementException
+      end
+    end
+
+    def get_or_else(default_value)
+      is_defined ? get : default_value
+    end
+
+    def map(&block)
+      is_defined ? Option.new(yield @value) : self
+    end
+
+    def fold(if_empty, &block)
+      is_empty ? if_empty : yield(@value)
+    end
+
+  end
+end
+