miasma 0.0.1 → 0.1.0

data/lib/miasma/types/data.rb

@@ -0,0 +1,53 @@
+require 'miasma'
+
+module Miasma
+  module Types
+
+    # Base data container
+    class Data
+
+      include Miasma::Utils::Lazy
+
+      attribute :id, [String, Numeric]
+
+      # Build new data instance
+      #
+      # @param args [Hash] attribute values
+      # @return [self]
+      def initialize(args={})
+        load_data(args)
+        valid_state
+      end
+
+      # Convert model to JSON string
+      #
+      # @return [String]
+      def to_json(*_)
+        MultiJson.dump(attributes)
+      end
+
+      # Load model using JSON string
+      #
+      # @param json [String]
+      # @return [self]
+      def from_json(json)
+        load_data(
+          MultiJson.load(json).to_smash
+        ).valid_state
+      end
+
+      class << self
+
+        # Build new instance from JSON string
+        #
+        # @param json [String]
+        # @return [Data]
+        def from_json(json)
+          self.new(MultiJson.load(json).to_smash)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/types/model.rb

@@ -0,0 +1,118 @@
+require 'miasma'
+
+module Miasma
+  module Types
+
+    # Base model
+    class Model < Data
+
+      # @return [Miasma::Types::Api] underlying service API
+      attr_reader :api
+
+      class << self
+
+        # Build new model from JSON
+        #
+        # @param api [Miasma::Types::Api]
+        # @param json [String]
+        # @return [Model]
+        def from_json(api, json)
+          instance = self.new(api)
+          instance.from_json(json)
+          instance
+        end
+
+      end
+
+      # Build new model
+      #
+      # @param api [Miasma::Types::Api] service API
+      # @param model_data [Smash] load model data if provided
+      # @return [self]
+      def initialize(api, model_data=nil)
+        @api = api
+        @data = Smash.new
+        @dirty = Smash.new
+        if(model_data)
+          if(model_data.is_a?(Hash))
+            load_data(model_data)
+          else
+            raise TypeError.new "Expecting `model_data` to be of type `Hash`. Received: `#{model_data.class}`"
+          end
+        end
+      end
+
+      # Save changes to the model
+      #
+      # @return [TrueClass, FalseClass] save was performed
+      # @raises [Miasma::Error::Save]
+      def save
+        if(dirty?)
+          perform_save
+          reload
+        else
+          false
+        end
+      end
+
+      # Destroy the model
+      #
+      # @return [TrueClass, FalseClass] destruction was performed
+      # @raises [Miasma::Error::Destroy]
+      def destroy
+        if(persisted?)
+          perform_destroy
+          reload
+          true
+        else
+          false
+        end
+      end
+
+      # Reload the underlying data for model
+      #
+      # @return [self]
+      def reload
+        perform_reload
+        self
+      end
+
+      # @return [TrueClass, FalseClass] model is persisted
+      def persisted?
+        id?
+      end
+
+      # @return [String, Integer]
+      def id?
+        data[:id] || dirty[:id]
+      end
+
+      protected
+
+      # Save model state to remote API
+      #
+      # @return [TrueClass, FalseClass] performed remote action
+      # @raises [Miasma::Error::Save]
+      def perform_save
+        raise NotImplementedError.new 'Remote API save has not been implemented'
+      end
+
+      # Reload model state from remote API
+      #
+      # @return [TrueClass, FalseClass] performed remote action
+      # @raises [Miasma::Error::Save]
+      def perform_reload
+        raise NotImplementedError.new 'Remote API reload has not been implemented'
+      end
+
+      # Destroy model from remote API
+      #
+      # @return [TrueClass, FalseClass] performed remote action
+      # @raises [Miasma::Error::Save]
+      def perform_destroy
+        raise NotImplementedError.new 'Remote API destroy has not been implemented'
+      end
+
+    end
+  end
+end

data/lib/miasma/types/thin_model.rb

