twimock 0.0.1

data/lib/twimock/auth_hash.rb

@@ -0,0 +1,8 @@
+require 'omniauth/auth_hash'
+require 'twimock/database'
+require 'hashie'
+
+module Twimock
+  class AuthHash < OmniAuth::AuthHash
+  end
+end

data/lib/twimock/config.rb

@@ -0,0 +1,90 @@
+require 'yaml'
+require 'hashie'
+require 'twimock/errors'
+require 'twimock/database'
+require 'active_support'
+
+module Twimock
+  module Config
+    mattr_accessor :host
+    mattr_accessor :port
+    mattr_accessor :callback_url
+
+    @@host         = "api.twimock.com"
+    @@port         = 443
+    @@callback_url = "http://localhost/auth/twiter/callback"
+
+    extend self
+
+    def default_database
+      Twimock::Database.new
+    end
+
+    def database
+      default_database
+    end
+
+    def reset_database
+      db = Twimock::Database.new
+      db.disconnect!
+      db.drop
+    end
+
+    def load_users(ymlfile)
+      load_data = YAML.load_file(ymlfile)
+      raise Twimock::Errors::IncorrectDataFormat.new "data is not Array" unless load_data.kind_of?(Array)
+
+      load_data.each do |app_data|
+        data = Hashie::Mash.new(app_data)
+        app_id     = data.id
+        api_key    = data.api_key
+        api_secret = data.api_secret
+        users      = data.users
+
+        # Validate data format
+        [:id, :api_key, :api_secret, :users].each {|key| validate_format(key, data.send(key)) }
+        users.each do |user|
+          [:id, :name, :password].each {|key| validate_format(key, user.send(key)) }
+        end
+
+        # Create application and user record
+        app = Twimock::Application.create!({ id: app_id, api_key: api_key, api_secret: api_secret })
+        users.each do |options|
+          access_token = AccessToken.new
+          access_token.string = options.delete(:access_token)
+          access_token.secret = options.delete(:access_token_secret)
+          user = Twimock::User.new(options)
+          user.save! unless Twimock::User.find_by_id(user.id)
+          unless Twimock::AccessToken.find_by_string(access_token.string)
+            access_token.user_id = user.id
+            access_token.application_id = app_id
+            access_token.save!
+          end
+        end
+      end
+    end
+
+    private
+
+    AVAILABLE_TYPE = { id: [String, Integer],
+                       api_key: [String],
+                       api_secret: [String],
+                       users: [Array],
+                       name: [String],
+                       password: [String] }
+
+    def available?(key, value)
+      return false unless AVAILABLE_TYPE[key].any? { |t| value.kind_of?(t) }
+      case value
+      when String, Array
+         value.present?
+      when Integer
+         value >= 0
+      end
+    end
+
+    def validate_format(key, value)
+      raise Twimock::Errors::IncorrectDataFormat.new "format of #{key} is incorrect" unless available?(key, value)
+    end
+  end
+end

data/lib/twimock/database/table.rb

