agrippa 0.0.1

data/lib/agrippa.rb

@@ -0,0 +1,10 @@
+require "agrippa/utilities"
+require "agrippa/version"
+require "agrippa/methods"
+require "agrippa/delegation"
+require "agrippa/proxy"
+require "agrippa/state"
+require "agrippa/maybe"
+require "agrippa/mutable"
+require "agrippa/mutable_hash"
+Agrippa::Utilities.try_require "agrippa/immutable"

data/lib/agrippa/accessor_methods.rb

@@ -0,0 +1,28 @@
+module Agrippa
+    module AccessorMethods
+        def state_reader(*args)
+            options = args.last.is_a?(Hash) ? args.pop : {}
+            args.flatten.each do |arg|
+                __define_state_reader(arg, caller, options)
+            end
+            self
+        end
+
+        def state_writer(*args)
+            options = args.last.is_a?(Hash) ? args.pop : {}
+            args.flatten.each do |arg|
+                __define_state_writer(arg, caller, options)
+            end
+            self
+        end
+
+        def state_accessor(*args)
+            options = args.last.is_a?(Hash) ? args.pop : {}
+            args.flatten.each do |arg|
+                __define_state_reader(arg, caller, options)
+                __define_state_writer(arg, caller, options)
+            end
+            self
+        end
+    end
+end

data/lib/agrippa/delegation.rb

@@ -0,0 +1,67 @@
+require "agrippa/methods"
+
+module Agrippa
+    module Delegation
+        def self.included(base)
+            base.send(:include, Agrippa::Methods)
+            base.send(:extend, ClassMethods)
+        end
+
+        def self.interpolate(string, vars)
+            output = string.gsub(/[A-Z]{3,}/) do |match|
+                vars.fetch(match.downcase.to_sym)
+            end
+            output.lines.map(&:strip).join("; ")
+        end
+
+        def self.build(base, delegate_caller, methods, definition)
+            options = methods.last.is_a?(Hash) ? methods.pop.dup : {}
+            target = options.delete(:to)
+            target = "self.class" if (target.to_sym == :class)
+            raise(ArgumentError) unless target
+
+            options[:prefix] = target if (options[:prefix] == true)
+            options[:suffix] = target if (options[:suffix] == true)
+
+            file, line = delegate_caller.first.split(':', 2)
+            line = line.to_i
+
+            methods.each do |method|
+                name = ::Agrippa::Methods.name(method, options)
+                generated = ::Agrippa::Delegation.interpolate(definition,
+                    name: name, target: target, method: method)
+                base.send(:module_eval, generated, file, line)
+            end
+            self
+        end
+
+        module ClassMethods
+            def delegate(*methods)
+                ::Agrippa::Delegation.build(self, caller, methods, <<-END)
+                    def NAME(*args, &block)
+                        TARGET.METHOD(*args, &block)
+                    end
+                END
+                self
+            end
+
+            def class_delegate(*methods)
+                ::Agrippa::Delegation.build(self, caller, methods, <<-END)
+                    def self.NAME(*args, &block)
+                        TARGET.METHOD(*args, &block)
+                    end
+                END
+                self
+            end
+
+            def delegate_command(*methods)
+                ::Agrippa::Delegation.build(self, caller, methods, <<-END)
+                    def NAME(*args, &block)
+                        store('TARGET', TARGET.METHOD(*args, &block))
+                    end
+                END
+                self
+            end
+        end
+    end
+end

data/lib/agrippa/immutable.rb

