rfunk 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67d0f85734d6898bb2d564a59f4e3ec06e3e32b9
-  data.tar.gz: 5ff36ad9b6ee2c6fae4e9fc8fa10f19eb5135679
+  metadata.gz: 3c7fa7d2d0ae8bb59de9d14f9393c7fc99c9225e
+  data.tar.gz: 617c897cd4843dd3ef0782b40f20c70edd4ecf7d
 SHA512:
-  metadata.gz: 904998816f7d080cadd75e274e9a4f1321ee396d69b9c4d84e6f2ea96179018260f4a50b8fa2fb9c385b30655f80158edf1295e617a09e925380ec9f1440ff9b
-  data.tar.gz: a7f3a9ba4847578253c7e53357d5f1be431f05ca2073019bf8fc8f3cc23271f7820d00c6e5044de1ed9ecbdcb8a93823687b9766854b9dd32aee63efd5c64c22
+  metadata.gz: 036a43078df1545a68c123d85b53b4800009c1a7f4242e2959aa288925fa74b5b5df213243b883557db40d64703c0c0e3ba24d18481aee59a0836233f838300a
+  data.tar.gz: c824e1f69c3dff059959e22f830aa886d06e822648afdcc8c659612b2cb9a066a97ecf0ca749a7a84867fda7982480252b06d153694746c2c929e66e5b4fdcc4

data/lib/rfunk.rb

@@ -2,17 +2,21 @@ require 'singleton'
 require 'ice_nine'
 require 'ice_nine/core_ext/object'
 
+require 'rfunk/attribute/immutable'
+require 'rfunk/attribute/not_found_error'
+require 'rfunk/attribute/immutable_error'
+require 'rfunk/attribute/attribute_variable'
+require 'rfunk/attribute/error_checking'
 require 'rfunk/attribute/attribute_type'
+require 'rfunk/attribute/variable'
 require 'rfunk/attribute/attribute'
 require 'rfunk/maybe/option'
 require 'rfunk/maybe/none'
 require 'rfunk/maybe/some'
-require 'rfunk/attribute/not_found_error'
 require 'rfunk/lazy'
-require 'rfunk/either/value'
+require 'rfunk/either/either'
 require 'rfunk/either/failure'
 require 'rfunk/either/success'
-require 'rfunk/either/either'
 require 'rfunk/tuple'
 
 include RFunk

data/lib/rfunk/attribute/attribute.rb

@@ -1,6 +1,6 @@
 module RFunk
   module Attribute
-    ATTRIBUTES_VARIABLE_NAME = '@attributes'
+    include RFunk::Variable
 
     def self.included(base)
       base.extend(ClassMethods)
@@ -13,31 +13,28 @@ module RFunk
 
     module ClassMethods
       def attribute(name, type, options = {})
-        add_attribute(name, type, options)
+        AttributeVariable.new.add(instance: self,
+                                  name: name,
+                                  type: type,
+                                  options: options)
 
-        self.send :define_method, name do |value = nil|
+        define_method(name) { |value = nil|
           if value
-            raise_expected_type(name, value, type)
-            create_immutable(variable_name(name), value)
+            ErrorChecking.new.raise_expected_type(name, value, type)
+            Immutable.new.create(instance: self,
+                                 variable_name: variable_name(name),
+                                 value: value)
           else
             Option(self.instance_variable_get(variable_name(name)))
           end
-        end
-      end
-
-      private
-
-      def add_attribute(name, type, options)
-        attributes = self.instance_variable_get(ATTRIBUTES_VARIABLE_NAME) || {}
-        attributes[name] = AttributeType.new(name, type, options)
-        self.instance_variable_set(ATTRIBUTES_VARIABLE_NAME, attributes)
+        }
       end
     end
 
     private
 
     def attributes
-      self.class.instance_variable_get(ATTRIBUTES_VARIABLE_NAME)
+      AttributeVariable.new.attributes(self.class)
     end
 
     def with_defaults
