algebrick 0.4.0 → 0.5.0

data/lib/algebrick/reclude.rb

@@ -0,0 +1,39 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  # fix module to re-include itself to where it was already included when a module is included into it
+  #noinspection RubySuperCallWithoutSuperclassInspection
+  module Reclude
+    def included(base)
+      included_into << base
+      super(base)
+    end
+
+    def include(*modules)
+      super(*modules)
+      modules.reverse.each do |module_being_included|
+        included_into.each do |mod|
+          mod.send :include, module_being_included
+        end
+      end
+    end
+
+    private
+
+    def included_into
+      @included_into ||= []
+    end
+  end
+end

data/lib/algebrick/serializer.rb

@@ -0,0 +1,129 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+module Algebrick
+  class Serializer
+    include TypeCheck
+
+    TYPE_KEY  = :algebrick_type
+    FIELD_KEY = :algebrick_fields
+
+    def load(data, options = {})
+      case data
+      when ::Hash
+        parse_value(data, options)
+      when Numeric, String, ::Array, Symbol, TrueClass, FalseClass, NilClass
+        data
+      else
+        parse_other(data, options)
+      end
+    end
+
+    def dump(object, options = {})
+      case object
+      when Value
+        generate_value object, options
+      when Numeric, String, ::Array, ::Hash, Symbol, TrueClass, FalseClass, NilClass
+        object
+      else
+        generate_other(object, options)
+      end
+    end
+
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      parameter = nil
+      names.last.tap do |last|
+        name, parameter = last.split /\[|\]/
+        last.replace name
+      end
+
+      constant = Object
+      names.each do |name|
+        constant = if constant.const_defined?(name)
+                     constant.const_get(name)
+                   else
+                     constant.const_missing(name)
+                   end
+      end
+      constant = constant[constantize(parameter)] if parameter
+      constant
+    end
+
+    protected
+
+    def parse_other(other, options = {})
+      other
+    end
+
+    def generate_other(object, options = {})
+      case
+      when object.respond_to?(:to_h)
+        object.to_h
+      when object.respond_to?(:to_hash)
+        object.to_hash
+      else
+        raise "do not know how to convert (#{object.class}) #{object}"
+      end
+    end
+
+    private
+
+    def parse_value(value, options)
+      type_name = value[TYPE_KEY] || value[TYPE_KEY.to_s]
+      if type_name
+        type = constantize(type_name)
+
+        fields = value[FIELD_KEY] || value[FIELD_KEY.to_s] ||
+            value.dup.tap { |h| h.delete TYPE_KEY; h.delete TYPE_KEY.to_s }
+        Type! fields, Hash, Array
+
+        if type.is_a? Atom
+          type
+        else
+          case fields
+          when Array
+            type[*fields.map { |value| load value, options }]
+          when Hash
+            type[fields.inject({}) do |h, (name, value)|
+                   raise ArgumentError unless type.field_names.map(&:to_s).include? name.to_s
+                   h.update name.to_sym => load(value, options)
+                 end]
+          end
+        end
+      else
+        parse_other value, options
+      end
+    end
+
+    def generate_value(value, options)
+      { TYPE_KEY => value.type.name }.
+          update(case value
+                 when Atom
+                   {}
+                 when ProductConstructors::Basic
+                   { FIELD_KEY => value.fields.map { |v| dump v, options } }
+                 when ProductConstructors::Named
+                   value.type.field_names.inject({}) do |h, name|
+                     h.update name => dump(value[name], options)
+                   end
+                 else
+                   raise
+                 end)
+    end
+  end
+end

data/lib/algebrick/serializers.rb

@@ -0,0 +1,25 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  module Serializers
+
+    require 'algebrick/serializers/abstract'
+    require 'algebrick/serializers/abstract_to_hash'
+    require 'algebrick/serializers/chain'
+    require 'algebrick/serializers/strict_to_hash'
+    require 'algebrick/serializers/benevolent_to_hash'
+
+  end
+end

data/lib/algebrick/type.rb

@@ -0,0 +1,61 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  # Any Algebraic type defined by Algebrick is kind of Type
+  class Type < Module
+    include TypeCheck
+    include Matching
+    include MatcherDelegations
+    include Reclude
+
+    def initialize(name, &definition)
+      super &definition
+      @name = name
+    end
+
+    def name
+      super || @name || 'NoName'
+    end
+
+    def to_m(*args)
+      raise NotImplementedError
+    end
+
+    def ==(other)
+      raise NotImplementedError
+    end
+
+    def be_kind_of(type)
+      raise NotImplementedError
+    end
+
+    def to_s
+      raise NotImplementedError
+    end
+
+    def inspect
+      to_s
+    end
+
+    def match(value, *cases)
+      Type! value, self
+      super value, *cases
+    end
+
+    #def pretty_print(q) TODO
+    #  raise NotImplementedError
+    #end
+  end
+end

data/lib/algebrick/type_check.rb

@@ -0,0 +1,58 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  #noinspection RubyInstanceMethodNamingConvention
+  module TypeCheck
+    # FIND: type checking of collections?
+
+    def Type?(value, *types)
+      types.any? { |t| value.is_a? t }
+    end
+
+    def Type!(value, *types)
+      Type?(value, *types) or
+          TypeCheck.error(value, 'is not', types)
+      value
+    end
+
+    def Match?(value, *types)
+      types.any? { |t| t === value }
+    end
+
+    def Match!(value, *types)
+      Match?(value, *types) or
+          TypeCheck.error(value, 'is not matching', types)
+      value
+    end
+
+    def Child?(value, *types)
+      Type?(value, Class) &&
+          types.any? { |t| value <= t }
+    end
+
+    def Child!(value, *types)
+      Child?(value, *types) or
+          TypeCheck.error(value, 'is not child', types)
+      value
+    end
+
+    private
+
+    def self.error(value, message, types)
+      raise TypeError,
+            "Value (#{value.class}) '#{value}' #{message} any of: #{types.join('; ')}."
+    end
+  end
+end

data/lib/algebrick/types.rb

@@ -0,0 +1,59 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  #noinspection RubyConstantNamingConvention
+  module Types
+    Maybe = Algebrick.type(:v) do
+      variants None = atom,
+               Some = type(:v) { fields :v }
+    end
+
+    module Maybe
+      def maybe
+        match self,
+              on(None, nil),
+              on(Some) { yield value }
+      end
+    end
+
+    Boolean = Algebrick.type do
+      variants TrueClass, FalseClass
+    end
+
+    LinkedList = Algebrick.type(:value_type) do |list|
+      fields! value: :value_type, next: list
+      variants EmptyLinkedList = atom, list
+    end
+
+    module LinkedList
+      include Enumerable
+
+      def each(&block)
+        it = self
+        loop do
+          break if LinkedListEmpty === it
+          block.call it.value
+          it = it.next
+        end
+      end
+
+      def self.empty
+        LinkedListEmpty
+      end
+    end
+  end
+
+  include Types
+end

data/lib/algebrick/value.rb

@@ -0,0 +1,41 @@
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Algebrick
+  # Any value of Algebraic type is kind of Value
+  module Value
+    include TypeCheck
+    include Matching
+
+    def ==(other)
+      raise NotImplementedError
+    end
+
+    def type
+      raise NotImplementedError
+    end
+
+    def to_s
+      raise NotImplementedError
+    end
+
+    def pretty_print(q)
+      raise NotImplementedError
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end