modgen 0.0.1

data/lib/modgen/discovery/method.rb

@@ -0,0 +1,137 @@
+module Modgen
+  module API
+    class Method
+
+      attr_reader :name, :path, :url, :http_method, :description, :method_parameters
+      
+      def initialize(name, values)
+        @name   = name
+        @values = values
+
+        @path               = values['path']
+        @url                = URI.join(Modgen.config.api.base_url, "#{Modgen::API.api.version}/", @path)
+        @http_method        = values['http_method']
+        @description        = values['description']
+        @method_parameters  = values['parameters']
+      end
+
+      def call(params)
+        # if params == nil
+        #   return self
+        # end
+
+        query(params)
+      end
+
+      # Check if value has property type(s)
+      #
+      def check_type(param, value, *types)
+        types.each do |type|
+          return(true) if value.is_a?(type)
+        end
+
+        raise Modgen::APIRequestError, "Parameter #{param} has invalid type. Must be #{types.join(' or ')}."
+      end
+
+      # Check one parameter
+      #
+      def validate_parameter(param, spec, value)
+        if value.nil?
+          if spec['required']
+            raise Modgen::APIRequestError, "Parameter #{param} is required."
+          end
+
+          return 'next'
+        end
+
+        case spec['type']
+          when 'integer'; check_type(param, value, Integer)
+          when 'float';   check_type(param, value, Integer, Float)
+          when 'string';  check_type(param, value, String)
+          when 'hash'
+            check_type(param, value, Hash)
+            validate_parameters(spec['attributes'], value)
+          when 'file'
+            if !File.file?(value)
+              raise Modgen::APIRequestError, "File #{value} doesn't exists."
+            end
+        end
+
+        if spec['format']
+          unless value =~ /#{spec['format']}/
+            raise Modgen::APIRequestError, "Parameter #{param} hasn't required format (#{spec['format']})."
+          end
+        end
+      end
+
+      # Check all parameters
+      #
+      def validate_parameters(attributes, params = {})
+        if !attributes
+          return nil
+        end
+
+        params.stringify_keys!
+
+        parameters_left = params.keys - attributes.keys
+        if !parameters_left.empty?
+          raise Modgen::APIRequestError, "Parameters: #{parameters_left} are unknow."
+        end
+
+        attributes.each do |param, spec|
+          value = params[param]
+
+          if validate_parameter(param, spec, value) == 'next'
+            next
+          end
+        end
+      end
+
+      def build_file(path)
+        mime = MimeMagic.by_path(path)
+        Faraday::UploadIO.new(path, mime)
+      end
+
+      # Buld request data based on discoverd API
+      #
+      def build_request_data(params = {})
+        result = {
+          'path'   => {},
+          'params' => {},
+          'body'   => {}
+        }
+
+        params.each do |key, value|
+          case @method_parameters[key]['location']
+            when 'path'; result['path'][key] = value
+            when 'body'; result['body'][key] = value
+            else
+              if @method_parameters[key]['type'] == 'file'
+                result['params'][key] = build_file(value)
+              else
+                result['params'][key] = value
+              end
+          end
+        end
+
+        result
+      end
+
+      # Create request and call response on it.
+      #
+      def query(params)
+        request_data = {}
+
+        if !params.is_a?(Hash)
+          raise Modgen::TypeError, "Parameters must be Hash. #{params.class.name} inserted."
+        end
+
+        validate_parameters(@method_parameters, params)
+        request_data = build_request_data(params)
+
+        Modgen::API::APIRequest.new(self, request_data).response
+      end
+
+    end
+  end
+end

data/lib/modgen/discovery/resource.rb

@@ -0,0 +1,53 @@
+module Modgen
+  module API
+    class Resource
+      
+      attr_reader :name
+
+      def initialize(name, values)
+        @name    = name
+        @values  = values
+        @methods = []
+
+        build_resources
+      end
+
+      def methods
+        @methods
+      end
+
+      private
+
+        def build_resources
+          @values.each do |key, value|
+            if key == 'methods'
+              build_methods(value)
+            else
+              build_resource(key, value)
+            end
+          end
+        end
+
+        def build_resource(name, values)
+          resource = Modgen::API::Resource.new(name, values)
+
+          @methods << name.to_sym          
+
+          metaclass = class << self; self; end
+          metaclass.send(:define_method, name) { resource }
+        end
+
+        def build_methods(value)
+          value.each do |key, value|
+            method = Modgen::API::Method.new(key, value)
+
+            @methods << key.to_sym
+
+            metaclass = class << self; self; end
+            metaclass.send(:define_method, key) { |params={}| method.send(:call, params) }
+          end
+        end
+
+    end
+  end
+end