@@ -0,0 +1,359 @@
+require 'twimock/database'
+require 'sqlite3'
+require 'hashie'
+
+module Twimock
+  class Database
+    class Table
+      # 以下は継承先でオーバーライド必須
+      #  * TABLE_NAME, COLUMN_NAMES
+      #  * initialize()
+      TABLE_NAME = :tables
+      COLUMN_NAMES = [:id, :text, :active, :number, :created_at]
+      CHILDREN = []
+
+      def initialize(options={})
+        opts = Hashie::Mash.new(options)
+        self.id = opts.id
+        self.text = opts.text
+        self.active = opts.active || false
+        self.number = opts.number
+        self.created_at = opts.created_at
+      end
+
+      def save!(options={})
+        persisted? ? update!(options) : insert!(options)
+      end
+
+      def update_attributes!(options)
+        # カラムに含まれるかどうかの確認。なければNoMethodError
+        options.each_key {|key| self.send(key) }
+        persisted? ? update!(options) : insert!(options)
+      end
+
+      def destroy
+        raise unless persisted?
+        self.class.children.each do |klass|
+          klass_last_name = self.class.name.split("::").last.downcase
+          find_method_name = "find_all_by_#{klass_last_name}_id"
+          objects = klass.send(find_method_name, self.id)
+          objects.each{|object| object.destroy }
+        end
+
+        execute "DELETE FROM #{table_name} WHERE ID = #{self.id};"
+        self
+      end
+
+      def fetch
+        if persisted?
+          sql = "SELECT * FROM #{table_name} WHERE ID = #{self.id} LIMIT 1;"
+          records = execute sql
+          return nil unless record = records.first
+          set_attributes_from_record(record)
+          self
+        end
+      end
+
+      def method_missing(name, *args)
+        method_name = name.to_s.include?("=") ? name.to_s[0...-1].to_sym : name
+        case name
+        when :identifier  then return send(:id)
+        when :identifier= then return send(:id=, *args)
+        else
+          if column_names.include?(method_name) && args.size <= 1
+            if !name.to_s.include?("=") && args.empty?
+              define_column_getter(name)
+              return send(name)
+            else
+              define_column_setter(name)
+              return send(name, args.first)
+            end
+          else
+            super
+          end
+        end
+      end
+
+      def self.create!(options={})
+        instance = self.new(options)
+        instance.save!
+        instance
+      end
+
+      def self.all
+        records = execute "SELECT * FROM #{table_name};"
+        records_to_objects(records)
+      end
+
+      def self.first
+        records = execute "SELECT * FROM #{table_name} LIMIT 1;"
+        record_to_object(records.first)
+      end
+
+      def self.last
+        records = execute "SELECT * FROM #{table_name} ORDER BY ID DESC LIMIT 1 ;"
+        record_to_object(records.first)
+      end
+
+      def self.where(column)
+        column_name = column.keys.first
+        value = column.values.first
+        column_value = (value.kind_of?(String)) ? "'" + value + "'" : value.to_s
+
+        records = execute "SELECT * FROM #{table_name} WHERE #{column_name} = #{column_value};"
+        records_to_objects(records)
+      end
+
+      def self.method_missing(name, *args)
+        if ((name =~ /^find_by_(.+)/ || name =~ /^find_all_by_(.+)/) && 
+          (column_name = $1) && column_names.include?(column_name.to_sym))
+          raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" unless args.size == 1
+          define_find_method(name, column_name) ? send(name, args.first) : super
+        else
+          super
+        end
+      end
+
+      def table_name
+        self.class.table_name
+      end
+
+      def column_names
+        self.class.column_names
+      end
+
+      def persisted?
+        !!(self.id && !(self.class.find_by_id(self.id).nil?))
+      end
+
+      def self.table_name
+        self::TABLE_NAME
+      end
+
+      def self.column_names
+        self::COLUMN_NAMES
+      end
+
+      def self.children
+        self::CHILDREN
+      end
+
+      def self.column_type(column_name)
+        return nil unless column_names.include?(column_name.to_s.to_sym)
+        table_info.send(column_name).type
+      end
+
+      def self.table_info
+        sql = "PRAGMA TABLE_INFO(#{table_name});"
+        records = execute sql
+        info = Hashie::Mash.new
+        records.each do |record|
+          column_info = Hashie::Mash.new(
+            { cid:         record[0],
+              name:        record[1].to_sym,
+              type:        record[2],
+              notnull:    (record[3] == 1),
+              dflt_value:  record[4],
+              pk:         (record[5] == 1) }
+          )
+          info.send(record[1] + "=", column_info)
+        end
+        info
+      end
+
+      private
+
+      def execute(sql)
+        self.class.execute(sql)
+      end
+
+      def self.execute(sql)
+        database = Twimock::Database.new
+        records = database.connection.execute sql
+        if records.empty? && sql =~ /^INSERT /
+          records = database.connection.execute <<-SQL
+            SELECT * FROM #{table_name} WHERE ROWID = last_insert_rowid();
+          SQL
+        end
+        database.disconnect!
+        records
+      end
+
+      def self.record_to_object(record)
+        return nil unless record
+        self.new(record_to_hash(record))
+      end
+
+      def self.records_to_objects(records)
+        records.inject([]) do |objects, record|
+          objects << record_to_object(record)
+        end
+      end
+
+      def record_to_hash(record)
+        self.class.record_to_hash(record)
+      end
+
+      # 以下の形式のHashが返される
+      #   { id: x, ..., created_at: yyyy-mm-dd :hh:mm +xxxx }
+      def self.record_to_hash(record)
+        hash = Hashie::Mash.new
+        column_names.each_with_index do |column_name, index|
+          value = (record[index] == "") ? nil : record[index]
+          parsed_value = case column_type(column_name)
+          when "BOOLEAN"  then eval(value)
+          when "DATETIME" then Time.parse(value)
+          else  value
+          end
+          hash.send(column_name.to_s + "=", parsed_value)
+        end
+        hash
+      end
+
+      def self.define_find_method(method_name, column_name)
+        case method_name
+        when /^find_by_(.+)/     then define_find_by_column(column_name)
+        when /^find_all_by_(.+)/ then define_find_all_by_column(column_name)
+        end
+      end
+
+      def self.define_find_by_column(column_name)
+        self.class_eval <<-EOF
+          def self.find_by_#{column_name}(value)
+            return nil if value.nil?
+
+            column_value = case value
+            when String then "'" + value + "'"
+            when Time   then "'" + value.to_s + "'"
+            else value.to_s
+            end
+
+            sql  = "SELECT * FROM #{table_name} WHERE #{column_name} = "
+            sql += column_value + " LIMIT 1;"
+            records = execute sql
+            record_to_object(records.first)
+          end
+        EOF
+        true
+      end
+
+      def self.define_find_all_by_column(column_name)
+        self.class_eval <<-EOF
+          def self.find_all_by_#{column_name}(value)
+            return [] if value.nil?
+
+            column_value = case value
+            when String then "'" + value + "'"
+            when Time   then "'" + value.to_s + "'"
+            else value.to_s
+            end
+
+            sql  = "SELECT * FROM #{table_name} WHERE #{column_name} = "
+            sql += column_value + ";"
+            records = execute sql
+            records_to_objects(records)
+          end
+        EOF
+        true
+      end
+
+      def define_column_getter(name)
+        self.class.class_eval <<-EOF
+          def #{name}
+            self.instance_variable_get(:@#{name})
+          end
+        EOF
+      end
+
+      def define_column_setter(name)
+        self.class.class_eval <<-EOF
+          def #{name}(value)
+            instance_variable_set(:@#{name.to_s.gsub("=", "")}, value)
+          end
+        EOF
+      end
+
+      # DatabaseへのINSERTが成功してからインスタンスのフィールド値を更新する
+      def insert!(options={})
+        opts = Hashie::Mash.new(options)
+        instance = self.class.new
+        column_names.each do |column_name|
+          next if column_name == :created_at
+          notnull_check(column_name)
+          instance.send(column_name.to_s + "=", self.send(column_name))
+
+          if opts.send(column_name)
+            instance.send(column_name.to_s + "=", opts.send(column_name))
+          end
+        end
+
+        target_column_names = if instance.id
+          column_names
+        else
+          column_names.select{|name| name != :id}
+        end
+        instance.created_at = Time.now
+        target_column_values = target_column_names.inject([]) do |ary, column_name|
+          ary << "'#{instance.send(column_name)}'"
+        end
+        values  = target_column_values.join(", ")
+        columns = target_column_names.join(', ')
+
+        sql = "INSERT INTO #{table_name}(#{columns}) VALUES ( #{values} );"
+        records = execute sql
+        set_attributes_from_record(records.first)
+        true
+      end
+
+      def update!(options={})
+        if options.empty?
+          column_names.each do |column_name|
+            if (value = self.send(column_name)) && column_name != :id
+              options[column_name] = value unless options.nil?
+            end
+          end
+        end
+
+        unless options.empty?
+          target_key_values = options.inject([]) do |ary, (key, value)|
+            ary << (value.kind_of?(Integer) ? "#{key} = #{value}" : "#{key} = '#{value}'")
+          end
+          sql = "UPDATE #{table_name} SET #{target_key_values.join(', ')} WHERE ID = #{self.id};"
+          execute sql
+        end
+        fetch
+        true
+      end
+
+      def set_attributes_from_record(record)
+        hash = record_to_hash(record)
+        column_names.each do |column_name|
+          method_name = column_name.to_s + "="
+          self.send(method_name, hash.send(column_name))
+        end
+      end
+
+      def column_is_empty?(column_name)
+        return true if self.send(column_name).nil?
+
+        return case self.class.column_type(column_name)
+        when "TEXT", "DATETIME", "BOOLEAN"
+          true if self.send(column_name) == ""
+        else
+          false
+        end
+      end
+
+      def self.column_notnull(column_name)
+        return nil unless column_names.include?(column_name.to_s.to_sym)
+        table_info.send(column_name).notnull
+      end
+
+      def notnull_check(column_name)
+        if self.class.column_notnull(column_name) && column_is_empty?(column_name)
+          raise Twimock::Errors::ColumnTypeNotNull, "#{column_name} is null"
+        end
+      end
+    end
+  end
+end

data/lib/twimock/database.rb

@@ -0,0 +1,133 @@
+require 'sqlite3'
+require 'twimock/database/table'
+
+module Twimock
+  class Database
+    ADAPTER = "sqlite3"
+    DB_DIRECTORY = File.expand_path("../../../db", __FILE__)
+    DEFAULT_DB_NAME = "twimock"
+    TABLE_NAMES = [:applications, :users, :access_tokens, :request_tokens]
+
+    attr_reader :name
+    attr_reader :connection
+
+    def initialize(name=nil)
+      @name = DEFAULT_DB_NAME
+      connect
+      create_tables
+    end
+
+    def connect
+      @connection = SQLite3::Database.new filepath
+      @state = :connected
+      @connection
+    end
+
+    def disconnect!
+      @connection.close
+      @state = :disconnected
+      nil
+    end
+      
+    def connected?
+      @state == :connected
+    end
+
+    def drop
+      disconnect!
+      File.delete(filepath) if File.exist?(filepath)
+      nil
+    end
+
+    def clear
+      drop_tables
+      create_tables
+    end
+
+    def create_tables
+      TABLE_NAMES.each do |table_name|
+        self.send "create_#{table_name}_table" unless table_exists?(table_name)
+      end
+      true
+    end
+
+    def drop_table(table_name)
+      return false unless File.exist?(filepath) && table_exists?(table_name)
+      @connection.execute "drop table #{table_name};"
+      true
+    end
+
+    def drop_tables
+      return false unless File.exist?(filepath)
+      TABLE_NAMES.each{|table_name| drop_table(table_name) }
+      true
+    end
+
+    def filepath
+      name ||= @name
+      File.join(DB_DIRECTORY, "#{@name}.#{ADAPTER}")
+    end
+
+    def table_exists?(table_name)
+      tables = @connection.execute "select * from sqlite_master"
+      tables.each do |table|
+        return true if table[1].to_s == table_name.to_s
+      end
+      false
+    end
+
+    private
+
+    def create_applications_table
+      @connection.execute <<-SQL
+        CREATE TABLE applications (
+          id          INTEGER   PRIMARY KEY AUTOINCREMENT,
+          api_key     TEXT      NOT NULL,
+          api_secret  TEXT      NOT NULL,
+          created_at  DATETIME  NOT NULL,
+          UNIQUE(api_secret)
+        );
+      SQL
+    end 
+
+    def create_users_table
+      @connection.execute <<-SQL
+        CREATE TABLE users (
+          id                   INTEGER   PRIMARY KEY AUTOINCREMENT,
+          name                 TEXT      NOT NULL,
+          twitter_id           TEXT      NOT NULL,
+          email                TEXT      NOT NULL,
+          password             TEXT      NOT NULL,
+          created_at           DATETIME  NOT NULL,
+          UNIQUE(twitter_id, email));
+      SQL
+    end
+
+    def create_access_tokens_table
+      @connection.execute <<-SQL
+        CREATE TABLE access_tokens (
+          id              INTEGER   PRIMARY KEY AUTOINCREMENT,
+          string          TEXT      NOT NULL,
+          secret          TEXT      NOT NULL,
+          application_id  INTEGER,
+          user_id         INTEGER   NOT NULL,
+          created_at      DATETIME  NOT NULL,
+          UNIQUE(string, secret));
+      SQL
+    end
+
+    def create_request_tokens_table
+      @connection.execute <<-SQL
+        CREATE TABLE request_tokens (
+          id              INTEGER   PRIMARY KEY AUTOINCREMENT,
+          string          TEXT      NOT NULL,
+          secret          TEXT      NOT NULL,
+          verifier        TEXT      NOT NULL,
+          application_id  INTEGER   NOT NULL,
+          user_id         INTEGER,
+          created_at      DATETIME  NOT NULL,
+          UNIQUE(string, secret, verifier));
+      SQL
+    end
+  end
+end

data/lib/twimock/errors.rb

@@ -0,0 +1,13 @@
+module Twimock
+  module Errors
+    class Error < StandardError; end
+    class ColumnTypeNotNull < Error; end
+    class IncorrectDataFormat < Error; end
+    class InvalidRequestToken < Error; end
+    class InvalidConsumerKey < Error; end
+    class InvalidAccessToken < Error; end
+    class InvalidUsernameOrEmail < Error; end
+    class InvalidPassword < Error; end
+    class ApplicationNotFound < Error; end
+  end
+end

data/lib/twimock/omniauth/strategies/twitter.rb

@@ -0,0 +1,28 @@
+require 'uri'
+
+module Twimock
+  module OmniAuth
+    module Strategies
+      module Twitter
+        def request_phase
+          status, header, body = __request_phase
+          location = URI.parse(header["Location"])
+
+          if status == 302 && location.host == "api.twitter.com"
+            location.host   = Twimock::Config.host
+            case Twimock::Config.port
+            when 443 then location.scheme = "https"
+            when 80  then location.scheme = "http"
+            else
+              location.scheme = "http"
+              location.port   = Twimock::Config.port
+            end
+            header["Location"] = location.to_s
+          end
+
+          [ status, header, body ]
+        end
+      end
+    end
+  end
+end

data/lib/twimock/omniauth_twitter.rb

@@ -0,0 +1,36 @@
+require 'twimock/omniauth/strategies/twitter'
+require 'omniauth-twitter'
+
+module Twimock
+  module OmniAuthTwitter
+    extend self
+    @@enable = false
+
+    def on?
+      @@enable
+    end
+
+    def on
+      unless Twimock::OmniAuthTwitter.on?
+        ::OmniAuth::Strategies::Twitter.class_eval do
+          alias_method  :__request_phase, :request_phase
+          remove_method :request_phase
+          include Twimock::OmniAuth::Strategies::Twitter
+        end
+        @@enable = true
+      end
+      true
+    end
+
+    def off
+      if Twimock::OmniAuthTwitter.on?
+        ::OmniAuth::Strategies::Twitter.class_eval do
+          alias_method  :request_phase, :__request_phase
+          remove_method :__request_phase
+        end
+        @@enable = false
+      end
+      true
+    end
+  end
+end

data/lib/twimock/request_token.rb

@@ -0,0 +1,23 @@
+require 'faker'
+require 'twimock/database/table'
+
+module Twimock
+  class RequestToken < Database::Table
+    TABLE_NAME = :request_tokens
+    COLUMN_NAMES = [:id, :string, :secret, :verifier, :application_id, :user_id, :created_at]
+
+    def initialize(options={})
+      opts = Hashie::Mash.new(options)
+      id = opts.id.to_i
+      @id             = id if id > 0
+      @string         = opts.string   || Faker::Lorem.characters(32)
+      @secret         = opts.secret   || Faker::Lorem.characters(32)
+      @verifier       = opts.verifier || Faker::Lorem.characters(32)
+      app_id = opts.application_id.to_i
+      @application_id = app_id if app_id > 0
+      user_id = opts.user_id.to_i
+      @user_id        = user_id if user_id > 0
+      @created_at     = opts.created_at
+    end
+  end
+end