@@ -0,0 +1,76 @@
+require 'miasma'
+
+module Miasma
+  module Types
+
+    # Base data container
+    class ThinModel < Data
+
+      class << self
+
+        # Get/Set fat model
+        #
+        # @param klass [Class] fat model class
+        # @return [Class] fat model class
+        def model(klass=nil)
+          if(klass)
+            unless(klass.ancestors.include?(Miasma::Types::Model))
+              raise TypeError.new "Expecting `Miasma::Types::Model` subclass! (got #{klass})"
+            else
+              self._model = klass
+            end
+          end
+          self._model
+        end
+
+        protected
+
+        # @return [Class] fat model class
+        attr_accessor :_model
+
+      end
+
+      # @return [Miasma::Types::Api] service API
+      attr_reader :api
+
+      # Build new instance
+      #
+      # @param api [Miasma::Types::Api] service API
+      # @param args [Hash] model data
+      def initialize(api, args={})
+        @api = api
+        super args
+      end
+
+      # @return [FalseClass]
+      # @note thin models are always false
+      def persisted?
+        false
+      end
+
+      # Associated model class
+      #
+      # @return [Class] of type Miasma::Types::Model
+      # @note will deconstruct namespace and rebuild using provider
+      def model
+        if(self.class.model)
+          self.class.model
+        else
+          raise NotImplementedError.new "No associated model for this thin model type (#{self.class})"
+        end
+      end
+
+      # Build fat model instance
+      #
+      # @return [Miasma::Types::Model]
+      def expand
+        inst = model.new(api)
+        inst.data[:id] = self.id
+        inst.reload
+      end
+      alias_method :instance, :expand
+
+    end
+
+  end
+end

data/lib/miasma/utils.rb

@@ -0,0 +1,12 @@
+require 'miasma'
+
+module Miasma
+  module Utils
+    autoload :Lazy, 'miasma/utils/lazy'
+    autoload :Memoization, 'miasma/utils/memoization'
+    autoload :Immutable, 'miasma/utils/immutable'
+  end
+end
+
+require 'miasma/utils/animal_strings'
+require 'miasma/utils/smash'

data/lib/miasma/utils/animal_strings.rb

@@ -0,0 +1,29 @@
+require 'miasma'
+
+module Miasma
+
+  module Utils
+    # Animal stylings on strings
+    module AnimalStrings
+
+      # Camel case string
+      # @param string [String]
+      # @return [String]
+      def camel(string)
+        string.to_s.split('_').map{|k| "#{k.slice(0,1).upcase}#{k.slice(1,k.length)}"}.join
+      end
+
+      # Snake case (underscore) string
+      #
+      # @param string [String]
+      # @return [String]
+      def snake(string)
+        string.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').gsub('-', '_').downcase
+      end
+
+    end
+
+    extend AnimalStrings
+  end
+
+end

data/lib/miasma/utils/immutable.rb

@@ -0,0 +1,36 @@
+require 'miasma'
+
+module Miasma
+
+  module Utils
+    # Make best effort to make model immutable
+    # @note this should be included at end of model definition
+    module Immutable
+
+      # Freezes underlying data hash
+      def frozen_valid_state(*args)
+        unfrozen_valid_state(*args)
+        data.freeze
+        dirty.freeze
+        self
+      end
+
+      # @raises [Error::ImmutableError]
+      def save
+        raise Error::ImmutableError.new 'Resource information cannot be mutated!'
+      end
+
+      class << self
+
+        def included(klass)
+          klass.class_eval do
+            alias_method :unfrozen_valid_state, :valid_state
+            alias_method :valid_state, :frozen_valid_state
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/utils/lazy.rb

