miasma 0.0.1 → 0.1.0

data/lib/miasma/models/storage/bucket.rb

@@ -0,0 +1,36 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Storage
+      # Abstract bucket
+      class Bucket < Types::Model
+
+        attribute :metadata, Hash, :coerce => lambda{|o| o.to_smash}
+
+        # Filter buckets
+        #
+        # @param filter [Hash]
+        # @return [Array<Bucket>]
+        def filter(filter={})
+        end
+
+        # Rename bucket
+        #
+        # @param new_name [String]
+        # @return [self]
+        def rename(new_name)
+          perform_rename(new_name)
+        end
+
+        protected
+
+        def perform_rename(new_name)
+          api.bucket_rename(self, new_name)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/models/storage/buckets.rb

@@ -0,0 +1,41 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    # Abstract storage API
+    class Storage
+
+      # Abstract bucket collection
+      class Buckets < Types::Collection
+
+        # Return buckets matching given filter
+        #
+        # @param options [Hash] filter options
+        # @return [Array<Bucket>]
+        # @option options [String] :prefix key prefix
+        def filter(options={})
+          raise NotImplementedError
+        end
+
+        # @return [Bucket] new unsaved instance
+        def build(args={})
+          Bucket.new(api, args.to_smash)
+        end
+
+        # @return [Bucket] collection item class
+        def model
+          Bucket
+        end
+
+        protected
+
+        # @return [Array<Bucket>]
+        def perform_population
+          api.bucket_all
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/models/storage/file.rb

@@ -0,0 +1,45 @@
+require 'miasma'
+require 'stringio'
+
+module Miasma
+  module Models
+    class Storage
+
+      # Abstract file
+      class File < Types::Collection
+
+        attribute :body, IO, :coerce => lambda{|v| StringIO.new(v.to_s) }
+        attribute :content_type, String
+        attribute :content_disposition, String
+        attribute :etag, String
+        attribute :last_modified, DateTime
+        attribute :size, Integer
+        attribute :metadata, Hash, :coerce => lambda{|o| o.to_smash}
+
+        # @return [Bucket] parent bucket
+        attr_reader :bucket
+
+        # Create a new instance
+        #
+        # @param bucket [Bucket]
+        # @param args [Hash]
+        # @return [self]
+        def initialize(bucket, args={})
+          @bucket = bucket
+          super bucket.api, args
+        end
+
+        # Return files matching given filter
+        #
+        # @param options [Hash] filter options
+        # @return [Array<File>]
+        # @option options [String] :prefix key prefix
+        def filter(options={})
+          raise NotImplementedError
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/models/storage/files.rb

@@ -0,0 +1,52 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Storage
+
+      # Abstract file collection
+      class Files < Types::Collection
+
+        # @return [Bucket] parent bucket
+        attr_reader :bucket
+
+        # Create new instance
+        #
+        # @param bucket [Bucket] parent bucket
+        # @return [self]
+        def initialize(bucket)
+          @bucket = bucket
+          super bucket.api
+        end
+
+        # Return files matching given filter
+        #
+        # @param options [Hash] filter options
+        # @return [Array<File>]
+        # @option options [String] :prefix key prefix
+        def filter(options={})
+          raise NotImplementedError
+        end
+
+        # @return [File] new unsaved instance
+        def build(args={})
+          File.new(api, args.to_smash)
+        end
+
+        # @return [File] collection item class
+        def model
+          File
+        end
+
+        protected
+
+        # @return [Array<File>]
+        def perform_population
+          api.file_all(bucket)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/types.rb

@@ -0,0 +1,13 @@
+require 'miasma'
+
+module Miasma
+  module Types
+
+    autoload :Api, 'miasma/types/api'
+    autoload :Collection, 'miasma/types/collection'
+    autoload :Model, 'miasma/types/model'
+    autoload :ThinModel, 'miasma/types/thin_model'
+    autoload :Data, 'miasma/types/data'
+
+  end
+end

data/lib/miasma/types/api.rb

