social_snippet 0.0.1 → 0.0.2

data/lib/social_snippet/registry/registry_resources.rb

@@ -0,0 +1,3 @@
+module SocialSnippet::Registry::RegistryResources; end
+require_relative "registry_resources/base"
+require_relative "registry_resources/repositories"

data/lib/social_snippet/registry/registry_resources/base.rb

@@ -0,0 +1,80 @@
+module SocialSnippet::Registry::RegistryResources
+
+  require "rest_client"
+  require "json"
+
+  class Base
+
+    attr_reader :social_snippet
+    attr_reader :rest_client
+    attr_reader :protocol
+    attr_reader :host
+    attr_reader :api_version
+    attr_reader :end_point
+    attr_reader :cookies
+    attr_reader :default_headers
+
+    def initialize(new_social_snippet)
+      @social_snippet = new_social_snippet
+      @host           = social_snippet.config.sspm_host
+      @api_version    = social_snippet.config.sspm_version
+      @protocol       = social_snippet.config.sspm_protocol
+      @end_point      = "#{protocol}://#{host}/api/#{api_version}"
+      @rest_client    = ::RestClient::Resource.new(end_point)
+      @cookies        = {}
+      @default_headers = {
+        :accept => :json,
+      }
+
+      social_snippet.logger.debug "registry: end-point = #{end_point}"
+    end
+
+    def post(req_path, params, headers = {})
+      social_snippet.logger.debug "registry: post: #{req_path}"
+      social_snippet.logger.debug params
+      csrf_token = fetch_csrf_token
+
+      # set headers
+      headers.merge! default_headers
+      headers["Content-Type"] = "application/json"
+      headers["X-CSRF-Token"] = csrf_token
+
+      # debug output
+      social_snippet.logger.debug "registry: post: csrf_token = #{csrf_token}"
+      social_snippet.logger.debug "registry: post: headers:"
+      social_snippet.logger.debug headers
+
+      parse_response rest_client[req_path].post(params.to_json, headers)
+    end
+
+    def get(req_path, headers = {})
+      social_snippet.logger.debug "registry: get #{req_path}"
+      headers.merge! default_headers
+      social_snippet.logger.debug "registry: headers:"
+      social_snippet.logger.debug headers
+      parse_response rest_client[req_path].get(headers)
+    end
+
+    private
+
+    def fetch_csrf_token
+      unless @csrf_token
+        @csrf_token = get("token")
+        default_headers.merge! :cookies => cookies
+      end
+      @csrf_token
+    end
+
+    def parse_response(res)
+      cookies.merge! res.cookies
+      s = res.to_s
+      begin
+        ::JSON.parse s
+      rescue ::JSON::ParserError
+        s
+      end
+    end
+
+  end # Base
+
+end

data/lib/social_snippet/registry/registry_resources/repositories.rb

@@ -0,0 +1,23 @@
+module SocialSnippet::Registry::RegistryResources
+
+  class Repositories < Base
+
+    def all
+      get "repositories"
+    end
+
+    def search(query)
+      get "repositories?q=#{query}"
+    end
+
+    def find(repo_name)
+      get "repositories/#{repo_name}"
+    end
+
+    def add_url(repo_url)
+      post "repositories", :url => repo_url
+    end
+
+  end # Repositories
+
+end # SocialSnippet

data/lib/social_snippet/repository.rb

@@ -0,0 +1,6 @@
+module SocialSnippet::Repository; end
+require_relative "repository/drivers"
+require_relative "repository/repository_factory"
+require_relative "repository/repository_manager"
+require_relative "repository/repository_errors"
+require_relative "repository/repository_installer"

data/lib/social_snippet/repository/drivers.rb

@@ -0,0 +1,3 @@
+module SocialSnippet::Repository::Drivers; end
+require_relative "drivers/base_repository"
+require_relative "drivers/git_repository"

data/lib/social_snippet/repository/drivers/base_repository.rb