@@ -0,0 +1,80 @@
+require "agrippa/utilities"
+require "agrippa/methods"
+require "agrippa/accessor_methods"
+
+Agrippa::Utilities.try_require("hamster/hash",
+    "Agrippa::Immutable requires the Hamster gem.")
+
+module Agrippa
+    module Immutable
+        def self.included(base)
+            base.send(:include, Agrippa::Methods)
+            return if base.respond_to?(:state_reader)
+            base.send(:extend, ClassMethods)
+            base.send(:include, InstanceMethods)
+            base.send(:mark_as_commands, :chain, :store)
+            base.send(:private, :__symbolize_keys)
+        end
+
+        module ClassMethods
+            include AccessorMethods
+
+            def __define_state_reader(key, original_caller, options)
+                name = ::Agrippa::Methods.name(key, options)
+                file, line = original_caller.first.split(':', 2)
+                line = line.to_i
+                spec = "def #{name}; fetch(:#{key}); end"
+                module_eval(spec, file, line)
+                self
+            end
+
+            def __define_state_writer(key, original_caller, options)
+                name = ::Agrippa::Methods.name(key, options)
+                name = ::Agrippa::Methods.name(name, prefix: "set") \
+                    unless (options[:prefix] == false)
+                file, line = original_caller.first.split(':', 2)
+                line = line.to_i
+                spec = "def #{name}(v); store(:#{key}, v); end"
+                module_eval(spec, file, line)
+                mark_as_command(name)
+                self
+            end
+        end
+
+        module InstanceMethods
+            def initialize(state = Hamster::Hash.new, apply_default = true)
+                raise(ArgumentError, "#{self.class}#new requires a hash.") \
+                    unless state.respond_to?(:each_pair)
+                if(apply_default and respond_to?(:default_state))
+                    @state = Hamster::Hash.new(default_state)
+                    @state = @state.merge(state) unless state.nil?
+                elsif(state.is_a?(Hamster::Hash))
+                    @state = state
+                else
+                    @state = Hamster::Hash.new(__symbolize_keys(state))
+                end
+            end
+
+            def chain(updates)
+                raise(ArgementError, "#set requires a Hash") \
+                    unless updates.respond_to?(:each_pair)
+                self.class.new(@state.merge(__symbolize_keys(updates)), false)
+            end
+
+            def store(key, value)
+                self.class.new(@state.store(key.to_sym, value), false)
+            end
+
+            def fetch(key, default = nil)
+                @state.fetch(key.to_sym, default)
+            end
+
+            def __symbolize_keys(input)
+                output = input.dup
+                input.keys { |k| output[k.to_sym] = output.delete(k) \
+                    unless k.is_a?(Symbol) }
+                output
+            end
+        end
+    end
+end

data/lib/agrippa/maybe.rb

@@ -0,0 +1,18 @@
+require "agrippa/proxy"
+
+module Agrippa
+    class Maybe < Proxy
+        def method_missing(method, *args, &block)
+            return(self) if @value.nil?
+            output = begin
+                @value.send(method, *args, &block)
+            rescue ::NoMethodError
+                nil
+            end
+            return(output) unless proxied_method?(method)
+            @value = output
+            __chain(@value)
+        end
+    end        
+end
+

data/lib/agrippa/methods.rb

@@ -0,0 +1,52 @@
+module Agrippa
+    class MethodRedefinitionError < StandardError
+        def initialize(klass, method)
+            @klass, @method = klass, method
+        end
+
+        def to_s
+            "Redefinition of #{@klass}##{@method}; use the 'redefine' option if you really want to overwrite the existing method."
+        end
+    end
+
+    module Methods
+        def self.included(base)
+            return if base.respond_to?(:command_methods)
+            base.send(:extend, ClassMethods)
+            base.send(:include, InstanceMethods)
+        end
+
+        def self.name(name, options = {})
+            result = name
+            suffix = options[:suffix]
+            result = "#{result}_#{suffix}".to_sym if suffix
+            prefix = options[:prefix]
+            result = "#{prefix}_#{result}".to_sym if prefix
+            result
+        end
+
+        module ClassMethods
+            def mark_as_commands(*args)
+                args.flatten.each do |arg|
+                    command_methods[arg.to_sym] = true
+                end
+            end
+
+            alias_method :mark_as_command, :mark_as_commands
+
+            def command_methods
+                @__command_methods ||= {}
+            end
+
+            def command_method?(name)
+                command_methods.has_key?(name.to_sym)
+            end
+        end
+
+        module InstanceMethods
+            def command_methods
+                self.class.command_methods
+            end
+        end
+    end
+end

data/lib/agrippa/mutable.rb

@@ -0,0 +1,62 @@
+require "agrippa/methods"
+require "agrippa/accessor_methods"
+
+module Agrippa
+    module Mutable
+        def self.included(base)
+            base.send(:include, Agrippa::Methods)
+            return if base.respond_to?(:state_reader)
+            base.send(:extend, ClassMethods)
+            base.send(:include, InstanceMethods)
+            base.send(:mark_as_commands, :chain, :store)
+        end
+
+        module ClassMethods
+            include AccessorMethods
+
+            def __define_state_reader(key, original_caller, options)
+                name = ::Agrippa::Methods.name(key, options)
+                file, line = original_caller.first.split(':', 2)
+                line = line.to_i
+                spec = "def #{name}; @#{key}; end"
+                module_eval(spec, file, line)
+                self
+            end
+
+            def __define_state_writer(key, original_caller, options)
+                name = ::Agrippa::Methods.name(key, options)
+                name = ::Agrippa::Methods.name(name, prefix: "set") \
+                    unless (options[:prefix] == false)
+                file, line = original_caller.first.split(':', 2)
+                line = line.to_i
+                spec = "def #{name}(value); @#{key} = value; self; end"
+                module_eval(spec, file, line)
+                mark_as_command(name)
+                self
+            end
+        end
+
+        module InstanceMethods
+            def initialize(state = nil)
+                chain(default_state) if respond_to?(:default_state)
+                chain(state) unless state.nil?
+            end
+
+            def chain(state)
+                raise(ArgumentError, "#set requires a Hash") \
+                    unless state.respond_to?(:each_pair)
+                state.each_pair { |key, value| store(key, value) }
+                self
+            end
+
+            def store(key, value)
+                instance_variable_set("@#{key}", value)
+                self
+            end
+
+            def fetch(key, default = nil)
+                instance_variable_get("@#{key}") || default
+            end
+        end
+    end
+end