data/lib/modgen/errors.rb

@@ -0,0 +1,21 @@
+module Modgen
+  
+  # Errors in API
+  #
+  # e.g. API was not discovered
+  class APIError < StandardError
+  end
+
+  # Error during request such as missing parameters
+  class APIRequestError < StandardError
+  end
+
+  # Type error
+  class TypeError < StandardError
+  end
+
+  # Configuration error
+  class ConfigurationError < StandardError
+  end
+
+end

data/lib/modgen/session/api_key.rb

@@ -0,0 +1,42 @@
+module Modgen
+  module Session
+    class APIKey
+
+      def self.config
+        Modgen.config
+      end
+      
+      def self.start
+        if config.api_key.key == nil
+          raise Modgen::ConfigurationError, "API key cannot be nil."
+        end
+
+        client = Modgen::Session::APIKey.new
+
+        Modgen::Session.store(client)
+      end
+
+      def initialize
+        @key = Modgen.config.api_key.key
+      end
+
+      def execute(request)
+        conn = Faraday.new(url: request.url)
+
+        if request.data['body'] && request.data['body'].empty?
+          response = conn.send(request.http_method, "", request.data['params']) { |req|
+            req.headers['Api-Key'] = @key
+          }
+        else
+          response = conn.send(@http_method, "") { |req|
+            req.headers['Api-Key'] = @key
+            req.body = request.data['body']
+          }
+        end
+
+        response
+      end
+
+    end
+  end
+end

data/lib/modgen/session/oauth2.rb

