emery 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7526be75b8c44c624947657c22214dd7715170e1bbdb8b46a8369a6ca66d4fc
-  data.tar.gz: 5483955dd2c563ca2c6c04662aea8bc1f9b4a5e34817b9d60a046afa32ca5a04
+  metadata.gz: 629dad4de96ce6b80b94e883ac9dee5dff07c677d431727e83a7c379c229524b
+  data.tar.gz: 3dc8b2cc93ff053470be638ca64659f02de7c7f07894427212c603b3f36a8ad0
 SHA512:
-  metadata.gz: e1e408199c42d0c877c1ca9be978f698357449ac9f4c909c6157ec190bfb83f19434184e68bf7ab6cf96b93007e6658f1eae1f744c57a97d8fae0231eed03a76
-  data.tar.gz: 80f702c3cd1bd7edd8359a03576519db0002efcedd3db144ef1c3e94192ccd6fb129dd0ac8a25177f9d9dd96f016f3cf84c4237e69fe5d2e15c12f2790530456
+  metadata.gz: fed3812431f78ab7bb66066c19c788babe478675a1108ef038c237a2e47734dce7e572b53d3d781430da4d72eb4e4c29ab36f0cf80721395d3d971acaa6be83d
+  data.tar.gz: 9dfc4c611a1da41452861b565c7a4042a1ea8f685ebc79d87a6186fabc0cf96ba1e005a5c6e4617a50d22619799eb46e49c42238d348f6687d8b80cacd47f661

data/lib/emery/dataclass.rb

@@ -1,86 +1,84 @@
-module Emery
-  module DataClass
-    def initialize(params)
-      self.class.json_attributes.each do |attr, attr_type|
-        attr_value = params[attr]
-        self.instance_variable_set("@#{attr}", T.check_var(attr, attr_type, attr_value))
-      end
+module DataClass
+  def initialize(params)
+    self.class.json_attributes.each do |attr, attr_type|
+      attr_value = params[attr]
+      self.instance_variable_set("@#{attr}", T.check_var(attr, attr_type, attr_value))
     end
+  end
 
-    def ==(other)
-      begin
-        T.check(self.class, other)
-        self.class.json_attributes.keys.each do |attr|
-          if self.instance_variable_get("@#{attr}") != other.instance_variable_get("@#{attr}")
-            return false
-          end
+  def ==(other)
+    begin
+      T.check(self.class, other)
+      self.class.json_attributes.keys.each do |attr|
+        if self.instance_variable_get("@#{attr}") != other.instance_variable_get("@#{attr}")
+          return false
         end
-        return true
-      rescue
-        return false
       end
+      return true
+    rescue
+      return false
     end
+  end
 
-    def copy(params)
-      params.each do |attr, attr_value|
-        if !self.class.json_attributes.key?(attr)
-          raise TypeError.new("Non existing attribute #{attr}")
-        end
+  def copy(params)
+    params.each do |attr, attr_value|
+      if !self.class.json_attributes.key?(attr)
+        raise TypeError.new("Non existing attribute #{attr}")
       end
-      new_params =
-        self.class.json_attributes.map do |attr, attr_type|
-          attr_value =
-            if params.key?(attr)
-              params[attr]
-            else
-              self.instance_variable_get("@#{attr}")
-            end
-          [attr, attr_value]
-        end.to_h
-      return self.class.new(new_params)
     end
+    new_params =
+      self.class.json_attributes.map do |attr, attr_type|
+        attr_value =
+          if params.key?(attr)
+            params[attr]
+          else
+            self.instance_variable_get("@#{attr}")
+          end
+        [attr, attr_value]
+      end.to_h
+    return self.class.new(new_params)
+  end
 
-    def self.included(base)
-      base.extend ClassMethods
-    end
+  def self.included(base)
+    base.extend ClassMethods
+  end
 
-    module ClassMethods
-      def json_attributes
-        @json_attributes
-      end
+  module ClassMethods
+    def json_attributes
+      @json_attributes
+    end
 
-      def val(name, type)
-        if @json_attributes == nil
-          @json_attributes = {}
-        end
-        @json_attributes[name] = type
-        attr_reader name
+    def val(name, type)
+      if @json_attributes == nil
+        @json_attributes = {}
       end
+      @json_attributes[name] = type
+      attr_reader name
+    end
 
-      def var(name, type)
-        if @json_attributes == nil
-          @json_attributes = {}
-        end
-        @json_attributes[name] = type
-        attr_accessor name
+    def var(name, type)
+      if @json_attributes == nil
+        @json_attributes = {}
       end
+      @json_attributes[name] = type
+      attr_accessor name
+    end
 
-      def jsoner_deserialize(json_value)
-        T.check(T.hash(String, NilableUntyped), json_value)
-        parameters = @json_attributes.map do |attr, attr_type|
-          attr_value = json_value[attr.to_s]
-          [attr, Jsoner.deserialize(attr_type, attr_value)]
-        end
-        return self.new parameters.to_h
+    def jsoner_deserialize(json_value)
+      T.check(T.hash(String, NilableUntyped), json_value)
+      parameters = @json_attributes.map do |attr, attr_type|
+        attr_value = json_value[attr.to_s]
+        [attr, Jsoner.deserialize(attr_type, attr_value)]
       end