data/lib/agrippa/mutable_hash.rb

@@ -0,0 +1,72 @@
+require "agrippa/methods"
+require "agrippa/accessor_methods"
+
+module Agrippa
+    module MutableHash
+        def self.included(base)
+            base.send(:include, Agrippa::Methods)
+            return if base.respond_to?(:state_reader)
+            base.send(:extend, ClassMethods)
+            base.send(:include, InstanceMethods)
+            base.send(:mark_as_commands, :chain, :store)
+            base.send(:private, :__apply_default_state)
+        end
+
+        module ClassMethods
+            include AccessorMethods
+
+            def __define_state_reader(key, original_caller, options)
+                name = ::Agrippa::Methods.name(key, options)
+                file, line = original_caller.first.split(':', 2)
+                line = line.to_i
+                spec = "def #{name}; @state[:#{key}]; end"
+                module_eval(spec, file, line)
+                self
+            end
+
+            def __define_state_writer(key, original_caller, options)
+                name = ::Agrippa::Methods.name(key, options)
+                name = ::Agrippa::Methods.name(name, prefix: "set") \
+                    unless (options[:prefix] == false)
+                file, line = original_caller.first.split(':', 2)
+                line = line.to_i
+                spec = "def #{name}(v); @state[:#{key}] = v; self; end"
+                module_eval(spec, file, line)
+                mark_as_command(name)
+                self
+            end
+        end
+
+        module InstanceMethods
+            def initialize(state = nil)
+                raise(ArgumentError, "#{self.class}#new requires a hash.") \
+                    unless (state.nil? or state.respond_to?(:each_pair))
+                __apply_default_state
+                chain(state) if (state.respond_to?(:each_pair))
+            end
+
+            def chain(updates)
+                raise(ArgumentError, "#set requires a Hash") \
+                    unless updates.respond_to?(:each_pair)
+                updates.each_pair { |key, value| store(key, value) }
+                self
+            end
+
+            def store(key, value)
+                @state.store(key.to_sym, value)
+                self
+            end
+
+            def fetch(key, default = nil)
+                @state.fetch(key.to_sym, default)
+            end
+
+            def __apply_default_state
+                return(self) unless @state.nil?
+                @state = default_state if respond_to?(:default_state)
+                @state ||= {}
+                self
+            end
+        end
+    end
+end

data/lib/agrippa/proxy.rb

@@ -0,0 +1,77 @@
+require "agrippa/methods"
+
+module Agrippa
+    class Proxy < BasicObject
+        include Methods
+
+        instance_methods.each do |method|
+            next if (method =~ /(^__|^nil\?$|^send$|^object_id$)/)
+            undef_method(method) 
+        end
+
+        attr_reader :proxied_methods
+
+        def initialize(value, *methods)
+            @value, @proxied_methods = value, {}
+            __build_method_lookup_table(value, methods.flatten)
+        end
+
+        def _value
+            @value
+        end
+
+        def _
+            @value
+        end
+
+        def _deep_value
+            return(@value) unless @value.respond_to?(:_value)
+            @value._value
+        end
+
+        def respond_to?(method, include_private = false)
+            return(true) if (method == :_value)
+            return(true) if (method == :proxied_methods)
+            return(true) if (method == :proxied_method?)
+            @value.respond_to?(method, include_private)
+        end
+
+        def is_a?(klass)
+            @value.is_a?(klass) || (klass == ::Agrippa::Proxy)
+        end
+
+        def proxied_method?(method)
+            @proxied_methods.empty? \
+                or @proxied_methods.has_key?(method.to_sym)
+        end
+
+        def method_missing(method, *args, &block)
+            ::Kernel.raise(::NoMethodError,
+                "Implement method_missing in a subclass.")
+        end
+
+        def __set_proxied_methods(lookup_hash)
+            @proxied_methods = lookup_hash
+            self
+        end
+
+        private
+
+        def __class
+            @__class ||= (class << self; self end).superclass
+        end
+
+        def __chain(value)
+            __class.new(value, false).__set_proxied_methods(@proxied_methods)
+        end
+
+        def __build_method_lookup_table(value, methods)
+            return(self) if (methods.first == false)
+            @proxied_methods.merge!(value.command_methods) \
+                if value.respond_to?(:command_methods)
+            methods.each { |method| @proxied_methods[method.to_sym] = true }
+            self
+        end
+    end
+end
+