@@ -0,0 +1,94 @@
+require 'oauth2'
+
+module Modgen
+  module Session
+    class Oauth2
+
+      def self.config
+        Modgen.config
+      end
+      
+      # Start session
+      #
+      #
+      def self.start
+        client = Modgen::Session::Oauth2.new
+
+        Modgen::Session.store(client)
+
+        if config.oauth2.redirect_uri == nil
+          get_authorize_code
+        else
+          client.authorize_url
+        end
+      end
+
+      def self.authorize(auth_code)
+        Modgen::Session.get.authorize(auth_code)
+      end
+
+      # Automaticaly open autorization url a waiting for callback.
+      # Launchy gem is required
+      #
+      # Steps:
+      # 1) create server
+      # 2) launch browser and redirect to google api
+      # 3) confirm and modgen redirect to localhost
+      # 4) server get code and start session
+      # 5) close server - you are login
+      def self.get_authorize_code
+        require "socket"  # tcp server
+
+        uri = URI(Modgen::OAUTH2_REDIRECT_URI)
+        
+        webserver = TCPServer.new(uri.host, 0) # start webserver
+                                               # port=0 - automatically choose free port
+
+        uri.port = webserver.addr[1] # get choosen port
+
+        Launchy.open(Modgen::Session.get.authorize_url)
+
+        session = webserver.accept
+
+        # parse header for query.
+        request = session.gets.gsub(/GET\ \//, '').gsub(/\ HTTP.*/, '')
+        request = Hash[URI.decode_www_form(URI(request).query)]
+
+        # failure login
+        to_return = false
+        message   = "You have not been logged. Please try again."
+
+        if Modgen::Session.get.authorize(request['code'])
+          message   = "You have been successfully logged. Now you can close the browser."
+          to_return = true
+        end
+
+        session.write(message)
+        session.close
+
+        return to_return
+      end
+
+
+
+      attr_reader :authorize_url
+
+      def initialize
+        @client = OAuth2::Client.new(client_id, client_secret, site: Modgen::SITE_URL)
+
+        @authorize_url = client.auth_code.authorize_url(redirect_uri: redirect_uri)
+      end
+
+      def authorize(auth_code)
+        @auth_code = auth_code
+
+        @token = @client.auth_code.get_token(auth_code)
+      end
+
+      def execute(request)
+        
+      end
+
+    end
+  end
+end

data/lib/modgen/session.rb

@@ -0,0 +1,26 @@
+module Modgen
+  module Session
+
+    autoload :Oauth2, 'modgen/session/oauth2'
+    autoload :APIKey, 'modgen/session/api_key'
+
+    @@session = nil
+    
+    def self.oauth2
+      Modgen::Session::Oauth2
+    end
+
+    def self.api_key
+      Modgen::Session::APIKey
+    end
+
+    def self.store(client)
+      @@session = client
+    end
+
+    def self.get
+      @@session
+    end
+    
+  end
+end

data/lib/modgen/version.rb

@@ -0,0 +1,3 @@
+module Modgen
+  VERSION = "0.0.1"
+end

data/lib/modgen.rb

@@ -0,0 +1,43 @@
+require "modgen/core_ext/hash"
+require "modgen/core_ext/object"
+require "modgen/core_ext/string"
+
+require "modgen/version"
+require "modgen/configuration"
+require "modgen/default_configuration"
+require "modgen/errors"
+
+require "faraday"
+require "multi_json"
+require "mimemagic"
+
+module Modgen
+
+  autoload :Discovery, 'modgen/discovery/discovery'
+  autoload :API,       'modgen/api'
+  autoload :Session,   'modgen/session'
+
+  # Line set and get configuration
+  #
+  # *Set:* Modgen.config.key = "value"
+  #
+  # *Get:* Modgen.config.key
+  #
+  # == Returns:
+  # Top of Modgen::Configuration
+  #
+  def self.config
+    @config ||= Modgen::Configuration.new(DEFAULT_CONFIGURATION)
+  end
+
+  # Cofiguration with DSL
+  #
+  #   Modgen.configure do
+  #     key "value"
+  #   end
+  #
+  def self.configure(&block)
+    config.instance_eval(&block)
+  end
+
+end

data/modgen.gemspec

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'modgen/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "modgen"
+  spec.version       = Modgen::VERSION
+  spec.authors       = ["Ondřej Moravčík"]
+  spec.email         = ["moravcik.ondrej@gmail.com"]
+  spec.description   = %q{Modgen allow discover and use modgen's API}
+  spec.summary       = %q{Gem for using modgen's API}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday"
+  spec.add_dependency "multi_json"
+  spec.add_dependency "mimemagic"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/lib/01_authenticate_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Modgen::Session do
+  it "should not be logged" do
+    Modgen::Session.get.should eql(nil)
+  end
+
+  it "key cannot be nil" do
+    lambda { Modgen::Session.api_key.start }.should raise_error(Modgen::ConfigurationError)
+  end
+
+  it "should use Api Key" do
+    Modgen.config.api_key.key = 'f0ddaaef2903e6f2ac634e7f6037c9b2'
+    Modgen::Session.api_key.start
+
+    lambda { Modgen::Session.api_key.start }.should_not raise_error(Modgen::ConfigurationError)
+  end
+end

data/spec/lib/02_discovery_spec.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Modgen::Discovery do
+  before(:all) {
+    Modgen.configure do
+      api do
+        base_url "#{API_URL}/api/"
+      end
+    end
+  }
+
+  let(:config)    { Modgen.config }
+  let(:api)       { Modgen::API.api }
+  let(:discovery) { Modgen::Discovery }
+
+  context "configure" do
+    it "api_base_url should be localhost" do
+      config.api.base_url.should eql("#{API_URL}/api/")
+    end
+
+    it "api_discovery_versions_url shoud be base_url + versions" do
+      config.api.discovery_versions_url.to_s.should eql("#{API_URL}/api/discovery/versions")
+    end
+
+    it "api_discovery_version_url shoud be base_url + version/:id" do
+      config.api.discovery_version_url.to_s.should eql("#{API_URL}/api/discovery/version/:id")
+    end
+  end
+
+  context "API detils" do
+    it "should show preffered version" do
+      discovery.preffered_version.should eql('v1')
+    end
+
+    it "should show 2 version" do
+      versions = discovery.versions
+
+      versions.status.should eql(200)
+
+      versions.body['versions'].size.should eql(2)
+    end
+
+    it "non exist version" do
+      lambda { discovery.version('v3') }.should raise_error(Modgen::APIError)
+    end
+
+    it "version should take preffered version" do
+      discovery.version.body['version'].should eql('v1')
+    end
+
+    it "verion should have some values" do
+      result = discovery.version('v1').body
+
+      result['name'].should       eql('Modgen API')
+      result['version'].should    eql('v1')
+      result['created_at'].should eql('16022013')
+      result['updated_at'].should eql('16022013')
+      result['base_url'].should   eql('https://modgen.net/api')
+    end
+  end
+
+  context "before discover" do
+    it "shoud raise Modgen::APIError" do
+      lambda { api }.should raise_error(Modgen::APIError)
+    end
+
+    it "should false" do
+      Modgen::API.discovered?.should eql(false)
+    end
+  end
+
+  context "discover" do
+    before(:all) {
+      Modgen::Discovery.discover('v1')
+    }
+
+    it "details about API" do
+      api.name.should        eql('Modgen API')
+      api.description.should eql('Predikační platforma')
+      api.version.should     eql('v1')
+      api.created_at.should  eql('16022013')
+      api.updated_at.should  eql('16022013')
+      api.base_url.should    eql('https://modgen.net/api')
+    end
+
+    it "should true" do
+      Modgen::API.discovered?.should eql(true)
+    end
+
+    it "some methods should exist" do
+      Modgen::API.methods.should eql([:profile, :dataset])
+      Modgen::API.profile.methods.should eql([:get, :update])
+      Modgen::API.dataset.methods.should eql([:list, :get])
+    end
+  end
+
+end

data/spec/lib/03_api_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe Modgen::API do
+  before(:all) do
+    Modgen.config.api_key.key = 'f0ddaaef2903e6f2ac634e7f6037c9b2'
+    Modgen::Session.api_key.start
+
+    @user = Modgen::API.profile.get.body
+  end
+
+  let(:profile) { Modgen::API.profile }
+  let(:dataset) { Modgen::API.dataset }
+
+  context "profile" do
+    it "get" do
+      result = profile.get
+
+      result.status.should eql(200)
+
+      result.body["id"].should          eql(@user["id"])
+      result.body["first_name"].should  eql(@user["first_name"])
+      result.body["last_name"].should   eql(@user["last_name"])
+      result.body["email"].should       eql(@user["email"])
+      result.body["created_at"].should  eql(@user["created_at"])
+      result.body["updated_at"].should  eql(@user["updated_at"])
+      result.body["last_access"].should eql(@user["last_access"])
+    end
+
+    context "update" do
+      it "should update" do
+        result = profile.update(user: { first_name: "a",
+                                        last_name: "a",
+                                        email: "a@a.aa" })
+
+        result.status.should eql(200)
+
+        result.body["id"].should          eql(@user["id"])
+        result.body["first_name"].should  eql("a")
+        result.body["last_name"].should   eql("a")
+        result.body["email"].should       eql("a@a.aa")
+      end
+
+      it "missing value" do
+        lambda { profile.update(first_name: "a") }.should raise_error(Modgen::APIRequestError)
+      end
+
+      it "wrong format" do
+        lambda { profile.update(user: {first_name: "."}) }.should raise_error(Modgen::APIRequestError)
+      end
+    end
+  end
+
+  context "dataset" do
+    it "list" do
+      result = dataset.list
+
+      result.status.should eql(200)
+
+      result.body['datasets'].size.should eql(3)
+    end
+
+    context "get" do
+      it "should get" do
+        result = dataset.get(id: 1)
+
+        result.status.should eql(200)
+
+        result.body['id'].should eql(1)
+      end
+
+      it "missing value" do
+        lambda { dataset.get }.should raise_error(Modgen::APIRequestError)
+      end
+
+      it "non exist id" do
+        result = dataset.get(id: 6)
+
+        result.status.should eql(404)
+      end
+
+      it "unknow parameteres" do
+        lambda { dataset.get(a: "a") }.should raise_error(Modgen::APIRequestError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require "modgen"
+
+API_URL = 'http://localhost:3000'
+
+API_KEY = 'f0ddaaef2903e6f2ac634e7f6037c9b2'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  # config.filter_run :focus
+  config.color_enabled = true
+  config.formatter     = 'documentation'
+end

data/test_api/.gitignore

@@ -0,0 +1,15 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp

data/test_api/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'rails', '3.2.13'
+
+gem 'sqlite3'
+gem 'grape'
+gem 'multi_json'