@@ -0,0 +1,192 @@
+module SocialSnippet::Repository::Drivers
+
+  require "version_sorter"
+  require "json"
+
+  # Repository base class
+  # usage: class GitRepository < BaseRepository
+  class BaseRepository
+
+    attr_reader :path
+    attr_reader :cache_path
+    attr_reader :name
+    attr_reader :desc
+    attr_reader :main
+    attr_reader :ref
+    attr_reader :dependencies
+    attr_reader :ref
+    attr_reader :url
+
+    # Constructor
+    #
+    # @param path [String] The path of repository
+    def initialize(new_path, new_ref = nil)
+      @path = new_path
+      @cache_path = nil
+      @ref = new_ref
+
+      if ( not ref.nil? ) && ( not refs.empty? ) && ( not refs.include?(ref) )
+        raise Errors::NotExistRef
+      end
+
+      @url = nil
+    end
+
+    # Set repo's URL
+    def set_url(new_url)
+      @url = new_url
+    end
+
+    def load_cache(base_cache_path)
+      cache_path_cand = "#{base_cache_path}/#{name}/#{short_commit_id}"
+
+      if ::Dir.exists?(cache_path_cand)
+        return @cache_path = cache_path_cand
+      end
+
+      return @cache_path = nil
+    end
+
+    # Create cache of repository
+    #
+    # @param cache_path [String] The path of cache dir
+    # @return [String] the path
+    def create_cache(base_cache_path)
+      @cache_path = "#{base_cache_path}/#{name}/#{short_commit_id}"
+
+      return if ::Dir.exists?(cache_path)
+
+      ::FileUtils.mkdir_p "#{base_cache_path}/#{name}"
+      ::FileUtils.cp_r path, cache_path
+
+      return cache_path
+    end
+
+    # Load snippet.json file
+    def load_snippet_json
+      text = ::File.read(::File.join(path, "snippet.json"))
+      snippet_json = ::JSON.parse(text)
+      @name = snippet_json["name"]
+      @desc = snippet_json["desc"]
+      @main = snippet_json["main"] || ""
+      @dependencies = snippet_json["dependencies"] || {}
+    end
+
+    # Returns json text from repo instance
+    # 
+    # @return json text
+    def to_snippet_json
+      required = [
+        :name,
+      ]
+
+      optional = [
+        :desc,
+        :main,
+        :dependencies,
+      ]
+
+      data = {}
+      required.each do |key|
+        data[key] = send(key)
+      end
+      optional.each do |key|
+        val = send(key)
+        if val.nil? === false && val != ""
+          data[key] = send(key)
+        end
+      end
+
+      return data.to_json
+    end
+
+    # Returns latest version
+    #
+    # @param pattern [String] The pattern of version
+    # @return [String] The version
+    def latest_version(pattern = "")
+      pattern = "" if pattern.nil?
+      matched_versions = versions.select {|ref| ::SocialSnippet::Version.is_matched_version_pattern(pattern, ref)}
+      return ::VersionSorter.rsort(matched_versions).first
+    end
+
+    # Returns all versions
+    #
+    # @return [Array<String>] All versions of repository
+    def versions
+      refs.select {|ref| ::SocialSnippet::Version.is_version(ref) }
+    end
+
+    def current_ref
+      raise "not implete current_ref"
+    end
+
+    # Returns all refs
+    #
+    # @return [Array<String>] All references of repository
+    def refs
+      raise "not implement refs"
+    end
+
+    # Returns short current ref's commit id
+    #
+    # @return [String]
+    def short_commit_id
+      commit_id[0..7]
+    end
+
+    # Returns current ref's commit id
+    #
+    # @return [String]
+    def commit_id
+      raise "not implement commit_id"
+    end
+
+    # Returns the directory or file names within repository
+    #
+    # @param glob_path [String]
+    def glob(glob_path)
+      root_path = real_path("/")
+      ::Dir.glob("#{root_path}/#{glob_path}")
+    end
+
+    # Returns the real path of given path
+    #
+    # @param target_path [String] The real path of repo's file or directory
+    def real_path(target_path)
+      # TODO: normalize path
+      if is_cached?
+        "#{cache_path}/#{main}/#{target_path}"
+      else
+        "#{path}/#{main}/#{target_path}"
+      end
+    end
+
+    # Checkout to ref
+    #
+    # @param ref [String] The reference of repository
+    def checkout(new_ref)
+      raise "not implement checkout"
+    end
+
+    # Check repository has version ref
+    #
+    # @return [Boolean]
+    def has_versions?
+      versions.empty? === false
+    end
+
+    # Check repository is cached
+    #
+    # @return [Boolean]
+    def is_cached?
+      @cache_path.nil? === false
+    end
+
+    def update(options = {})
+      throw "not implement update"
+    end
+
+  end # BaseRepository
+
+end # SocialSnippet

