facemock 0.0.4 → 0.0.5

data/lib/facemock/database/table.rb

@@ -0,0 +1,340 @@
+require 'facemock/database'
+require 'sqlite3'
+require 'hashie'
+
+module Facemock
+  class Database
+    class Table
+      # 以下は継承先でオーバーライド必須
+      #  * TABLE_NAME, COLUMN_NAMES
+      #  * initialize()
+      TABLE_NAME = :tables
+      COLUMN_NAMES = [:id, :text, :active, :number, :created_at]
+
+      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) }
+        if persisted?
+          update!(options)
+        else
+          insert!(options)
+        end
+      end
+
+      def destroy
+        raise unless persisted?
+        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.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
+        else
+          super
+        end
+        super unless column_names.include?(column_name.to_sym)
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" unless args.size == 1
+        super unless define_find_method(name, column_name)
+        send(name, args.first)
+      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.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 = Facemock::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)
+        else false
+        end
+      end
+
+      def self.define_find_by_column(column_name)
+        self.class_eval <<-EOF
+          def self.find_by_#{column_name}(value)
+            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)
+            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|
+          if column_name != :created_at
+            if self.class.column_notnull(column_name) && column_is_empty?(column_name)
+              raise Facemock::Errors::ColumnTypeNotNull, "#{column_name} is null"
+            end
+            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
+        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
+    end
+  end
+end

data/lib/facemock/database/user.rb

@@ -0,0 +1,26 @@
+require 'facemock/database'
+require 'facemock/database/table'
+require 'sqlite3'
+require 'hashie'
+
+module Facemock
+  class Database
+    class User < Table
+      TABLE_NAME = :users
+      COLUMN_NAMES = [:id, :name, :email, :password, :installed, :access_token, :application_id, :created_at]
+
+      def initialize(options={})
+        opts = Hashie::Mash.new(options)
+        @id             = (opts.id.to_i > 0) ? opts.id.to_i : ("10000" + (0..9).to_a.shuffle[0..10].join).to_i
+        @name           = opts.name         || rand(36**10).to_s(36)
+        @email          = opts.email        || name.gsub(" ", "_") + "@example.com"
+        @password       = opts.password     || rand(36**10).to_s(36)
+        @installed      = opts.installed    || false
+        @access_token   = opts.access_token || Digest::SHA512.hexdigest(identifier.to_s)
+        app_id = opts.application_id.to_i
+        @application_id = (app_id > 0) ? app_id : nil
+        @created_at     = opts.created_at
+      end
+    end
+  end
+end

data/lib/facemock/database.rb

@@ -0,0 +1,121 @@
+require 'sqlite3'
+require 'facemock/database/table'
+require 'facemock/database/application'
+require 'facemock/database/user'
+require 'facemock/database/permission'
+
+module Facemock
+  class Database
+    ADAPTER = "sqlite3"
+    DB_DIRECTORY = File.expand_path("../../../db", __FILE__)
+    DEFAULT_DB_NAME = "facemock"
+    TABLE_NAMES = [:applications, :users, :permissions]
+
+    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,
+          secret      TEXT      NOT NULL,
+          created_at  DATETIME  NOT NULL,
+          UNIQUE(secret)
+        );
+      SQL
+    end
+
+    def create_users_table
+      @connection.execute <<-SQL
+        CREATE TABLE users (
+          id              INTEGER  PRIMARY KEY AUTOINCREMENT,
+          name            TEXT      NOT NULL,
+          email           TEXT      NOT NULL,
+          password        TEXT      NOT NULL,
+          installed       BOOLEAN   NOT NULL,
+          access_token    TEXT      NOT NULL,
+          application_id  INTEGER   NOT NULL,
+          created_at      DATETIME  NOT NULL,
+          UNIQUE(access_token));
+      SQL
+    end
+
+    def create_permissions_table
+      @connection.execute <<-SQL
+        CREATE TABLE permissions (
+          id          INTEGER   PRIMARY KEY AUTOINCREMENT,
+          name        TEXT      NOT NULL,
+          user_id     INTEGER   NOT NULL,
+          created_at  DATETIME  NOT NULL
+        );
+      SQL
+    end
+  end
+end

data/lib/facemock/errors.rb

@@ -0,0 +1,7 @@
+module Facemock
+  module Errors
+    class Error < StandardError; end
+    class IncorrectDataFormat < Error; end
+    class ColumnTypeNotNull < Error; end
+  end
+end

data/lib/facemock/fb_graph/application/test_users.rb

@@ -0,0 +1,36 @@
+require 'facemock/fb_graph/application/user'
+
+module Facemock
+  module FbGraph
+    class Application
+      class TestUsers < Array
+        DEFAULT_LIMIT = 50
+        DEFAULT_AFTER = 0
+
+        def initialize(application_id, options={})
+          @limit = limit = (options[:limit] && options[:limit] > 0) ? options[:limit] : DEFAULT_LIMIT
+          @after = after = (options[:after] && options[:after] > 0) ? options[:after] : DEFAULT_AFTER
+          @application_id = application_id
+          st = after
+          ed = after + limit - 1
+          users = User.find_all_by_application_id(application_id).sort_by{|u| u.created_at}
+          users = users.reverse[st..ed] || []
+          super(users)
+        end
+
+        def collection
+          self
+        end
+        
+        def next
+          options = { limit: @limit, after: @after + @limit }
+          TestUsers.new(@application_id, options)
+        end
+
+        def select
+          { limit: DEFAULT_LIMIT, after: DEFAULT_AFTER }
+        end
+      end
+    end
+  end
+end

