fuby 0.0.1

data/lib/fuby/drop_until.rb

@@ -0,0 +1,18 @@
+require_relative 'method_added_as_filter'
+
+using Fuby
+
+module Fuby
+  refine ::Array do
+
+    def drop_until &blk
+      drop_while &blk.not
+    end
+
+    def drop_until! &blk
+      drop_while! &blk.not
+    end
+
+    method_added_as_filter :drop_until, :drop_until!
+  end
+end

data/lib/fuby/drop_while.rb

@@ -0,0 +1,15 @@
+require_relative 'shift_while'
+
+using Fuby
+
+module Fuby
+  refine ::Array do
+
+    def drop_while! &blk
+      shift_while &blk
+      self
+    end
+
+    method_added_as_filter :drop_while, :drop_while!
+  end
+end

data/lib/fuby/each.rb

@@ -0,0 +1,2 @@
+Dir.glob "each_*.rb", &method(:require)
+Dir.glob "*_each.rb", &method(:require)

data/lib/fuby/each_with_index_or_key.rb

@@ -0,0 +1,19 @@
+using Fuby
+
+module Fuby
+  refine ::Hash do
+
+    def each_with_index_or_key
+      return each { |key, val| yield val, key } if block_given?
+      return ::Enumerator.new { |result| each { |key, val| result.<< val, key } }
+    end
+
+  end
+  refine ::Array do
+
+    def each_with_index_or_key *sig, &blk
+      each_with_index *sig, &blk
+    end
+
+  end
+end

data/lib/fuby/eql.rb

@@ -0,0 +1 @@
+Dir.glob "#{ __FILE__.chomp ".rb" }_*.rb", &method(:require)

data/lib/fuby/eql_componentwise.rb

@@ -0,0 +1,13 @@
+require_relative 'each_with_index_or_key'
+
+using Fuby
+
+module Fuby
+  module ::Enumerable # can't refine Module
+
+    def eql_componentwise? that
+      each_with_index_or_key.all? { |e, k| e == that[k] }
+    end
+
+  end
+end

data/lib/fuby/equivalence.rb

@@ -0,0 +1,13 @@
+require_relative 'splat'
+
+using Fuby
+
+module Fuby
+  module ::Enumerable # can't refine Module
+
+    def equivalence? eq = :eql?
+      each_cons(2).splat.all? { |fst, snd| fst.send eq, snd }
+    end
+
+  end
+end

data/lib/fuby/eval.rb

@@ -0,0 +1,54 @@
+require_relative 'intercept'
+
+module Fuby
+
+  refine ::Hash do
+
+    def hash_eval &body
+      intercept do |key, *sig, &blk|
+        val = self[key]
+        key = key.to_s.chomp!("!").to_sym and self.delete key if /!$/ === key.to_s
+
+        case sig
+        when [] then sig.unshift ({}) if blk
+        when [Object]
+        else raise ::ArgumentError
+        end
+
+        case arg = sig.first
+        when nil then next val
+        when ::Hash
+          self[key] = {} if self[key].nil?
+          self[key].merge! arg
+          self[key].hash_exec &blk if blk
+        else
+          self[key] = arg
+        end
+
+        self[key]
+      end.instance_exec &body
+    end
+
+    alias_method :hash_exec, :hash_eval
+
+  end
+
+  refine ::Object do
+
+    def curry_eval *pre, &shell
+
+      if Hash === pre.last
+        defaults = pre.pop
+        intercept { |*sig, &blk| send *pre, sig, (sig.pop_options defaults), &blk }
+
+      else
+        intercept { |*sig, &blk| send *pre, &blk }
+
+      end.instance_exec self, &shell
+    end
+
+    alias_method :curry_exec, :curry_eval
+
+  end
+
+end

data/lib/fuby/extend.rb

@@ -0,0 +1,13 @@
+using Fuby
+
+module Fuby
+  refine ::Object do
+
+    def extend! *extends, &body
+      extend *extends unless extends.empty?
+      extend ::Module.new(&body) if block_given?
+      self
+    end
+
+  end
+end

data/lib/fuby/format.rb

@@ -0,0 +1,9 @@
+module Fuby
+  refine ::Symbol do
+
+    def % format
+      (to_s % format).to_sym
+    end
+
+  end
+end

data/lib/fuby/include.rb

@@ -0,0 +1,13 @@
+using Fuby
+
+module Fuby
+  refine ::Module do
+
+    def include! *includes, &body
+      include *includes unless includes.empty?
+      include ::Module.new(&body) if block_given?
+      self
+    end
+
+  end
+end

data/lib/fuby/index_or_key.rb

@@ -0,0 +1,19 @@
+module Fuby
+
+  refine ::Array do
+
+    def index_or_key
+      index
+    end
+
+  end
+
+  refine ::Hash do
+
+    def index_or_key
+      key
+    end
+
+  end
+
+end

data/lib/fuby/instance_attributes.rb

@@ -0,0 +1,39 @@
+require_relative 'attributes'
+
+using Fuby
+
+module Fuby
+  refine ::Object do
+
+    def instance_attribute_set key, val
+      (respond_to? "#{ key }=") ? (send "#{ key }=", val) : (instance_variable_set "@{ key }", val)
+    end
+
+    def instance_attribute_get key
+      (respond_to? key) ? (send key) : (instance_variable_get "@#{ key }")
+    end
+
+    def instance_attributes_set opt
+      opt.each { |key, val| instance_attribute_set key, val }
+      self
+    end
+
+    def instance_attributes_get key
+      keys.map &(method :instance_attribute_get)
+    end
+
+    alias_method :instance_attributes_at, :instance_attributes_get
+
+    def instance_attributes
+      InstanceAttributes.new self
+    end
+
+  end
+  class InstanceAttributes < Attributes
+
+    def __name__
+      :instance_attributes
+    end
+
+  end
+end