@@ -0,0 +1,231 @@
+require 'miasma'
+require 'digest/sha2'
+
+module Miasma
+  module Utils
+    # Adds functionality to facilitate laziness
+    module Lazy
+
+      # Instance methods for laziness
+      module InstanceMethods
+
+        # @return [Smash] argument hash
+        def data
+          unless(@data)
+            @data = Smash.new
+          end
+          @data
+        end
+
+        # @return [Smash] updated data
+        def dirty
+          unless(@dirty)
+            @dirty = Smash.new
+          end
+          @dirty
+        end
+
+        # @return [Smash] current data state
+        def attributes
+          data.merge(dirty)
+        end
+
+        # Create new instance
+        #
+        # @param args [Hash]
+        # @return [self]
+        def load_data(args={})
+          args = args.to_smash
+          @data = Smash.new
+          self.class.attributes.each do |name, options|
+            val = args[name]
+            if(options[:required] && !args.has_key?(name) && !options.has_key?(:default))
+              raise ArgumentError.new("Missing required option: `#{name}`")
+            end
+            if(val.nil? && !args.has_key?(name) && options[:default])
+              if(options[:default])
+                val = options[:default].respond_to?(:call) ? options[:default].call : options[:default]
+              end
+            end
+            if(args.has_key?(name) || val)
+              self.send("#{name}=", val)
+            end
+          end
+          self
+        end
+
+        # Identifies valid state and automatically
+        # merges dirty attributes into data, clears
+        # dirty attributes
+        #
+        # @return [self]
+        def valid_state
+          data.merge!(dirty)
+          dirty.clear
+          @_checksum = Digest::SHA256.hexdigest(MultiJson.dump(data))
+          self
+        end
+
+        # Model is dirty or specific attribute is dirty
+        #
+        # @param attr [String, Symbol] name of attribute
+        # @return [TrueClass, FalseClass] model or attribute is dirty
+        def dirty?(attr=nil)
+          if(attr)
+            dirty.has_key?(attr)
+          else
+            if(@_checksum)
+              !dirty.empty? ||
+                @_checksum != Digest::SHA256.hexdigest(MultiJson.dump(data))
+            else
+              true
+            end
+          end
+        end
+
+        # @return [String]
+        def to_s
+          "<#{self.class.name}:#{object_id}>"
+        end
+
+        # @return [String]
+        def inspect
+          "<#{self.class.name}:#{object_id} [#{data.inspect}]>"
+        end
+
+      end
+
+      # Class methods for laziness
+      module ClassMethods
+
+        # Add new attributes to class
+        #
+        # @param name [String]
+        # @param type [Class, Array<Class>]
+        # @param options [Hash]
+        # @option options [TrueClass, FalseClass] :required must be provided on initialization
+        # @option options [Object, Proc] :default default value
+        # @option options [Proc] :coerce
+        # @return [nil]
+        def attribute(name, type, options={})
+          name = name.to_sym
+          options = options.to_smash
+          attributes[name] = Smash.new(:type => type).merge(options)
+          coerce = attributes[name][:coerce]
+          valid_types = [attributes[name][:type], NilClass].flatten.compact
+          allowed_values = attributes[name][:allowed]
+          multiple_values = attributes[name][:multiple]
+          depends_on = attributes[name][:depends]
+          define_method(name) do
+            send(depends_on) if depends_on
+            self.class.on_missing(self) unless data.has_key?(name) || dirty.has_key?(name)
+            dirty[name] || data[name]
+          end
+          define_method("#{name}=") do |val|
+            values = multiple_values && val.is_a?(Array) ? val : [val]
+            values.map! do |item|
+              valid_type = valid_types.detect do |klass|
+                item.is_a?(klass)
+              end
+              if(coerce && !valid_type)
+                item = coerce.arity == 2 ? coerce.call(item, self) : coerce.call(item)
+              end
+              valid_type = valid_types.detect do |klass|
+                item.is_a?(klass)
+              end
+              unless(valid_type)
+                raise TypeError.new("Invalid type for `#{name}` (#{item} <#{item.class}>). Valid - #{valid_types.map(&:to_s).join(',')}")
+              end
+              if(allowed_values)
+                unless(allowed_values.include?(item))
+                  raise ArgumentError.new("Invalid value provided for `#{name}` (#{item.inspect}). Allowed - #{allowed_values.map(&:inspect).join(', ')}")
+                end
+              end
+              item
+            end
+            if(!multiple_values && !val.is_a?(Array))
+              dirty[name] = values.first
+            else
+              dirty[name] = values
+            end
+          end
+          define_method("#{name}?") do
+            send(depends_on) if depends_on
+            self.class.on_missing(self) unless data.has_key?(name)
+            !!data[name]
+          end
+          nil
+        end
+
+        # Return attributes
+        #
+        # @param args [Symbol] :required or :optional
+        # @return [Array<Hash>]
+        def attributes(*args)
+          @attributes ||= Smash.new
+          if(args.include?(:required))
+            Smash[@attributes.find_all{|k,v| v[:required]}]
+          elsif(args.include?(:optional))
+            Smash[@attributes.find_all{|k,v| !v[:required]}]
+          else
+            @attributes
+          end
+        end
+
+        # Instance method to call on missing attribute or
+        # object to call method on if set
+        #
+        # @param param [Symbol, Object]
+        # @return [Symbol]
+        def on_missing(param=nil)
+          if(param)
+            if(param.is_a?(Symbol))
+              @missing_method = param
+            else
+              if(@missing_method)
+                param.send(@missing_method)
+              end
+              @missing_method
+            end
+          else
+            @missing_method
+          end
+        end
+
+        # Directly set attribute hash
+        #
+        # @param attrs [Hash]
+        # @return [TrueClass]
+        # @todo need deep dup here
+        def set_attributes(attrs)
+          @attributes = attrs.to_smash
+          true
+        end
+
+      end
+
+      class << self
+
+        # Injects laziness into class
+        #
+        # @param klass [Class]
+        def included(klass)
+          klass.class_eval do
+            include InstanceMethods
+            extend ClassMethods
+
+            class << self
+
+              def inherited(klass)
+                klass.set_attributes(self.attributes)
+              end
+
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end