@@ -49,44 +46,18 @@ module RFunk
 
     def with_attributes(options)
       options.each { |key, value|
-        raise_not_found(key, attributes)
+        ErrorChecking.new.raise_not_found(key, attributes)
         set_variable(attributes[key], key, value)
       }
     end
 
     def set_variable(attribute, key, value)
-      raise_expected_type(key, value, attribute.type)
+      ErrorChecking.new.raise_expected_type(key, value, attribute.type)
       self.instance_variable_set(variable_name(key), value)
     end
 
     def variable_name(name)
       "@#{name}"
     end
-
-    def create_immutable(variable_name, value)
-      self.class.new.tap { |object|
-        self.instance_variables.select { |v| v != variable_name }.each { |v|
-          previous_value = self.instance_variable_get(v)
-          object.instance_variable_set(v, previous_value)
-        }
-
-        object.instance_variable_set(variable_name, value)
-        object.deep_freeze
-      }
-    end
-
-    def raise_expected_type(name, value, type)
-      unless value.instance_of?(type)
-        message = "Expected a type of '#{type}' for attribute '#{name}'"
-        raise TypeError, message
-      end
-    end
-
-    def raise_not_found(key, attributes)
-      unless attributes.key?(key)
-        message = "Attribute with name '#{key}' does not exist. The only available attributes are '#{attributes.keys}'"
-        raise RFunk::NotFoundError, message
-      end
-    end
   end
 end

data/lib/rfunk/attribute/attribute_variable.rb

@@ -0,0 +1,24 @@
+module RFunk
+  class AttributeVariable
+    ATTRIBUTES_VARIABLE_NAME = '@attributes'
+
+    def add(options)
+      instance = options.fetch(:instance)
+      name = options.fetch(:name)
+      attributes = attributes(instance)
+
+      attributes[name] = AttributeType.new(name, options.fetch(:type), options.fetch(:options))
+      attributes(instance, attributes)
+    end
+
+    def attributes(*args)
+      instance = args[0]
+
+      if args.length == 1
+        instance.instance_variable_get(ATTRIBUTES_VARIABLE_NAME) || {}
+      else
+        instance.instance_variable_set(ATTRIBUTES_VARIABLE_NAME, args[1])
+      end
+    end
+  end
+end

data/lib/rfunk/attribute/error_checking.rb

@@ -0,0 +1,23 @@
+module RFunk
+  class ErrorChecking
+    def raise_expected_type(name, value, type)
+      unless value.is_a?(type)
+        message = "Expected a type of '#{type}' for attribute '#{name}'"
+        raise TypeError, message
+      end
+    end
+
+    def raise_not_found(key, attributes)
+      unless attributes.key?(key)
+        message = "Attribute with name '#{key}' does not exist. The only available attributes are '#{attributes.keys}'"
+        raise RFunk::NotFoundError, message
+      end
+    end
+
+    def raise_immutable(options, variable)
+      keys = options.keys.select { |k| variable.has_key?(k) }
+      message = "Could not set variables '#{keys}', because variables are immutable."
+      raise ImmutableError, message if keys.any?
+    end
+  end
+end

data/lib/rfunk/attribute/immutable.rb

@@ -0,0 +1,19 @@
+module RFunk
+  class Immutable
+    def create(options)
+      instance = options.fetch(:instance)
+      variable_name = options.fetch(:variable_name)
+      value = options.fetch(:value)
+
+      instance.class.new.tap { |object|
+        instance.instance_variables.select { |v| v != variable_name }.each { |v|
+          previous_value = instance.instance_variable_get(v)
+          object.instance_variable_set(v, previous_value)
+        }
+
+        object.instance_variable_set(variable_name, value)
+        object.deep_freeze
+      }
+    end
+  end
+end

data/lib/rfunk/attribute/immutable_error.rb

@@ -0,0 +1,4 @@
+module RFunk
+  class ImmutableError < StandardError
+  end
+end