data/lib/social_snippet/repository/drivers/git_repository.rb

@@ -0,0 +1,76 @@
+module SocialSnippet::Repository::Drivers
+
+  require "rugged"
+
+  class GitRepository < BaseRepository
+
+    attr_reader :rugged_repo
+
+    def initialize(repo_path, new_ref = nil)
+      @rugged_repo = ::Rugged::Repository.new(repo_path)
+      super(repo_path)
+    end
+
+    def current_ref
+      rugged_repo.head.name.gsub /^refs\/heads\//, ""
+    end
+
+    def update
+      # TODO: write tests
+      fetch_status = rugged_repo.fetch("origin")
+      fetch_status[:received_bytes]
+    end
+
+    def commit_id
+      rugged_repo.head.target_id
+    end
+
+    def checkout(ref_name)
+      rugged_repo.checkout ref_name, :strategy => [:force]
+    end
+
+    def refs
+      refs = []
+      refs.concat remote_refs
+      refs.concat tags
+      return refs
+    end
+
+    def remote_refs
+      rugged_repo.references
+        .select {|ref| /^refs\/remotes\/origin\// === ref.name }
+        .map {|ref| /^refs\/remotes\/origin\/(.*)/.match(ref.name)[1] }
+    end
+
+    def tags
+      rugged_repo.references
+        .select {|ref| /^refs\/tags\// === ref.name }
+        .map {|ref| /^refs\/tags\/(.*)/.match(ref.name)[1] }
+    end
+
+    class << self
+
+      # @return path
+      def download(uri, dest_path = nil)
+        if dest_path.nil?
+          dest_path = Dir.mktmpdir
+        end
+
+        # git clone
+        cloned_repo = ::Rugged::Repository.clone_at uri.to_s, dest_path
+        cloned_repo_files = cloned_repo.head.target.tree.map {|item| item[:name] }
+
+        # check snippet.json
+        unless cloned_repo_files.include?("snippet.json")
+          raise "ERROR: Not found snippet.json in the repository"
+        end
+
+        cloned_repo.close
+        dest_path
+      end
+
+    end # class << self
+
+  end # GitRepository
+
+end # SocialSnippet

data/lib/social_snippet/repository/repository_errors.rb

@@ -0,0 +1,5 @@
+module SocialSnippet::Repository::Errors
+
+  class NotExistRef < StandardError; end
+
+end

data/lib/social_snippet/repository/repository_factory.rb

@@ -0,0 +1,59 @@
+module SocialSnippet::Repository::RepositoryFactory
+
+  class << self
+
+    def clone(repo_url)
+      uri = URI.parse repo_url
+      if is_git_repo(uri)
+        path = ::SocialSnippet::Repository::Drivers::GitRepository.download uri
+        repo = create_git_repo(path)
+        repo.set_url repo_url
+        repo.load_snippet_json
+        return repo
+      else
+        raise "unknown repository type"
+      end
+    end
+
+    def clone_local(repo_path)
+      if has_git_dir?(repo_path)
+        cloned_path = ::SocialSnippet::Repository::Drivers::GitRepository.download repo_path
+        repo = create_git_repo(cloned_path)
+        repo.set_url repo_path
+        repo.load_snippet_json
+        return repo
+      else
+        raise "unknown local repository type"
+      end
+    end
+
+    # Create suitable Repository class instance from path
+    #
+    # @param path [String] The path of repository
+    def create(path, ref = nil, options = {})
+      if has_git_dir?(path)
+        repo = create_git_repo(path, ref)
+        repo.load_snippet_json
+        return repo
+      end
+
+      return nil
+    end
+
+    def create_git_repo(path, ref = nil)
+      ::SocialSnippet::Repository::Drivers::GitRepository.new(path, ref)
+    end
+
+    def has_git_dir?(dir_path)
+      Dir.exists?("#{dir_path}/.git")
+    end
+
+    def is_git_repo(uri)
+      return true if uri.scheme === "git"
+      return true if uri.host === "github.com"
+      return false
+    end
+
+  end # class << self
+
+end # RepositoryFactory