data/lib/facemock/fb_graph/application/user/permission.rb

@@ -0,0 +1,10 @@
+module Facemock
+  module FbGraph
+    class Application
+      class User < Facemock::Database::User
+        class Permission < Facemock::Database::Permission
+        end
+      end
+    end
+  end
+end

data/lib/facemock/fb_graph/application/user.rb

@@ -0,0 +1,69 @@
+require 'hashie'
+require 'facemock/fb_graph/application/user/permission'
+
+module Facemock
+  module FbGraph
+    class Application
+      class User < Facemock::Database::User
+        attr_reader :permission_objects
+
+        def initialize(options={})
+          opts = Hashie::Mash.new(options)
+          if opts.identifier
+            opts[:id] = opts.identifier
+            opts.delete(:identifier)
+          end
+          super(opts)
+
+          @permission_objects = User::Permission.find_all_by_user_id(self.id)
+          set_permissions(opts.permissions) if opts.permissions
+        end
+
+        def permissions
+          @permission_objects.inject([]) do |names, perm|
+            names << perm.name.to_sym
+          end
+        end
+
+        def save!
+          super
+          @permission_objects.each do |permission|
+            permission.save!
+          end
+        end
+
+        def fetch
+          @permission_objects = User::Permission.find_all_by_user_id(self.id)
+          super
+        end
+
+        def destroy
+          @permission_objects.each do |permission|
+            permission.destroy
+          end
+          super
+        end
+
+        def revoke!
+          @permission_objects.each do |permission|
+            permission.destroy
+          end
+          @permission_objects = []
+        end
+
+        private
+
+        def set_permissions(permissions_string)
+          permissions_string.gsub(/\s/, "").split(",").uniq.each do |permission_name|
+            unless @permission_objects.find{|perm| perm.name == permission_name}
+              @permission_objects << User::Permission.new(
+                name: permission_name,
+                user_id: self.id
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facemock/fb_graph/application.rb

@@ -0,0 +1,48 @@
+require 'hashie'
+require 'facemock/config'
+require 'facemock/fb_graph/application/user'
+require 'facemock/fb_graph/application/test_users'
+require 'facemock/database/application'
+
+module Facemock
+  module FbGraph
+    class Application
+      attr_reader :identifier
+      attr_reader :secret
+
+      def initialize(identifier, options={})
+        opts = Hashie::Mash.new(options)
+        if (identifier == :app && opts.access_token)
+          identifier = (0..9).to_a.shuffle[0..15].join
+          secret = opts.access_token
+        else
+          secret = opts.secret || rand(36**32).to_s(36)
+        end
+
+        @record = Facemock::Database::Application.new({id: identifier, secret: secret})
+        @record.save! unless Facemock::Database::Application.find_by_id(identifier)
+        @identifier = identifier.to_i
+        @secret     = secret
+      end
+
+      def fetch
+        if @record = Facemock::Database::Application.find_by_id(@identifier)
+          @identifier = @record.id
+          @secret     = @record.secret
+        end
+        self
+      end
+
+      def test_user!(options={})
+        options.merge!({application_id: self.identifier})
+        user = User.new(options)
+        user.save!
+        user
+      end
+
+      def test_users(options={})
+        TestUsers.new(self.identifier, options)
+      end
+    end
+  end
+end

data/lib/facemock/fb_graph/user.rb

@@ -0,0 +1,13 @@
+require 'facemock/fb_graph/application/user'
+
+module Facemock
+  module FbGraph
+    module User
+      extend self
+
+      def me(access_token)
+        Application::User.find_by_access_token(access_token)
+      end
+    end
+  end
+end

data/lib/facemock/fb_graph.rb

@@ -0,0 +1,30 @@
+require 'fb_graph'
+require 'facemock/config'
+require 'facemock/fb_graph/user'
+require 'facemock/fb_graph/application'
+
+module Facemock
+  module FbGraph
+    extend self
+
+    def on(options={})
+      if ::FbGraph != Facemock::FbGraph
+        Object.const_set(:SourceFbGraph, ::FbGraph)
+        Object.send(:remove_const, :FbGraph) if Object.constants.include?(:FbGraph)
+        Object.const_set(:FbGraph, Facemock::FbGraph)
+      end
+      true
+    end
+
+    def off
+      if ::FbGraph == Facemock::FbGraph
+        Object.send(:remove_const, :FbGraph) if Object.constants.include?(:FbGraph)
+        Object.const_set(:FbGraph, ::SourceFbGraph)
+        Object.send(:remove_const, :SourceFbGraph) if Object.constants.include?(:FbGraph)
+      end
+      true
+    end
+
+    class InvalidToken < ::FbGraph::InvalidToken; end
+  end
+end