@@ -0,0 +1,145 @@
+require 'miasma'
+
+module Miasma
+  module Types
+
+    # Remote API connection
+    class Api
+
+      include Miasma::Utils::Lazy
+      include Miasma::Utils::Memoization
+
+      # Create new API connection
+      #
+      # @param creds [Smash] credentials
+      # @return [self]
+      def initialize(creds)
+        if(creds.is_a?(Hash))
+          load_data(creds)
+        else
+          raise TypeError.new "Expecting `credentials` to be of type `Hash`. Received: `#{creds.class}`"
+        end
+        connect
+      end
+
+      # @return [Symbol] name of provider
+      def provider
+        Utils.snake(self.class.to_s.split('::').last).to_sym
+      end
+
+      # Connect to the remote API
+      #
+      # @return [self]
+      def connect
+        self
+      end
+
+      # Build new API for specified type using current provider / creds
+      #
+      # @param type [Symbol] api type
+      # @return [Api]
+      def api_for(type)
+        memoize(type) do
+          Miasma.api(
+            Smash.new(
+              :type => type,
+              :provider => provider,
+              :credentials => attributes
+            )
+          )
+        end
+      end
+
+      # @return [HTTP]
+      def connection
+        HTTP.with_headers('User-Agent' => "miasma/v#{Miasma::VERSION}")
+      end
+
+      # @return [String] url endpoint
+      def endpoint
+        'http://api.example.com'
+      end
+
+      # Perform request to remote API
+      #
+      # @param args [Hash] options
+      # @option args [String, Symbol] :method HTTP request method
+      # @option args [String] :path request path
+      # @option args [Integer] :expects expected response status code
+      # @return [Smash] {:result => HTTP::Response, :headers => Smash, :body => Object}
+      # @raises [Error::ApiError::RequestError]
+      def request(args)
+        args = args.to_smash
+        http_method = args.fetch(:method, 'get').to_s.downcase.to_sym
+        unless(HTTP::Request::METHODS.include?(http_method))
+          raise ArgumentError.new 'Invalid request method provided!'
+        end
+        request_args = [].tap do |ary|
+          ary.push(
+            File.join(endpoint, args[:path].to_s)
+          )
+          options = {}.tap do |opts|
+            [:form, :params, :json, :body].each do |key|
+              opts[key] = args[key] if args[key]
+            end
+          end
+          ary.push(options) unless options.empty?
+        end
+        if(args[:headers])
+          _connection = connection.with_headers(args[:headers])
+          args.delete(:headers)
+        else
+          _connection = connection
+        end
+        result = make_request(_connection, http_method, request_args)
+        unless(result.code == args.fetch(:expects, 200).to_i)
+          raise Error::ApiError::RequestError.new(result.reason, :response => result)
+        end
+        format_response(result)
+      end
+
+      # Perform request
+      #
+      # @param connection [HTTP]
+      # @param http_method [Symbol]
+      # @param request_args [Array]
+      # @return [HTTP::Response]
+      # @note this is mainly here for concrete APIs to
+      #   override if things need to be done prior to
+      #   the actual request (like signature generation)
+      def make_request(connection, http_method, request_args)
+        connection.send(http_method, *request_args)
+      end
+
+      # Makes best attempt at formatting response
+      #
+      # @param result [HTTP::Response]
+      # @return [Smash]
+      def format_response(result)
+        extracted_headers = Smash[result.headers.map{|k,v| [Utils.snake(k), v]}]
+        if(extracted_headers[:content_type].include?('application/json'))
+          begin
+            extracted_body = MultiJson.load(result.body.to_s).to_smash
+          rescue MultiJson::ParseError
+            extracted_body = result.body.to_s
+          end
+        elsif(extracted_headers[:content_type].include?('text/xml'))
+          begin
+            extracted_body = MultiXml.parse(result.body.to_s).to_smash
+          rescue MultiXml::ParseError
+            extracted_body = result.body.to_s
+          end
+        else
+          extracted_body = result.body.to_s
+        end
+        Smash.new(
+          :response => result,
+          :headers => extracted_headers,
+          :body => extracted_body
+        )
+      end
+
+    end
+
+  end
+end

data/lib/miasma/types/collection.rb

@@ -0,0 +1,116 @@
+require 'miasma'
+
+module Miasma
+  module Types
+
+    # Base collection
+    class Collection
+
+      include Utils::Memoization
+
+      # @return [Miasma::Api] underlying service API
+      attr_reader :api
+
+      def initialize(api)
+        @api = api
+        @collection = nil
+      end
+
+      # @return [Array<Model>]
+      def all
+        memoize(:collection) do
+          perform_population
+        end
+      end
+
+      # Reload the collection
+      #
+      # @return [self]
+      def reload
+        clear_memoizations!
+        self
+      end
+
+      # Return model with given name or ID
+      #
+      # @param ident [String, Symbol] model identifier
+      # @return [Model, NilClass]
+      def get(ident)
+        memoize(ident) do
+          perform_get(ident)
+        end
+      end
+
+      # Return models matching given filter
+      #
+      # @param args [Hash] filter options
+      # @return [Array<Model>]
+      # @todo need to add helper to deep sort args, convert to string
+      #   and hash to use as memoization key
+      def filter(args={})
+        memoize(args.to_s)
+        raise NotImplementedError
+      end
+
+      # Build a new model
+      #
+      # @param args [Hash] creation options
+      # @return [Model]
+      def build(args={})
+        instance = self.model.new(self.api)
+        args.each do |m_name, m_value|
+          m_name = "#{m_name}="
+          instance.send(m_name, m_value)
+        end
+        instance
+      end
+
+      # @return [String] collection of models
+      def to_json(*_)
+        self.all.to_json
+      end
+
+      # Load collection via JSON
+      #
+      # @param json [String]
+      # @return [self]
+      def from_json(json)
+        loaded = MultiJson.load(json)
+        unless(loaded.is_a?(Array))
+          raise TypeError.new "Expecting type `Array` but received `#{loaded.class}`"
+        end
+        unmemoize(:collection)
+        memoize(:collection) do
+          loaded.map do |item|
+            model.from_json(self.api, MultiJson.dump(item))
+          end
+        end
+        self
+      end
+
+      # @return [Miasma::Types::Model] model class within collection
+      def model
+        raise NotImplementedError
+      end
+
+      protected
+
+      # Return model with given name or ID
+      #
+      # @param ident [String, Symbol] model identifier
+      # @return [Model, NilClass]
+      def perform_get(ident)
+        all.detect do |obj|
+          obj.id == ident ||
+            (obj.respond_to?(:name) && obj.name == ident)
+        end
+      end
+
+      # @return [Array<Model>]
+      def perform_population
+        raise NotImplementedError
+      end
+
+    end
+  end
+end