data/lib/rfunk/attribute/variable.rb

@@ -0,0 +1,21 @@
+module RFunk
+  module Variable
+    def var(options)
+      name = "#{self.class.to_s.downcase}_#{caller_locations(1, 1)[0].label}"
+      name = variable_name("#{name}_#{Digest::MD5.hexdigest(name)}")
+
+      if options.is_a?(Hash)
+        variable = self.instance_variable_get(name)
+
+        if variable
+          ErrorChecking.new.raise_immutable(options, variable)
+          self.instance_variable_set(name, variable.merge(options))
+        else
+          self.instance_variable_set(name, options)
+        end
+      else
+        Some(Some(self.instance_variable_get(name))[options])
+      end
+    end
+  end
+end

data/lib/rfunk/either/either.rb

@@ -1,4 +1,27 @@
 module RFunk
+  class Either
+    def initialize(value)
+      @value = value
+    end
+
+    def result
+      case value
+      when Some, None
+        value
+      else
+        Option(value)
+      end
+    end
+
+    def ==(other)
+      other.result == result
+    end
+
+    private
+
+    attr_reader :value
+  end
+
   def Either(value)
     if lambda?(value)
       either_with_lambda(value)

data/lib/rfunk/either/failure.rb

@@ -1,5 +1,5 @@
 module RFunk
-  class Failure < Value
+  class Failure < Either
     def success?
       false
     end

data/lib/rfunk/either/success.rb

@@ -1,5 +1,5 @@
 module RFunk
-  class Success < Value
+  class Success < Either
     def success?
       true
     end

data/lib/rfunk/maybe/none.rb

@@ -2,7 +2,7 @@ module RFunk
   class None < Option
     include Singleton
 
-    def value(default = nil)
+    def value(default = None())
       Option(default)
     end
 

data/lib/rfunk/maybe/option.rb

@@ -22,6 +22,6 @@ module RFunk
   private
 
   def nothing?(value)
-    value.nil? || (value.respond_to?(:empty?) && value.empty?) || value.is_a?(None)
+    value.nil? || (value.respond_to?(:empty?) && value.empty?) || value == None.instance
   end
 end

data/lib/rfunk/maybe/some.rb

@@ -1,11 +1,13 @@
 module RFunk
   class Some < Option
-    attr_reader :value
-
     def initialize(value)
       @value = value
     end
 
+    def value(_ = None())
+      @value
+    end
+
     def or(_)
       self
     end

data/lib/rfunk/version.rb

@@ -1,3 +1,3 @@
 module RFunk
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfunk
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Alex Falkowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-14 00:00:00.000000000 Z
+date: 2014-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ice_nine
@@ -62,11 +62,15 @@ files:
 - lib/rfunk.rb
 - lib/rfunk/attribute/attribute.rb
 - lib/rfunk/attribute/attribute_type.rb
+- lib/rfunk/attribute/attribute_variable.rb
+- lib/rfunk/attribute/error_checking.rb
+- lib/rfunk/attribute/immutable.rb
+- lib/rfunk/attribute/immutable_error.rb
 - lib/rfunk/attribute/not_found_error.rb
+- lib/rfunk/attribute/variable.rb
 - lib/rfunk/either/either.rb
 - lib/rfunk/either/failure.rb
 - lib/rfunk/either/success.rb
-- lib/rfunk/either/value.rb
 - lib/rfunk/lazy.rb
 - lib/rfunk/maybe/none.rb
 - lib/rfunk/maybe/option.rb

data/lib/rfunk/either/value.rb

@@ -1,24 +0,0 @@
-module RFunk
-  class Value
-    def initialize(value)
-      @value = value
-    end
-
-    def result
-      case value
-      when Some, None
-        value
-      else
-        Option(value)
-      end
-    end
-
-    def ==(other)
-      other.result == result
-    end
-
-    private
-
-    attr_reader :value
-  end
-end