data/lib/fuby/intercept.rb

@@ -0,0 +1,27 @@
+require_relative 'bind'
+require_relative 'define_missing_method'
+
+using Fuby
+
+module Fuby
+
+  refine ::Object do
+
+    def intercept &intercept
+      Intercept.new self, &intercept
+    end
+
+  end
+
+  class Intercept < BasicObject
+
+    def initialize intercepted, &intercept
+      @intercept = intercept.bind intercepted
+    end
+
+    def method_missing *sig, &blk
+      @intercept.call *sig, &blk
+    end
+
+  end
+end

data/lib/fuby/invert.rb

@@ -0,0 +1,16 @@
+require_relative 'self_and_descendants'
+require_relative 'each_with_index_or_key'
+
+using Fuby
+
+module Fuby
+
+  module ::Enumerable # can't refine Module
+
+    def invert
+      ::Hash[ each_with_index_or_key.to_a ]
+    end
+
+  end
+
+end

data/lib/fuby/longest_common.rb

@@ -0,0 +1,16 @@
+require_relative 'equivalence'
+using Fuby
+
+module Fuby
+  module ::Enumerable # can't refine Module
+
+    def longest_common_prefix *those
+      zip(*those).take_while(:equivalence?).map(:first)
+    end
+
+    def longest_common_suffix *those
+      zip(*those).map(&:reverse).take_while(:equivalence?).map(:first).map(&:reverse)
+    end
+
+  end
+end

data/lib/fuby/matches.rb

@@ -0,0 +1,11 @@
+module Fuby
+  module ::Enumerable # can't refine Module
+
+    def matches? that
+      count == that.count and matches_componentwise? that
+    end
+
+  end
+end
+
+Dir.glob "#{ __FILE__.chomp ".rb" }_*.rb", &method(:require)

data/lib/fuby/matches_componentwise.rb

@@ -0,0 +1,11 @@
+require_relative 'each_with_index_or_key'
+
+module Fuby
+  module ::Enumerable # can't refine Module
+
+    def matches_componentwise? that
+      each_with_index_or_key.all? { |e, k| e === that[k] }
+    end
+
+  end
+end

data/lib/fuby/matches_part_of.rb

@@ -0,0 +1,16 @@
+require_relative 'method_added_as_binary_operator'
+require_relative 'matches_componentwise'
+
+using Fuby
+
+module Fuby
+  module ::Enumerable # can't refine Module
+
+    def matches_part_of? that
+      count <= that.count and matches_componentwise? that
+    end
+
+    method_added_as_binary_operator :matches_part_of?
+
+  end
+end

data/lib/fuby/matches_prefix_of.rb

@@ -0,0 +1,11 @@
+require_relative 'matches_part_of'
+
+module Fuby
+  refine ::Array do
+
+    alias_method :matches_prefix_of?, :matches_part_of?
+
+    method_added_as_binary_operator :matches_prefix_of?
+
+  end
+end

data/lib/fuby/matches_suffix_of.rb

@@ -0,0 +1,13 @@
+using Fuby
+
+module Fuby
+  refine ::Array do
+
+    def matches_suffix_of? that
+      matches? that.drop - length
+    end
+
+    method_added_as_binary_operator :matches_suffix_of?
+
+  end
+end

data/lib/fuby/member.rb

@@ -0,0 +1,11 @@
+require_relative 'method_added_as_binary_operator'
+
+using Fuby
+
+module Fuby
+  module ::Enumerable # can't refine Module
+
+    method_added_as_binary_operator :member?, :include?
+
+  end
+end

data/lib/fuby/merge.rb

@@ -0,0 +1,20 @@
+module Fuby
+  refine ::Hash do
+
+    [ :'', :'!' ].each { |i| eval %{
+
+      def merge#{ i } that = self, key = nil, &blk
+        case key
+        when nil
+        when Symbol then return send merge_\#{ key }#{ i } that, &blk if respond_to? merge_\#{ key }#{ i }
+        else raise ArgumentError
+        end
+        return super
+      end
+
+    }}
+
+  end
+end
+
+Dir.glob "#{ __FILE__.chomp ".rb" }_*.rb", &method(:require)

data/lib/fuby/merge_css.rb

@@ -0,0 +1,32 @@
+module Fuby
+  refine ::Hash do
+
+    def merge_css that
+      dup.merge_css! that
+    end
+
+    def merge_css! that
+      merge! that do |key, lft, rgt|
+        case key
+        when /^class$/ then "#{ lft } #{ rgt }"
+        when /^style$/ then "#{ lft };#{ rgt }"
+        else rgt
+        end
+      end
+    end
+
+  end
+
+  module MergeCSS
+
+    def merge_css *hashes
+      hashes.inject ({}) do |memo, hash|
+        memo.merge_css! hash
+      end.tap do |hash|
+        hash.each { |key, val| hash.merge_css! val if send k      if respond_to? k      if /\?$/ === key }
+        hash.each { |key, val| hash.merge!     val if send k.to_? if respond_to? k.to_? if /\!$/ === key }
+      end
+    end
+
+  end
+end