+      return self.new parameters.to_h
+    end
 
-      def jsoner_serialize(value)
-        T.check(self, value)
-        attrs = @json_attributes.map do |attr, attr_type|
-          [attr, Jsoner.serialize(attr_type, value.send(attr))]
-        end
-        return attrs.to_h
+    def jsoner_serialize(value)
+      T.check(self, value)
+      attrs = @json_attributes.map do |attr, attr_type|
+        [attr, Jsoner.serialize(attr_type, value.send(attr))]
       end
+      return attrs.to_h
     end
   end
 end

data/lib/emery/enum.rb

@@ -1,101 +1,99 @@
-module Emery
-  module Enum
-    attr_reader :key, :value
+module Enum
+  attr_reader :key, :value
 
-    def initialize(key, value)
-      @key = key
-      @value = value
-    end
+  def initialize(key, value)
+    @key = key
+    @value = value
+  end
 
-    def self.included(base)
-      base.extend Enumerable
-      base.extend ClassMethods
+  def self.included(base)
+    base.extend Enumerable
+    base.extend ClassMethods
 
-      base.private_class_method(:new)
-    end
+    base.private_class_method(:new)
+  end
 
-    module ClassMethods
-      def check(value)
-        T.check_not_nil(self, value)
-        if !value?(value)
-          raise TypeError.new("Value '#{value.inspect.to_s}' is not a member of enum #{self}")
-        end
+  module ClassMethods
+    def check(value)
+      T.check_not_nil(self, value)
+      if !value?(value)
+        raise TypeError.new("Value '#{value.inspect.to_s}' is not a member of enum #{self}")
       end
+    end
 
-      def jsoner_deserialize(json_value)
-        T.check(self, json_value)
-      end
+    def jsoner_deserialize(json_value)
+      T.check(self, json_value)
+    end
 
-      def jsoner_serialize(value)
-        T.check(self, value)
-      end
+    def jsoner_serialize(value)
+      T.check(self, value)
+    end
 
-      def define(key, value)
-        @_enum_hash ||= {}
-        @_enums_by_value ||= {}
+    def define(key, value)
+      @_enum_hash ||= {}
+      @_enums_by_value ||= {}
 
-        if @_enum_hash.key?(key) then
-          raise TypeError.new("Duplicate key: #{key}")
-        end
+      if @_enum_hash.key?(key) then
+        raise TypeError.new("Duplicate key: #{key}")
+      end
 
-        if @_enums_by_value.key?(value) then
-          raise TypeError.new("Duplicate value: #{value}")
-        end
+      if @_enums_by_value.key?(value) then
+        raise TypeError.new("Duplicate value: #{value}")
+      end
 
-        new_instance = new(key, value)
-        @_enum_hash[key] = new_instance
-        @_enums_by_value[value] = new_instance
+      new_instance = new(key, value)
+      @_enum_hash[key] = new_instance
+      @_enums_by_value[value] = new_instance
 
-        if key.to_s == key.to_s.upcase
-          const_set key, value
-        else
-          define_singleton_method(key) { value }
-        end
+      if key.to_s == key.to_s.upcase
+        const_set key, value
+      else
+        define_singleton_method(key) { value }
       end
+    end
 
-      def each(&block)
-        @_enum_hash.each(&block)
-      end
+    def each(&block)
+      @_enum_hash.each(&block)
+    end
 
-      def parse(k)
-        k = k.to_s.upcase
-        each do |key, enum|
-          return enum.value if key.to_s.upcase == k
-        end
-        nil
+    def parse(k)
+      k = k.to_s.upcase
+      each do |key, enum|
+        return enum.value if key.to_s.upcase == k
       end
+      nil
+    end
 
-      def key?(k)
-        @_enum_hash.key?(k)
-      end
+    def key?(k)
+      @_enum_hash.key?(k)
+    end
 
-      def value(k)
-        enum = @_enum_hash[k]
-        enum.value if enum
-      end
+    def value(k)
+      enum = @_enum_hash[k]
+      enum.value if enum
+    end
 
-      def value?(v)
-        @_enums_by_value.key?(v)
-      end
+    def value?(v)
+      @_enums_by_value.key?(v)
+    end
 
-      def key(v)
-        enum = @_enums_by_value[v]
-        enum.key if enum
-      end
+    def key(v)
+      enum = @_enums_by_value[v]
+      enum.key if enum
+    end
 
-      def keys
-        @_enum_hash.values.map(&:key)
-      end
+    def keys
+      @_enum_hash.values.map(&:key)
+    end
 
-      def values
-        @_enum_hash.values.map(&:value)
-      end
+    def values
+      @_enum_hash.values.map(&:value)
+    end
 
-      def to_h
-        Hash[@_enum_hash.map do |key, enum|
-          [key, enum.value]
-        end]
-      end
+    def to_h
+      Hash[@_enum_hash.map do |key, enum|
+        [key, enum.value]
+      end]
     end
   end
 end